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

mcp_vector_search/cli/commands/init.py

@@ -0,0 +1,658 @@
+"""Init command for MCP Vector Search CLI."""
+
+from pathlib import Path
+
+import typer
+from loguru import logger
+
+from ...config.constants import (
+    SUBPROCESS_MCP_TIMEOUT,
+    SUBPROCESS_TEST_TIMEOUT,
+)
+from ...config.defaults import DEFAULT_EMBEDDING_MODELS, DEFAULT_FILE_EXTENSIONS
+from ...core.exceptions import ProjectInitializationError
+from ...core.project import ProjectManager
+from ..output import (
+    confirm_action,
+    console,
+    print_error,
+    print_info,
+    print_next_steps,
+    print_panel,
+    print_project_info,
+    print_success,
+    print_tip,
+    print_warning,
+)
+
+# Create init subcommand app
+init_app = typer.Typer(
+    help="Initialize project for semantic search",
+    invoke_without_command=True,
+    no_args_is_help=False,
+)
+
+
+@init_app.callback()
+def main(
+    ctx: typer.Context,
+    config_file: Path | None = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Configuration file to use",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        rich_help_panel="📁 Configuration",
+    ),
+    extensions: str | None = typer.Option(
+        None,
+        "--extensions",
+        "-e",
+        help="Comma-separated list of file extensions to index (e.g., '.py,.js,.ts,.txt,.md')",
+        rich_help_panel="📁 Configuration",
+    ),
+    embedding_model: str = typer.Option(
+        DEFAULT_EMBEDDING_MODELS["code"],
+        "--embedding-model",
+        "-m",
+        help="Embedding model to use for semantic search",
+        rich_help_panel="🧠 Model Settings",
+    ),
+    similarity_threshold: float = typer.Option(
+        0.5,
+        "--similarity-threshold",
+        "-s",
+        help="Similarity threshold for search results (0.0 to 1.0)",
+        min=0.0,
+        max=1.0,
+        rich_help_panel="🧠 Model Settings",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force re-initialization if project is already initialized",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+    auto_index: bool = typer.Option(
+        True,
+        "--auto-index/--no-auto-index",
+        help="Automatically start indexing after initialization",
+        rich_help_panel="🚀 Workflow Options",
+    ),
+    mcp: bool = typer.Option(
+        True,
+        "--mcp/--no-mcp",
+        help="Install Claude Code MCP integration after initialization",
+        rich_help_panel="🚀 Workflow Options",
+    ),
+    auto_indexing: bool = typer.Option(
+        True,
+        "--auto-indexing/--no-auto-indexing",
+        help="Set up automatic indexing for file changes",
+        rich_help_panel="🚀 Workflow Options",
+    ),
+) -> None:
+    """🚀 Complete project setup for semantic code search with MCP integration.
+
+    This command provides a comprehensive one-step installation that:
+
+    ✅ **Installs** mcp-vector-search in the current project
+    ✅ **Auto-detects** your project's programming languages and file types
+    ✅ **Initializes** vector database and configuration
+    ✅ **Indexes** your codebase automatically
+    ✅ **Sets up** auto-indexing for file changes
+    ✅ **Installs** Claude Code MCP integration with project-scoped .mcp.json
+    ✅ **Creates** shareable team configuration
+
+    Perfect for getting started quickly in any project!
+
+    [bold cyan]Examples:[/bold cyan]
+
+    [green]Basic setup (recommended):[/green]
+        $ mcp-vector-search init
+
+    [green]Quick setup without MCP:[/green]
+        $ mcp-vector-search init --no-mcp
+
+    [green]Custom file extensions:[/green]
+        $ mcp-vector-search init --extensions .py,.js,.ts,.txt,.md
+
+    [green]Re-initialize existing project:[/green]
+        $ mcp-vector-search init --force
+
+    [green]Setup without auto-indexing:[/green]
+        $ mcp-vector-search init --no-auto-index
+
+    [dim]💡 Tip: The command creates .mcp-vector-search/ for project config
+       and .mcp.json for MCP integration.[/dim]
+    """
+    # Only run main logic if no subcommand was invoked
+    if ctx.invoked_subcommand is not None:
+        return
+
+    try:
+        # Get project root from context or auto-detect
+        project_root = ctx.obj.get("project_root")
+        if not project_root:
+            project_root = Path.cwd()
+
+        print_info(f"Initializing project at: {project_root}")
+
+        # Create project manager
+        project_manager = ProjectManager(project_root)
+
+        # Check if already initialized
+        if project_manager.is_initialized() and not force:
+            print_success("Project is already initialized and ready to use!")
+            print_info("Your project has vector search capabilities enabled.")
+            print_info(
+                "Use --force to re-initialize or run 'mcp-vector-search status' to see current configuration"
+            )
+            return  # Exit gracefully without raising an exception
+
+        # Parse file extensions
+        file_extensions = None
+        if extensions:
+            file_extensions = [ext.strip() for ext in extensions.split(",")]
+            # Ensure extensions start with dot
+            file_extensions = [
+                ext if ext.startswith(".") else f".{ext}" for ext in file_extensions
+            ]
+        else:
+            file_extensions = DEFAULT_FILE_EXTENSIONS
+
+        # Show what will be initialized
+        console.print("\n[bold blue]🚀 MCP Vector Search Setup:[/bold blue]")
+        console.print(f"  📁 Project Root: {project_root}")
+        console.print(f"  📄 File Extensions: {', '.join(file_extensions)}")
+        console.print(f"  🧠 Embedding Model: {embedding_model}")
+        console.print(f"  🎯 Similarity Threshold: {similarity_threshold}")
+        console.print(
+            f"  🔍 Auto-indexing: {'✅ Enabled' if auto_index else '❌ Disabled'}"
+        )
+        console.print(
+            f"  ⚡ File watching: {'✅ Enabled' if auto_indexing else '❌ Disabled'}"
+        )
+        console.print(f"  🔗 Claude Code MCP: {'✅ Enabled' if mcp else '❌ Disabled'}")
+
+        # Confirm initialization (only if not using defaults)
+        if not force and (not auto_index or not mcp or not auto_indexing):
+            if not confirm_action("\nProceed with setup?", default=True):
+                print_info("Setup cancelled")
+                raise typer.Exit(0)
+
+        # Initialize project
+        console.print("\n[bold]Initializing project...[/bold]")
+
+        project_manager.initialize(
+            file_extensions=file_extensions,
+            embedding_model=embedding_model,
+            similarity_threshold=similarity_threshold,
+            force=force,
+        )
+
+        print_success("Project initialized successfully!")
+
+        # Show project information
+        console.print()
+        project_info = project_manager.get_project_info()
+        print_project_info(project_info)
+
+        # Start indexing if requested
+        if auto_index:
+            console.print("\n[bold]🔍 Indexing your codebase...[/bold]")
+
+            # Import and run indexing (avoid circular imports)
+            import asyncio
+
+            from .index import run_indexing
+
+            try:
+                asyncio.run(
+                    run_indexing(
+                        project_root=project_root,
+                        force_reindex=False,
+                        show_progress=True,
+                    )
+                )
+                print_success("✅ Indexing completed!")
+            except Exception as e:
+                print_error(f"❌ Indexing failed: {e}")
+                print_info(
+                    "You can run 'mcp-vector-search index' later to index your codebase"
+                )
+        else:
+            print_info(
+                "💡 Run 'mcp-vector-search index' to index your codebase when ready"
+            )
+
+        # Install MCP integration if requested
+        if mcp:
+            console.print("\n[bold]🔗 Installing Claude Code MCP integration...[/bold]")
+
+            try:
+                # Import MCP functionality
+                from .mcp import create_project_claude_config
+
+                # Create .mcp.json in project root with proper configuration
+                create_project_claude_config(
+                    project_root,
+                    "mcp-vector-search",
+                    enable_file_watching=auto_indexing,
+                )
+                print_success("✅ Claude Code MCP integration installed!")
+                print_info(
+                    "📁 Created .mcp.json for team sharing - commit this file to your repo"
+                )
+
+                # Also set up auto-indexing if requested
+                if auto_indexing:
+                    try:
+                        import asyncio
+
+                        from .auto_index import _setup_auto_indexing
+
+                        asyncio.run(_setup_auto_indexing(project_root, "search", 60, 5))
+                        print_success("⚡ Auto-indexing configured for file changes")
+                    except Exception as e:
+                        print_warning(f"Auto-indexing setup failed: {e}")
+                        print_info(
+                            "You can set it up later with: mcp-vector-search auto-index setup"
+                        )
+
+            except Exception as e:
+                print_warning(f"MCP integration failed: {e}")
+                print_info(
+                    "You can install it later with: mcp-vector-search mcp install"
+                )
+
+        # Show completion status and next steps
+        print_success("🎉 Setup Complete!")
+
+        if auto_index and mcp:
+            # Full setup completed
+            completed_items = [
+                "Vector database initialized",
+                "Codebase indexed and searchable",
+                "Auto-indexing enabled for file changes",
+                "Claude Code MCP integration installed",
+                "Team configuration saved in .mcp.json",
+            ]
+            print_panel(
+                "\n".join(f"  ✅ {item}" for item in completed_items),
+                title="✨ Your Project is Fully Configured",
+                border_style="green",
+            )
+
+            # Next steps for fully configured project
+            next_steps = [
+                "[cyan]mcp-vector-search search 'your query'[/cyan] - Search your code",
+                "Use MCP tools in Claude Code for AI-powered code search",
+                "[cyan]mcp-vector-search status[/cyan] - Check indexing statistics",
+            ]
+            print_next_steps(next_steps, title="Ready to Use")
+
+            print_tip("Commit .mcp.json to share MCP integration with your team!")
+        else:
+            # Partial setup - show what's next
+            steps = []
+            if not auto_index:
+                steps.append(
+                    "[cyan]mcp-vector-search index[/cyan] - Index your codebase"
+                )
+            steps.append(
+                "[cyan]mcp-vector-search search 'your query'[/cyan] - Try semantic search"
+            )
+            steps.append("[cyan]mcp-vector-search status[/cyan] - Check project status")
+            if not mcp:
+                steps.append(
+                    "[cyan]mcp-vector-search mcp install[/cyan] - Add Claude Code integration"
+                )
+
+            print_next_steps(steps)
+
+    except ProjectInitializationError as e:
+        print_error(f"Initialization failed: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        logger.error(f"Unexpected error during initialization: {e}")
+        print_error(f"Unexpected error: {e}")
+        raise typer.Exit(1)
+
+
+@init_app.command("check")
+def check_initialization(ctx: typer.Context) -> None:
+    """Check if the current project is initialized for MCP Vector Search."""
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        project_manager = ProjectManager(project_root)
+
+        if project_manager.is_initialized():
+            print_success(f"Project is initialized at {project_root}")
+
+            # Show project info
+            project_info = project_manager.get_project_info()
+            print_project_info(project_info)
+        else:
+            print_error(f"Project is not initialized at {project_root}")
+            print_info("Run 'mcp-vector-search init' to initialize the project")
+            raise typer.Exit(1)
+
+    except Exception as e:
+        logger.error(f"Error checking initialization: {e}")
+        print_error(f"Error: {e}")
+        raise typer.Exit(1)
+
+
+async def run_init_setup(
+    project_root: Path,
+    file_extensions: list[str] | None = None,
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2",
+    similarity_threshold: float = 0.5,
+    mcp: bool = True,
+    auto_index: bool = True,
+    auto_indexing: bool = True,
+    force: bool = False,
+) -> None:
+    """Reusable initialization setup function.
+
+    This function contains the core initialization logic that can be used
+    by both the init command and the install command.
+    """
+    from ...config.defaults import DEFAULT_FILE_EXTENSIONS
+    from ...core.project import ProjectManager
+    from ..output import print_project_info
+
+    # Create project manager
+    project_manager = ProjectManager(project_root)
+
+    # Parse file extensions
+    if not file_extensions:
+        file_extensions = DEFAULT_FILE_EXTENSIONS
+
+    # Initialize project
+    project_manager.initialize(
+        file_extensions=file_extensions,
+        embedding_model=embedding_model,
+        similarity_threshold=similarity_threshold,
+        force=force,
+    )
+
+    print_success("Project initialized successfully!")
+
+    # Show project information
+    project_info = project_manager.get_project_info()
+    print_project_info(project_info)
+
+    # Start indexing if requested
+    if auto_index:
+        console.print("\n[bold]🔍 Indexing your codebase...[/bold]")
+
+        # Import and run indexing (avoid circular imports)
+        from .index import run_indexing
+
+        try:
+            await run_indexing(
+                project_root=project_root,
+                force_reindex=False,
+                show_progress=True,
+            )
+            print_success("✅ Indexing completed!")
+        except Exception as e:
+            print_error(f"❌ Indexing failed: {e}")
+            print_info(
+                "You can run 'mcp-vector-search index' later to index your codebase"
+            )
+    else:
+        print_info("💡 Run 'mcp-vector-search index' to index your codebase when ready")
+
+    # Install MCP integration if requested
+    if mcp:
+        console.print("\n[bold]🔗 Installing Claude Code MCP integration...[/bold]")
+
+        try:
+            # Import MCP functionality
+            import subprocess
+
+            from .mcp import (
+                check_claude_code_available,
+                get_claude_command,
+                get_mcp_server_command,
+            )
+
+            # Check if Claude Code is available
+            if not check_claude_code_available():
+                print_warning("Claude Code not found. Skipping MCP integration.")
+                print_info("Install Claude Code from: https://claude.ai/download")
+            else:
+                claude_cmd = get_claude_command()
+                server_command = get_mcp_server_command(project_root)
+
+                # First, try to remove existing server (safe to ignore if doesn't exist)
+                # This ensures clean registration when server already exists
+                print_info("Updating MCP server configuration...")
+                remove_cmd = [claude_cmd, "mcp", "remove", "mcp-vector-search"]
+
+                subprocess.run(
+                    remove_cmd,
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                # Ignore result - it's OK if server doesn't exist
+
+                # Install MCP server with project scope for team sharing
+                cmd_args = [
+                    claude_cmd,
+                    "mcp",
+                    "add",
+                    "--scope=project",  # Use project scope for team sharing
+                    "mcp-vector-search",
+                    "--",
+                ] + server_command.split()
+
+                result = subprocess.run(
+                    cmd_args,
+                    capture_output=True,
+                    text=True,
+                    timeout=SUBPROCESS_MCP_TIMEOUT,
+                )
+
+                if result.returncode == 0:
+                    print_success("✅ Claude Code MCP integration installed!")
+                    print_info(
+                        "📁 Created .mcp.json for team sharing - commit this file to your repo"
+                    )
+
+                    # Also set up auto-indexing if requested
+                    if auto_indexing:
+                        try:
+                            from .auto_index import _setup_auto_indexing
+
+                            await _setup_auto_indexing(project_root, "search", 60, 5)
+                            print_success(
+                                "⚡ Auto-indexing configured for file changes"
+                            )
+                        except Exception as e:
+                            print_warning(f"Auto-indexing setup failed: {e}")
+                            print_info(
+                                "You can set it up later with: mcp-vector-search auto-index setup"
+                            )
+                else:
+                    print_warning(f"MCP integration failed: {result.stderr}")
+                    print_info(
+                        "You can install it later with: mcp-vector-search mcp install"
+                    )
+
+        except Exception as e:
+            print_warning(f"MCP integration failed: {e}")
+            print_info("You can install it later with: mcp-vector-search mcp install")
+
+
+@init_app.command("mcp")
+def init_mcp_integration(
+    ctx: typer.Context,
+    server_name: str = typer.Option(
+        "mcp-vector-search", "--name", help="Name for the MCP server"
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force installation even if server already exists"
+    ),
+) -> None:
+    """Install/fix Claude Code MCP integration for the current project.
+
+    This command sets up MCP integration by:
+    ✅ Creating project-level .claude.json configuration
+    ✅ Testing server startup and connectivity
+    ✅ Providing troubleshooting information if needed
+
+    Perfect for fixing MCP integration issues or setting up team-shared configuration.
+    """
+    try:
+        # Import MCP functions
+        import json
+
+        from .mcp import (
+            check_claude_code_available,
+            create_project_claude_config,
+        )
+
+        # Get project root
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+
+        # Check if project is initialized
+        project_manager = ProjectManager(project_root)
+        if not project_manager.is_initialized():
+            print_error("Project not initialized. Run 'mcp-vector-search init' first.")
+            raise typer.Exit(1)
+
+        print_info(f"Setting up MCP integration for project: {project_root}")
+
+        # Check if project-level .mcp.json already has the server
+        mcp_config_path = project_root / ".mcp.json"
+        if mcp_config_path.exists() and not force:
+            with open(mcp_config_path) as f:
+                config = json.load(f)
+            if config.get("mcpServers", {}).get(server_name):
+                print_warning(f"MCP server '{server_name}' already exists in .mcp.json")
+                print_info("Use --force to overwrite or try a different --name")
+
+                # Still test the existing configuration
+                print_info("Testing existing configuration...")
+                _test_mcp_server(project_root)
+                return
+
+        # Create project-level configuration
+        create_project_claude_config(project_root, server_name)
+
+        print_success(
+            f"✅ MCP server '{server_name}' installed in project configuration"
+        )
+        print_info(
+            "📁 Created .mcp.json for team sharing - commit this file to your repo"
+        )
+
+        # Test the server
+        print_info("Testing server startup...")
+        _test_mcp_server(project_root)
+
+        # Check if Claude Code is available and provide guidance
+        if not check_claude_code_available():
+            print_warning("⚠️  Claude Code not detected on this system")
+            print_info("📥 Install Claude Code from: https://claude.ai/download")
+            print_info(
+                "🔄 After installation, restart Claude Code to detect the MCP server"
+            )
+        else:
+            print_success(
+                "✅ Claude Code detected - server should be available automatically"
+            )
+            print_info(
+                "🔄 If Claude Code is running, restart it to detect the new server"
+            )
+
+        print_info("\n📋 Next steps:")
+        print_info("  1. Restart Claude Code if it's currently running")
+        print_info("  2. Open this project in Claude Code")
+        print_info("  3. The MCP server should appear automatically in the tools list")
+        print_info(
+            "  4. Test with: 'Search for functions that handle user authentication'"
+        )
+
+    except Exception as e:
+        logger.error(f"MCP integration setup failed: {e}")
+        print_error(f"MCP integration setup failed: {e}")
+        raise typer.Exit(1)
+
+
+def _test_mcp_server(project_root: Path) -> None:
+    """Test MCP server startup and basic functionality."""
+    try:
+        import json
+        import subprocess
+
+        from .mcp import get_mcp_server_command
+
+        server_command = get_mcp_server_command(project_root)
+        test_process = subprocess.Popen(
+            server_command.split(),
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+
+        # Send a simple initialization request
+        init_request = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "test", "version": "1.0.0"},
+            },
+        }
+
+        try:
+            stdout, stderr = test_process.communicate(
+                input=json.dumps(init_request) + "\n", timeout=SUBPROCESS_TEST_TIMEOUT
+            )
+
+            if test_process.returncode == 0:
+                print_success("✅ Server startup test passed")
+            else:
+                print_warning(
+                    f"⚠️  Server test failed with return code {test_process.returncode}"
+                )
+                if stderr:
+                    print_info(f"Error output: {stderr}")
+
+        except subprocess.TimeoutExpired:
+            test_process.kill()
+            print_warning("⚠️  Server test timed out (this may be normal)")
+
+    except Exception as e:
+        print_warning(f"⚠️  Server test failed: {e}")
+        print_info("This may be normal - the server should still work with Claude Code")
+
+
+@init_app.command("models")
+def list_embedding_models() -> None:
+    """List available embedding models."""
+    console.print("[bold blue]Available Embedding Models:[/bold blue]\n")
+
+    for category, model in DEFAULT_EMBEDDING_MODELS.items():
+        console.print(f"[cyan]{category.title()}:[/cyan] {model}")
+
+    console.print(
+        "\n[dim]You can also use any model from Hugging Face that's compatible with sentence-transformers[/dim]"
+    )
+
+
+if __name__ == "__main__":
+    init_app()