From 69e612e521608bc2c55831d4fc132227c76bb586 Mon Sep 17 00:00:00 2001
From: Timur Gordon <31495328+timurgordon@users.noreply.github.com>
Date: Thu, 7 Aug 2025 15:45:09 +0200
Subject: [PATCH] clean up debug logging and restore normal tree behavior

---
 core/actor/src/terminal_ui.rs | 38 +++--------------------------------
 1 file changed, 3 insertions(+), 35 deletions(-)

diff --git a/core/actor/src/terminal_ui.rs b/core/actor/src/terminal_ui.rs
index 81d8706..311af18 100644
--- a/core/actor/src/terminal_ui.rs
+++ b/core/actor/src/terminal_ui.rs
@@ -10,7 +10,7 @@ use crossterm::{
     execute,
 };
 use hero_job::{Job, JobStatus, ScriptType};
-use log::{error, info};
+use log::error;
 use ratatui::{
     backend::{Backend, CrosstermBackend},
     layout::{Alignment, Constraint, Direction, Layout, Rect},
@@ -225,32 +225,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 +251,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 +271,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())
@@ -355,19 +328,15 @@ impl App {
     
     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 +346,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);