Smart Tree - ST

//! Integration helpers for easier Smart Tree usage in other applications //! //! This module provides simplified APIs and helper functions that make it easier //! to integrate Smart Tree functionality into other applications without dealing //! with all the low-level details. use anyhow::Result; use serde::{Deserialize, Serialize}; use std::path::{Path, PathBuf}; use std::time::SystemTime; use crate::{detect_project_context, FileNode, Scanner, ScannerConfig, TreeStats}; /// Simplified project analysis result optimized for external integrations #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ProjectAnalysis { pub project_path: PathBuf, pub project_type: String, pub project_name: String, pub total_files: usize, pub total_directories: usize, pub total_size: u64, pub key_files: Vec<String>, pub recent_files: Vec<String>, pub file_types: std::collections::HashMap<String, usize>, pub insights: Vec<String>, } /// Quick project analyzer for integration use cases pub struct ProjectAnalyzer { default_config: ScannerConfig, } impl Default for ProjectAnalyzer { fn default() -> Self { Self::new() } } impl ProjectAnalyzer { /// Create a new project analyzer with sensible defaults for integration pub fn new() -> Self { let config = ScannerConfig { max_depth: 10, show_hidden: false, respect_gitignore: true, ..ScannerConfig::default() }; Self { default_config: config, } } /// Analyze a project directory and return simplified results pub fn analyze_project(&self, project_path: &Path) -> Result<ProjectAnalysis> { let scanner = Scanner::new(project_path, self.default_config.clone())?; let (nodes, stats) = scanner.scan()?; // Detect project type let project_type = detect_project_context(project_path).unwrap_or_else(|| "Unknown".to_string()); // Get project name from directory let project_name = project_path .file_name() .and_then(|n| n.to_str()) .unwrap_or("Unknown") .to_string(); // Find key files let key_files = Self::extract_key_files(&nodes); // Find recent files (last hour) let recent_files = Self::find_recent_files(&nodes, 1); // Analyze file types let file_types = Self::analyze_file_types(&nodes); // Generate insights let insights = Self::generate_insights(&stats, &project_type, &nodes); Ok(ProjectAnalysis { project_path: project_path.to_path_buf(), project_type, project_name, total_files: stats.total_files as usize, total_directories: stats.total_dirs as usize, total_size: stats.total_size, key_files, recent_files, file_types, insights, }) } /// Quick analysis for dashboard use - limited depth and faster execution pub fn quick_analysis(&self, project_path: &Path) -> Result<ProjectAnalysis> { let mut config = self.default_config.clone(); config.max_depth = 2; // Very shallow for quick analysis let scanner = Scanner::new(project_path, config)?; let (_nodes, stats) = scanner.quick_scan()?; let project_type = detect_project_context(project_path).unwrap_or_else(|| "Unknown".to_string()); let project_name = project_path .file_name() .and_then(|n| n.to_str()) .unwrap_or("Unknown") .to_string(); Ok(ProjectAnalysis { project_path: project_path.to_path_buf(), project_type: project_type.clone(), project_name, total_files: stats.total_files as usize, total_directories: stats.total_dirs as usize, total_size: stats.total_size, key_files: vec![], // Skip for quick analysis recent_files: vec![], // Skip for quick analysis file_types: std::collections::HashMap::new(), // Skip for quick analysis insights: vec![format!( "{} project with {} files", project_type, stats.total_files )], }) } /// Find files modified within the last N hours pub fn find_recent_activity(&self, project_path: &Path, hours: u64) -> Result<Vec<FileNode>> { let scanner = Scanner::new(project_path, self.default_config.clone())?; scanner.find_recent_files(hours) } /// Get only key project files for quick overview pub fn get_key_files(&self, project_path: &Path) -> Result<Vec<FileNode>> { let scanner = Scanner::new(project_path, self.default_config.clone())?; scanner.find_key_files() } // Helper methods fn extract_key_files(nodes: &[FileNode]) -> Vec<String> { let important_patterns = [ "main.rs", "lib.rs", "mod.rs", "package.json", "Cargo.toml", "requirements.txt", "pyproject.toml", "README.md", "LICENSE", "Makefile", "CMakeLists.txt", "index.js", "app.js", "server.js", "main.js", "main.py", "__init__.py", "setup.py", "go.mod", "main.go", ]; let mut key_files = Vec::new(); for node in nodes { if !node.is_dir { let file_name = node.path.file_name().and_then(|n| n.to_str()).unwrap_or(""); for pattern in &important_patterns { if file_name == *pattern { key_files.push(node.path.to_string_lossy().to_string()); break; } } } } key_files.sort(); key_files.dedup(); key_files } fn find_recent_files(nodes: &[FileNode], hours_ago: u64) -> Vec<String> { let cutoff_time = SystemTime::now() - std::time::Duration::from_secs(hours_ago * 3600); nodes .iter() .filter(|node| !node.is_dir && node.modified > cutoff_time) .map(|node| node.path.to_string_lossy().to_string()) .collect() } fn analyze_file_types(nodes: &[FileNode]) -> std::collections::HashMap<String, usize> { let mut types = std::collections::HashMap::new(); for node in nodes { if !node.is_dir { let category = format!("{:?}", node.category); *types.entry(category).or_insert(0) += 1; } } types } fn generate_insights(stats: &TreeStats, project_type: &str, nodes: &[FileNode]) -> Vec<String> { let mut insights = Vec::new(); // Size insights if stats.total_files > 1000 { insights.push("Large codebase with extensive structure".to_string()); } else if stats.total_files > 100 { insights.push("Medium-sized project".to_string()); } else { insights.push("Focused project with concise structure".to_string()); } // Technology insights insights.push(format!("{} project", project_type)); // Feature detection let has_tests = nodes.iter().any(|n| { let path_str = n.path.to_string_lossy(); path_str.contains("test") || path_str.contains("spec") }); if has_tests { insights.push("Includes test suite".to_string()); } let has_docs = nodes.iter().any(|n| { let path_str = n.path.to_string_lossy(); path_str.contains("README") || path_str.contains("doc") }); if has_docs { insights.push("Well-documented project".to_string()); } insights } } /// Convenience function for one-off project analysis pub fn analyze_project(project_path: &Path) -> Result<ProjectAnalysis> { let analyzer = ProjectAnalyzer::new(); analyzer.analyze_project(project_path) } /// Convenience function for quick project overview pub fn quick_project_overview(project_path: &Path) -> Result<String> { let analyzer = ProjectAnalyzer::new(); let analysis = analyzer.quick_analysis(project_path)?; Ok(format!( "{} | {} ({} files, {} dirs)", analysis.project_name, analysis.project_type, analysis.total_files, analysis.total_directories )) }