mcp-vector-search 0.0.3__py3-none-any.whl

mcp_vector_search/cli/main.py

@@ -0,0 +1,117 @@
+"""Main CLI application for MCP Vector Search."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from loguru import logger
+from rich.console import Console
+from rich.traceback import install
+
+from .. import __version__
+from .commands.config import config_app
+from .commands.index import index_app
+from .commands.init import init_app
+from .commands.search import search_app
+from .commands.status import status_app
+from .commands.watch import app as watch_app
+from .output import setup_logging
+
+# Install rich traceback handler
+install(show_locals=True)
+
+# Create console for rich output
+console = Console()
+
+# Create main Typer app
+app = typer.Typer(
+    name="mcp-vector-search",
+    help="CLI-first semantic code search with MCP integration",
+    add_completion=False,
+    rich_markup_mode="rich",
+)
+
+# Add subcommands
+app.add_typer(init_app, name="init", help="Initialize project for semantic search")
+app.add_typer(index_app, name="index", help="Index codebase for semantic search")
+app.add_typer(search_app, name="search", help="Search code semantically")
+app.add_typer(status_app, name="status", help="Show project status and statistics")
+app.add_typer(config_app, name="config", help="Manage project configuration")
+app.add_typer(watch_app, name="watch", help="Watch for file changes and update index")
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False, "--version", "-v", help="Show version and exit"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", help="Enable verbose logging"
+    ),
+    quiet: bool = typer.Option(
+        False, "--quiet", help="Suppress non-error output"
+    ),
+    project_root: Optional[Path] = typer.Option(
+        None,
+        "--project-root",
+        "-p",
+        help="Project root directory (auto-detected if not specified)",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+    ),
+) -> None:
+    """MCP Vector Search - CLI-first semantic code search with MCP integration.
+    
+    A modern, lightweight tool for semantic code search using ChromaDB and Tree-sitter.
+    Designed for local development with optional MCP server integration.
+    """
+    if version:
+        console.print(f"mcp-vector-search version {__version__}")
+        raise typer.Exit()
+
+    # Setup logging
+    log_level = "DEBUG" if verbose else "WARNING" if quiet else "INFO"
+    setup_logging(log_level)
+
+    # Store global options in context
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+    ctx.obj["quiet"] = quiet
+    ctx.obj["project_root"] = project_root
+
+    if verbose:
+        logger.info(f"MCP Vector Search v{__version__}")
+        if project_root:
+            logger.info(f"Using project root: {project_root}")
+
+
+@app.command()
+def version() -> None:
+    """Show version information."""
+    console.print(f"[bold blue]mcp-vector-search[/bold blue] version [green]{__version__}[/green]")
+    console.print("\n[dim]CLI-first semantic code search with MCP integration[/dim]")
+    console.print("[dim]Built with ChromaDB, Tree-sitter, and modern Python[/dim]")
+
+
+@app.command()
+def doctor() -> None:
+    """Check system dependencies and configuration."""
+    from .commands.status import check_dependencies
+    
+    console.print("[bold blue]MCP Vector Search - System Check[/bold blue]\n")
+    
+    # Check dependencies
+    deps_ok = check_dependencies()
+    
+    if deps_ok:
+        console.print("\n[green]✓ All dependencies are available[/green]")
+    else:
+        console.print("\n[red]✗ Some dependencies are missing[/red]")
+        console.print("Run [code]pip install mcp-vector-search[/code] to install missing dependencies")
+
+
+if __name__ == "__main__":
+    app()

mcp_vector_search/cli/output.py

@@ -0,0 +1,242 @@
+"""Rich formatting and display utilities for CLI."""
+
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TimeElapsedColumn,
+)
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+from ..core.models import ProjectInfo, SearchResult
+
+# Global console instance
+console = Console()
+
+
+def setup_logging(level: str = "INFO") -> None:
+    """Setup structured logging with rich formatting.
+    
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR)
+    """
+    # Remove default handler
+    logger.remove()
+    
+    # Add console handler with rich formatting
+    logger.add(
+        sys.stderr,
+        level=level,
+        format="<green>{time:HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+        colorize=True,
+    )
+
+
+def print_success(message: str) -> None:
+    """Print success message."""
+    console.print(f"[green]✓[/green] {message}")
+
+
+def print_error(message: str) -> None:
+    """Print error message."""
+    console.print(f"[red]✗[/red] {message}")
+
+
+def print_warning(message: str) -> None:
+    """Print warning message."""
+    console.print(f"[yellow]⚠[/yellow] {message}")
+
+
+def print_info(message: str) -> None:
+    """Print info message."""
+    console.print(f"[blue]ℹ[/blue] {message}")
+
+
+def create_progress() -> Progress:
+    """Create a progress bar for long-running operations."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+
+def print_project_info(project_info: ProjectInfo) -> None:
+    """Print project information in a formatted table."""
+    table = Table(title="Project Information", show_header=False)
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    
+    table.add_row("Name", project_info.name)
+    table.add_row("Root Path", str(project_info.root_path))
+    table.add_row("Config Path", str(project_info.config_path))
+    table.add_row("Index Path", str(project_info.index_path))
+    table.add_row("Initialized", "✓" if project_info.is_initialized else "✗")
+    table.add_row("Languages", ", ".join(project_info.languages) if project_info.languages else "None detected")
+    table.add_row("Indexable Files", str(project_info.file_count))
+    
+    console.print(table)
+
+
+def print_search_results(
+    results: List[SearchResult],
+    query: str,
+    show_content: bool = True,
+    max_content_lines: int = 10,
+) -> None:
+    """Print search results in a formatted display."""
+    if not results:
+        print_warning(f"No results found for query: '{query}'")
+        return
+    
+    console.print(f"\n[bold blue]Search Results for:[/bold blue] [green]'{query}'[/green]")
+    console.print(f"[dim]Found {len(results)} results[/dim]\n")
+    
+    for i, result in enumerate(results, 1):
+        # Create result header
+        header = f"[bold]{i}. {result.file_path.name}[/bold]"
+        if result.function_name:
+            header += f" → [cyan]{result.function_name}()[/cyan]"
+        if result.class_name:
+            header += f" in [yellow]{result.class_name}[/yellow]"
+        
+        # Add location and similarity
+        location = f"[dim]{result.location}[/dim]"
+        similarity = f"[green]{result.similarity_score:.2%}[/green]"
+        
+        console.print(f"{header}")
+        console.print(f"  {location} | Similarity: {similarity}")
+        
+        # Show code content if requested
+        if show_content and result.content:
+            content_lines = result.content.splitlines()
+            if len(content_lines) > max_content_lines:
+                content_lines = content_lines[:max_content_lines]
+                content_lines.append("...")
+            
+            content = "\n".join(content_lines)
+            
+            # Create syntax-highlighted code block
+            syntax = Syntax(
+                content,
+                result.language,
+                theme="monokai",
+                line_numbers=True,
+                start_line=result.start_line,
+                word_wrap=True,
+            )
+            
+            console.print(Panel(syntax, border_style="dim"))
+        
+        console.print()  # Empty line between results
+
+
+def print_index_stats(stats: Dict[str, Any]) -> None:
+    """Print indexing statistics."""
+    table = Table(title="Index Statistics", show_header=False)
+    table.add_column("Metric", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    
+    table.add_row("Total Files", str(stats.get("total_indexable_files", 0)))
+    table.add_row("Indexed Files", str(stats.get("indexed_files", 0)))
+    table.add_row("Total Chunks", str(stats.get("total_chunks", 0)))
+    
+    # Language distribution
+    languages = stats.get("languages", {})
+    if languages:
+        lang_str = ", ".join(f"{lang}: {count}" for lang, count in languages.items())
+        table.add_row("Languages", lang_str)
+    
+    # File extensions
+    extensions = stats.get("file_extensions", [])
+    if extensions:
+        table.add_row("Extensions", ", ".join(extensions))
+    
+    console.print(table)
+
+
+def print_config(config_dict: Dict[str, Any]) -> None:
+    """Print configuration in a formatted table."""
+    table = Table(title="Configuration", show_header=False)
+    table.add_column("Setting", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    
+    for key, value in config_dict.items():
+        if isinstance(value, (list, dict)):
+            value_str = str(value)
+        elif isinstance(value, Path):
+            value_str = str(value)
+        else:
+            value_str = str(value)
+        
+        table.add_row(key.replace("_", " ").title(), value_str)
+    
+    console.print(table)
+
+
+def confirm_action(message: str, default: bool = False) -> bool:
+    """Ask for user confirmation."""
+    default_str = "Y/n" if default else "y/N"
+    response = console.input(f"{message} [{default_str}]: ").strip().lower()
+    
+    if not response:
+        return default
+    
+    return response in ("y", "yes", "true", "1")
+
+
+def print_banner() -> None:
+    """Print application banner."""
+    banner = """
+[bold blue]MCP Vector Search[/bold blue]
+[dim]CLI-first semantic code search with MCP integration[/dim]
+"""
+    console.print(Panel(banner.strip(), border_style="blue"))
+
+
+def format_file_path(file_path: Path, project_root: Optional[Path] = None) -> str:
+    """Format file path for display (relative to project root if possible)."""
+    if project_root:
+        try:
+            relative_path = file_path.relative_to(project_root)
+            return str(relative_path)
+        except ValueError:
+            pass
+    
+    return str(file_path)
+
+
+def print_dependency_status(name: str, available: bool, version: Optional[str] = None) -> None:
+    """Print dependency status."""
+    if available:
+        version_str = f" ({version})" if version else ""
+        console.print(f"[green]✓[/green] {name}{version_str}")
+    else:
+        console.print(f"[red]✗[/red] {name} - Not available")
+
+
+def print_json(data: Any, title: Optional[str] = None) -> None:
+    """Print data as formatted JSON."""
+    import json
+    
+    json_str = json.dumps(data, indent=2, default=str)
+    syntax = Syntax(json_str, "json", theme="monokai")
+    
+    if title:
+        console.print(Panel(syntax, title=title, border_style="blue"))
+    else:
+        console.print(syntax)

mcp_vector_search/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration management for MCP Vector Search."""

mcp_vector_search/config/defaults.py

@@ -0,0 +1,175 @@
+"""Default configurations for MCP Vector Search."""
+
+from pathlib import Path
+from typing import Dict, List
+
+# Default file extensions to index (prioritize supported languages)
+DEFAULT_FILE_EXTENSIONS = [
+    ".py",      # Python (fully supported)
+    ".js",      # JavaScript (fully supported)
+    ".ts",      # TypeScript (fully supported)
+    ".jsx",     # React JSX (fully supported)
+    ".tsx",     # React TSX (fully supported)
+    ".mjs",     # ES6 modules (fully supported)
+    ".java",    # Java (fallback parsing)
+    ".cpp",     # C++ (fallback parsing)
+    ".c",       # C (fallback parsing)
+    ".h",       # C/C++ headers (fallback parsing)
+    ".hpp",     # C++ headers (fallback parsing)
+    ".cs",      # C# (fallback parsing)
+    ".go",      # Go (fallback parsing)
+    ".rs",      # Rust (fallback parsing)
+    ".php",     # PHP (fallback parsing)
+    ".rb",      # Ruby (fallback parsing)
+    ".swift",   # Swift (fallback parsing)
+    ".kt",      # Kotlin (fallback parsing)
+    ".scala",   # Scala (fallback parsing)
+    ".sh",      # Shell scripts (fallback parsing)
+    ".bash",    # Bash scripts (fallback parsing)
+    ".zsh",     # Zsh scripts (fallback parsing)
+]
+
+# Language mappings for parsers
+LANGUAGE_MAPPINGS: Dict[str, str] = {
+    ".py": "python",
+    ".pyw": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".java": "java",
+    ".cpp": "cpp",
+    ".c": "c",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".cs": "c_sharp",
+    ".go": "go",
+    ".rs": "rust",
+    ".php": "php",
+    ".rb": "ruby",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".scala": "scala",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+}
+
+# Default embedding models by use case
+DEFAULT_EMBEDDING_MODELS = {
+    "code": "microsoft/codebert-base",
+    "multilingual": "sentence-transformers/all-MiniLM-L6-v2",
+    "fast": "sentence-transformers/all-MiniLM-L12-v2",
+    "precise": "microsoft/unixcoder-base",
+}
+
+# Default similarity thresholds by language
+DEFAULT_SIMILARITY_THRESHOLDS = {
+    "python": 0.75,
+    "javascript": 0.70,
+    "typescript": 0.70,
+    "java": 0.75,
+    "cpp": 0.70,
+    "c": 0.70,
+    "go": 0.75,
+    "rust": 0.75,
+    "default": 0.70,
+}
+
+# Default chunk sizes by language (in tokens)
+DEFAULT_CHUNK_SIZES = {
+    "python": 512,
+    "javascript": 384,
+    "typescript": 384,
+    "java": 512,
+    "cpp": 384,
+    "c": 384,
+    "go": 512,
+    "rust": 512,
+    "default": 512,
+}
+
+# Directories to ignore during indexing
+DEFAULT_IGNORE_PATTERNS = [
+    ".git",
+    ".svn",
+    ".hg",
+    "__pycache__",
+    ".pytest_cache",
+    "node_modules",
+    ".venv",
+    "venv",
+    ".env",
+    "build",
+    "dist",
+    "target",
+    ".idea",
+    ".vscode",
+    "*.egg-info",
+    ".DS_Store",
+    "Thumbs.db",
+]
+
+# File patterns to ignore
+DEFAULT_IGNORE_FILES = [
+    "*.pyc",
+    "*.pyo",
+    "*.pyd",
+    "*.so",
+    "*.dll",
+    "*.dylib",
+    "*.exe",
+    "*.bin",
+    "*.obj",
+    "*.o",
+    "*.a",
+    "*.lib",
+    "*.jar",
+    "*.war",
+    "*.ear",
+    "*.zip",
+    "*.tar",
+    "*.gz",
+    "*.bz2",
+    "*.xz",
+    "*.7z",
+    "*.rar",
+    "*.iso",
+    "*.dmg",
+    "*.img",
+    "*.log",
+    "*.tmp",
+    "*.temp",
+    "*.cache",
+    "*.lock",
+]
+
+def get_default_config_path(project_root: Path) -> Path:
+    """Get the default configuration file path for a project."""
+    return project_root / ".mcp-vector-search" / "config.json"
+
+
+def get_default_index_path(project_root: Path) -> Path:
+    """Get the default index directory path for a project."""
+    return project_root / ".mcp-vector-search"
+
+
+def get_default_cache_path(project_root: Path) -> Path:
+    """Get the default cache directory path for a project."""
+    return project_root / ".mcp-vector-search" / "cache"
+
+
+def get_language_from_extension(extension: str) -> str:
+    """Get the language name from file extension."""
+    return LANGUAGE_MAPPINGS.get(extension.lower(), "text")
+
+
+def get_similarity_threshold(language: str) -> float:
+    """Get the default similarity threshold for a language."""
+    return DEFAULT_SIMILARITY_THRESHOLDS.get(language.lower(), DEFAULT_SIMILARITY_THRESHOLDS["default"])
+
+
+def get_chunk_size(language: str) -> int:
+    """Get the default chunk size for a language."""
+    return DEFAULT_CHUNK_SIZES.get(language.lower(), DEFAULT_CHUNK_SIZES["default"])

mcp_vector_search/config/settings.py

@@ -0,0 +1,108 @@
+"""Pydantic configuration schemas for MCP Vector Search."""
+
+from pathlib import Path
+from typing import List, Optional
+
+from pydantic import Field, validator
+from pydantic_settings import BaseSettings
+
+
+class ProjectConfig(BaseSettings):
+    """Type-safe project configuration with validation."""
+
+    project_root: Path = Field(..., description="Project root directory")
+    index_path: Path = Field(
+        default=".mcp-vector-search", description="Index storage path"
+    )
+    file_extensions: List[str] = Field(
+        default=[".py", ".js", ".ts", ".jsx", ".tsx"],
+        description="File extensions to index",
+    )
+    embedding_model: str = Field(
+        default="microsoft/codebert-base", description="Embedding model name"
+    )
+    similarity_threshold: float = Field(
+        default=0.75, ge=0.0, le=1.0, description="Similarity threshold"
+    )
+    max_chunk_size: int = Field(
+        default=512, gt=0, description="Maximum chunk size in tokens"
+    )
+    languages: List[str] = Field(default=[], description="Detected programming languages")
+    watch_files: bool = Field(
+        default=False, description="Enable file watching for incremental updates"
+    )
+    cache_embeddings: bool = Field(
+        default=True, description="Enable embedding caching"
+    )
+    max_cache_size: int = Field(
+        default=1000, gt=0, description="Maximum number of cached embeddings"
+    )
+
+    @validator("project_root", "index_path")
+    def validate_paths(cls, v: Path) -> Path:
+        """Ensure paths are absolute and normalized."""
+        return v.resolve()
+
+    @validator("file_extensions")
+    def validate_extensions(cls, v: List[str]) -> List[str]:
+        """Ensure extensions start with dot."""
+        return [ext if ext.startswith(".") else f".{ext}" for ext in v]
+
+    class Config:
+        env_prefix = "MCP_VECTOR_SEARCH_"
+        case_sensitive = False
+
+
+class DatabaseConfig(BaseSettings):
+    """Database configuration settings."""
+
+    persist_directory: Optional[Path] = Field(
+        default=None, description="ChromaDB persistence directory"
+    )
+    collection_name: str = Field(
+        default="code_search", description="ChromaDB collection name"
+    )
+    batch_size: int = Field(
+        default=32, gt=0, description="Batch size for embedding operations"
+    )
+    enable_telemetry: bool = Field(
+        default=False, description="Enable ChromaDB telemetry"
+    )
+
+    @validator("persist_directory")
+    def validate_persist_directory(cls, v: Optional[Path]) -> Optional[Path]:
+        """Ensure persist directory is absolute if provided."""
+        return v.resolve() if v else None
+
+    class Config:
+        env_prefix = "MCP_VECTOR_SEARCH_DB_"
+        case_sensitive = False
+
+
+class SearchConfig(BaseSettings):
+    """Search configuration settings."""
+
+    default_limit: int = Field(
+        default=10, gt=0, description="Default number of search results"
+    )
+    max_limit: int = Field(
+        default=100, gt=0, description="Maximum number of search results"
+    )
+    enable_reranking: bool = Field(
+        default=True, description="Enable result reranking"
+    )
+    context_lines: int = Field(
+        default=3, ge=0, description="Number of context lines to include"
+    )
+
+    @validator("max_limit")
+    def validate_max_limit(cls, v: int, values: dict) -> int:
+        """Ensure max_limit is greater than default_limit."""
+        default_limit = values.get("default_limit", 10)
+        if v < default_limit:
+            raise ValueError("max_limit must be greater than or equal to default_limit")
+        return v
+
+    class Config:
+        env_prefix = "MCP_VECTOR_SEARCH_SEARCH_"
+        case_sensitive = False

mcp_vector_search/core/__init__.py

@@ -0,0 +1 @@
+"""Core functionality for MCP Vector Search."""