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

mcp_vector_search/cli/main.py

@@ -1,21 +1,35 @@
 """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 .. import __build__, __version__
+from .commands.auto_index import auto_index_app
 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.init import (
+    init_app,
+    main as init_main,
+    check_initialization as init_check,
+    init_mcp_integration,
+    list_embedding_models,
+)
+from .commands.install import install_app
+from .commands.mcp import mcp_app
+from .commands.search import (
+    search_app,
+    search_context_cmd,
+    search_main,
+    search_similar_cmd,
+)
 from .commands.status import status_app
 from .commands.watch import app as watch_app
-from .output import setup_logging
+from .didyoumean import create_enhanced_typer, add_common_suggestions
+from .output import print_error, setup_logging
 
 # Install rich traceback handler
 install(show_locals=True)
@@ -23,21 +37,132 @@ install(show_locals=True)
 # Create console for rich output
 console = Console()
 
-# Create main Typer app
-app = typer.Typer(
+# Create main Typer app with "did you mean" functionality
+app = create_enhanced_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")
+# Add install command directly (not as subcommand app)
+from .commands.install import main as install_main, demo as install_demo
+from .commands.status import main as status_main
+app.command("install", help="🚀 Install mcp-vector-search in projects")(install_main)
+app.command("demo", help="🎬 Run installation demo with sample project")(install_demo)
+app.command("status", help="📊 Show project status and statistics")(status_main)
+# Register init as a direct command
+app.command("init", help="🔧 Initialize project for semantic search")(init_main)
+# Add init subcommands as separate commands
+app.command("init-check", help="Check if project is initialized")(init_check)
+app.command("init-mcp", help="Install/fix Claude Code MCP integration")(init_mcp_integration)
+app.command("init-models", help="List available embedding models")(list_embedding_models)
 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.add_typer(auto_index_app, name="auto-index", help="Manage automatic indexing")
+app.add_typer(mcp_app, name="mcp", help="Manage Claude Code MCP integration")
+
+# Add search command - simplified syntax as default
+app.command("search", help="Search code semantically")(search_main)
+
+# Keep old nested structure for backward compatibility
+app.add_typer(search_app, name="search-legacy", help="Legacy search commands", hidden=True)
+app.add_typer(status_app, name="status-legacy", help="Legacy status commands", hidden=True)
+app.command("find", help="Search code semantically (alias for search)")(search_main)
+app.command("search-similar", help="Find code similar to a specific file or function")(
+    search_similar_cmd
+)
+app.command("search-context", help="Search for code based on contextual description")(
+    search_context_cmd
+)
+
+
+# Add interactive search command
+@app.command("interactive")
+def interactive_search(
+    ctx: typer.Context,
+    project_root: Path | None = typer.Option(
+        None, "--project-root", "-p", help="Project root directory"
+    ),
+) -> None:
+    """Start an interactive search session with filtering and refinement."""
+    import asyncio
+
+    from .interactive import start_interactive_search
+
+    root = project_root or ctx.obj.get("project_root") or Path.cwd()
+
+    try:
+        asyncio.run(start_interactive_search(root))
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interactive search cancelled[/yellow]")
+    except Exception as e:
+        print_error(f"Interactive search failed: {e}")
+        raise typer.Exit(1)
+
+
+# Add history management commands
+@app.command("history")
+def show_history(
+    ctx: typer.Context,
+    limit: int = typer.Option(20, "--limit", "-l", help="Number of entries to show"),
+    project_root: Path | None = typer.Option(
+        None, "--project-root", "-p", help="Project root directory"
+    ),
+) -> None:
+    """Show search history."""
+    from .history import show_search_history
+
+    root = project_root or ctx.obj.get("project_root") or Path.cwd()
+    show_search_history(root, limit)
+
+
+@app.command("favorites")
+def show_favorites_cmd(
+    ctx: typer.Context,
+    project_root: Path | None = typer.Option(
+        None, "--project-root", "-p", help="Project root directory"
+    ),
+) -> None:
+    """Show favorite queries."""
+    from .history import show_favorites
+
+    root = project_root or ctx.obj.get("project_root") or Path.cwd()
+    show_favorites(root)
+
+
+@app.command("add-favorite")
+def add_favorite(
+    ctx: typer.Context,
+    query: str = typer.Argument(..., help="Query to add to favorites"),
+    description: str | None = typer.Option(None, "--desc", help="Optional description"),
+    project_root: Path | None = typer.Option(
+        None, "--project-root", "-p", help="Project root directory"
+    ),
+) -> None:
+    """Add a query to favorites."""
+    from .history import SearchHistory
+
+    root = project_root or ctx.obj.get("project_root") or Path.cwd()
+    history_manager = SearchHistory(root)
+    history_manager.add_favorite(query, description)
+
+
+@app.command("remove-favorite")
+def remove_favorite(
+    ctx: typer.Context,
+    query: str = typer.Argument(..., help="Query to remove from favorites"),
+    project_root: Path | None = typer.Option(
+        None, "--project-root", "-p", help="Project root directory"
+    ),
+) -> None:
+    """Remove a query from favorites."""
+    from .history import SearchHistory
+
+    root = project_root or ctx.obj.get("project_root") or Path.cwd()
+    history_manager = SearchHistory(root)
+    history_manager.remove_favorite(query)
 
 
 @app.callback()
@@ -46,13 +171,9 @@ def main(
     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(
+    verbose: bool = typer.Option(False, "--verbose", help="Enable verbose logging"),
+    quiet: bool = typer.Option(False, "--quiet", help="Suppress non-error output"),
+    project_root: Path | None = typer.Option(
         None,
         "--project-root",
         "-p",
@@ -64,16 +185,16 @@ def main(
     ),
 ) -> 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__}")
+        console.print(f"mcp-vector-search version {__version__} (build {__build__})")
         raise typer.Exit()
 
     # Setup logging
-    log_level = "DEBUG" if verbose else "WARNING" if quiet else "INFO"
+    log_level = "DEBUG" if verbose else "ERROR" if quiet else "WARNING"
     setup_logging(log_level)
 
     # Store global options in context
@@ -83,7 +204,7 @@ def main(
     ctx.obj["project_root"] = project_root
 
     if verbose:
-        logger.info(f"MCP Vector Search v{__version__}")
+        logger.info(f"MCP Vector Search v{__version__} (build {__build__})")
         if project_root:
             logger.info(f"Using project root: {project_root}")
 
@@ -91,26 +212,53 @@ def main(
 @app.command()
 def version() -> None:
     """Show version information."""
-    console.print(f"[bold blue]mcp-vector-search[/bold blue] version [green]{__version__}[/green]")
+    console.print(
+        f"[bold blue]mcp-vector-search[/bold blue] version [green]{__version__}[/green] [dim](build {__build__})[/dim]"
+    )
     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]")
 
 
+def handle_command_error(ctx, param, value):
+    """Handle command errors with suggestions."""
+    if ctx.resilient_parsing:
+        return
+
+    # This will be called when a command is not found
+    import click
+    try:
+        return value
+    except click.UsageError as e:
+        if "No such command" in str(e):
+            # Extract the command name from the error
+            import re
+            match = re.search(r"No such command '([^']+)'", str(e))
+            if match:
+                command_name = match.group(1)
+                add_common_suggestions(ctx, command_name)
+        raise
+
+
 @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")
+        console.print(
+            "Run [code]pip install mcp-vector-search[/code] to install missing dependencies"
+        )
+
+
+
 
 
 if __name__ == "__main__":

mcp_vector_search/cli/output.py

@@ -2,7 +2,7 @@
 
 import sys
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 from rich.console import Console
@@ -17,7 +17,6 @@ from rich.progress import (
 )
 from rich.syntax import Syntax
 from rich.table import Table
-from rich.text import Text
 
 from ..core.models import ProjectInfo, SearchResult
 
@@ -25,22 +24,32 @@ from ..core.models import ProjectInfo, SearchResult
 console = Console()
 
 
-def setup_logging(level: str = "INFO") -> None:
+def setup_logging(level: str = "WARNING") -> None:
     """Setup structured logging with rich formatting.
-    
+
     Args:
         level: Log level (DEBUG, INFO, WARNING, ERROR)
     """
-    # Remove default handler
+    # Remove all existing handlers
     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,
-    )
+
+    # Only add console handler if level is DEBUG or INFO
+    # For WARNING and ERROR, we want minimal output
+    if level in ["DEBUG", "INFO"]:
+        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,
+        )
+    else:
+        # For WARNING and ERROR, use minimal format and only show WARNING+ messages
+        logger.add(
+            sys.stderr,
+            level=level,
+            format="<level>{level}</level>: <level>{message}</level>",
+            colorize=True,
+        )
 
 
 def print_success(message: str) -> None:
@@ -80,20 +89,25 @@ def print_project_info(project_info: ProjectInfo) -> None:
     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(
+        "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],
+    results: list[SearchResult],
     query: str,
     show_content: bool = True,
     max_content_lines: int = 10,
@@ -102,10 +116,12 @@ def print_search_results(
     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"\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]"
@@ -113,23 +129,23 @@ def print_search_results(
             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,
@@ -139,52 +155,52 @@ def print_search_results(
                 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:
+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:
+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)):
+        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)
 
 
@@ -192,10 +208,10 @@ 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")
 
 
@@ -208,7 +224,7 @@ def print_banner() -> None:
     console.print(Panel(banner.strip(), border_style="blue"))
 
 
-def format_file_path(file_path: Path, project_root: Optional[Path] = None) -> str:
+def format_file_path(file_path: Path, project_root: Path | None = None) -> str:
     """Format file path for display (relative to project root if possible)."""
     if project_root:
         try:
@@ -216,11 +232,13 @@ def format_file_path(file_path: Path, project_root: Optional[Path] = None) -> st
             return str(relative_path)
         except ValueError:
             pass
-    
+
     return str(file_path)
 
 
-def print_dependency_status(name: str, available: bool, version: Optional[str] = None) -> None:
+def print_dependency_status(
+    name: str, available: bool, version: str | None = None
+) -> None:
     """Print dependency status."""
     if available:
         version_str = f" ({version})" if version else ""
@@ -229,13 +247,13 @@ def print_dependency_status(name: str, available: bool, version: Optional[str] =
         console.print(f"[red]✗[/red] {name} - Not available")
 
 
-def print_json(data: Any, title: Optional[str] = None) -> None:
+def print_json(data: Any, title: str | None = 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:

mcp_vector_search/config/defaults.py

@@ -1,36 +1,38 @@
 """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)
+    ".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)
+    ".json",  # JSON configuration files
+    ".md",  # Markdown documentation
+    ".txt",  # Plain text files
 ]
 
 # Language mappings for parsers
-LANGUAGE_MAPPINGS: Dict[str, str] = {
+LANGUAGE_MAPPINGS: dict[str, str] = {
     ".py": "python",
     ".pyw": "python",
     ".js": "javascript",
@@ -54,27 +56,33 @@ LANGUAGE_MAPPINGS: Dict[str, str] = {
     ".sh": "bash",
     ".bash": "bash",
     ".zsh": "bash",
+    ".json": "json",
+    ".md": "markdown",
+    ".txt": "text",
 }
 
 # Default embedding models by use case
 DEFAULT_EMBEDDING_MODELS = {
-    "code": "microsoft/codebert-base",
+    "code": "sentence-transformers/all-MiniLM-L6-v2",  # Changed from microsoft/codebert-base which doesn't exist
     "multilingual": "sentence-transformers/all-MiniLM-L6-v2",
     "fast": "sentence-transformers/all-MiniLM-L12-v2",
-    "precise": "microsoft/unixcoder-base",
+    "precise": "sentence-transformers/all-mpnet-base-v2",  # Changed from 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,
+    "python": 0.3,
+    "javascript": 0.3,
+    "typescript": 0.3,
+    "java": 0.3,
+    "cpp": 0.3,
+    "c": 0.3,
+    "go": 0.3,
+    "rust": 0.3,
+    "json": 0.4,  # JSON files may have more structural similarity
+    "markdown": 0.3,  # Markdown documentation
+    "text": 0.3,  # Plain text files
+    "default": 0.3,
 }
 
 # Default chunk sizes by language (in tokens)
@@ -87,6 +95,9 @@ DEFAULT_CHUNK_SIZES = {
     "c": 384,
     "go": 512,
     "rust": 512,
+    "json": 256,  # JSON files are often smaller and more structured
+    "markdown": 512,  # Markdown documentation can be chunked normally
+    "text": 384,  # Plain text files with paragraph-based chunking
     "default": 512,
 }
 
@@ -145,6 +156,7 @@ DEFAULT_IGNORE_FILES = [
     "*.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"
@@ -167,7 +179,9 @@ def get_language_from_extension(extension: str) -> str:
 
 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"])
+    return DEFAULT_SIMILARITY_THRESHOLDS.get(
+        language.lower(), DEFAULT_SIMILARITY_THRESHOLDS["default"]
+    )
 
 
 def get_chunk_size(language: str) -> int: