Feat - add search for searching a file, filetype or keyword

Author: caffienerd

README.md

@@ -45,7 +45,7 @@ sudo cp target/release/struct /usr/local/bin/
 ```bash
 struct 3              # Show structure up to depth 3
 struct 0              # Show everything (infinite depth)
-struct --size 2       # Show file sizes
+struct -z 2           # Show file sizes
 struct -g 2           # Git-tracked files only
 struct -s 100 3       # Skip folders larger than 100MB
 struct -i "*.log" 2   # Add custom ignore patterns
@@ -65,6 +65,19 @@ struct clear                    # Reset config
 
 Config is stored in `~/.config/struct/ignores.txt`
 
+### Search
+
+Find files by pattern across your project:
+
+```bash
+struct search "*.env"           # Find all .env files
+struct search "config*"         # Find files starting with "config"
+struct search "test*.py"        # Find Python test files
+struct search "Cargo.toml" ~    # Search from home directory
+```
+
+Shows file paths with sizes, skips ignored directories for speed.
+
 ## Auto-Ignored Directories
 
 Common bloat folders are hidden by default:

src/main.rs

@@ -92,6 +92,134 @@ fn clear_config_patterns() {
     }
 }
 
+fn search_files(pattern: &str, start_path: &Path) {
+    // Convert glob pattern to regex
+    let regex_pattern = pattern.replace("*", ".*").replace("?", ".");
+    let re = match Regex::new(&format!("^{}$", regex_pattern)) {
+        Ok(r) => r,
+        Err(e) => {
+            eprintln!("invalid pattern: {}", e);
+            return;
+        }
+    };
+
+    let mut found_count = 0;
+    let mut matching_paths: HashSet<PathBuf> = HashSet::new();
+
+    // Search through all files
+    for entry in WalkDir::new(start_path)
+        .into_iter()
+        .filter_entry(|e| {
+            // Skip common ignore directories to make search faster
+            if let Some(name) = e.file_name().to_str() {
+                !should_ignore_dir(name)
+            } else {
+                true
+            }
+        })
+        .filter_map(|e| e.ok())
+    {
+        if entry.file_type().is_file() {
+            if let Some(filename) = entry.file_name().to_str() {
+                if re.is_match(filename) {
+                    // Add the file path
+                    let file_path = entry.path().to_path_buf();
+                    matching_paths.insert(file_path.clone());
+                    
+                    // Add all parent directories
+                    let mut current = file_path.parent();
+                    while let Some(parent) = current {
+                        if parent == start_path {
+                            break;
+                        }
+                        matching_paths.insert(parent.to_path_buf());
+                        current = parent.parent();
+                    }
+                    
+                    found_count += 1;
+                }
+            }
+        }
+    }
+
+    if found_count == 0 {
+        println!("{}", format!("no files matching '{}' found", pattern).yellow());
+        return;
+    }
+
+    println!("{} {}", format!("found {} file(s) matching", found_count).green(), pattern.cyan());
+    println!();
+    
+    // Display as tree
+    display_search_tree(start_path, &matching_paths, 0, "", true);
+}
+
+fn display_search_tree(
+    path: &Path,
+    matching_paths: &HashSet<PathBuf>,
+    current_depth: usize,
+    prefix: &str,
+    _is_last: bool,
+) {
+    let mut entries: Vec<_> = match fs::read_dir(path) {
+        Ok(entries) => entries
+            .filter_map(|e| e.ok())
+            .filter(|e| {
+                let entry_path = e.path();
+                // Only show entries that are in our matching set or are parents of matches
+                matching_paths.contains(&entry_path) || 
+                matching_paths.iter().any(|p| p.starts_with(&entry_path))
+            })
+            .collect(),
+        Err(_) => return,
+    };
+
+    // Sort: directories first, then alphabetically
+    entries.sort_by_key(|e| {
+        let path = e.path();
+        let is_dir = path.is_dir();
+        let name = e.file_name().to_string_lossy().to_lowercase();
+        (!is_dir, name)
+    });
+
+    let total = entries.len();
+
+    for (idx, entry) in entries.iter().enumerate() {
+        let is_last_entry = idx == total - 1;
+        let entry_path = entry.path();
+        let name = entry.file_name().to_string_lossy().to_string();
+        let is_dir = entry_path.is_dir();
+
+        let connector = if is_last_entry { "└── " } else { "├── " };
+        
+        if is_dir {
+            let dir_name = format!("{}/", name).blue().bold();
+            println!("{}{}{}", prefix, connector, dir_name);
+            
+            let new_prefix = if is_last_entry {
+                format!("{}    ", prefix)
+            } else {
+                format!("{}│   ", prefix)
+            };
+            display_search_tree(&entry_path, matching_paths, current_depth + 1, &new_prefix, is_last_entry);
+        } else {
+            // This is a matching file
+            let file_name = if is_executable(&entry_path) {
+                name.green().bold()
+            } else {
+                name.cyan().bold()
+            };
+            
+            if let Ok(metadata) = fs::metadata(&entry_path) {
+                let size_str = format!(" ({})", format_size(metadata.len())).bright_black();
+                println!("{}{}{}{}", prefix, connector, file_name, size_str);
+            } else {
+                println!("{}{}{}", prefix, connector, file_name);
+            }
+        }
+    }
+}
+
 #[derive(Parser, Debug)]
 #[command(name = "struct")]
 #[command(about = "A smarter tree command with intelligent defaults", long_about = None)]
@@ -140,6 +268,14 @@ enum Commands {
     List,
     /// Clear all custom ignore patterns
     Clear,
+    /// Search for files matching a pattern
+    Search {
+        /// Pattern to search for (e.g., "*.env", "config", "test*")
+        pattern: String,
+        /// Starting directory
+        #[arg(default_value = ".")]
+        path: PathBuf,
+    },
 }
 
 struct StructConfig {
@@ -172,6 +308,10 @@ fn main() {
                 clear_config_patterns();
                 return;
             }
+            Commands::Search { pattern, path } => {
+                search_files(&pattern, &path);
+                return;
+            }
         }
     }