mcp-vector-search 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

mcp_vector_search/cli/commands/mcp.py

@@ -1,11 +1,13 @@
-"""MCP integration commands for Claude Code."""
+"""MCP integration commands for multiple AI tools."""
 
 import json
 import os
 import shutil
 import subprocess
 import sys
+import tomllib
 from pathlib import Path
+from typing import Any
 
 import typer
 from rich.console import Console
@@ -18,10 +20,57 @@ from ..didyoumean import create_enhanced_typer
 from ..output import print_error, print_info, print_success, print_warning
 
 # Create MCP subcommand app with "did you mean" functionality
-mcp_app = create_enhanced_typer(help="Manage Claude Code MCP integration")
+mcp_app = create_enhanced_typer(
+    help="""🤖 Manage MCP integration for AI tools
+
+Configure mcp-vector-search as an MCP server for various AI coding assistants.
+Each tool has its own configuration format and location.
+
+[bold cyan]Supported Tools:[/bold cyan]
+  • [green]auggie[/green]      - Augment Code AI assistant
+  • [green]claude-code[/green] - Claude Code (project-scoped)
+  • [green]codex[/green]       - OpenAI Codex CLI
+  • [green]gemini[/green]      - Google Gemini CLI
+
+[bold cyan]Quick Start:[/bold cyan]
+  1. List tools:     [green]mcp-vector-search mcp list[/green]
+  2. Configure tool: [green]mcp-vector-search mcp <tool>[/green]
+  3. Test setup:     [green]mcp-vector-search mcp test[/green]
+
+[dim]Use --force to overwrite existing configurations[/dim]
+"""
+)
 
 console = Console()
 
+# Supported AI tools and their configuration details
+SUPPORTED_TOOLS = {
+    "auggie": {
+        "name": "Auggie",
+        "config_path": "~/.augment/settings.json",
+        "format": "json",
+        "description": "Augment Code AI assistant",
+    },
+    "claude-code": {
+        "name": "Claude Code",
+        "config_path": ".mcp.json",
+        "format": "json",
+        "description": "Claude Code (project-scoped)",
+    },
+    "codex": {
+        "name": "Codex",
+        "config_path": "~/.codex/config.toml",
+        "format": "toml",
+        "description": "OpenAI Codex CLI",
+    },
+    "gemini": {
+        "name": "Gemini",
+        "config_path": "~/.gemini/mcp.json",
+        "format": "json",
+        "description": "Google Gemini CLI",
+    },
+}
+
 
 def get_claude_command() -> str | None:
     """Get the Claude Code command path."""
@@ -74,6 +123,42 @@ def get_mcp_server_command(
     return f"{python_exe} -m mcp_vector_search.mcp.server{watch_flag} {project_root}"
 
 
+def get_mcp_server_config_for_tool(
+    project_root: Path,
+    tool_name: str,
+    server_name: str,
+    enable_file_watching: bool = True,
+) -> dict[str, Any]:
+    """Generate MCP server configuration for a specific tool."""
+    base_config = {
+        "command": "uv",
+        "args": ["run", "mcp-vector-search", "mcp"],
+        "env": {
+            "MCP_ENABLE_FILE_WATCHING": "true" if enable_file_watching else "false"
+        },
+    }
+
+    if tool_name == "auggie":
+        # Auggie uses stdio transport
+        return base_config
+    elif tool_name == "claude-code":
+        # Claude Code requires type: stdio and no cwd
+        return {"type": "stdio", **base_config}
+    elif tool_name == "codex":
+        # Codex uses TOML format with different structure
+        return {
+            "command": base_config["command"],
+            "args": base_config["args"],
+            "env": base_config["env"],
+        }
+    elif tool_name == "gemini":
+        # Gemini uses standard format with cwd
+        return {**base_config, "cwd": str(project_root.absolute())}
+    else:
+        # Default configuration
+        return {**base_config, "cwd": str(project_root.absolute())}
+
+
 def create_project_claude_config(
     project_root: Path, server_name: str, enable_file_watching: bool = True
 ) -> None:
@@ -119,9 +204,254 @@ def create_project_claude_config(
         print_info("File watching is disabled")
 
 
-@mcp_app.command("install")
-@mcp_app.command("init", hidden=False)  # Add 'init' as an alias
-def install_mcp_integration(
+def configure_tool_mcp(
+    tool_name: str,
+    project_root: Path,
+    server_name: str = "mcp-vector-search",
+    enable_file_watching: bool = True,
+    force: bool = False,
+) -> bool:
+    """Configure MCP integration for a specific AI tool."""
+    if tool_name not in SUPPORTED_TOOLS:
+        print_error(f"Unsupported tool: {tool_name}")
+        print_info(f"Supported tools: {', '.join(SUPPORTED_TOOLS.keys())}")
+        return False
+
+    tool_info = SUPPORTED_TOOLS[tool_name]
+    config_path_str = tool_info["config_path"]
+
+    # Handle path expansion
+    if config_path_str.startswith("~/"):
+        config_path = Path.home() / config_path_str[2:]
+    elif config_path_str.startswith("."):
+        config_path = project_root / config_path_str
+    else:
+        config_path = Path(config_path_str)
+
+    try:
+        if tool_name == "auggie":
+            return configure_auggie_mcp(
+                config_path, project_root, server_name, enable_file_watching, force
+            )
+        elif tool_name == "claude-code":
+            return configure_claude_code_mcp(
+                config_path, project_root, server_name, enable_file_watching, force
+            )
+        elif tool_name == "codex":
+            return configure_codex_mcp(
+                config_path, project_root, server_name, enable_file_watching, force
+            )
+        elif tool_name == "gemini":
+            return configure_gemini_mcp(
+                config_path, project_root, server_name, enable_file_watching, force
+            )
+        else:
+            print_error(f"Configuration for {tool_name} not implemented yet")
+            return False
+    except Exception as e:
+        print_error(f"Failed to configure {tool_name}: {e}")
+        return False
+
+
+def configure_auggie_mcp(
+    config_path: Path,
+    project_root: Path,
+    server_name: str,
+    enable_file_watching: bool,
+    force: bool,
+) -> bool:
+    """Configure Auggie MCP integration."""
+    # Create backup if file exists
+    backup_path = config_path.with_suffix(config_path.suffix + ".backup")
+
+    # Load existing config or create new one
+    if config_path.exists():
+        if not force:
+            with open(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 Auggie config"
+                )
+                print_info("Use --force to overwrite")
+                return False
+        shutil.copy2(config_path, backup_path)
+        with open(config_path) as f:
+            config = json.load(f)
+    else:
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config = {}
+
+    # Ensure mcpServers section exists
+    if "mcpServers" not in config:
+        config["mcpServers"] = {}
+
+    # Get server configuration
+    server_config = get_mcp_server_config_for_tool(
+        project_root, "auggie", server_name, enable_file_watching
+    )
+    config["mcpServers"][server_name] = server_config
+
+    # Write updated config
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+    print_success(f"✅ Configured Auggie at {config_path}")
+    return True
+
+
+def configure_claude_code_mcp(
+    config_path: Path,
+    project_root: Path,
+    server_name: str,
+    enable_file_watching: bool,
+    force: bool,
+) -> bool:
+    """Configure Claude Code MCP integration."""
+    # Use existing function for Claude Code
+    if config_path.exists() and not force:
+        with open(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 Claude Code config"
+            )
+            print_info("Use --force to overwrite")
+            return False
+
+    create_project_claude_config(project_root, server_name, enable_file_watching)
+    print_success(f"✅ Configured Claude Code at {config_path}")
+    return True
+
+
+def configure_codex_mcp(
+    config_path: Path,
+    project_root: Path,
+    server_name: str,
+    enable_file_watching: bool,
+    force: bool,
+) -> bool:
+    """Configure Codex MCP integration."""
+    # Create backup if file exists
+    backup_path = config_path.with_suffix(config_path.suffix + ".backup")
+
+    # Load existing config or create new one
+    if config_path.exists():
+        if not force:
+            try:
+                with open(config_path, "rb") as f:
+                    config = tomllib.load(f)
+                if config.get("mcp_servers", {}).get(server_name):
+                    print_warning(
+                        f"MCP server '{server_name}' already exists in Codex config"
+                    )
+                    print_info("Use --force to overwrite")
+                    return False
+            except Exception as e:
+                print_warning(f"Could not parse existing Codex config: {e}")
+
+        shutil.copy2(config_path, backup_path)
+        # Read as text to preserve existing content
+        with open(config_path) as f:
+            config_text = f.read()
+    else:
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_text = ""
+
+    # Get server configuration
+    server_config = get_mcp_server_config_for_tool(
+        project_root, "codex", server_name, enable_file_watching
+    )
+
+    # Generate TOML section for the server
+    toml_section = f"\n[mcp_servers.{server_name}]\n"
+    toml_section += f'command = "{server_config["command"]}"\n'
+    toml_section += f"args = {server_config['args']}\n"
+
+    if server_config.get("env"):
+        toml_section += f"\n[mcp_servers.{server_name}.env]\n"
+        for key, value in server_config["env"].items():
+            toml_section += f'{key} = "{value}"\n'
+
+    # Append or replace the section
+    if f"[mcp_servers.{server_name}]" in config_text:
+        # Replace existing section (simple approach)
+        lines = config_text.split("\n")
+        new_lines = []
+        skip_section = False
+
+        for line in lines:
+            if line.strip() == f"[mcp_servers.{server_name}]":
+                skip_section = True
+                continue
+            elif line.strip().startswith("[") and skip_section:
+                skip_section = False
+                new_lines.append(line)
+            elif not skip_section:
+                new_lines.append(line)
+
+        config_text = "\n".join(new_lines) + toml_section
+    else:
+        config_text += toml_section
+
+    # Write updated config
+    with open(config_path, "w") as f:
+        f.write(config_text)
+
+    print_success(f"✅ Configured Codex at {config_path}")
+    return True
+
+
+def configure_gemini_mcp(
+    config_path: Path,
+    project_root: Path,
+    server_name: str,
+    enable_file_watching: bool,
+    force: bool,
+) -> bool:
+    """Configure Gemini MCP integration."""
+    # Create backup if file exists
+    backup_path = config_path.with_suffix(config_path.suffix + ".backup")
+
+    # Load existing config or create new one
+    if config_path.exists():
+        if not force:
+            with open(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 Gemini config"
+                )
+                print_info("Use --force to overwrite")
+                return False
+        shutil.copy2(config_path, backup_path)
+        with open(config_path) as f:
+            config = json.load(f)
+    else:
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config = {}
+
+    # Ensure mcpServers section exists
+    if "mcpServers" not in config:
+        config["mcpServers"] = {}
+
+    # Get server configuration
+    server_config = get_mcp_server_config_for_tool(
+        project_root, "gemini", server_name, enable_file_watching
+    )
+    config["mcpServers"][server_name] = server_config
+
+    # Write updated config
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+    print_success(f"✅ Configured Gemini at {config_path}")
+    return True
+
+
+# Tool-specific commands
+@mcp_app.command("auggie")
+def configure_auggie(
     ctx: typer.Context,
     server_name: str = typer.Option(
         "mcp-vector-search",
@@ -143,59 +473,298 @@ def install_mcp_integration(
         rich_help_panel="⚙️  Advanced Options",
     ),
 ) -> None:
-    """🔗 Install MCP integration for Claude Code in the current project.
+    """🤖 Configure MCP integration for Auggie AI.
 
-    Creates .mcp.json to enable semantic code search in Claude Code.
-    The integration provides AI-powered semantic search tools directly in Claude Code.
+    Sets up mcp-vector-search as an MCP server for Auggie AI assistant.
+    Configuration is stored in ~/.augment/settings.json.
 
-    [bold cyan]Basic Examples:[/bold cyan]
+    [bold cyan]Examples:[/bold cyan]
 
-    [green]Install with defaults:[/green]
-        $ mcp-vector-search mcp install
+    [green]Configure with defaults:[/green]
+        $ mcp-vector-search mcp auggie
 
-    [green]Install with custom server name:[/green]
-        $ mcp-vector-search mcp install --name my-search-server
+    [green]Force overwrite existing config:[/green]
+        $ mcp-vector-search mcp auggie --force
 
-    [green]Reinstall/update configuration:[/green]
-        $ mcp-vector-search mcp install --force
+    [green]Disable file watching:[/green]
+        $ mcp-vector-search mcp auggie --no-watch
+    """
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        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)
 
-    [bold cyan]Advanced:[/bold cyan]
+        enable_file_watching = not no_watch
+        success = configure_tool_mcp(
+            "auggie", project_root, server_name, enable_file_watching, force
+        )
 
-    [green]Disable file watching:[/green]
-        $ mcp-vector-search mcp install --no-watch
+        if success:
+            print_info("Auggie will automatically detect the server when restarted")
+        else:
+            raise typer.Exit(1)
+
+    except Exception as e:
+        print_error(f"Configuration failed: {e}")
+        raise typer.Exit(1)
 
-    [dim]💡 Tip: The .mcp.json file can be committed to share
-       MCP integration with your team.[/dim]
+
+@mcp_app.command("claude-code")
+def configure_claude_code(
+    ctx: typer.Context,
+    server_name: str = typer.Option(
+        "mcp-vector-search",
+        "--name",
+        help="Name for the MCP server",
+        rich_help_panel="📁 Configuration",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force installation even if server already exists",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+    no_watch: bool = typer.Option(
+        False,
+        "--no-watch",
+        help="Disable file watching for automatic reindexing",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+) -> None:
+    """🤖 Configure MCP integration for Claude Code.
+
+    Creates .mcp.json to enable semantic code search in Claude Code.
+    Configuration is project-scoped for team sharing.
+
+    [bold cyan]Examples:[/bold cyan]
+
+    [green]Configure with defaults:[/green]
+        $ mcp-vector-search mcp claude-code
+
+    [green]Force overwrite existing config:[/green]
+        $ mcp-vector-search mcp claude-code --force
+
+    [green]Disable file watching:[/green]
+        $ mcp-vector-search mcp claude-code --no-watch
     """
     try:
-        # Get project root for checking initialization
         project_root = ctx.obj.get("project_root") or Path.cwd()
+        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)
+
+        enable_file_watching = not no_watch
+        success = configure_tool_mcp(
+            "claude-code", project_root, server_name, enable_file_watching, force
+        )
+
+        if success:
+            print_info(
+                "Claude Code will automatically detect the server when you open this project"
+            )
+        else:
+            raise typer.Exit(1)
+
+    except Exception as e:
+        print_error(f"Configuration failed: {e}")
+        raise typer.Exit(1)
+
 
-        # Check if project is initialized
+@mcp_app.command("codex")
+def configure_codex(
+    ctx: typer.Context,
+    server_name: str = typer.Option(
+        "mcp-vector-search",
+        "--name",
+        help="Name for the MCP server",
+        rich_help_panel="📁 Configuration",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force installation even if server already exists",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+    no_watch: bool = typer.Option(
+        False,
+        "--no-watch",
+        help="Disable file watching for automatic reindexing",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+) -> None:
+    """🤖 Configure MCP integration for OpenAI Codex.
+
+    Sets up mcp-vector-search as an MCP server for OpenAI Codex CLI.
+    Configuration is stored in ~/.codex/config.toml.
+
+    [bold cyan]Examples:[/bold cyan]
+
+    [green]Configure with defaults:[/green]
+        $ mcp-vector-search mcp codex
+
+    [green]Force overwrite existing config:[/green]
+        $ mcp-vector-search mcp codex --force
+
+    [green]Disable file watching:[/green]
+        $ mcp-vector-search mcp codex --no-watch
+    """
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
         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)
 
-        # Check if .mcp.json already has the server configuration
-        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")
-                raise typer.Exit(1)
+        enable_file_watching = not no_watch
+        success = configure_tool_mcp(
+            "codex", project_root, server_name, enable_file_watching, force
+        )
+
+        if success:
+            print_info("Codex will automatically detect the server when restarted")
+        else:
+            raise typer.Exit(1)
+
+    except Exception as e:
+        print_error(f"Configuration failed: {e}")
+        raise typer.Exit(1)
+
+
+@mcp_app.command("gemini")
+def configure_gemini(
+    ctx: typer.Context,
+    server_name: str = typer.Option(
+        "mcp-vector-search",
+        "--name",
+        help="Name for the MCP server",
+        rich_help_panel="📁 Configuration",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force installation even if server already exists",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+    no_watch: bool = typer.Option(
+        False,
+        "--no-watch",
+        help="Disable file watching for automatic reindexing",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+) -> None:
+    """🤖 Configure MCP integration for Google Gemini.
+
+    Sets up mcp-vector-search as an MCP server for Google Gemini CLI.
+    Configuration is stored in ~/.gemini/mcp.json.
+
+    [bold cyan]Examples:[/bold cyan]
+
+    [green]Configure with defaults:[/green]
+        $ mcp-vector-search mcp gemini
+
+    [green]Force overwrite existing config:[/green]
+        $ mcp-vector-search mcp gemini --force
+
+    [green]Disable file watching:[/green]
+        $ mcp-vector-search mcp gemini --no-watch
+    """
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        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)
 
-        # Create configuration in project root
         enable_file_watching = not no_watch
-        create_project_claude_config(project_root, server_name, enable_file_watching)
+        success = configure_tool_mcp(
+            "gemini", project_root, server_name, enable_file_watching, force
+        )
 
-        print_info(f"MCP server '{server_name}' installed in {mcp_config_path}")
-        print_info(
-            "Claude Code will automatically detect the server when you open this project"
+        if success:
+            print_info("Gemini will automatically detect the server when restarted")
+        else:
+            raise typer.Exit(1)
+
+    except Exception as e:
+        print_error(f"Configuration failed: {e}")
+        raise typer.Exit(1)
+
+
+# Legacy install command (deprecated)
+@mcp_app.command("install", hidden=True)
+@mcp_app.command("init", hidden=True)  # Add 'init' as an alias
+def install_mcp_integration(
+    ctx: typer.Context,
+    server_name: str = typer.Option(
+        "mcp-vector-search",
+        "--name",
+        help="Name for the MCP server",
+        rich_help_panel="📁 Configuration",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force installation even if server already exists",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+    no_watch: bool = typer.Option(
+        False,
+        "--no-watch",
+        help="Disable file watching for automatic reindexing",
+        rich_help_panel="⚙️  Advanced Options",
+    ),
+) -> None:
+    """[DEPRECATED] Use tool-specific commands instead.
+
+    This command is deprecated. Use the tool-specific commands instead:
+
+    [bold cyan]New Commands:[/bold cyan]
+
+    [green]For Auggie:[/green]
+        $ mcp-vector-search mcp auggie
+
+    [green]For Claude Code:[/green]
+        $ mcp-vector-search mcp claude-code
+
+    [green]For Codex:[/green]
+        $ mcp-vector-search mcp codex
+
+    [green]For Gemini:[/green]
+        $ mcp-vector-search mcp gemini
+    """
+    print_warning("⚠️  The 'mcp install' command is deprecated.")
+    print_info("Use tool-specific commands instead:")
+    print_info("  • mcp-vector-search mcp auggie")
+    print_info("  • mcp-vector-search mcp claude-code")
+    print_info("  • mcp-vector-search mcp codex")
+    print_info("  • mcp-vector-search mcp gemini")
+    print_info("")
+    print_info("Defaulting to Claude Code configuration...")
+
+    try:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        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)
+
+        enable_file_watching = not no_watch
+        success = configure_tool_mcp(
+            "claude-code", project_root, server_name, enable_file_watching, force
         )
 
+        if success:
+            print_info(
+                "Claude Code will automatically detect the server when you open this project"
+            )
+
         # Test the server (using project_root for the server command)
         print_info("Testing server startup...")
 
@@ -277,6 +846,74 @@ def install_mcp_integration(
         raise typer.Exit(1)
 
 
+@mcp_app.command("list")
+def list_tools() -> None:
+    """📋 List supported AI tools and their configuration status.
+
+    Shows all supported AI tools, their configuration paths, and whether
+    they are currently configured with mcp-vector-search.
+
+    [bold cyan]Examples:[/bold cyan]
+
+    [green]List all tools:[/green]
+        $ mcp-vector-search mcp list
+    """
+    console.print("\n[bold blue]🤖 Supported AI Tools[/bold blue]\n")
+
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Tool", style="cyan", no_wrap=True)
+    table.add_column("Name", style="white")
+    table.add_column("Config Path", style="dim")
+    table.add_column("Status", justify="center")
+
+    for tool_id, tool_info in SUPPORTED_TOOLS.items():
+        config_path_str = tool_info["config_path"]
+
+        # Handle path expansion
+        if config_path_str.startswith("~/"):
+            config_path = Path.home() / config_path_str[2:]
+        elif config_path_str.startswith("."):
+            config_path = Path.cwd() / config_path_str
+        else:
+            config_path = Path(config_path_str)
+
+        # Check if configured
+        status = "❌ Not configured"
+        try:
+            if config_path.exists():
+                if tool_info["format"] == "json":
+                    with open(config_path) as f:
+                        config = json.load(f)
+                    if config.get("mcpServers", {}).get("mcp-vector-search"):
+                        status = "✅ Configured"
+                    else:
+                        status = "⚠️  Config exists"
+                elif tool_info["format"] == "toml":
+                    with open(config_path, "rb") as f:
+                        config = tomllib.load(f)
+                    if config.get("mcp_servers", {}).get("mcp-vector-search"):
+                        status = "✅ Configured"
+                    else:
+                        status = "⚠️  Config exists"
+            else:
+                status = "❌ No config file"
+        except Exception:
+            status = "❓ Unknown"
+
+        table.add_row(tool_id, tool_info["name"], str(config_path), status)
+
+    console.print(table)
+    console.print(
+        "\n[dim]💡 Use 'mcp-vector-search mcp <tool>' to configure a specific tool[/dim]"
+    )
+
+
+@mcp_app.command("tools")
+def list_tools_alias() -> None:
+    """📋 Alias for 'list' command."""
+    list_tools()
+
+
 @mcp_app.command("test")
 def test_mcp_integration(
     ctx: typer.Context,