n level recursion

Author: ODAncona

crates/code2prompt/src/model/file_tree.rs

@@ -24,6 +24,7 @@ pub struct FileNode {
     pub is_selected: bool,
     pub children: Vec<FileNode>,
     pub level: usize,
+    pub children_loaded: bool,
 }
 
 impl FileTreeState {
@@ -66,6 +67,15 @@ impl FileTreeState {
         Self::set_directory_expanded(&mut self.file_tree, &path_str, false);
     }
 
+    /// Load children for a directory if not already loaded
+    pub fn load_directory_children(
+        &mut self,
+        path: &std::path::Path,
+    ) -> Result<(), std::io::Error> {
+        let path_str = path.to_string_lossy();
+        Self::load_children_for_path(&mut self.file_tree, &path_str)
+    }
+
     fn toggle_directory_selection_recursive(nodes: &mut [FileNode], path: &str, selected: bool) {
         for node in nodes {
             if node.path.to_string_lossy() == path {
@@ -175,6 +185,39 @@ impl FileTreeState {
         // Fallback to contains
         text.to_lowercase().contains(&pattern.to_lowercase())
     }
+
+    /// Load children for a specific directory path
+    fn load_children_for_path(nodes: &mut [FileNode], path: &str) -> Result<(), std::io::Error> {
+        for node in nodes {
+            if node.path.to_string_lossy() == path && node.is_directory && !node.children_loaded {
+                // Load children from filesystem
+                let entries = std::fs::read_dir(&node.path)?;
+                let mut children = Vec::new();
+
+                for entry in entries {
+                    let entry = entry?;
+                    let child_path = entry.path();
+                    let child_node = FileNode::new(child_path, node.level + 1);
+                    children.push(child_node);
+                }
+
+                // Sort children (directories first, then alphabetically)
+                children.sort_by(|a, b| match (a.is_directory, b.is_directory) {
+                    (true, false) => std::cmp::Ordering::Less,
+                    (false, true) => std::cmp::Ordering::Greater,
+                    _ => a.name.cmp(&b.name),
+                });
+
+                node.children = children;
+                node.children_loaded = true;
+                return Ok(());
+            }
+            if !node.children.is_empty() {
+                Self::load_children_for_path(&mut node.children, path)?;
+            }
+        }
+        Ok(())
+    }
 }
 
 impl FileNode {
@@ -194,6 +237,7 @@ impl FileNode {
             is_selected: false,
             children: Vec::new(),
             level,
+            children_loaded: false,
         }
     }
 }

crates/code2prompt/src/model/mod.rs

@@ -255,12 +255,31 @@ impl Model {
                     if node.is_directory {
                         let node_path = node.path.clone();
                         let name = node.name.clone();
+                        let needs_loading = !node.children_loaded;
 
                         // Drop the immutable borrow before making mutable changes
                         drop(visible_nodes);
 
+                        // First, load children if needed
+                        if needs_loading {
+                            match new_model.file_tree.load_directory_children(&node_path) {
+                                Ok(_) => {
+                                    new_model.status_message =
+                                        format!("Loaded and expanded {}", name);
+                                }
+                                Err(e) => {
+                                    new_model.status_message =
+                                        format!("Failed to load children for {}: {}", name, e);
+                                    return (new_model, Cmd::None);
+                                }
+                            }
+                        }
+
+                        // Then expand the directory
                         new_model.file_tree.expand_directory(&node_path);
-                        new_model.status_message = format!("Expanded {}", name);
+                        if !needs_loading {
+                            new_model.status_message = format!("Expanded {}", name);
+                        }
                     }
                 }
                 (new_model, Cmd::None)

crates/code2prompt/src/tui.rs

@@ -30,7 +30,7 @@ pub enum InputMode {
     Normal,
     Search,
 }
-use crate::utils::build_file_tree_from_session;
+use crate::utils::{build_file_tree_from_session, build_lightweight_file_tree};
 
 pub struct TuiApp {
     model: Model,
@@ -575,14 +575,29 @@ impl TuiApp {
             }
 
             crate::model::Cmd::RefreshFileTree => {
-                // Build file tree using session data
-                match build_file_tree_from_session(&mut self.model.session) {
-                    Ok(tree) => {
-                        self.model.file_tree.set_file_tree(tree);
-                        self.model.status_message = "File tree refreshed".to_string();
+                // Use lightweight tree for initial navigation, full tree only when needed
+                if self.model.session.data.files.is_none() {
+                    // First time: use lightweight tree for fast startup
+                    match build_lightweight_file_tree(&self.model.session.config.path) {
+                        Ok(tree) => {
+                            self.model.file_tree.set_file_tree(tree);
+                            self.model.status_message =
+                                "File tree loaded (lightweight mode)".to_string();
+                        }
+                        Err(e) => {
+                            self.model.status_message = format!("Error loading files: {}", e);
+                        }
                     }
-                    Err(e) => {
-                        self.model.status_message = format!("Error loading files: {}", e);
+                } else {
+                    // Subsequent refreshes: use full tree with session data
+                    match build_file_tree_from_session(&mut self.model.session) {
+                        Ok(tree) => {
+                            self.model.file_tree.set_file_tree(tree);
+                            self.model.status_message = "File tree refreshed".to_string();
+                        }
+                        Err(e) => {
+                            self.model.status_message = format!("Error loading files: {}", e);
+                        }
                     }
                 }
             }

crates/code2prompt/src/utils.rs

@@ -12,10 +12,12 @@ use crate::model::FileNode;
 
 /// Build a file tree using session data from core traversal
 pub fn build_file_tree_from_session(session: &mut Code2PromptSession) -> Result<Vec<FileNode>> {
-    // Load codebase data using the session
-    session
-        .load_codebase()
-        .context("Failed to load codebase from session")?;
+    // Only load codebase if not already loaded (performance optimization)
+    if session.data.files.is_none() {
+        session
+            .load_codebase()
+            .context("Failed to load codebase from session")?;
+    }
 
     // Get the files data from session
     let files_data = session
@@ -42,12 +44,9 @@ pub fn build_file_tree_from_session(session: &mut Code2PromptSession) -> Result<
     Ok(root_nodes)
 }
 
-/// Build directory hierarchy from file paths - simplified approach
-fn build_directory_hierarchy(
-    root: &std::path::Path,
-    file_paths: &[String],
-) -> Result<Vec<FileNode>> {
-    let entries = fs::read_dir(root).context("Failed to read root directory")?;
+/// Build a lightweight file tree for navigation only (no file content loading)
+pub fn build_lightweight_file_tree(root_path: &std::path::Path) -> Result<Vec<FileNode>> {
+    let entries = fs::read_dir(root_path).context("Failed to read root directory")?;
     let mut root_children = Vec::new();
 
     for entry in entries {
@@ -56,81 +55,59 @@ fn build_directory_hierarchy(
 
         let mut node = FileNode::new(path, 0);
 
-        // Check if this file/directory should be selected based on session data
-        let relative_path = node.path.strip_prefix(root).unwrap_or(&node.path);
-        let relative_str = relative_path.to_string_lossy();
-
-        node.is_selected = file_paths.iter().any(|file_path| {
-            file_path == &relative_str || file_path.starts_with(&format!("{}/", relative_str))
-        });
-
-        // For directories, recursively load if they contain session files
+        // For directories, mark as not loaded for lazy loading
         if node.is_directory {
-            let has_session_files = file_paths
-                .iter()
-                .any(|file_path| file_path.starts_with(&format!("{}/", relative_str)));
-
-            if has_session_files {
-                // Load children for this directory since it contains files from session
-                if let Ok(children) = build_directory_children(root, &node.path, file_paths, 1) {
-                    node.children = children;
-                    node.is_expanded = true;
-                }
-            }
+            node.children_loaded = false;
         }
 
+        // Don't pre-select any files in lightweight mode
+        node.is_selected = false;
+
         root_children.push(node);
     }
 
+    // Sort nodes
+    root_children.sort_by(|a, b| match (a.is_directory, b.is_directory) {
+        (true, false) => std::cmp::Ordering::Less,
+        (false, true) => std::cmp::Ordering::Greater,
+        _ => a.name.cmp(&b.name),
+    });
+
     Ok(root_children)
 }
 
-/// Recursively build children for a directory  
-fn build_directory_children(
+/// Build directory hierarchy from file paths - simplified approach
+fn build_directory_hierarchy(
     root: &std::path::Path,
-    dir_path: &std::path::Path,
     file_paths: &[String],
-    level: usize,
 ) -> Result<Vec<FileNode>> {
-    if level > 3 {
-        return Ok(Vec::new()); // Prevent too deep recursion
-    }
-
-    let entries = fs::read_dir(dir_path).context("Failed to read directory")?;
-    let mut children = Vec::new();
+    let entries = fs::read_dir(root).context("Failed to read root directory")?;
+    let mut root_children = Vec::new();
 
     for entry in entries {
         let entry = entry.context("Failed to read directory entry")?;
         let path = entry.path();
 
-        let mut node = FileNode::new(path, level);
+        let mut node = FileNode::new(path, 0);
 
-        // Check selection against session data
+        // Check if this file/directory should be selected based on session data
         let relative_path = node.path.strip_prefix(root).unwrap_or(&node.path);
         let relative_str = relative_path.to_string_lossy();
 
-        node.is_selected = file_paths.contains(&relative_str.to_string());
+        node.is_selected = file_paths.iter().any(|file_path| {
+            file_path == &relative_str || file_path.starts_with(&format!("{}/", relative_str))
+        });
 
-        // Recursively load subdirectories that contain session files
+        // For directories, mark as not loaded for lazy loading
+        // This prevents initial recursive loading and improves performance
         if node.is_directory {
-            let has_session_files = file_paths
-                .iter()
-                .any(|file_path| file_path.starts_with(&format!("{}/", relative_str)));
-
-            if has_session_files {
-                if let Ok(grandchildren) =
-                    build_directory_children(root, &node.path, file_paths, level + 1)
-                {
-                    node.children = grandchildren;
-                    node.is_expanded = true;
-                }
-            }
+            node.children_loaded = false;
         }
 
-        children.push(node);
+        root_children.push(node);
     }
 
-    Ok(children)
+    Ok(root_children)
 }
 
 /// Sort file nodes (directories first, then alphabetically)