st/smart/

smart_ls.rs

//! 📂 SmartLS - Task-Aware Directory Intelligence
//!
//! This module provides intelligent directory listings that understand
//! the user's current task and prioritize files by relevance, achieving
//! significant token savings while improving workflow efficiency.

use super::context::ContextAnalyzer;
use super::{SmartResponse, TaskContext, TokenSavings};
use crate::scanner::{FileNode, Scanner, ScannerConfig};
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::path::Path;

/// 📂 Smart directory lister with task awareness
pub struct SmartLS {
    context_analyzer: ContextAnalyzer,
}

/// 📁 Smart directory entry with relevance scoring
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SmartDirEntry {
    /// File node information
    pub node: FileNode,
    /// Relevance score for current task
    pub relevance: super::RelevanceScore,
    /// Suggested actions for this file
    pub suggested_actions: Vec<String>,
}

/// 📊 Smart directory listing response
pub type SmartLSResponse = SmartResponse<SmartDirEntry>;

impl SmartLS {
    /// Create new smart directory lister
    pub fn new() -> Self {
        Self {
            context_analyzer: ContextAnalyzer::new(),
        }
    }

    /// 📂 List directory with task awareness
    pub fn list_smart(
        &self,
        path: &Path,
        context: &TaskContext,
        max_depth: Option<usize>,
    ) -> Result<SmartLSResponse> {
        // Scan directory
        let config = ScannerConfig {
            max_depth: max_depth.unwrap_or(2),
            show_hidden: false,
            follow_symlinks: false,
            ..Default::default()
        };

        let scanner = Scanner::new(path, config)?;
        let (nodes, _stats) = scanner.scan()?;

        // Score and categorize files
        let scored_entries = self.score_and_categorize(&nodes, context)?;

        // Split into primary and secondary based on relevance
        let (primary, secondary) = self.split_by_relevance(&scored_entries, context);

        // Calculate token savings
        let original_tokens = self.estimate_tokens_for_all(&nodes);
        let compressed_tokens = self.estimate_tokens_for_entries(&primary)
            + self.estimate_tokens_for_entries(&secondary);
        let token_savings = TokenSavings::new(original_tokens, compressed_tokens, "smart-ls");

        // Generate context summary and suggestions
        let context_summary = self.generate_context_summary(&primary, &secondary, context);
        let suggestions = self.generate_suggestions(&primary, &secondary, context);

        Ok(SmartLSResponse {
            primary,
            secondary,
            context_summary,
            token_savings,
            suggestions,
        })
    }

    /// Score and categorize directory entries
    fn score_and_categorize(
        &self,
        nodes: &[FileNode],
        context: &TaskContext,
    ) -> Result<Vec<SmartDirEntry>> {
        let mut entries = Vec::new();

        for node in nodes {
            let relevance = if node.is_dir {
                self.context_analyzer
                    .score_directory_relevance(node, context)
            } else {
                self.context_analyzer.score_file_relevance(node, context)
            };

            let suggested_actions = self.generate_file_actions(node, context, &relevance);

            entries.push(SmartDirEntry {
                node: node.clone(),
                relevance,
                suggested_actions,
            });
        }

        // Sort by relevance score
        entries.sort_by(|a, b| b.relevance.score.partial_cmp(&a.relevance.score).unwrap());

        Ok(entries)
    }

    /// Split entries by relevance threshold
    fn split_by_relevance(
        &self,
        entries: &[SmartDirEntry],
        context: &TaskContext,
    ) -> (Vec<SmartDirEntry>, Vec<SmartDirEntry>) {
        let mut primary = Vec::new();
        let mut secondary = Vec::new();

        for entry in entries {
            if entry.relevance.score >= context.relevance_threshold {
                primary.push(entry.clone());
            } else if entry.relevance.score >= context.relevance_threshold * 0.6 {
                secondary.push(entry.clone());
            }
            // Entries below 60% of threshold are filtered out
        }

        // Limit results if specified
        if let Some(max_results) = context.max_results {
            primary.truncate(max_results / 2);
            secondary.truncate(max_results / 2);
        }

        (primary, secondary)
    }

    /// Generate suggested actions for a file
    fn generate_file_actions(
        &self,
        node: &FileNode,
        context: &TaskContext,
        relevance: &super::RelevanceScore,
    ) -> Vec<String> {
        let mut actions = Vec::new();

        if node.is_dir {
            actions.push("Explore directory".to_string());
            if relevance.score > 0.7 {
                actions.push("Analyze contents".to_string());
            }
        } else {
            actions.push("Read file".to_string());
            if relevance.score > 0.8 {
                actions.push("Smart read with context".to_string());
            }

            // Task-specific suggestions
            for focus_area in &context.focus_areas {
                match focus_area {
                    super::FocusArea::Testing
                        if node
                            .path
                            .file_name()
                            .and_then(|n| n.to_str())
                            .unwrap_or("")
                            .contains("test") =>
                    {
                        actions.push("Run tests".to_string());
                    }
                    super::FocusArea::Configuration
                        if {
                            let name = node.path.file_name().and_then(|n| n.to_str()).unwrap_or("");
                            name.ends_with(".json") || name.ends_with(".yaml")
                        } =>
                    {
                        actions.push("Edit configuration".to_string());
                    }
                    super::FocusArea::API
                        if {
                            let name = node.path.file_name().and_then(|n| n.to_str()).unwrap_or("");
                            name.contains("api") || name.contains("handler")
                        } =>
                    {
                        actions.push("Analyze API endpoints".to_string());
                    }
                    _ => {}
                }
            }
        }

        actions
    }

    /// Estimate tokens for all nodes
    fn estimate_tokens_for_all(&self, nodes: &[FileNode]) -> usize {
        // Rough estimation based on file count and average metadata size
        nodes.len() * 50 // ~50 tokens per file entry
    }

    /// Estimate tokens for smart entries
    fn estimate_tokens_for_entries(&self, entries: &[SmartDirEntry]) -> usize {
        // Smart entries have more metadata but are filtered
        entries.len() * 30 // ~30 tokens per smart entry
    }

    /// Generate context summary
    fn generate_context_summary(
        &self,
        primary: &[SmartDirEntry],
        _secondary: &[SmartDirEntry],
        _context: &TaskContext,
    ) -> String {
        format!(
            "SmartLS analyzed directory. Found {} high-priority items.",
            primary.len()
        )
    }

    /// Generate proactive suggestions
    fn generate_suggestions(
        &self,
        primary: &[SmartDirEntry],
        _secondary: &[SmartDirEntry],
        _context: &TaskContext,
    ) -> Vec<String> {
        let mut suggestions = Vec::new();

        if primary.is_empty() {
            suggestions.push(
                "No high-priority files found. Consider broadening the task context.".to_string(),
            );
        }

        // Suggest related tools based on file types found
        let has_config = primary.iter().any(|e| {
            let name = e
                .node
                .path
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("");
            name.ends_with(".json") || name.ends_with(".yaml")
        });
        let has_code = primary.iter().any(|e| {
            matches!(
                e.node.category,
                crate::scanner::FileCategory::Rust
                    | crate::scanner::FileCategory::Python
                    | crate::scanner::FileCategory::JavaScript
            )
        });

        if has_config {
            suggestions
                .push("Use find_config_files for detailed configuration analysis.".to_string());
        }

        if has_code {
            suggestions.push("Use find_code_files for comprehensive code discovery.".to_string());
        }

        suggestions
    }
}

impl Default for SmartLS {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    // use std::path::PathBuf;  // Commented out as unused

    #[test]
    fn test_smart_ls_creation() {
        let _smart_ls = SmartLS::new();
        // Basic creation test - verify it was created
        // SmartLS structure verified by successful creation
    }
}