codesearch 0.1.12

//! Advanced Symbol Extraction and Indexing
//!
//! This module provides comprehensive symbol extraction for AI agent consumption.
//! It captures rich structural information including signatures, relationships,
//! hierarchies, and context without using LLM.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::Path;

#[cfg(feature = "mcp")]
use schemars::JsonSchema;

pub mod extractor;
pub mod indexer;
pub mod relationships;
pub mod context;

pub use extractor::{SymbolExtractor, extract_symbols_from_file};
pub use indexer::{SymbolIndex, SymbolIndexStore};
pub use relationships::RelationshipGraph;
pub use context::SymbolContext;

/// Comprehensive symbol information with rich metadata
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub struct Symbol {
    /// Unique identifier for the symbol
    pub id: String,

    /// Symbol name
    pub name: String,

    /// Symbol kind (function, class, method, variable, etc.)
    pub kind: SymbolKind,

    /// File path where symbol is defined
    pub file_path: String,

    /// Line number where symbol is defined
    pub line: usize,

    /// Column number where symbol is defined
    pub column: usize,

    /// End line number
    pub end_line: usize,

    /// Full signature with parameters and return types
    pub signature: String,

    /// Documentation comment (if any)
    pub documentation: Option<String>,

    /// Visibility (public, private, protected, etc.)
    pub visibility: SymbolVisibility,

    /// Parent symbol (for methods, nested classes, etc.)
    pub parent: Option<String>,

    /// Type information (if applicable)
    pub type_info: Option<TypeInfo>,

    /// Generic parameters (if applicable)
    pub generics: Vec<String>,

    /// Annotations/decorators
    pub annotations: Vec<String>,

    /// Attributes/modifiers
    pub attributes: Vec<String>,

    /// Language-specific metadata
    pub metadata: HashMap<String, String>,
}

/// Symbol kind classification
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub enum SymbolKind {
    // Top-level declarations
    Module,
    Package,
    Namespace,

    // Types
    Class,
    Interface,
    Trait,
    Struct,
    Enum,
    Union,
    TypeAlias,

    // Functions
    Function,
    Method,
    Constructor,
    Destructor,

    // Variables
    Variable,
    Field,
    Property,
    Parameter,
    Constant,

    // Other
    Macro,
    Import,
    Export,
    Unknown,
}

/// Visibility modifiers
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub enum SymbolVisibility {
    Public,
    Private,
    Protected,
    Internal,
    PackagePrivate,
    FilePrivate,
    None,
}

/// Type information
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub struct TypeInfo {
    /// Type name
    pub name: String,

    /// Type parameters
    pub parameters: Vec<String>,

    /// Return type (for functions)
    pub return_type: Option<Box<TypeInfo>>,

    /// Is nullable/optional
    pub nullable: bool,

    /// Type kind (primitive, object, array, etc.)
    pub kind: TypeKind,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub enum TypeKind {
    Primitive,
    Object,
    Array,
    Map,
    Tuple,
    Function,
    Union,
    Intersection,
    Unknown,
}

/// File-level symbol information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileSymbols {
    /// File path
    pub path: String,

    /// Language
    pub language: String,

    /// All symbols in this file
    pub symbols: Vec<Symbol>,

    /// Import statements
    pub imports: Vec<ImportInfo>,

    /// Export statements
    pub exports: Vec<ExportInfo>,

    /// File-level documentation
    pub file_doc: Option<String>,
}

/// Import information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImportInfo {
    /// Import path/module
    pub path: String,

    /// Imported symbols (if specific)
    pub symbols: Vec<String>,

    /// Alias (if renamed)
    pub alias: Option<String>,

    /// Is wildcard import
    pub is_wildcard: bool,

    /// Line number
    pub line: usize,
}

/// Export information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportInfo {
    /// Exported symbol name
    pub name: String,

    /// Alias (if renamed)
    pub alias: Option<String>,

    /// Line number
    pub line: usize,
}

/// Symbol search result with context
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub struct SymbolSearchResult {
    /// The matching symbol
    pub symbol: Symbol,

    /// Relevance score (0-100)
    pub score: f64,

    /// Context lines before the symbol
    pub context_before: Vec<String>,

    /// Context lines after the symbol
    pub context_after: Vec<String>,

    /// Related symbols
    pub related_symbols: Vec<SymbolRelation>,
}

/// Relationship between symbols
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub struct SymbolRelation {
    /// Related symbol ID
    pub symbol_id: String,

    /// Relationship type
    pub relation_type: SymbolRelationType,

    /// Confidence score (0-1)
    pub confidence: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "mcp", derive(schemars::JsonSchema))]
pub enum SymbolRelationType {
    Inherits,
    Implements,
    Calls,
    CalledBy,
    Contains,
    ContainedIn,
    References,
    ReferencedBy,
    Overrides,
    OverriddenBy,
    Instantiates,
    InstantiatedBy,
    ParameterOf,
    ReturnTypeOf,
    FieldOf,
    MethodOf,
    Imports,
    ImportedBy,
    Exports,
    ExportedBy,
}

/// Index statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IndexStats {
    /// Total number of symbols indexed
    pub total_symbols: usize,

    /// Number of files indexed
    pub total_files: usize,

    /// Symbols by kind
    pub symbols_by_kind: HashMap<String, usize>,

    /// Symbols by language
    pub symbols_by_language: HashMap<String, usize>,

    /// Index size in bytes
    pub index_size_bytes: u64,

    /// Last update time
    pub last_updated: chrono::DateTime<chrono::Utc>,
}

impl Symbol {
    /// Create a unique symbol ID
    pub fn create_id(file_path: &str, name: &str, kind: &SymbolKind, line: usize) -> String {
        format!("{}:{}:{}:{}",
            file_path.replace("/", "_").replace(".", "_"),
            name,
            format!("{:?}", kind),
            line
        )
    }

    /// Get the qualified name (including parent if any)
    pub fn qualified_name(&self) -> String {
        if let Some(ref parent) = self.parent {
            format!("{}.{}", parent, self.name)
        } else {
            self.name.clone()
        }
    }

    /// Check if this is a public symbol
    pub fn is_public(&self) -> bool {
        matches!(self.visibility, SymbolVisibility::Public)
    }

    /// Check if this is a type symbol
    pub fn is_type(&self) -> bool {
        matches!(
            self.kind,
            SymbolKind::Class |
            SymbolKind::Interface |
            SymbolKind::Trait |
            SymbolKind::Struct |
            SymbolKind::Enum |
            SymbolKind::Union
        )
    }

    /// Check if this is a function/method
    pub fn is_function(&self) -> bool {
        matches!(
            self.kind,
            SymbolKind::Function |
            SymbolKind::Method |
            SymbolKind::Constructor
        )
    }

    /// Get display name with signature
    pub fn display_name(&self) -> String {
        if self.signature.is_empty() {
            self.name.clone()
        } else {
            format!("{}{}", self.name, self.signature)
        }
    }
}

impl std::fmt::Display for SymbolKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SymbolKind::Module => write!(f, "module"),
            SymbolKind::Package => write!(f, "package"),
            SymbolKind::Namespace => write!(f, "namespace"),
            SymbolKind::Class => write!(f, "class"),
            SymbolKind::Interface => write!(f, "interface"),
            SymbolKind::Trait => write!(f, "trait"),
            SymbolKind::Struct => write!(f, "struct"),
            SymbolKind::Enum => write!(f, "enum"),
            SymbolKind::Union => write!(f, "union"),
            SymbolKind::TypeAlias => write!(f, "type"),
            SymbolKind::Function => write!(f, "function"),
            SymbolKind::Method => write!(f, "method"),
            SymbolKind::Constructor => write!(f, "constructor"),
            SymbolKind::Destructor => write!(f, "destructor"),
            SymbolKind::Variable => write!(f, "variable"),
            SymbolKind::Field => write!(f, "field"),
            SymbolKind::Property => write!(f, "property"),
            SymbolKind::Parameter => write!(f, "parameter"),
            SymbolKind::Constant => write!(f, "constant"),
            SymbolKind::Macro => write!(f, "macro"),
            SymbolKind::Import => write!(f, "import"),
            SymbolKind::Export => write!(f, "export"),
            SymbolKind::Unknown => write!(f, "unknown"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_symbol_id_creation() {
        let id = Symbol::create_id("src/main.rs", "test_func", &SymbolKind::Function, 42);
        assert!(id.contains("src_main_rs"));
        assert!(id.contains("test_func"));
        assert!(id.contains("42"));
    }

    #[test]
    fn test_qualified_name() {
        let symbol = Symbol {
            id: "test".to_string(),
            name: "method".to_string(),
            kind: SymbolKind::Method,
            file_path: "test.rs".to_string(),
            line: 10,
            column: 0,
            end_line: 15,
            signature: "()".to_string(),
            documentation: None,
            visibility: SymbolVisibility::Public,
            parent: Some("MyClass".to_string()),
            type_info: None,
            generics: vec![],
            annotations: vec![],
            attributes: vec![],
            metadata: HashMap::new(),
        };

        assert_eq!(symbol.qualified_name(), "MyClass.method");
    }

    #[test]
    fn test_symbol_type_checks() {
        let class_symbol = Symbol {
            id: "test".to_string(),
            name: "MyClass".to_string(),
            kind: SymbolKind::Class,
            file_path: "test.rs".to_string(),
            line: 10,
            column: 0,
            end_line: 15,
            signature: "".to_string(),
            documentation: None,
            visibility: SymbolVisibility::Public,
            parent: None,
            type_info: None,
            generics: vec![],
            annotations: vec![],
            attributes: vec![],
            metadata: HashMap::new(),
        };

        assert!(class_symbol.is_type());
        assert!(!class_symbol.is_function());

        let func_symbol = Symbol {
            id: "test2".to_string(),
            name: "my_func".to_string(),
            kind: SymbolKind::Function,
            file_path: "test.rs".to_string(),
            line: 20,
            column: 0,
            end_line: 25,
            signature: "()".to_string(),
            documentation: None,
            visibility: SymbolVisibility::Public,
            parent: None,
            type_info: None,
            generics: vec![],
            annotations: vec![],
            attributes: vec![],
            metadata: HashMap::new(),
        };

        assert!(!func_symbol.is_type());
        assert!(func_symbol.is_function());
    }
}