claude-mpm 4.3.6__py3-none-any.whl → 4.3.12__py3-none-any.whl

claude_mpm/cli/commands/run.py

@@ -15,7 +15,7 @@ DESIGN DECISIONS:
 
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
 from ...constants import LogLevel
@@ -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",
@@ -522,7 +523,7 @@ class RunCommand(BaseCommand):
             # Update session usage
             session = session_manager.load_session(resume_session_id)
             if session:
-                session.last_used = datetime.now().isoformat()
+                session.last_used = datetime.now(timezone.utc).isoformat()
                 session.use_count += 1
                 session_manager.save_session(session)
         else:
@@ -568,6 +569,71 @@ class RunCommand(BaseCommand):
             return False
 
 
+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.cli.agent_cleanup_service import AgentCleanupService
+        from ...services.agents.deployment.agent_deployment import AgentDeploymentService
+
+        # 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 +690,10 @@ 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)
+
     try:
         from ...core.claude_runner import ClaudeRunner, create_simple_context
     except ImportError:
@@ -936,7 +1006,7 @@ def run_session_legacy(args):
         # Update session usage
         session = session_manager.load_session(resume_session_id)
         if session:
-            session.last_used = datetime.now().isoformat()
+            session.last_used = datetime.now(timezone.utc).isoformat()
             session.use_count += 1
             session_manager.save_session(session)
     else:

claude_mpm/cli/commands/search.py

@@ -0,0 +1,285 @@
+"""
+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:
+            result = await self.mcp_gateway.call_tool(tool_name, params)
+            return result
+        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(f"\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/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,21 @@ 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,

claude_mpm/cli/parsers/search_parser.py

@@ -0,0 +1,239 @@
+"""
+Search command parser for mcp-vector-search integration.
+
+This module provides argument parsing for the /mpm-search command.
+"""
+
+import argparse
+from typing import Optional
+
+
+def add_search_subparser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    """
+    Add the search command parser.
+
+    Args:
+        subparsers: The subparsers action to add the search parser to.
+
+    Returns:
+        The created search parser.
+    """
+    search_parser = subparsers.add_parser(
+        "mpm-search",
+        aliases=["search"],
+        help="Search codebase using semantic search",
+        description=(
+            "Search the codebase using semantic search powered by mcp-vector-search. "
+            "Can search by query, find similar code, search by context, or manage the search index."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Search for code by query
+  claude-mpm mpm-search "authentication logic"
+
+  # Find code similar to a file
+  claude-mpm mpm-search --similar src/auth.py
+
+  # Search by contextual description
+  claude-mpm mpm-search --context "find all API endpoints"
+
+  # Index the project (required before searching)
+  claude-mpm mpm-search --index
+
+  # Force reindex the project
+  claude-mpm mpm-search --index --force
+
+  # Check index status
+  claude-mpm mpm-search --status
+
+  # Search with filters
+  claude-mpm mpm-search "database" --language python --limit 20
+
+  # Search with multiple file extensions
+  claude-mpm mpm-search "test" --extensions .py --extensions .js
+
+  # Find similar code to a specific function
+  claude-mpm mpm-search --similar src/auth.py --function authenticate_user
+
+  # Search with context and focus areas
+  claude-mpm mpm-search --context "security vulnerabilities" --focus authentication --focus encryption
+
+  # Output as JSON for processing
+  claude-mpm mpm-search "api" --json
+""",
+    )
+
+    # Primary search modes (mutually exclusive)
+    search_mode = search_parser.add_mutually_exclusive_group()
+
+    search_mode.add_argument(
+        "query",
+        nargs="?",
+        help="Search query for semantic code search",
+    )
+
+    search_mode.add_argument(
+        "--similar",
+        "-s",
+        metavar="FILE",
+        help="Find code similar to the specified file",
+    )
+
+    search_mode.add_argument(
+        "--context",
+        "-c",
+        metavar="DESCRIPTION",
+        help="Search by contextual description of what you're looking for",
+    )
+
+    # Index management options
+    search_parser.add_argument(
+        "--index",
+        action="store_true",
+        help="Index or reindex the project codebase",
+    )
+
+    search_parser.add_argument(
+        "--status",
+        action="store_true",
+        help="Check project indexing status and statistics",
+    )
+
+    # Search filters and options
+    search_parser.add_argument(
+        "--limit",
+        "-l",
+        type=int,
+        default=10,
+        metavar="N",
+        help="Maximum number of results to return (default: 10, max: 50)",
+    )
+
+    search_parser.add_argument(
+        "--threshold",
+        "-t",
+        type=float,
+        default=0.3,
+        metavar="SCORE",
+        help="Similarity threshold between 0.0 and 1.0 (default: 0.3)",
+    )
+
+    search_parser.add_argument(
+        "--language",
+        metavar="LANG",
+        help="Filter by programming language (e.g., python, javascript, go)",
+    )
+
+    search_parser.add_argument(
+        "--extensions",
+        action="append",
+        metavar="EXT",
+        help="Filter by file extensions (e.g., .py, .js). Can be specified multiple times",
+    )
+
+    # Options for --similar mode
+    search_parser.add_argument(
+        "--function",
+        "-f",
+        metavar="NAME",
+        help="Function name within the file (used with --similar)",
+    )
+
+    # Options for --context mode
+    search_parser.add_argument(
+        "--focus",
+        action="append",
+        metavar="AREA",
+        help="Focus areas for contextual search (e.g., security, performance). Can be specified multiple times",
+    )
+
+    # Options for --index mode
+    search_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force reindexing even if index already exists (used with --index)",
+    )
+
+    # Output options
+    search_parser.add_argument(
+        "--json",
+        action="store_true",
+        dest="output_json",
+        help="Output results as JSON instead of formatted text",
+    )
+
+    # Additional filters
+    search_parser.add_argument(
+        "--class",
+        dest="class_name",
+        metavar="NAME",
+        help="Filter by class name",
+    )
+
+    search_parser.add_argument(
+        "--files",
+        metavar="PATTERN",
+        help="Filter by file patterns (e.g., '*.py' or 'src/*.js')",
+    )
+
+    # Verbose output
+    search_parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output with additional details",
+    )
+
+    return search_parser
+
+
+def validate_search_args(args: argparse.Namespace) -> Optional[str]:
+    """
+    Validate search command arguments.
+
+    Args:
+        args: Parsed command line arguments.
+
+    Returns:
+        Error message if validation fails, None otherwise.
+    """
+    # Check threshold is in valid range
+    if hasattr(args, "threshold") and args.threshold is not None:
+        if not 0.0 <= args.threshold <= 1.0:
+            return "Similarity threshold must be between 0.0 and 1.0"
+
+    # Check limit is reasonable
+    if hasattr(args, "limit") and args.limit is not None:
+        if args.limit < 1:
+            return "Limit must be at least 1"
+        if args.limit > 50:
+            return "Limit cannot exceed 50"
+
+    # Check that function is only used with --similar
+    if hasattr(args, "function") and args.function and not getattr(args, "similar", None):
+        return "--function can only be used with --similar"
+
+    # Check that focus is only used with --context
+    if hasattr(args, "focus") and args.focus and not getattr(args, "context", None):
+        return "--focus can only be used with --context"
+
+    # Check that force is only used with --index
+    if hasattr(args, "force") and args.force and not getattr(args, "index", False):
+        return "--force can only be used with --index"
+
+    # Ensure at least one operation is specified
+    if hasattr(args, "command") and args.command in ["mpm-search", "search"]:
+        has_operation = any(
+            [
+                getattr(args, "query", None),
+                getattr(args, "similar", None),
+                getattr(args, "context", None),
+                getattr(args, "index", False),
+                getattr(args, "status", False),
+            ]
+        )
+        if not has_operation:
+            return "No search operation specified. Use --help for options."
+
+    return None