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

mcp_vector_search/cli/commands/search.py

@@ -136,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.
 
@@ -166,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]
@@ -242,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,
                 )
             )
 
@@ -251,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,
@@ -264,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)
 
@@ -371,6 +481,88 @@ async def run_search(
                     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
@@ -424,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

mcp_vector_search/cli/commands/setup.py

@@ -31,6 +31,9 @@ from pathlib import Path
 
 import typer
 from loguru import logger
+
+# Import Platform enum to filter excluded platforms
+from py_mcp_installer import Platform
 from rich.console import Console
 from rich.panel import Panel
 
@@ -53,6 +56,9 @@ from ..output import (
 # Import functions from refactored install module
 from .install import _install_to_platform, detect_all_platforms
 
+# Platforms to exclude from auto-setup (user can still manually install)
+EXCLUDED_PLATFORMS_FROM_SETUP = {Platform.CLAUDE_DESKTOP}
+
 # Create console for rich output
 console = Console()
 
@@ -148,9 +154,10 @@ def register_with_claude_cli(
 
         # Build the add command using mcp-vector-search CLI
         # This works for all installation methods: pipx, homebrew, and uv
+        # Claude Code sets CWD to the project directory, so no path needed
         # claude mcp add --transport stdio mcp-vector-search \
         #   --env MCP_ENABLE_FILE_WATCHING=true \
-        #   -- mcp-vector-search mcp /project/root
+        #   -- mcp-vector-search mcp
         cmd = [
             "claude",
             "mcp",
@@ -163,7 +170,6 @@ def register_with_claude_cli(
             "--",
             "mcp-vector-search",
             "mcp",
-            str(project_root.absolute()),
         ]
 
         if verbose:
@@ -959,15 +965,35 @@ async def _run_smart_setup(
     detected_platforms_list = detect_all_platforms()
 
     if detected_platforms_list:
-        platform_names = [p.platform.value for p in detected_platforms_list]
-        print_success(
-            f"   ✅ Found {len(platform_names)} platform(s): {', '.join(platform_names)}"
-        )
-        if verbose:
-            for platform_info in detected_platforms_list:
-                print_info(
-                    f"      {platform_info.platform.value}: {platform_info.config_path}"
-                )
+        # Filter out excluded platforms for display
+        configurable_platforms = [
+            p
+            for p in detected_platforms_list
+            if p.platform not in EXCLUDED_PLATFORMS_FROM_SETUP
+        ]
+        excluded_platforms = [
+            p
+            for p in detected_platforms_list
+            if p.platform in EXCLUDED_PLATFORMS_FROM_SETUP
+        ]
+
+        if configurable_platforms:
+            platform_names = [p.platform.value for p in configurable_platforms]
+            print_success(
+                f"   ✅ Found {len(platform_names)} platform(s): {', '.join(platform_names)}"
+            )
+            if verbose:
+                for platform_info in configurable_platforms:
+                    print_info(
+                        f"      {platform_info.platform.value}: {platform_info.config_path}"
+                    )
+
+        # Note excluded platforms
+        if excluded_platforms:
+            excluded_names = [p.platform.value for p in excluded_platforms]
+            print_info(
+                f"   ℹ️  Skipping: {', '.join(excluded_names)} (use 'install mcp --platform' for manual install)"
+            )
     else:
         print_info("   No MCP platforms detected (will configure Claude Code)")
 
@@ -1012,7 +1038,27 @@ async def _run_smart_setup(
     # ===========================================================================
     # Phase 4: Indexing
     # ===========================================================================
-    if not already_initialized or force:
+    # Determine if indexing is needed:
+    # 1. Not already initialized (new setup)
+    # 2. Force flag is set
+    # 3. Index database doesn't exist
+    # 4. Index exists but is empty
+    # 5. Files have changed (incremental indexing will handle this)
+    needs_indexing = not already_initialized or force
+
+    if already_initialized and not force:
+        # Check if index exists and has content
+        index_db_path = project_root / ".mcp-vector-search" / "chroma.sqlite3"
+        if not index_db_path.exists():
+            print_info("   Index database not found, will create...")
+            needs_indexing = True
+        else:
+            # Check if index is empty or files have changed
+            # Run incremental indexing to catch any changes
+            print_info("   Checking for file changes...")
+            needs_indexing = True  # Always run incremental to catch changes
+
+    if needs_indexing:
         console.print("\n[bold blue]🔍 Indexing codebase...[/bold blue]")
 
         from .index import run_indexing
@@ -1045,7 +1091,12 @@ async def _run_smart_setup(
         print_info("   ✅ Claude CLI detected, using native integration")
 
     # Use detected platforms or default to empty list
-    platforms_to_configure = detected_platforms_list if detected_platforms_list else []
+    # Filter out excluded platforms (e.g., Claude Desktop) - exclusion already noted in Phase 1
+    platforms_to_configure = [
+        p
+        for p in (detected_platforms_list or [])
+        if p.platform not in EXCLUDED_PLATFORMS_FROM_SETUP
+    ]
 
     # Configure all detected platforms using new library
     for platform_info in platforms_to_configure: