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

mcp_vector_search/cli/commands/uninstall.py

@@ -0,0 +1,404 @@
+"""Uninstall commands for MCP Vector Search CLI.
+
+This module provides commands to remove MCP integrations from various platforms
+using the py-mcp-installer library.
+
+Examples:
+    # Remove from auto-detected platform
+    $ mcp-vector-search uninstall mcp
+
+    # Remove from specific platform
+    $ mcp-vector-search uninstall mcp --platform cursor
+
+    # Remove from all platforms
+    $ mcp-vector-search uninstall mcp --all
+
+    # Use alias
+    $ mcp-vector-search remove mcp
+"""
+
+from pathlib import Path
+
+import typer
+from loguru import logger
+
+# Import from py-mcp-installer library
+from py_mcp_installer import MCPInstaller, Platform, PlatformDetector, PlatformInfo
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..didyoumean import create_enhanced_typer
+from ..output import (
+    confirm_action,
+    print_error,
+    print_info,
+    print_success,
+)
+
+# Create console for rich output
+console = Console()
+
+# Create uninstall app with subcommands
+uninstall_app = create_enhanced_typer(
+    help="""🗑️  Remove MCP integrations from platforms
+
+[bold cyan]Usage Patterns:[/bold cyan]
+
+  [green]1. Remove from Auto-Detected Platform[/green]
+     Remove MCP integration from highest confidence platform:
+     [code]$ mcp-vector-search uninstall mcp[/code]
+
+  [green]2. Remove from Specific Platform[/green]
+     Remove from a specific platform:
+     [code]$ mcp-vector-search uninstall mcp --platform cursor[/code]
+
+  [green]3. Remove from All Platforms[/green]
+     Remove from all configured platforms:
+     [code]$ mcp-vector-search uninstall mcp --all[/code]
+
+  [green]4. List Current Installations[/green]
+     See what's currently configured:
+     [code]$ mcp-vector-search uninstall list[/code]
+
+[bold cyan]Supported Platforms:[/bold cyan]
+  • [green]claude-code[/green]     - Claude Code
+  • [green]claude-desktop[/green]  - Claude Desktop
+  • [green]cursor[/green]          - Cursor IDE
+  • [green]auggie[/green]          - Auggie
+  • [green]codex[/green]           - Codex
+  • [green]windsurf[/green]        - Windsurf IDE
+  • [green]gemini-cli[/green]      - Gemini CLI
+
+[dim]💡 Alias: 'mcp-vector-search remove' works the same way[/dim]
+""",
+    invoke_without_command=True,
+    no_args_is_help=True,
+)
+
+
+# ==============================================================================
+# Helper Functions
+# ==============================================================================
+
+
+def detect_all_platforms() -> list[PlatformInfo]:
+    """Detect all available platforms on the system.
+
+    Returns:
+        List of detected platforms with confidence scores
+    """
+    detector = PlatformDetector()
+    detected_platforms = []
+
+    # Try to detect each platform
+    platform_detectors = {
+        Platform.CLAUDE_CODE: detector.detect_claude_code,
+        Platform.CLAUDE_DESKTOP: detector.detect_claude_desktop,
+        Platform.CURSOR: detector.detect_cursor,
+        Platform.AUGGIE: detector.detect_auggie,
+        Platform.CODEX: detector.detect_codex,
+        Platform.WINDSURF: detector.detect_windsurf,
+        Platform.GEMINI_CLI: detector.detect_gemini_cli,
+    }
+
+    for platform_enum, detector_func in platform_detectors.items():
+        try:
+            confidence, config_path = detector_func()
+            if confidence > 0.0 and config_path:
+                # Determine CLI availability
+                cli_available = False
+                from py_mcp_installer.utils import resolve_command_path
+
+                if platform_enum in (Platform.CLAUDE_CODE, Platform.CLAUDE_DESKTOP):
+                    cli_available = resolve_command_path("claude") is not None
+                elif platform_enum == Platform.CURSOR:
+                    cli_available = resolve_command_path("cursor") is not None
+
+                platform_info = PlatformInfo(
+                    platform=platform_enum,
+                    confidence=confidence,
+                    config_path=config_path,
+                    cli_available=cli_available,
+                )
+                detected_platforms.append(platform_info)
+        except Exception as e:
+            logger.debug(f"Failed to detect {platform_enum.value}: {e}")
+            continue
+
+    return detected_platforms
+
+
+def platform_name_to_enum(name: str) -> Platform | None:
+    """Convert platform name to enum.
+
+    Args:
+        name: Platform name (e.g., "cursor", "claude-code")
+
+    Returns:
+        Platform enum or None if not found
+    """
+    name_map = {
+        "claude-code": Platform.CLAUDE_CODE,
+        "claude-desktop": Platform.CLAUDE_DESKTOP,
+        "cursor": Platform.CURSOR,
+        "auggie": Platform.AUGGIE,
+        "codex": Platform.CODEX,
+        "windsurf": Platform.WINDSURF,
+        "gemini-cli": Platform.GEMINI_CLI,
+    }
+    return name_map.get(name.lower())
+
+
+def find_configured_platforms() -> list[PlatformInfo]:
+    """Find all platforms that have mcp-vector-search configured.
+
+    Returns:
+        List of platforms with mcp-vector-search installed
+    """
+    detected = detect_all_platforms()
+    configured = []
+
+    for platform_info in detected:
+        try:
+            installer = MCPInstaller(platform=platform_info.platform)
+            server = installer.get_server("mcp-vector-search")
+            if server:
+                configured.append(platform_info)
+        except Exception as e:
+            logger.debug(
+                f"Failed to check {platform_info.platform.value} configuration: {e}"
+            )
+            continue
+
+    return configured
+
+
+def uninstall_from_platform(platform_info: PlatformInfo) -> bool:
+    """Uninstall from a specific platform.
+
+    Args:
+        platform_info: Platform information
+
+    Returns:
+        True if uninstallation succeeded
+    """
+    try:
+        installer = MCPInstaller(platform=platform_info.platform)
+
+        # Uninstall server
+        result = installer.uninstall_server("mcp-vector-search")
+
+        if result.success:
+            print_success(f"  ✅ Removed from {platform_info.platform.value}")
+            return True
+        else:
+            print_error(
+                f"  ❌ Failed to remove from {platform_info.platform.value}: {result.message}"
+            )
+            return False
+
+    except Exception as e:
+        logger.exception(f"Uninstallation from {platform_info.platform.value} failed")
+        print_error(f"  ❌ Uninstallation failed: {e}")
+        return False
+
+
+# ==============================================================================
+# Main Uninstall Command
+# ==============================================================================
+
+
+@uninstall_app.command(name="mcp")
+def uninstall_mcp(
+    ctx: typer.Context,
+    platform: str | None = typer.Option(
+        None,
+        "--platform",
+        "-p",
+        help="Specific platform to uninstall from (e.g., cursor, claude-code)",
+    ),
+    all_platforms: bool = typer.Option(
+        False,
+        "--all",
+        "-a",
+        help="Uninstall from all configured platforms",
+    ),
+) -> None:
+    """Remove MCP integration from platforms.
+
+    By default, uninstalls from the highest confidence platform. Use --all to
+    remove from all configured platforms.
+
+    [bold cyan]Examples:[/bold cyan]
+
+      [green]Remove from auto-detected platform:[/green]
+        $ mcp-vector-search uninstall mcp
+
+      [green]Remove from specific platform:[/green]
+        $ mcp-vector-search uninstall mcp --platform cursor
+
+      [green]Remove from all platforms:[/green]
+        $ mcp-vector-search uninstall mcp --all
+
+    [dim]💡 Use 'mcp-vector-search uninstall list' to see configured platforms[/dim]
+    """
+    project_root = ctx.obj.get("project_root") or Path.cwd()
+
+    console.print(
+        Panel.fit(
+            "[bold yellow]Removing MCP Integration[/bold yellow]\n"
+            f"📁 Project: {project_root}",
+            border_style="yellow",
+        )
+    )
+
+    try:
+        # Find configured platforms
+        print_info("🔍 Finding configured platforms...")
+        configured = find_configured_platforms()
+
+        if not configured:
+            print_info("No MCP integrations found to remove")
+            return
+
+        # Display configured platforms
+        table = Table(title="Configured MCP Platforms")
+        table.add_column("Platform", style="cyan")
+        table.add_column("Config Path", style="green")
+        table.add_column("Confidence", style="yellow")
+
+        for p in configured:
+            table.add_row(
+                p.platform.value,
+                str(p.config_path) if p.config_path else "N/A",
+                f"{p.confidence:.2f}",
+            )
+
+        console.print(table)
+
+        # Filter platforms
+        target_platforms = configured
+
+        if platform:
+            # Uninstall from specific platform
+            platform_enum = platform_name_to_enum(platform)
+            if not platform_enum:
+                print_error(f"Unknown platform: {platform}")
+                print_info(
+                    "Supported: claude-code, claude-desktop, cursor, auggie, codex, windsurf, gemini-cli"
+                )
+                raise typer.Exit(1)
+
+            target_platforms = [p for p in configured if p.platform == platform_enum]
+
+            if not target_platforms:
+                print_error(
+                    f"Platform '{platform}' does not have mcp-vector-search configured"
+                )
+                raise typer.Exit(1)
+
+        elif not all_platforms:
+            # By default, uninstall from highest confidence platform only
+            if configured:
+                max_confidence_platform = max(configured, key=lambda p: p.confidence)
+                target_platforms = [max_confidence_platform]
+                print_info(
+                    f"Removing from highest confidence platform: {max_confidence_platform.platform.value}"
+                )
+                print_info("Use --all to remove from all configured platforms")
+
+        # Show what will be removed
+        console.print("\n[bold]Target platforms:[/bold]")
+        for p in target_platforms:
+            console.print(f"  • {p.platform.value}")
+
+        # Confirm removal if multiple platforms
+        if len(target_platforms) > 1:
+            if not confirm_action("\nRemove from all these platforms?", default=False):
+                print_info("Cancelled")
+                raise typer.Exit(0)
+
+        # Uninstall from each platform
+        console.print("\n[bold]Removing integrations...[/bold]")
+        successful = 0
+        failed = 0
+
+        for platform_info in target_platforms:
+            if uninstall_from_platform(platform_info):
+                successful += 1
+            else:
+                failed += 1
+
+        # Summary
+        console.print("\n[bold green]✨ Removal Summary[/bold green]")
+        console.print(f"  ✅ Successful: {successful}")
+        if failed > 0:
+            console.print(f"  ❌ Failed: {failed}")
+
+        console.print("\n[dim]💡 Restart your AI coding tool to apply changes[/dim]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        logger.exception("MCP uninstallation failed")
+        print_error(f"Uninstallation failed: {e}")
+        raise typer.Exit(1)
+
+
+# ==============================================================================
+# List Configured Platforms Command
+# ==============================================================================
+
+
+@uninstall_app.command("list")
+def list_integrations(ctx: typer.Context) -> None:
+    """List all currently configured MCP integrations."""
+    console.print(
+        Panel.fit(
+            "[bold cyan]Configured MCP Integrations[/bold cyan]", border_style="cyan"
+        )
+    )
+
+    try:
+        configured = find_configured_platforms()
+
+        if not configured:
+            console.print("\n[yellow]No MCP integrations configured[/yellow]")
+            console.print(
+                "\n[dim]Use 'mcp-vector-search install mcp' to add integrations[/dim]"
+            )
+            return
+
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Platform", style="cyan")
+        table.add_column("Config Path")
+        table.add_column("Confidence", style="yellow")
+        table.add_column("Removal Command", style="dim")
+
+        for platform_info in configured:
+            table.add_row(
+                platform_info.platform.value,
+                str(platform_info.config_path) if platform_info.config_path else "N/A",
+                f"{platform_info.confidence:.2f}",
+                f"mcp-vector-search uninstall mcp --platform {platform_info.platform.value}",
+            )
+
+        console.print(table)
+
+        console.print("\n[bold blue]Removal Options:[/bold blue]")
+        console.print(
+            "  • Remove specific: [code]mcp-vector-search uninstall mcp --platform <name>[/code]"
+        )
+        console.print(
+            "  • Remove all:      [code]mcp-vector-search uninstall mcp --all[/code]"
+        )
+
+    except Exception as e:
+        logger.exception("Failed to list configured platforms")
+        print_error(f"Failed to list configured platforms: {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    uninstall_app()

mcp_vector_search/cli/commands/visualize/__init__.py

@@ -0,0 +1,39 @@
+"""Modular visualization package for code graphs.
+
+This package provides D3.js-based interactive visualization of code relationships,
+organized into modular components for maintainability.
+
+Structure:
+    - graph_builder.py: Graph data construction logic
+    - server.py: HTTP server for serving visualization
+    - templates/: HTML, CSS, and JavaScript generation
+    - exporters/: Export functionality (JSON, HTML)
+    - cli.py: Typer CLI commands (imported for backwards compatibility)
+"""
+
+from .cli import app
+from .exporters import export_to_html, export_to_json
+from .graph_builder import (
+    build_graph_data,
+    get_subproject_color,
+    parse_project_dependencies,
+)
+from .server import find_free_port, start_visualization_server
+from .templates import generate_html_template
+
+__all__ = [
+    # CLI
+    "app",
+    # Graph building
+    "build_graph_data",
+    "get_subproject_color",
+    "parse_project_dependencies",
+    # Server
+    "find_free_port",
+    "start_visualization_server",
+    # Templates
+    "generate_html_template",
+    # Exporters
+    "export_to_html",
+    "export_to_json",
+]

mcp_vector_search/cli/commands/visualize/cli.py

@@ -0,0 +1,265 @@
+"""Visualization commands for MCP Vector Search.
+
+This module provides a backwards-compatible interface to the refactored
+modular visualization components.
+"""
+
+import asyncio
+import shutil
+from fnmatch import fnmatch
+from pathlib import Path
+
+import typer
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+
+from ....core.database import ChromaVectorDatabase
+from ....core.embeddings import create_embedding_function
+from ....core.project import ProjectManager
+
+# Import from refactored modules (same directory)
+from .exporters import export_to_html, export_to_json
+from .graph_builder import build_graph_data
+from .server import find_free_port, start_visualization_server
+
+app = typer.Typer(
+    help="Visualize code chunk relationships",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command()
+def export(
+    output: Path = typer.Option(
+        Path("chunk-graph.json"),
+        "--output",
+        "-o",
+        help="Output file for chunk relationship data",
+    ),
+    file_path: str | None = typer.Option(
+        None,
+        "--file",
+        "-f",
+        help="Export only chunks from specific file (supports wildcards)",
+    ),
+    code_only: bool = typer.Option(
+        False,
+        "--code-only",
+        help="Exclude documentation chunks (text, comment, docstring)",
+    ),
+) -> None:
+    """Export chunk relationships as JSON for D3.js visualization.
+
+    Examples:
+        # Export all chunks
+        mcp-vector-search visualize export
+
+        # Export from specific file
+        mcp-vector-search visualize export --file src/main.py
+
+        # Custom output location
+        mcp-vector-search visualize export -o graph.json
+
+        # Export only code chunks (exclude documentation)
+        mcp-vector-search visualize export --code-only
+    """
+    asyncio.run(_export_chunks(output, file_path, code_only))
+
+
+async def _export_chunks(
+    output: Path, file_filter: str | None, code_only: bool = False
+) -> None:
+    """Export chunk relationship data.
+
+    Args:
+        output: Path to output JSON file
+        file_filter: Optional file pattern to filter chunks
+        code_only: If True, exclude documentation chunks (text, comment, docstring)
+    """
+    try:
+        # Load project
+        project_manager = ProjectManager(Path.cwd())
+
+        if not project_manager.is_initialized():
+            console.print(
+                "[red]Project not initialized. Run 'mcp-vector-search init' first.[/red]"
+            )
+            raise typer.Exit(1)
+
+        config = project_manager.load_config()
+
+        # Get database
+        embedding_function, _ = create_embedding_function(config.embedding_model)
+        database = ChromaVectorDatabase(
+            persist_directory=config.index_path,
+            embedding_function=embedding_function,
+        )
+        await database.initialize()
+
+        # Get all chunks with metadata
+        console.print("[cyan]Fetching chunks from database...[/cyan]")
+        chunks = await database.get_all_chunks()
+
+        if len(chunks) == 0:
+            console.print(
+                "[yellow]No chunks found in index. Run 'mcp-vector-search index' first.[/yellow]"
+            )
+            raise typer.Exit(1)
+
+        console.print(f"[green]✓[/green] Retrieved {len(chunks)} chunks")
+
+        # Apply file filter if specified
+        if file_filter:
+            chunks = [c for c in chunks if fnmatch(str(c.file_path), file_filter)]
+            console.print(
+                f"[cyan]Filtered to {len(chunks)} chunks matching '{file_filter}'[/cyan]"
+            )
+
+        # Apply code-only filter if requested
+        if code_only:
+            original_count = len(chunks)
+            chunks = [
+                c
+                for c in chunks
+                if c.chunk_type not in ["text", "comment", "docstring"]
+            ]
+            filtered_count = len(chunks)
+            console.print(
+                f"[dim]Filtered out {original_count - filtered_count} documentation chunks "
+                f"({original_count} → {filtered_count} chunks)[/dim]"
+            )
+
+        # Build graph data using refactored module
+        graph_data = await build_graph_data(
+            chunks=chunks,
+            database=database,
+            project_manager=project_manager,
+            code_only=code_only,
+        )
+
+        # Export to JSON using refactored module
+        export_to_json(graph_data, output)
+
+        await database.close()
+
+        console.print()
+        # Count cycles from graph_data links
+        cycles = [link for link in graph_data["links"] if link.get("is_cycle", False)]
+        cycle_warning = f"[yellow]Cycles: {len(cycles)} ⚠️[/yellow]\n" if cycles else ""
+
+        # Count subprojects
+        subprojects_count = len(graph_data["metadata"].get("subprojects", []))
+
+        console.print(
+            Panel.fit(
+                f"[green]✓[/green] Exported graph data to [cyan]{output}[/cyan]\n\n"
+                f"Nodes: {len(graph_data['nodes'])}\n"
+                f"Links: {len(graph_data['links'])}\n"
+                f"{cycle_warning}"
+                f"{'Subprojects: ' + str(subprojects_count) if subprojects_count else ''}\n\n"
+                f"[dim]Next: Run 'mcp-vector-search visualize serve' to view[/dim]",
+                title="Export Complete",
+                border_style="green",
+            )
+        )
+
+    except Exception as e:
+        logger.error(f"Export failed: {e}")
+        console.print(f"[red]✗ Export failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def serve(
+    port: int = typer.Option(
+        8080, "--port", "-p", help="Port for visualization server"
+    ),
+    graph_file: Path = typer.Option(
+        Path("chunk-graph.json"),
+        "--graph",
+        "-g",
+        help="Graph JSON file to visualize",
+    ),
+    code_only: bool = typer.Option(
+        False,
+        "--code-only",
+        help="Exclude documentation chunks (text, comment, docstring)",
+    ),
+) -> None:
+    """Start local HTTP server for D3.js visualization.
+
+    Examples:
+        # Start server on default port 8080
+        mcp-vector-search visualize serve
+
+        # Custom port
+        mcp-vector-search visualize serve --port 3000
+
+        # Custom graph file
+        mcp-vector-search visualize serve --graph my-graph.json
+
+        # Serve with code-only filter
+        mcp-vector-search visualize serve --code-only
+    """
+    # Use specified port or find free one
+    if port == 8080:  # Default port, try to find free one
+        try:
+            port = find_free_port(8080, 8099)
+        except OSError as e:
+            console.print(f"[red]✗ {e}[/red]")
+            raise typer.Exit(1)
+
+    # Get visualization directory - use project-local storage
+    project_manager = ProjectManager(Path.cwd())
+    if not project_manager.is_initialized():
+        console.print(
+            "[red]Project not initialized. Run 'mcp-vector-search init' first.[/red]"
+        )
+        raise typer.Exit(1)
+
+    viz_dir = project_manager.project_root / ".mcp-vector-search" / "visualization"
+
+    if not viz_dir.exists():
+        console.print(
+            f"[yellow]Visualization directory not found. Creating at {viz_dir}...[/yellow]"
+        )
+        viz_dir.mkdir(parents=True, exist_ok=True)
+
+    # Always ensure index.html exists (regenerate if missing)
+    html_file = viz_dir / "index.html"
+    if not html_file.exists():
+        console.print("[yellow]Creating visualization HTML file...[/yellow]")
+        export_to_html(html_file)
+
+    # Check if we need to regenerate the graph file
+    needs_regeneration = not graph_file.exists() or code_only
+
+    if graph_file.exists() and not needs_regeneration:
+        # Use existing unfiltered file
+        dest = viz_dir / "chunk-graph.json"
+        shutil.copy(graph_file, dest)
+        console.print(f"[green]✓[/green] Copied graph data to {dest}")
+    else:
+        # Generate new file (with filter if requested)
+        if graph_file.exists() and code_only:
+            console.print(
+                "[yellow]Regenerating filtered graph data (--code-only)...[/yellow]"
+            )
+        elif not graph_file.exists():
+            console.print(
+                f"[yellow]Graph file {graph_file} not found. Generating it now...[/yellow]"
+            )
+
+        asyncio.run(_export_chunks(graph_file, None, code_only))
+        console.print()
+
+        # Copy the newly generated graph to visualization directory
+        if graph_file.exists():
+            dest = viz_dir / "chunk-graph.json"
+            shutil.copy(graph_file, dest)
+            console.print(f"[green]✓[/green] Copied graph data to {dest}")
+
+    # Start server using refactored module
+    start_visualization_server(port, viz_dir, auto_open=True)