claude-mpm 4.3.11__py3-none-any.whl → 4.3.13__py3-none-any.whl

claude_mpm/cli/commands/monitor.py

@@ -37,7 +37,7 @@ class MonitorCommand(BaseCommand):
 
         return None
 
-    def run(self, args) -> CommandResult:
+    def run(self, args) -> CommandResult:  # noqa: PLR0911
         """Execute the monitor command using unified monitoring daemon."""
         try:
             self.logger.info("Monitor command using unified monitoring daemon")
@@ -142,7 +142,7 @@ class MonitorCommand(BaseCommand):
             return CommandResult.error_result(
                 f"Port {port} is already in use. Try 'claude-mpm monitor stop' first or use a different port."
             )
-        except:
+        except Exception:
             pass
 
         return CommandResult.error_result(

claude_mpm/cli/commands/mpm_init_handler.py

@@ -11,7 +11,7 @@ from rich.console import Console
 console = Console()
 
 
-def manage_mpm_init(args):
+def manage_mpm_init(args):  # noqa: PLR0911
     """
     Handle mpm-init command execution.
 

claude_mpm/cli/commands/run.py

@@ -68,6 +68,7 @@ def filter_claude_mpm_args(claude_args):
         "--no-native-agents",
         "--launch-method",
         "--mpm-resume",
+        "--reload-agents",  # New flag to force rebuild system agents
         # Dependency checking flags (MPM-specific)
         "--no-check-dependencies",
         "--force-check-dependencies",
@@ -568,6 +569,112 @@ class RunCommand(BaseCommand):
             return False
 
 
+def _ensure_mcp_services_configured(logger):
+    """
+    Ensure MCP services are configured in .mcp.json on startup.
+
+    This function automatically configures the core MCP services
+    (mcp-vector-search, mcp-browser, mcp-ticketer) if they're not
+    already configured in the project's .mcp.json file.
+
+    Args:
+        logger: Logger instance for output
+    """
+    try:
+        from ...services.mcp_config_manager import MCPConfigManager
+
+        logger.debug("Checking MCP service configuration...")
+        manager = MCPConfigManager()
+
+        # Check and auto-configure missing MCP services
+        success, message = manager.ensure_mcp_services_configured()
+
+        if success:
+            if "already configured" not in message.lower():
+                logger.info(message)
+                print(f"✅ {message}")
+            else:
+                logger.debug(message)
+        else:
+            logger.warning(f"MCP auto-configuration issue: {message}")
+            # Don't fail the session, just warn
+
+    except Exception as e:
+        logger.debug(f"MCP auto-configuration skipped: {e}")
+        # Don't fail the session if auto-configuration fails
+
+
+def _handle_reload_agents(logger):
+    """
+    Handle the --reload-agents flag by deleting all local claude-mpm system agents.
+
+    This forces a fresh rebuild of system agents on the next deployment,
+    while preserving user-created agents.
+
+    Args:
+        logger: Logger instance for output
+    """
+    try:
+        logger.info("Reloading system agents - cleaning existing deployments...")
+
+        # Import the cleanup service
+        from ...services.agents.deployment.agent_deployment import (
+            AgentDeploymentService,
+        )
+        from ...services.cli.agent_cleanup_service import AgentCleanupService
+
+        # Create services
+        deployment_service = AgentDeploymentService()
+        cleanup_service = AgentCleanupService(deployment_service)
+
+        # Determine the agents directory
+        agents_dir = None  # Will auto-detect project or user directory
+
+        # Clean deployed agents (preserves user agents)
+        result = cleanup_service.clean_deployed_agents(agents_dir)
+
+        # Check if cleanup was successful based on the result structure
+        # The service returns a dict with 'removed', 'preserved', and possibly 'errors' keys
+        # If it has 'success' key, use it; otherwise infer from the result
+        success = (
+            result.get("success", True)
+            if "success" in result
+            else not result.get("errors")
+        )
+
+        if success:
+            removed_count = result.get("cleaned_count", len(result.get("removed", [])))
+            removed_agents = result.get("removed", [])
+            preserved_agents = result.get("preserved", [])
+
+            if removed_count > 0:
+                logger.info(f"✅ Successfully removed {removed_count} system agents")
+                if removed_agents:
+                    logger.debug(f"Removed agents: {', '.join(removed_agents)}")
+                print(f"🔄 Cleaned {removed_count} claude-mpm system agents")
+            else:
+                logger.info("No system agents found to clean")
+                print("ℹ️  No system agents found - already clean")
+
+            if preserved_agents:
+                logger.info(f"Preserved {len(preserved_agents)} user-created agents")
+                print(f"✅ Preserved {len(preserved_agents)} user-created agents")
+
+            print("🚀 System agents will be rebuilt on next use")
+        else:
+            error = result.get("error", "Cleanup failed")
+            if result.get("errors"):
+                error = f"Cleanup errors: {', '.join(result['errors'])}"
+            logger.error(f"Failed to clean system agents: {error}")
+            print(f"❌ Error cleaning agents: {error}")
+
+    except Exception as e:
+        logger.error(f"Error handling --reload-agents: {e}", exc_info=True)
+        print(f"❌ Failed to reload agents: {e}")
+        # Don't fail the entire session, just log the error
+        print("⚠️  Continuing with existing agents...")
+
+
 def run_session(args):
     """
     Main entry point for run command.
@@ -624,6 +731,13 @@ def run_session_legacy(args):
     # Check for memory usage issues with .claude.json
     _check_claude_json_memory(args, logger)
 
+    # Handle --reload-agents flag if specified
+    if getattr(args, "reload_agents", False):
+        _handle_reload_agents(logger)
+
+    # Auto-configure MCP services on startup
+    _ensure_mcp_services_configured(logger)
+
     try:
         from ...core.claude_runner import ClaudeRunner, create_simple_context
     except ImportError:

claude_mpm/cli/commands/search.py

@@ -0,0 +1,292 @@
+"""
+Search command module for mcp-vector-search integration.
+
+This module provides the /mpm-search command for semantic code search
+using the mcp-vector-search service.
+"""
+
+import asyncio
+import json
+import sys
+from typing import Any, Dict, Optional
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from claude_mpm.cli.utils import handle_async_errors
+from claude_mpm.services.service_container import get_service_container
+
+console = Console()
+
+
+class MCPSearchInterface:
+    """Interface for interacting with mcp-vector-search service."""
+
+    def __init__(self):
+        """Initialize the search interface."""
+        self.container = get_service_container()
+        self.mcp_gateway = None
+
+    async def initialize(self):
+        """Initialize the MCP gateway connection."""
+        try:
+            from claude_mpm.services.mcp_gateway import MCPGatewayService
+
+            self.mcp_gateway = self.container.resolve(MCPGatewayService)
+            if not self.mcp_gateway:
+                self.mcp_gateway = MCPGatewayService()
+                await self.mcp_gateway.initialize()
+        except Exception as e:
+            console.print(f"[red]Failed to initialize MCP gateway: {e}[/red]")
+            raise
+
+    async def search_code(
+        self,
+        query: str,
+        limit: int = 10,
+        similarity_threshold: float = 0.3,
+        file_extensions: Optional[list] = None,
+        language: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Search code using semantic similarity."""
+        params = {
+            "query": query,
+            "limit": limit,
+            "similarity_threshold": similarity_threshold,
+        }
+
+        if file_extensions:
+            params["file_extensions"] = file_extensions
+        if language:
+            params["language"] = language
+
+        return await self._call_mcp_tool("mcp__mcp-vector-search__search_code", params)
+
+    async def search_similar(
+        self,
+        file_path: str,
+        function_name: Optional[str] = None,
+        limit: int = 10,
+        similarity_threshold: float = 0.3,
+    ) -> Dict[str, Any]:
+        """Find code similar to a specific file or function."""
+        params = {
+            "file_path": file_path,
+            "limit": limit,
+            "similarity_threshold": similarity_threshold,
+        }
+
+        if function_name:
+            params["function_name"] = function_name
+
+        return await self._call_mcp_tool(
+            "mcp__mcp-vector-search__search_similar", params
+        )
+
+    async def search_context(
+        self, description: str, focus_areas: Optional[list] = None, limit: int = 10
+    ) -> Dict[str, Any]:
+        """Search for code based on contextual description."""
+        params = {"description": description, "limit": limit}
+
+        if focus_areas:
+            params["focus_areas"] = focus_areas
+
+        return await self._call_mcp_tool(
+            "mcp__mcp-vector-search__search_context", params
+        )
+
+    async def get_status(self) -> Dict[str, Any]:
+        """Get project indexing status and statistics."""
+        return await self._call_mcp_tool(
+            "mcp__mcp-vector-search__get_project_status", {}
+        )
+
+    async def index_project(
+        self, force: bool = False, file_extensions: Optional[list] = None
+    ) -> Dict[str, Any]:
+        """Index or reindex the project codebase."""
+        params = {"force": force}
+
+        if file_extensions:
+            params["file_extensions"] = file_extensions
+
+        return await self._call_mcp_tool(
+            "mcp__mcp-vector-search__index_project", params
+        )
+
+    async def _call_mcp_tool(
+        self, tool_name: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Call an MCP tool through the gateway."""
+        if not self.mcp_gateway:
+            await self.initialize()
+
+        try:
+            return await self.mcp_gateway.call_tool(tool_name, params)
+        except Exception as e:
+            return {"error": str(e)}
+
+
+def display_search_results(results: Dict[str, Any], output_format: str = "rich"):
+    """Display search results in the specified format."""
+    if output_format == "json":
+        console.print_json(json.dumps(results, indent=2))
+        return
+
+    if "error" in results:
+        console.print(f"[red]Error: {results['error']}[/red]")
+        return
+
+    if not results.get("results"):
+        console.print("[yellow]No results found.[/yellow]")
+        return
+
+    # Create a table for results
+    table = Table(title="Search Results", show_header=True, header_style="bold magenta")
+    table.add_column("File", style="cyan", no_wrap=False)
+    table.add_column("Score", style="green", width=8)
+    table.add_column("Type", style="yellow", width=10)
+    table.add_column("Name", style="blue", no_wrap=False)
+
+    for result in results["results"]:
+        file_path = result.get("file_path", "Unknown")
+        score = f"{result.get('score', 0):.3f}"
+        item_type = result.get("type", "unknown")
+        name = result.get("name", result.get("function_name", ""))
+
+        table.add_row(file_path, score, item_type, name)
+
+        # Show snippet if available
+        if result.get("snippet"):
+            snippet_panel = Panel(
+                Syntax(
+                    result["snippet"], result.get("language", "python"), theme="monokai"
+                ),
+                title=f"[cyan]{file_path}[/cyan]",
+                border_style="dim",
+            )
+            console.print(snippet_panel)
+
+    console.print(table)
+
+    # Show statistics if available
+    if "stats" in results:
+        stats = results["stats"]
+        console.print("\n[bold]Statistics:[/bold]")
+        console.print(f"  Total indexed files: {stats.get('total_files', 0)}")
+        console.print(f"  Total indexed functions: {stats.get('total_functions', 0)}")
+        console.print(f"  Index last updated: {stats.get('last_updated', 'Unknown')}")
+
+
+@click.command()
+@click.argument("query", required=False)
+@click.option("--similar", "-s", help="Find code similar to a specific file")
+@click.option("--context", "-c", help="Search by contextual description")
+@click.option("--index", is_flag=True, help="Index or reindex the project")
+@click.option("--status", is_flag=True, help="Check index status")
+@click.option("--limit", "-l", default=10, help="Maximum number of results")
+@click.option("--threshold", "-t", default=0.3, help="Similarity threshold (0.0-1.0)")
+@click.option("--language", help="Filter by programming language")
+@click.option("--extensions", multiple=True, help="Filter by file extensions")
+@click.option("--function", "-f", help="Function name (with --similar)")
+@click.option("--focus", multiple=True, help="Focus areas (with --context)")
+@click.option("--force", is_flag=True, help="Force reindexing (with --index)")
+@click.option("--json", "output_json", is_flag=True, help="Output results as JSON")
+@handle_async_errors
+async def search_command(
+    query: Optional[str],
+    similar: Optional[str],
+    context: Optional[str],
+    index: bool,
+    status: bool,
+    limit: int,
+    threshold: float,
+    language: Optional[str],
+    extensions: tuple,
+    function: Optional[str],
+    focus: tuple,
+    force: bool,
+    output_json: bool,
+):
+    """
+    Search the codebase using semantic search powered by mcp-vector-search.
+
+    Examples:
+        /mpm-search "authentication logic"
+        /mpm-search --similar src/auth.py
+        /mpm-search --context "find all API endpoints"
+        /mpm-search --index --force
+        /mpm-search --status
+    """
+    search = MCPSearchInterface()
+    await search.initialize()
+
+    output_format = "json" if output_json else "rich"
+
+    try:
+        # Handle different operation modes
+        if index:
+            console.print("[cyan]Indexing project...[/cyan]")
+            result = await search.index_project(
+                force=force, file_extensions=list(extensions) if extensions else None
+            )
+            if "error" not in result:
+                console.print("[green]✓ Project indexed successfully[/green]")
+            display_search_results(result, output_format)
+
+        elif status:
+            result = await search.get_status()
+            display_search_results(result, output_format)
+
+        elif similar:
+            result = await search.search_similar(
+                file_path=similar,
+                function_name=function,
+                limit=limit,
+                similarity_threshold=threshold,
+            )
+            display_search_results(result, output_format)
+
+        elif context:
+            result = await search.search_context(
+                description=context,
+                focus_areas=list(focus) if focus else None,
+                limit=limit,
+            )
+            display_search_results(result, output_format)
+
+        elif query:
+            result = await search.search_code(
+                query=query,
+                limit=limit,
+                similarity_threshold=threshold,
+                file_extensions=list(extensions) if extensions else None,
+                language=language,
+            )
+            display_search_results(result, output_format)
+
+        else:
+            console.print(
+                "[yellow]No search operation specified. Use --help for options.[/yellow]"
+            )
+
+    except Exception as e:
+        console.print(f"[red]Search failed: {e}[/red]")
+        if not output_json:
+            console.print(
+                "[dim]Tip: Make sure the project is indexed with --index first[/dim]"
+            )
+        sys.exit(1)
+
+
+def main():
+    """Main entry point for the search command."""
+    asyncio.run(search_command())
+
+
+if __name__ == "__main__":
+    main()

claude_mpm/cli/interactive/agent_wizard.py

@@ -600,7 +600,7 @@ class AgentWizard:
             tier="project",
         )
 
-    def _manage_single_agent(self, template: LocalAgentTemplate) -> Tuple[bool, str]:
+    def _manage_single_agent(self, template: LocalAgentTemplate) -> Tuple[bool, str]:  # noqa: PLR0911
         """Manage a single agent."""
         print(f"\n🔧 Managing Agent: {template.agent_id}")
         print(f"   Name: {template.metadata.get('name', template.agent_id)}")
@@ -815,7 +815,7 @@ class AgentWizard:
             return self.manager.project_agents_dir / f"{template.agent_id}.json"
         return self.manager.user_agents_dir / f"{template.agent_id}.json"
 
-    def _interactive_delete_menu(self, templates: list) -> Tuple[bool, str]:
+    def _interactive_delete_menu(self, templates: list) -> Tuple[bool, str]:  # noqa: PLR0911
         """Interactive deletion menu for multiple agents."""
         print("\n🗑️  Delete Agents")
         print("=" * 50)

claude_mpm/cli/parsers/base_parser.py

@@ -199,6 +199,11 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Force operations even with warnings (e.g., large .claude.json file)",
     )
+    run_group.add_argument(
+        "--reload-agents",
+        action="store_true",
+        help="Force rebuild of all system agents by deleting local claude-mpm agents",
+    )
 
     # Dependency checking options (for backward compatibility at top level)
     dep_group_top = parser.add_argument_group(
@@ -390,6 +395,14 @@ def create_parser(
     except ImportError:
         pass
 
+    # Add search command parser
+    try:
+        from .search_parser import add_search_subparser
+
+        add_search_subparser(subparsers)
+    except ImportError:
+        pass
+
     # Import and add additional command parsers from commands module
     try:
         from ..commands.aggregate import add_aggregate_parser

claude_mpm/cli/parsers/mcp_parser.py

@@ -177,4 +177,19 @@ def add_mcp_subparser(subparsers) -> argparse.ArgumentParser:
         help="Show setup instructions for Claude Code",
     )
 
+    # External MCP services management
+    external_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.EXTERNAL.value, help="Manage external MCP services"
+    )
+    external_mcp_parser.add_argument(
+        "external_action",
+        nargs="?",
+        choices=["setup", "list", "check", "fix-browser", "detect"],
+        default="list",
+        help="External service action (default: list)",
+    )
+    external_mcp_parser.add_argument(
+        "--force", action="store_true", help="Force overwrite existing configuration"
+    )
+
     return mcp_parser

claude_mpm/cli/parsers/run_parser.py

@@ -68,6 +68,11 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Force operations even with warnings (e.g., large .claude.json file)",
     )
+    run_group.add_argument(
+        "--reload-agents",
+        action="store_true",
+        help="Force rebuild of all system agents by deleting local claude-mpm agents",
+    )
     run_group.add_argument(
         "--mpm-resume",
         type=str,