mcp-vector-search 0.12.6__py3-none-any.whl → 1.1.22__py3-none-any.whl

mcp_vector_search/cli/commands/install_old.py

@@ -578,7 +578,8 @@ def demo(
             demo_dir.mkdir()
 
             # Create sample files
-            (demo_dir / "main.py").write_text("""
+            (demo_dir / "main.py").write_text(
+                """
 def main():
     '''Main entry point for the application.'''
     print("Hello, World!")
@@ -600,9 +601,11 @@ class UserService:
 
 if __name__ == "__main__":
     main()
-""")
+"""
+            )
 
-            (demo_dir / "utils.py").write_text("""
+            (demo_dir / "utils.py").write_text(
+                """
 import json
 from typing import Dict, Any
 
@@ -619,7 +622,8 @@ def hash_password(password: str) -> str:
     '''Hash password for secure storage.'''
     import hashlib
     return hashlib.sha256(password.encode()).hexdigest()
-""")
+"""
+            )
 
             console.print(
                 f"\n[bold blue]📁 Created demo project at:[/bold blue] {demo_dir}"

mcp_vector_search/cli/commands/mcp.py

@@ -38,11 +38,50 @@ Each tool has its own configuration format and location.
   3. Test setup:     [green]mcp-vector-search mcp test[/green]
 
 [dim]Use --force to overwrite existing configurations[/dim]
-"""
+""",
+    no_args_is_help=False,  # Allow running without subcommand
+    invoke_without_command=True,  # Call callback even without subcommand
 )
 
 console = Console()
 
+
+@mcp_app.callback()
+def mcp_callback(ctx: typer.Context):
+    """MCP server management.
+
+    When invoked without a subcommand, starts the MCP server over stdio.
+    Use subcommands to configure MCP integration for different AI tools.
+    """
+    # Store context for subcommands
+    if not ctx.obj:
+        ctx.obj = {}
+
+    # If a subcommand was invoked, let it handle things (check this FIRST)
+    if ctx.invoked_subcommand is not None:
+        return
+
+    # No subcommand - start the MCP server
+    import asyncio
+    from pathlib import Path
+
+    from ...mcp.server import run_mcp_server
+
+    project_root = ctx.obj.get("project_root") if ctx.obj else None
+    if project_root is None:
+        project_root = Path.cwd()
+
+    # Start the MCP server over stdio
+    try:
+        asyncio.run(run_mcp_server(project_root))
+        raise typer.Exit(0)
+    except KeyboardInterrupt:
+        raise typer.Exit(0)
+    except Exception as e:
+        print(f"MCP server error: {e}", file=sys.stderr)
+        raise typer.Exit(1)
+
+
 # Supported AI tools and their configuration details
 SUPPORTED_TOOLS = {
     "auggie": {
@@ -123,6 +162,29 @@ def get_mcp_server_command(
     return f"{python_exe} -m mcp_vector_search.mcp.server{watch_flag} {project_root}"
 
 
+def detect_install_method() -> tuple[str, list[str]]:
+    """Detect how mcp-vector-search is installed and return appropriate command.
+
+    Returns:
+        Tuple of (command, args) for running mcp-vector-search mcp
+    """
+    # Check if we're in a uv-managed environment
+    # uv sets UV_PROJECT_ENVIRONMENT or has .venv structure
+    if os.environ.get("VIRTUAL_ENV") and ".venv" in os.environ.get("VIRTUAL_ENV", ""):
+        # Likely uv project environment
+        if shutil.which("uv"):
+            return ("uv", ["run", "mcp-vector-search", "mcp"])
+
+    # Check if mcp-vector-search is directly available in PATH
+    mcp_cmd = shutil.which("mcp-vector-search")
+    if mcp_cmd:
+        # Installed via pipx or pip - use direct command
+        return ("mcp-vector-search", ["mcp"])
+
+    # Fallback to uv run (development mode)
+    return ("uv", ["run", "mcp-vector-search", "mcp"])
+
+
 def get_mcp_server_config_for_tool(
     project_root: Path,
     tool_name: str,
@@ -130,9 +192,11 @@ def get_mcp_server_config_for_tool(
     enable_file_watching: bool = True,
 ) -> dict[str, Any]:
     """Generate MCP server configuration for a specific tool."""
+    command, args = detect_install_method()
+
     base_config = {
-        "command": "uv",
-        "args": ["run", "mcp-vector-search", "mcp"],
+        "command": command,
+        "args": args,
         "env": {
             "MCP_ENABLE_FILE_WATCHING": "true" if enable_file_watching else "false"
         },
@@ -183,11 +247,12 @@ def create_project_claude_config(
     if "mcpServers" not in config:
         config["mcpServers"] = {}
 
-    # Use uv for better compatibility, with proper args structure
+    # Detect installation method and use appropriate command
+    command, args = detect_install_method()
     config["mcpServers"][server_name] = {
         "type": "stdio",
-        "command": "uv",
-        "args": ["run", "mcp-vector-search", "mcp"],
+        "command": command,
+        "args": args,
         "env": {
             "MCP_ENABLE_FILE_WATCHING": "true" if enable_file_watching else "false"
         },
@@ -198,6 +263,13 @@ def create_project_claude_config(
         json.dump(config, f, indent=2)
 
     print_success("Created project-level .mcp.json with MCP server configuration")
+
+    # Show which command will be used
+    if command == "uv":
+        print_info(f"Using uv: {command} {' '.join(args)}")
+    else:
+        print_info(f"Using direct command: {command} {' '.join(args)}")
+
     if enable_file_watching:
         print_info("File watching is enabled for automatic reindexing")
     else:

mcp_vector_search/cli/commands/reset.py

@@ -82,27 +82,58 @@ def reset_index(
                 console.print("[yellow]Reset cancelled[/yellow]")
                 raise typer.Exit(0)
 
-        # Get the database directory
-        project_manager.load_config()
-        db_path = root / ".mcp_vector_search" / "db"
+        # Get the database directory from config
+        config = project_manager.load_config()
+        db_path = Path(config.index_path)
+
+        # Check if index exists (look for chroma.sqlite3 or collection directories)
+        has_index = (db_path / "chroma.sqlite3").exists()
 
-        if not db_path.exists():
+        if not has_index:
             print_warning("No index found. Nothing to reset.")
             raise typer.Exit(0)
 
+        # Files/dirs to remove (index data)
+        index_files = [
+            "chroma.sqlite3",
+            "cache",
+            "indexing_errors.log",
+            "index_metadata.json",
+            "directory_index.json",
+        ]
+
+        # Also remove any UUID-named directories (ChromaDB collections)
+        if db_path.exists():
+            for item in db_path.iterdir():
+                if item.is_dir() and len(item.name) == 36 and "-" in item.name:
+                    # Looks like a UUID directory
+                    index_files.append(item.name)
+
         # Create backup if requested
         if backup:
-            backup_dir = root / ".mcp_vector_search" / "backups"
+            backup_dir = db_path / "backups"
             backup_dir.mkdir(exist_ok=True)
 
             import time
 
             timestamp = int(time.time())
-            backup_path = backup_dir / f"db_backup_{timestamp}"
+            backup_path = backup_dir / f"index_backup_{timestamp}"
+            backup_path.mkdir(exist_ok=True)
 
             try:
-                shutil.copytree(db_path, backup_path)
-                print_success(f"Created backup at: {backup_path.relative_to(root)}")
+                backed_up = []
+                for file in index_files:
+                    src = db_path / file
+                    if src.exists():
+                        dest = backup_path / file
+                        if src.is_dir():
+                            shutil.copytree(src, dest)
+                        else:
+                            shutil.copy2(src, dest)
+                        backed_up.append(file)
+
+                if backed_up:
+                    print_success(f"Created backup at: {backup_path.relative_to(root)}")
             except Exception as e:
                 print_warning(f"Could not create backup: {e}")
                 if not force:
@@ -110,12 +141,25 @@ def reset_index(
                         console.print("[yellow]Reset cancelled[/yellow]")
                         raise typer.Exit(0)
 
-        # Clear the index
+        # Clear the index files
         console.print("[cyan]Clearing index...[/cyan]")
+        removed_count = 0
         try:
-            shutil.rmtree(db_path)
-            db_path.mkdir(parents=True, exist_ok=True)
-            print_success("Index cleared successfully!")
+            for file in index_files:
+                path = db_path / file
+                if path.exists():
+                    if path.is_dir():
+                        shutil.rmtree(path)
+                    else:
+                        path.unlink()
+                    removed_count += 1
+
+            if removed_count > 0:
+                print_success(
+                    f"Index cleared successfully! ({removed_count} items removed)"
+                )
+            else:
+                print_warning("No index files found to remove.")
         except Exception as e:
             print_error(f"Failed to clear index: {e}")
             raise typer.Exit(1)
@@ -215,19 +259,9 @@ def reset_all(
         raise typer.Exit(1)
 
 
-@reset_app.command("health")
 async def check_health(
-    project_root: Path = typer.Option(
-        None,
-        "--project-root",
-        "-p",
-        help="Project root directory",
-    ),
-    fix: bool = typer.Option(
-        False,
-        "--fix",
-        help="Attempt to fix issues if found",
-    ),
+    project_root: Path,
+    fix: bool,
 ) -> None:
     """Check the health of the search index.
 
@@ -254,7 +288,7 @@ async def check_health(
         from ...core.embeddings import create_embedding_function
 
         config = project_manager.load_config()
-        db_path = root / ".mcp_vector_search" / "db"
+        db_path = Path(config.index_path)
 
         # Setup embedding function and cache
         cache_dir = get_default_cache_path(root) if config.cache_embeddings else None
@@ -376,6 +410,7 @@ main = reset_main
 
 
 # Make health check synchronous for CLI
+@reset_app.command("health")
 def health_main(
     project_root: Path = typer.Option(
         None,
@@ -389,5 +424,12 @@ def health_main(
         help="Attempt to fix issues if found",
     ),
 ) -> None:
-    """Check the health of the search index (sync wrapper)."""
+    """Check the health of the search index.
+
+    This command will:
+    - Verify database connectivity
+    - Check for index corruption
+    - Validate collection integrity
+    - Optionally attempt repairs with --fix
+    """
     asyncio.run(check_health(project_root, fix))

mcp_vector_search/cli/commands/search.py

@@ -1,6 +1,8 @@
 """Search command for MCP Vector Search CLI."""
 
 import asyncio
+import os
+from fnmatch import fnmatch
 from pathlib import Path
 
 import typer
@@ -62,7 +64,7 @@ def search_main(
         None,
         "--files",
         "-f",
-        help="Filter by file patterns (e.g., '*.py' or 'src/*.js')",
+        help="Filter by file glob patterns (e.g., '*.py', 'src/*.js', 'tests/*.ts'). Matches basename or relative path.",
         rich_help_panel="🔍 Filters",
     ),
     language: str | None = typer.Option(
@@ -134,6 +136,41 @@ def search_main(
         help="Custom export file path",
         rich_help_panel="💾 Export Options",
     ),
+    max_complexity: int | None = typer.Option(
+        None,
+        "--max-complexity",
+        help="Filter results with cognitive complexity greater than N",
+        min=1,
+        rich_help_panel="🎯 Quality Filters",
+    ),
+    no_smells: bool = typer.Option(
+        False,
+        "--no-smells",
+        help="Exclude results with code smells",
+        rich_help_panel="🎯 Quality Filters",
+    ),
+    grade: str | None = typer.Option(
+        None,
+        "--grade",
+        help="Filter by complexity grade (e.g., 'A,B,C' or 'A-C')",
+        rich_help_panel="🎯 Quality Filters",
+    ),
+    min_quality: int | None = typer.Option(
+        None,
+        "--min-quality",
+        help="Filter by minimum quality score (0-100)",
+        min=0,
+        max=100,
+        rich_help_panel="🎯 Quality Filters",
+    ),
+    quality_weight: float = typer.Option(
+        0.3,
+        "--quality-weight",
+        help="Weight for quality ranking (0.0=pure relevance, 1.0=pure quality, default=0.3)",
+        min=0.0,
+        max=1.0,
+        rich_help_panel="🎯 Quality Filters",
+    ),
 ) -> None:
     """🔍 Search your codebase semantically.
 
@@ -153,8 +190,10 @@ def search_main(
 
     [bold cyan]Advanced Search:[/bold cyan]
 
-    [green]Filter by file pattern:[/green]
-        $ mcp-vector-search search "validation" --files "src/*.py"
+    [green]Filter by file pattern (glob):[/green]
+        $ mcp-vector-search search "validation" --files "*.py"
+        $ mcp-vector-search search "component" --files "src/*.tsx"
+        $ mcp-vector-search search "test utils" --files "tests/*.ts"
 
     [green]Find similar code:[/green]
         $ mcp-vector-search search "src/auth.py" --similar
@@ -162,6 +201,25 @@ def search_main(
     [green]Context-based search:[/green]
         $ mcp-vector-search search "implement rate limiting" --context --focus security
 
+    [bold cyan]Quality Filters:[/bold cyan]
+
+    [green]Filter by complexity:[/green]
+        $ mcp-vector-search search "authentication" --max-complexity 15
+
+    [green]Exclude code smells:[/green]
+        $ mcp-vector-search search "login" --no-smells
+
+    [green]Filter by grade:[/green]
+        $ mcp-vector-search search "api" --grade A,B
+
+    [green]Minimum quality score:[/green]
+        $ mcp-vector-search search "handler" --min-quality 80
+
+    [green]Quality-aware ranking:[/green]
+        $ mcp-vector-search search "auth" --quality-weight 0.5  # Balance relevance and quality
+        $ mcp-vector-search search "api" --quality-weight 0.0   # Pure semantic search
+        $ mcp-vector-search search "util" --quality-weight 1.0  # Pure quality ranking
+
     [bold cyan]Export Results:[/bold cyan]
 
     [green]Export to JSON:[/green]
@@ -238,6 +296,11 @@ def search_main(
                     json_output=json_output,
                     export_format=export_format,
                     export_path=export_path,
+                    max_complexity=max_complexity,
+                    no_smells=no_smells,
+                    grade=grade,
+                    min_quality=min_quality,
+                    quality_weight=quality_weight,
                 )
             )
 
@@ -247,6 +310,52 @@ def search_main(
         raise typer.Exit(1)
 
 
+def _parse_grade_filter(grade_str: str) -> set[str]:
+    """Parse grade filter string into set of allowed grades.
+
+    Supports formats:
+    - Comma-separated: "A,B,C"
+    - Range: "A-C" (expands to A, B, C)
+    - Mixed: "A,C-D" (expands to A, C, D)
+
+    Args:
+        grade_str: Grade filter string
+
+    Returns:
+        Set of allowed grade letters
+    """
+    allowed_grades = set()
+    grade_order = ["A", "B", "C", "D", "F"]
+
+    # Split by comma
+    parts = [part.strip().upper() for part in grade_str.split(",")]
+
+    for part in parts:
+        if "-" in part:
+            # Range format (e.g., "A-C")
+            start, end = part.split("-", 1)
+            start = start.strip()
+            end = end.strip()
+
+            if start in grade_order and end in grade_order:
+                start_idx = grade_order.index(start)
+                end_idx = grade_order.index(end)
+
+                # Handle reverse ranges (C-A becomes A-C)
+                if start_idx > end_idx:
+                    start_idx, end_idx = end_idx, start_idx
+
+                # Add all grades in range
+                for grade in grade_order[start_idx : end_idx + 1]:
+                    allowed_grades.add(grade)
+        else:
+            # Single grade
+            if part in grade_order:
+                allowed_grades.add(part)
+
+    return allowed_grades
+
+
 async def run_search(
     project_root: Path,
     query: str,
@@ -260,8 +369,13 @@ async def run_search(
     json_output: bool = False,
     export_format: str | None = None,
     export_path: Path | None = None,
+    max_complexity: int | None = None,
+    no_smells: bool = False,
+    grade: str | None = None,
+    min_quality: int | None = None,
+    quality_weight: float = 0.3,
 ) -> None:
-    """Run semantic search."""
+    """Run semantic search with optional quality filters and quality-aware ranking."""
     # Load project configuration
     project_manager = ProjectManager(project_root)
 
@@ -326,7 +440,7 @@ async def run_search(
         similarity_threshold=similarity_threshold or config.similarity_threshold,
     )
 
-    # Build filters
+    # Build filters (exclude file_path - will be handled with post-filtering)
     filters = {}
     if language:
         filters["language"] = language
@@ -334,9 +448,6 @@ async def run_search(
         filters["function_name"] = function_name
     if class_name:
         filters["class_name"] = class_name
-    if files:
-        # Simple file pattern matching (could be enhanced)
-        filters["file_path"] = files
 
     try:
         async with database:
@@ -348,6 +459,110 @@ async def run_search(
                 include_context=show_content,
             )
 
+            # Post-filter results by file pattern if specified
+            if files and results:
+                filtered_results = []
+                for result in results:
+                    # Get relative path from project root
+                    try:
+                        rel_path = str(result.file_path.relative_to(project_root))
+                    except ValueError:
+                        # If file is outside project root, use absolute path
+                        rel_path = str(result.file_path)
+
+                    # Match against glob pattern (both full path and basename)
+                    if fnmatch(rel_path, files) or fnmatch(
+                        os.path.basename(rel_path), files
+                    ):
+                        filtered_results.append(result)
+
+                results = filtered_results
+                logger.debug(
+                    f"File pattern '{files}' filtered results to {len(results)} matches"
+                )
+
+            # Apply quality filters if specified
+            if any([max_complexity, no_smells, grade, min_quality]) and results:
+                filtered_results = []
+                for result in results:
+                    # Parse quality metrics from result metadata
+                    cognitive_complexity = getattr(result, "cognitive_complexity", None)
+                    complexity_grade = getattr(result, "complexity_grade", None)
+                    smell_count = getattr(result, "smell_count", None)
+                    quality_score = getattr(result, "quality_score", None)
+
+                    # Filter by max complexity
+                    if max_complexity is not None and cognitive_complexity is not None:
+                        if cognitive_complexity > max_complexity:
+                            continue
+
+                    # Filter by code smells
+                    if no_smells and smell_count is not None:
+                        if smell_count > 0:
+                            continue
+
+                    # Filter by grade
+                    if grade and complexity_grade:
+                        allowed_grades = _parse_grade_filter(grade)
+                        if complexity_grade not in allowed_grades:
+                            continue
+
+                    # Filter by minimum quality score
+                    if min_quality is not None and quality_score is not None:
+                        if quality_score < min_quality:
+                            continue
+
+                    filtered_results.append(result)
+
+                initial_count = len(results)
+                results = filtered_results
+                logger.debug(
+                    f"Quality filters reduced results from {initial_count} to {len(results)}"
+                )
+
+            # Apply quality-aware ranking if quality_weight > 0 and results have quality metrics
+            if quality_weight > 0.0 and results:
+                # Calculate quality scores for results that don't have them
+                for result in results:
+                    if result.quality_score is None:
+                        # Calculate quality score using the formula
+                        calculated_score = result.calculate_quality_score()
+                        if calculated_score is not None:
+                            result.quality_score = calculated_score
+
+                # Re-rank results based on combined score
+                # Store original similarity score for display
+                for result in results:
+                    # Store original relevance score
+                    if not hasattr(result, "_original_similarity"):
+                        result._original_similarity = result.similarity_score
+
+                    # Calculate combined score
+                    if result.quality_score is not None:
+                        # Normalize quality score to 0-1 range (it's 0-100)
+                        normalized_quality = result.quality_score / 100.0
+
+                        # Combined score: (1-W) × relevance + W × quality
+                        combined_score = (
+                            (1.0 - quality_weight) * result.similarity_score
+                            + quality_weight * normalized_quality
+                        )
+
+                        # Update similarity_score with combined score for sorting
+                        result.similarity_score = combined_score
+                    # If no quality score, keep original similarity_score
+
+                # Re-sort by combined score
+                results.sort(key=lambda r: r.similarity_score, reverse=True)
+
+                # Update ranks
+                for i, result in enumerate(results):
+                    result.rank = i + 1
+
+                logger.debug(
+                    f"Quality-aware ranking applied with weight {quality_weight:.2f}"
+                )
+
             # Handle export if requested
             if export_format:
                 from ..export import SearchResultExporter, get_export_path
@@ -401,6 +616,7 @@ async def run_search(
                     results=results,
                     query=query,
                     show_content=show_content,
+                    quality_weight=quality_weight,
                 )
 
                 # Add contextual tips based on results