aurora_semantic/

config.rs

//! Configuration types for the aurora-semantic engine.

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

use crate::types::Language;

/// Main configuration for the semantic search engine.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EngineConfig {
    /// Directory where indexes are stored.
    pub index_dir: PathBuf,
    /// Chunking configuration.
    pub chunking: ChunkingConfig,
    /// Embedding configuration.
    pub embedding: EmbeddingConfig,
    /// Search configuration.
    pub search: SearchConfig,
    /// Ignore patterns configuration.
    pub ignore: IgnoreConfig,
    /// Performance tuning.
    pub performance: PerformanceConfig,
}

impl EngineConfig {
    /// Create a new configuration with the given index directory.
    pub fn new(index_dir: PathBuf) -> Self {
        Self {
            index_dir,
            chunking: ChunkingConfig::default(),
            embedding: EmbeddingConfig::default(),
            search: SearchConfig::default(),
            ignore: IgnoreConfig::default(),
            performance: PerformanceConfig::default(),
        }
    }

    /// Builder-style method to set chunking config.
    pub fn with_chunking(mut self, config: ChunkingConfig) -> Self {
        self.chunking = config;
        self
    }

    /// Builder-style method to set embedding config.
    pub fn with_embedding(mut self, config: EmbeddingConfig) -> Self {
        self.embedding = config;
        self
    }

    /// Builder-style method to set search config.
    pub fn with_search(mut self, config: SearchConfig) -> Self {
        self.search = config;
        self
    }

    /// Builder-style method to set ignore config.
    pub fn with_ignore(mut self, config: IgnoreConfig) -> Self {
        self.ignore = config;
        self
    }

    /// Builder-style method to set performance config.
    pub fn with_performance(mut self, config: PerformanceConfig) -> Self {
        self.performance = config;
        self
    }
}

impl Default for EngineConfig {
    fn default() -> Self {
        Self::new(PathBuf::from(".aurora"))
    }
}

/// Configuration for code chunking.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChunkingConfig {
    /// Maximum chunk size in characters.
    pub max_chunk_size: usize,
    /// Minimum chunk size in characters.
    pub min_chunk_size: usize,
    /// Whether to extract documentation comments.
    pub extract_comments: bool,
}

impl Default for ChunkingConfig {
    fn default() -> Self {
        Self {
            max_chunk_size: 2000,
            min_chunk_size: 50,
            extract_comments: true,
        }
    }
}

/// Configuration for embedding generation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingConfig {
    /// Embedding dimension.
    pub dimension: usize,
    /// Batch size for embedding generation.
    pub batch_size: usize,
    /// Maximum sequence length.
    pub max_length: usize,
    /// Whether to normalize embeddings.
    pub normalize: bool,
}

impl Default for EmbeddingConfig {
    fn default() -> Self {
        Self {
            dimension: 768, // Common for code models like jina-code
            batch_size: 32,
            max_length: 512,
            normalize: true,
        }
    }
}

/// Configuration for search behavior.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchConfig {
    /// Default number of results to return.
    pub default_limit: usize,
    /// Maximum number of results to return.
    pub max_limit: usize,
    /// Default search mode.
    pub default_mode: SearchMode,
    /// Weight for lexical results in hybrid search (0.0 to 1.0).
    pub lexical_weight: f32,
    /// Weight for semantic results in hybrid search (0.0 to 1.0).
    pub semantic_weight: f32,
    /// Minimum score threshold for results (0.0 to 1.0).
    pub min_score: f32,
    /// Enable fuzzy matching in lexical search.
    pub fuzzy_matching: bool,
    /// Fuzzy matching distance (edit distance).
    pub fuzzy_distance: u8,
}

impl Default for SearchConfig {
    fn default() -> Self {
        Self {
            default_limit: 20,
            max_limit: 100,
            default_mode: SearchMode::Hybrid,
            lexical_weight: 0.4,
            semantic_weight: 0.6,
            min_score: 0.1,
            fuzzy_matching: true,
            fuzzy_distance: 2,
        }
    }
}

/// Search mode selection.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SearchMode {
    /// Keyword-based lexical search only.
    Lexical,
    /// Embedding-based semantic search only.
    Semantic,
    /// Combined lexical and semantic search.
    Hybrid,
}

impl Default for SearchMode {
    fn default() -> Self {
        Self::Hybrid
    }
}

/// Configuration for ignore patterns.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IgnoreConfig {
    /// Respect .gitignore files.
    pub use_gitignore: bool,
    /// Respect .ignore files.
    pub use_ignore_files: bool,
    /// Additional patterns to ignore.
    pub patterns: Vec<String>,
    /// File extensions to ignore.
    pub ignored_extensions: Vec<String>,
    /// Directories to always ignore.
    pub ignored_directories: Vec<String>,
    /// Maximum file size to index (in bytes).
    pub max_file_size: u64,
}

impl Default for IgnoreConfig {
    fn default() -> Self {
        Self {
            use_gitignore: true,
            use_ignore_files: true,
            patterns: vec![],
            ignored_extensions: vec![
                "exe".into(), "dll".into(), "so".into(), "dylib".into(),
                "bin".into(), "obj".into(), "o".into(), "a".into(), "lib".into(),
                "png".into(), "jpg".into(), "jpeg".into(), "gif".into(), "ico".into(),
                "svg".into(), "woff".into(), "woff2".into(), "ttf".into(), "eot".into(),
                "mp3".into(), "mp4".into(), "avi".into(), "mov".into(),
                "zip".into(), "tar".into(), "gz".into(), "rar".into(), "7z".into(),
                "pdf".into(), "doc".into(), "docx".into(),
            ],
            ignored_directories: vec![
                "node_modules".into(), ".git".into(), ".svn".into(), ".hg".into(),
                "target".into(), "build".into(), "dist".into(), "out".into(),
                ".next".into(), ".nuxt".into(), "__pycache__".into(),
                ".pytest_cache".into(), ".mypy_cache".into(),
                "venv".into(), ".venv".into(), "vendor".into(),
                ".idea".into(), ".vscode".into(), ".vs".into(),
            ],
            max_file_size: 1024 * 1024, // 1MB
        }
    }
}

/// Performance tuning configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceConfig {
    /// Number of threads for parallel processing.
    pub num_threads: usize,
    /// Memory limit for indexing (in bytes).
    pub memory_limit: usize,
    /// Enable incremental indexing.
    pub incremental: bool,
}

impl Default for PerformanceConfig {
    fn default() -> Self {
        Self {
            num_threads: std::thread::available_parallelism()
                .map(|p| p.get())
                .unwrap_or(4),
            memory_limit: 512 * 1024 * 1024, // 512MB
            incremental: true,
        }
    }
}

/// Configuration for a specific workspace.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkspaceConfig {
    /// Root path of the workspace.
    pub root_path: PathBuf,
    /// Workspace-specific ignore patterns (in addition to global).
    pub additional_ignores: Vec<String>,
    /// Languages to index (None = all).
    pub languages: Option<Vec<Language>>,
    /// Watch for file changes.
    pub watch_changes: bool,
}

impl WorkspaceConfig {
    /// Create a new workspace configuration.
    pub fn new(root_path: PathBuf) -> Self {
        Self {
            root_path,
            additional_ignores: vec![],
            languages: None,
            watch_changes: false,
        }
    }

    /// Builder-style method to add ignore patterns.
    pub fn with_ignores(mut self, patterns: Vec<String>) -> Self {
        self.additional_ignores = patterns;
        self
    }

    /// Builder-style method to set languages.
    pub fn with_languages(mut self, languages: Vec<Language>) -> Self {
        self.languages = Some(languages);
        self
    }

    /// Builder-style method to enable file watching.
    pub fn with_watch(mut self) -> Self {
        self.watch_changes = true;
        self
    }
}