claude-mpm 4.1.8__py3-none-any.whl → 4.1.10__py3-none-any.whl

claude_mpm/cli/parsers/analyze_code_parser.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Analyze Code Parser
+===================
+
+WHY: Provides argument parsing for the analyze-code command,
+defining available options and their validation.
+
+DESIGN DECISIONS:
+- Support multiple output formats for flexibility
+- Enable Socket.IO event emission for dashboard integration
+- Allow language and pattern filtering
+- Include caching control options
+"""
+
+import argparse
+from pathlib import Path
+from typing import Optional
+
+
+class AnalyzeCodeParser:
+    """Parser for analyze-code command arguments.
+
+    WHY: Centralizes argument definition and validation for the
+    code analysis command, ensuring consistent interface.
+    """
+
+    def __init__(self):
+        self.command_name = "analyze-code"
+        self.help_text = "Analyze code structure and generate AST tree with metrics"
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        """Add analyze-code specific arguments.
+
+        Args:
+            parser: Argument parser to configure
+        """
+        # Required arguments
+        parser.add_argument(
+            "path",
+            type=str,
+            default=".",
+            nargs="?",
+            help="Path to analyze (default: current directory)",
+        )
+
+        # Output options
+        output_group = parser.add_argument_group("output options")
+        output_group.add_argument(
+            "-o",
+            "--output",
+            choices=["json", "tree", "stats"],
+            help="Output format (default: summary)",
+        )
+        output_group.add_argument(
+            "--save", type=str, metavar="PATH", help="Save analysis results to file"
+        )
+        output_group.add_argument(
+            "--emit-events",
+            action="store_true",
+            help="Emit real-time events to dashboard via Socket.IO",
+        )
+
+        # Filter options
+        filter_group = parser.add_argument_group("filter options")
+        filter_group.add_argument(
+            "-l",
+            "--languages",
+            type=str,
+            metavar="LANGS",
+            help="Comma-separated list of languages to analyze (e.g., python,javascript)",
+        )
+        filter_group.add_argument(
+            "-i",
+            "--ignore",
+            type=str,
+            metavar="PATTERNS",
+            help="Comma-separated list of patterns to ignore",
+        )
+        filter_group.add_argument(
+            "--max-depth",
+            type=int,
+            metavar="N",
+            help="Maximum directory depth to traverse",
+        )
+        filter_group.add_argument(
+            "--no-tree", action="store_true", help="Skip file tree building phase"
+        )
+
+        # Performance options
+        perf_group = parser.add_argument_group("performance options")
+        perf_group.add_argument(
+            "--no-cache",
+            action="store_true",
+            help="Disable caching of analysis results",
+        )
+        perf_group.add_argument(
+            "--parallel",
+            action="store_true",
+            help="Use parallel processing for large codebases",
+        )
+
+        # Metric options
+        metric_group = parser.add_argument_group("metric options")
+        metric_group.add_argument(
+            "--complexity-threshold",
+            type=int,
+            default=10,
+            metavar="N",
+            help="Complexity threshold for warnings (default: 10)",
+        )
+        metric_group.add_argument(
+            "--include-metrics",
+            action="store_true",
+            help="Include detailed metrics in output",
+        )
+
+        # Note: --verbose and --debug are already defined in base_parser
+        # so we don't add them here to avoid conflicts
+
+    def validate_args(self, args: argparse.Namespace) -> Optional[str]:
+        """Validate parsed arguments.
+
+        Args:
+            args: Parsed arguments
+
+        Returns:
+            Error message if validation fails, None otherwise
+        """
+        # Validate path
+        path = Path(args.path)
+        if not path.exists():
+            return f"Path does not exist: {path}"
+
+        if not path.is_dir():
+            return f"Path is not a directory: {path}"
+
+        # Validate save path if provided
+        if args.save:
+            save_path = Path(args.save)
+            save_dir = save_path.parent
+            if not save_dir.exists():
+                return f"Save directory does not exist: {save_dir}"
+
+        # Validate max depth
+        if args.max_depth is not None and args.max_depth < 0:
+            return "Max depth must be non-negative"
+
+        # Validate complexity threshold
+        if args.complexity_threshold < 1:
+            return "Complexity threshold must be at least 1"
+
+        return None
+
+    def get_examples(self) -> list:
+        """Get usage examples.
+
+        Returns:
+            List of example command strings
+        """
+        return [
+            "claude-mpm analyze-code",
+            "claude-mpm analyze-code /path/to/project",
+            "claude-mpm analyze-code -l python,javascript",
+            "claude-mpm analyze-code --output json --save analysis.json",
+            "claude-mpm analyze-code --emit-events",
+            "claude-mpm analyze-code --ignore test,vendor --max-depth 3",
+            "claude-mpm analyze-code -o tree",
+            "claude-mpm analyze-code -o stats --include-metrics",
+        ]

claude_mpm/cli/parsers/analyze_parser.py

@@ -0,0 +1,135 @@
+"""
+Parser configuration for analyze command.
+
+WHY: This module adds the analyze subcommand to the CLI for code analysis
+with mermaid diagram generation capabilities.
+
+DESIGN DECISIONS:
+- Support mermaid diagram generation via flags
+- Allow specification of diagram types
+- Enable target directory/file selection
+- Follow existing parser patterns
+"""
+
+from pathlib import Path
+
+from .base_parser import add_common_arguments
+
+
+def add_analyze_subparser(subparsers):
+    """Add analyze command parser.
+
+    WHY: Provides CLI interface for code analysis with mermaid diagram
+    generation, allowing users to visualize their codebase architecture.
+
+    Args:
+        subparsers: The subparsers object from argparse
+    """
+    parser = subparsers.add_parser(
+        "analyze",
+        aliases=["analysis", "code-analyze"],
+        help="Analyze code and generate mermaid diagrams",
+        description="Run code analysis with optional mermaid diagram generation",
+    )
+
+    # Add common arguments
+    add_common_arguments(parser)
+
+    # Analysis target options
+    parser.add_argument(
+        "--target",
+        type=Path,
+        default=Path.cwd(),
+        help="Directory or file to analyze (default: current directory)",
+    )
+
+    parser.add_argument(
+        "--recursive",
+        action="store_true",
+        default=True,
+        help="Recursively analyze subdirectories (default: True)",
+    )
+
+    # Mermaid diagram options
+    mermaid_group = parser.add_argument_group("mermaid diagram options")
+    mermaid_group.add_argument(
+        "--mermaid", action="store_true", help="Enable mermaid diagram generation"
+    )
+
+    mermaid_group.add_argument(
+        "--mermaid-types",
+        nargs="+",
+        choices=[
+            "entry_points",
+            "class_diagram",
+            "sequence",
+            "flowchart",
+            "state",
+            "entity_relationship",
+            "component",
+            "dependency_graph",
+            "call_graph",
+            "architecture",
+        ],
+        default=["entry_points"],
+        help="Types of mermaid diagrams to generate (default: entry_points)",
+    )
+
+    mermaid_group.add_argument(
+        "--save-diagrams", action="store_true", help="Save generated diagrams to files"
+    )
+
+    mermaid_group.add_argument(
+        "--diagram-output",
+        type=Path,
+        help="Directory to save diagrams (default: ./diagrams/)",
+    )
+
+    # Analysis options
+    analysis_group = parser.add_argument_group("analysis options")
+    analysis_group.add_argument(
+        "--agent",
+        default="code-analyzer",
+        help="Agent to use for analysis (default: code-analyzer)",
+    )
+
+    analysis_group.add_argument(
+        "--prompt", type=str, help="Additional prompt/instructions for the analysis"
+    )
+
+    analysis_group.add_argument(
+        "--focus",
+        nargs="+",
+        choices=["security", "performance", "architecture", "quality", "documentation"],
+        help="Focus areas for analysis",
+    )
+
+    # Session options
+    session_group = parser.add_argument_group("session options")
+    session_group.add_argument(
+        "--session-id", type=str, help="Use specific session ID for analysis"
+    )
+
+    session_group.add_argument(
+        "--no-session", action="store_true", help="Run without session management"
+    )
+
+    # Output options
+    output_group = parser.add_argument_group("output options")
+    output_group.add_argument(
+        "--format",
+        choices=["text", "json", "markdown"],
+        default="text",
+        help="Output format (default: text)",
+    )
+
+    output_group.add_argument(
+        "--output", "-o", type=Path, help="Save analysis output to file"
+    )
+
+    # Note: --verbose/-v is already defined in base_parser, so removed to avoid conflict
+
+    # Import the command function
+    from ..commands.analyze import analyze_command
+
+    parser.set_defaults(func=analyze_command)

claude_mpm/cli/parsers/base_parser.py

@@ -338,6 +338,35 @@ def create_parser(
     except ImportError:
         pass
 
+    # Add debug command parser
+    try:
+        from .debug_parser import add_debug_subparser
+
+        add_debug_subparser(subparsers)
+    except ImportError:
+        pass
+
+    # Add analyze command parser
+    try:
+        from .analyze_parser import add_analyze_subparser
+
+        add_analyze_subparser(subparsers)
+    except ImportError:
+        pass
+
+    # Add analyze-code command parser
+    try:
+        from .analyze_code_parser import AnalyzeCodeParser
+
+        parser_obj = AnalyzeCodeParser()
+        analyze_code_parser = subparsers.add_parser(
+            "analyze-code", help=parser_obj.help_text
+        )
+        parser_obj.add_arguments(analyze_code_parser)
+        analyze_code_parser.set_defaults(command="analyze-code")
+    except ImportError:
+        pass
+
     # Import and add additional command parsers from commands module
     try:
         from ..commands.aggregate import add_aggregate_parser

claude_mpm/cli/parsers/debug_parser.py

@@ -0,0 +1,319 @@
+"""
+Debug command parser for claude-mpm CLI.
+
+This module contains all arguments specific to debugging tools,
+providing developer-focused commands for monitoring and analysis.
+"""
+
+import argparse
+
+from .base_parser import add_common_arguments
+
+
+def add_debug_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the debug subparser with all debugging commands.
+
+    This provides professional debugging tools for developers working
+    on claude-mpm, particularly for dashboard and event monitoring.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured debug subparser
+    """
+    # Main debug parser
+    debug_parser = subparsers.add_parser(
+        "debug",
+        help="Development debugging tools",
+        description="Professional debugging tools for claude-mpm developers",
+    )
+
+    # Add common arguments (logging, etc.)
+    add_common_arguments(debug_parser)
+
+    # Create subparsers for debug commands
+    debug_subparsers = debug_parser.add_subparsers(
+        dest="debug_command", help="Debug commands", metavar="SUBCOMMAND", required=True
+    )
+
+    # SocketIO event debugging
+    _add_socketio_parser(debug_subparsers)
+
+    # Connection debugging
+    _add_connections_parser(debug_subparsers)
+
+    # Services debugging
+    _add_services_parser(debug_subparsers)
+
+    # Agents debugging
+    _add_agents_parser(debug_subparsers)
+
+    # Hooks debugging
+    _add_hooks_parser(debug_subparsers)
+
+    # Cache debugging
+    _add_cache_parser(debug_subparsers)
+
+    # Performance debugging
+    _add_performance_parser(debug_subparsers)
+
+    return debug_parser
+
+
+def _add_socketio_parser(subparsers):
+    """Add SocketIO debugging subcommand."""
+    socketio_parser = subparsers.add_parser(
+        "socketio",
+        help="Monitor and debug SocketIO events in real-time",
+        aliases=["events", "socket"],
+        description="""
+Professional SocketIO event monitoring tool for dashboard development.
+
+This tool provides real-time monitoring of all SocketIO events with:
+- Live event streaming with formatted output
+- Event statistics and aggregation
+- Tool usage tracking
+- Session monitoring
+- Connection health checks
+- Event filtering and export capabilities
+
+Examples:
+  # Monitor all events in real-time
+  claude-mpm debug socketio
+
+  # Show event summary statistics
+  claude-mpm debug socketio --summary
+
+  # Filter specific event types
+  claude-mpm debug socketio --filter PreToolUse PostToolUse
+
+  # Save events to file for analysis
+  claude-mpm debug socketio --output events.jsonl
+
+  # Connect to specific server
+  claude-mpm debug socketio --host localhost --port 8765
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    # Connection settings
+    conn_group = socketio_parser.add_argument_group("connection settings")
+    conn_group.add_argument(
+        "--host", default="localhost", help="SocketIO server host (default: localhost)"
+    )
+    conn_group.add_argument(
+        "--port", type=int, default=8765, help="SocketIO server port (default: 8765)"
+    )
+    conn_group.add_argument(
+        "--max-reconnect",
+        type=int,
+        default=10,
+        help="Maximum reconnection attempts (default: 10)",
+    )
+    conn_group.add_argument(
+        "--reconnect-delay",
+        type=float,
+        default=1.0,
+        help="Reconnection delay in seconds (default: 1.0)",
+    )
+
+    # Display modes (mutually exclusive)
+    display_group = socketio_parser.add_argument_group("display modes")
+    mode_group = display_group.add_mutually_exclusive_group()
+    mode_group.add_argument(
+        "--live",
+        action="store_true",
+        help="Live event monitoring with formatted output (default)",
+    )
+    mode_group.add_argument(
+        "--summary",
+        action="store_true",
+        help="Show aggregated event statistics and summary",
+    )
+    mode_group.add_argument(
+        "--raw", action="store_true", help="Display raw JSON output for each event"
+    )
+    mode_group.add_argument(
+        "--pretty",
+        action="store_true",
+        help="Enhanced formatted output with colors and icons",
+    )
+
+    # Filtering and output
+    filter_group = socketio_parser.add_argument_group("filtering and output")
+    filter_group.add_argument(
+        "--filter",
+        nargs="+",
+        dest="filter_types",
+        metavar="TYPE",
+        help="Filter specific event types (e.g., PreToolUse PostToolUse)",
+    )
+    filter_group.add_argument(
+        "--output", "-o", metavar="FILE", help="Save events to file in JSONL format"
+    )
+    filter_group.add_argument(
+        "--quiet",
+        "-q",
+        action="store_true",
+        help="Suppress output except errors (useful with --output)",
+    )
+
+
+def _add_connections_parser(subparsers):
+    """Add connections debugging subcommand."""
+    connections_parser = subparsers.add_parser(
+        "connections",
+        help="Show active SocketIO server connections",
+        aliases=["conn", "servers"],
+        description="""
+Display information about active SocketIO servers and their status.
+
+This command shows:
+- All running SocketIO server instances
+- Port numbers and process IDs
+- Connection health status
+- Server start times
+
+Examples:
+  # Show all active servers
+  claude-mpm debug connections
+
+  # Show detailed information
+  claude-mpm debug connections --verbose
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    connections_parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed connection information in JSON format",
+    )
+    connections_parser.add_argument(
+        "--check-health",
+        action="store_true",
+        help="Perform health checks on each server",
+    )
+    connections_parser.add_argument(
+        "--cleanup", action="store_true", help="Clean up stale server entries"
+    )
+
+
+def _add_services_parser(subparsers):
+    """Add services debugging subcommand."""
+    services_parser = subparsers.add_parser(
+        "services",
+        help="Debug service container and dependencies",
+        description="Inspect services, dependencies, and health status",
+    )
+
+    services_group = services_parser.add_mutually_exclusive_group()
+    services_group.add_argument(
+        "--list", action="store_true", help="List all registered services"
+    )
+    services_group.add_argument(
+        "--status", action="store_true", help="Show service health status"
+    )
+    services_group.add_argument(
+        "--dependencies", action="store_true", help="Show service dependency graph"
+    )
+    services_group.add_argument(
+        "--trace",
+        metavar="SERVICE",
+        help="Trace service resolution for specific service",
+    )
+
+
+def _add_agents_parser(subparsers):
+    """Add agents debugging subcommand."""
+    agents_parser = subparsers.add_parser(
+        "agents",
+        help="Debug deployed agents and memory",
+        description="Inspect deployed agents, memory, and traces",
+    )
+
+    agents_group = agents_parser.add_mutually_exclusive_group()
+    agents_group.add_argument(
+        "--deployed", action="store_true", help="List all deployed agents"
+    )
+    agents_group.add_argument(
+        "--memory", action="store_true", help="Show agent memory status"
+    )
+    agents_group.add_argument(
+        "--trace", metavar="AGENT", help="Trace specific agent execution"
+    )
+    agents_parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Show detailed information"
+    )
+
+
+def _add_hooks_parser(subparsers):
+    """Add hooks debugging subcommand."""
+    hooks_parser = subparsers.add_parser(
+        "hooks",
+        help="Debug hook system",
+        description="List hooks, trace execution, analyze performance",
+    )
+
+    hooks_group = hooks_parser.add_mutually_exclusive_group()
+    hooks_group.add_argument(
+        "--list", action="store_true", help="List all registered hooks"
+    )
+    hooks_group.add_argument(
+        "--trace", metavar="HOOK", help="Trace specific hook execution"
+    )
+    hooks_group.add_argument(
+        "--performance", action="store_true", help="Analyze hook performance"
+    )
+    hooks_parser.add_argument(
+        "--test", action="store_true", help="Run test execution when tracing"
+    )
+
+
+def _add_cache_parser(subparsers):
+    """Add cache debugging subcommand."""
+    cache_parser = subparsers.add_parser(
+        "cache",
+        help="Debug cache system",
+        description="Inspect, clear, and analyze cache",
+    )
+
+    cache_group = cache_parser.add_mutually_exclusive_group()
+    cache_group.add_argument(
+        "--inspect", action="store_true", help="Inspect cache contents"
+    )
+    cache_group.add_argument("--clear", action="store_true", help="Clear all cache")
+    cache_group.add_argument(
+        "--stats", action="store_true", help="Show cache performance statistics"
+    )
+    cache_parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Show detailed cache information"
+    )
+    cache_parser.add_argument(
+        "--confirm",
+        "-y",
+        action="store_true",
+        help="Skip confirmation for clear operation",
+    )
+
+
+def _add_performance_parser(subparsers):
+    """Add performance debugging subcommand."""
+    performance_parser = subparsers.add_parser(
+        "performance",
+        help="Performance profiling and analysis",
+        description="Profile operations and analyze bottlenecks",
+    )
+
+    perf_group = performance_parser.add_mutually_exclusive_group()
+    perf_group.add_argument(
+        "--profile",
+        metavar="OPERATION",
+        help="Profile specific operation (agent_load, service_init, cache_ops, memory_ops)",
+    )
+    perf_group.add_argument(
+        "--benchmark", action="store_true", help="Run performance benchmarks"
+    )

claude_mpm/constants.py

@@ -38,6 +38,8 @@ class CLICommands(str, Enum):
     CONFIG = "config"
     CONFIGURE = "configure"
     AGGREGATE = "aggregate"
+    ANALYZE = "analyze"
+    ANALYZE_CODE = "analyze-code"
     CLEANUP = "cleanup-memory"
     MCP = "mcp"
     DOCTOR = "doctor"
@@ -217,7 +219,7 @@ class Paths(str, Enum):
 
     CLAUDE_AGENTS_DIR = ".claude/agents"
     CLAUDE_CONFIG_DIR = ".claude"
-    MPM_LOG_DIR = ".claude-mpm/logs"
+    MPM_LOG_DIR = "logs/mpm"
     MPM_SESSION_DIR = ".claude-mpm/session"
     MPM_PROMPTS_DIR = ".claude-mpm/prompts"