terminal ui fixes

core/actor/src/terminal_ui.rs

@@ -10,7 +10,7 @@ use crossterm::{
     execute,
 };
 use hero_job::{Job, JobStatus, ScriptType};
-use log::{error, info};
+
 use ratatui::{
     backend::{Backend, CrosstermBackend},
     layout::{Alignment, Constraint, Direction, Layout, Rect},
@@ -215,9 +215,7 @@ impl App {
         };
         
         if let Some(dir) = example_dir {
-            if let Err(e) = app.load_examples_tree(dir) {
-                error!("Failed to load examples tree: {}", e);
-            }
+            let _ = app.load_examples_tree(dir);
         }
         
         Ok(app)
@@ -225,32 +223,12 @@ impl App {
     
     pub fn load_examples_tree(&mut self, dir: PathBuf) -> Result<()> {
         if !dir.exists() {
-            log::warn!("Examples directory does not exist: {:?}", dir);
             return Ok(());
         }
         
-        log::info!("Loading examples tree from: {:?}", dir);
-        
         // Load hierarchical tree structure
-        match self.load_example_tree(&dir) {
-            Ok(tree) => {
-                self.example_tree = tree;
-                log::info!("Successfully loaded {} top-level tree nodes", self.example_tree.len());
-            }
-            Err(e) => {
-                log::error!("Failed to load example tree: {}", e);
-                // Create a simple fallback structure
-                self.example_tree = vec![
-                    ExampleTreeNode::File {
-                        name: "Error loading examples".to_string(),
-                        path: dir.join("error.rhai"),
-                    }
-                ];
-            }
-        }
-        
+        self.example_tree = self.load_example_tree(&dir)?;
         self.rebuild_tree_items();
-        log::info!("Rebuilt tree items: {} total items", self.example_tree_items.len());
         
         if !self.example_tree_items.is_empty() {
             self.example_tree_state.select(Some(0));
@@ -271,13 +249,9 @@ impl App {
     fn load_example_tree(&self, dir: &PathBuf) -> Result<Vec<ExampleTreeNode>> {
         let mut nodes = Vec::new();
         
-        log::debug!("Loading directory: {:?}", dir);
-        
         let mut entries: Vec<_> = fs::read_dir(dir)?
             .collect::<Result<Vec<_>, _>>()?;
         
-        log::debug!("Found {} entries in {:?}", entries.len(), dir);
-        
         // Sort entries: directories first, then files, both alphabetically
         entries.sort_by(|a, b| {
             let a_is_dir = a.path().is_dir();
@@ -295,17 +269,14 @@ impl App {
             let name = entry.file_name().to_string_lossy().to_string();
             
             if path.is_dir() {
-                log::debug!("Loading folder: {}", name);
                 let children = self.load_example_tree(&path)?;
-                log::debug!("Folder '{}' has {} children", name, children.len());
                 nodes.push(ExampleTreeNode::Folder {
                     name,
                     path,
                     children,
-                    expanded: true,  // Expand folders by default to show hierarchy
+                    expanded: false,  // Folders collapsed by default
                 });
             } else if path.extension().map_or(false, |ext| ext == "rhai") {
-                log::debug!("Loading file: {}", name);
                 nodes.push(ExampleTreeNode::File {
                     name: path.file_stem()
                         .and_then(|s| s.to_str())
@@ -319,55 +290,17 @@ impl App {
         Ok(nodes)
     }
     
-    fn load_flat_examples(&mut self, dir: &PathBuf) -> Result<()> {
-        let mut examples = Vec::new();
-        self.collect_all_rhai_files(&mut examples, dir)?;
-        self.examples = examples;
-        
-        if !self.examples.is_empty() {
-            self.example_list_state.select(Some(0));
-            if self.selected_example.is_none() {
-                self.selected_example = Some(self.examples[0].clone());
-            }
-        }
-        
-        Ok(())
-    }
-    
-    fn collect_all_rhai_files(&self, examples: &mut Vec<ExampleScript>, dir: &PathBuf) -> Result<()> {
-        for entry in fs::read_dir(dir)? {
-            let entry = entry?;
-            let path = entry.path();
-            
-            if path.is_dir() {
-                self.collect_all_rhai_files(examples, &path)?;
-            } else if path.extension().map_or(false, |ext| ext == "rhai") {
-                if let Some(name) = path.file_stem().and_then(|s| s.to_str()) {
-                    examples.push(ExampleScript {
-                        name: name.to_string(),
-                        path,
-                    });
-                }
-            }
-        }
-        Ok(())
-    }
-    
     fn rebuild_tree_items(&mut self) {
         self.example_tree_items.clear();
-        log::info!("Rebuilding tree items from {} root nodes", self.example_tree.len());
         let mut index = 0;
         let tree_clone = self.example_tree.clone();
         for node in &tree_clone {
-            log::info!("Processing root node: {:?}", node.name());
             self.add_tree_items_recursive(node, 0, &mut index);
         }
-        log::info!("Final tree items count: {}", self.example_tree_items.len());
     }
     
     fn add_tree_items_recursive(&mut self, node: &ExampleTreeNode, depth: usize, index: &mut usize) {
         // Always add the current node to the flattened list
-        log::debug!("Adding tree item: {} at depth {}", node.name(), depth);
         self.example_tree_items.push(ExampleTreeItem {
             node: node.clone(),
             depth,
@@ -377,7 +310,6 @@ impl App {
         
         // For folders, add children only if the folder is expanded
         if let ExampleTreeNode::Folder { children, expanded, .. } = node {
-            log::debug!("Folder '{}' has {} children, expanded: {}", node.name(), children.len(), expanded);
             if *expanded {
                 for child in children {
                     self.add_tree_items_recursive(child, depth + 1, index);
@@ -765,9 +697,7 @@ impl App {
 /// Setup terminal and run the TUI application
 pub async fn setup_and_run_tui(mut app: App) -> Result<()> {
     // Initial job refresh
-    if let Err(e) = app.refresh_jobs().await {
-        error!("Failed to refresh jobs: {}", e);
-    }
+    let _ = app.refresh_jobs().await;
     
     // Setup terminal
     enable_raw_mode()?;