claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/cli/parsers/agent_manager_parser.py

@@ -22,7 +22,7 @@ def add_agent_manager_subparser(subparsers: argparse._SubParsersAction) -> None:
         description="Comprehensive agent lifecycle management for Claude MPM",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-Examples:
+Standard Commands:
   claude-mpm agent-manager list                          # List all agents across tiers
   claude-mpm agent-manager create                        # Interactive agent creation
   claude-mpm agent-manager create --id my-agent          # Create agent with ID
@@ -35,6 +35,16 @@ Examples:
   claude-mpm agent-manager reset --dry-run               # Preview agent cleanup
   claude-mpm agent-manager reset --force                 # Remove all claude-mpm agents
   claude-mpm agent-manager reset --project-only          # Clean only project agents
+
+Local Agent Commands:
+  claude-mpm agent-manager create-local --agent-id my-custom  # Create local template
+  claude-mpm agent-manager deploy-local --agent-id my-custom  # Deploy local template
+  claude-mpm agent-manager list-local                         # List local templates
+  claude-mpm agent-manager sync-local                         # Sync templates with deployment
+  claude-mpm agent-manager export-local --output ./agents     # Export templates
+  claude-mpm agent-manager import-local --input ./agents      # Import templates
+  claude-mpm agent-manager delete-local --agent-id my-custom  # Delete single agent
+  claude-mpm agent-manager delete-local --all --backup        # Delete all with backup
 """,
     )
 
@@ -231,3 +241,153 @@ Examples:
         default="text",
         help="Output format (default: text)",
     )
+
+    # === Interactive Commands ===
+
+    # Create interactive command
+    agent_subparsers.add_parser(
+        "create-interactive", help="🧙‍♂️ Launch step-by-step agent creation wizard"
+    )
+
+    # Manage local interactive command
+    agent_subparsers.add_parser(
+        "manage-local", help="🔧 Interactive menu for managing local agents"
+    )
+
+    # Edit interactive command
+    edit_interactive_parser = agent_subparsers.add_parser(
+        "edit-interactive", help="✏️ Edit agent configuration interactively"
+    )
+    edit_interactive_parser.add_argument(
+        "--agent-id", required=True, help="Agent ID to edit"
+    )
+
+    # Test local command
+    test_local_parser = agent_subparsers.add_parser(
+        "test-local", help="🧪 Test local agent with validation and deployment"
+    )
+    test_local_parser.add_argument("--agent-id", required=True, help="Agent ID to test")
+
+    # === Local Agent Commands ===
+
+    # Create local command
+    create_local_parser = agent_subparsers.add_parser(
+        "create-local", help="Create a local JSON agent template"
+    )
+    create_local_parser.add_argument(
+        "--agent-id", required=True, help="Unique agent identifier"
+    )
+    create_local_parser.add_argument("--name", help="Human-readable agent name")
+    create_local_parser.add_argument("--description", help="Agent description")
+    create_local_parser.add_argument("--instructions", help="Agent instructions")
+    create_local_parser.add_argument(
+        "--model",
+        choices=["sonnet", "opus", "haiku"],
+        default="sonnet",
+        help="Model to use (default: sonnet)",
+    )
+    create_local_parser.add_argument(
+        "--tools", help="Tools available to agent (default: *)"
+    )
+    create_local_parser.add_argument("--parent", help="Parent agent to inherit from")
+    create_local_parser.add_argument(
+        "--tier",
+        choices=["project", "user"],
+        default="project",
+        help="Tier level (default: project)",
+    )
+
+    # Deploy local command
+    deploy_local_parser = agent_subparsers.add_parser(
+        "deploy-local", help="Deploy local JSON templates to Claude Code"
+    )
+    deploy_local_parser.add_argument(
+        "--agent-id", help="Specific agent to deploy (deploy all if not specified)"
+    )
+    deploy_local_parser.add_argument(
+        "--force", action="store_true", help="Force deployment even if file exists"
+    )
+    deploy_local_parser.add_argument(
+        "--tier", choices=["project", "user"], help="Filter by tier for bulk deployment"
+    )
+
+    # List local command
+    list_local_parser = agent_subparsers.add_parser(
+        "list-local", help="List all local agent templates"
+    )
+    list_local_parser.add_argument(
+        "--tier", choices=["project", "user"], help="Filter by tier"
+    )
+    list_local_parser.add_argument(
+        "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)",
+    )
+
+    # Sync local command
+    agent_subparsers.add_parser(
+        "sync-local", help="Synchronize local templates with deployed agents"
+    )
+
+    # Export local command
+    export_local_parser = agent_subparsers.add_parser(
+        "export-local", help="Export local templates to a directory"
+    )
+    export_local_parser.add_argument(
+        "--output",
+        default="./exported-agents",
+        help="Output directory (default: ./exported-agents)",
+    )
+
+    # Import local command
+    import_local_parser = agent_subparsers.add_parser(
+        "import-local", help="Import templates from a directory"
+    )
+    import_local_parser.add_argument(
+        "--input", required=True, help="Input directory containing templates"
+    )
+    import_local_parser.add_argument(
+        "--tier",
+        choices=["project", "user"],
+        default="project",
+        help="Tier to import into (default: project)",
+    )
+
+    # Delete local command
+    delete_local_parser = agent_subparsers.add_parser(
+        "delete-local", help="Delete local agent templates with safety checks"
+    )
+    delete_local_parser.add_argument(
+        "--agent-id",
+        nargs="+",
+        dest="agent_id",
+        help="Agent ID(s) to delete (space-separated for multiple)",
+    )
+    delete_local_parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Delete all local agents (requires confirmation)",
+    )
+    delete_local_parser.add_argument(
+        "--force",
+        "-f",
+        action="store_true",
+        help="Skip confirmation prompts",
+    )
+    delete_local_parser.add_argument(
+        "--keep-deployment",
+        action="store_true",
+        help="Keep Claude Code deployment, only delete template",
+    )
+    delete_local_parser.add_argument(
+        "--backup",
+        action="store_true",
+        help="Create backup before deletion",
+    )
+    delete_local_parser.add_argument(
+        "--tier",
+        choices=["project", "user", "all"],
+        default="project",
+        help="Tier to delete from (default: project)",
+    )

claude_mpm/cli/parsers/agents_parser.py

@@ -68,6 +68,113 @@ def add_agents_subparser(subparsers) -> argparse.ArgumentParser:
         "--show-config", action="store_true", help="Show agent configuration"
     )
 
+    # Create local agent
+    create_agent_parser = agents_subparsers.add_parser(
+        "create", help="Create a new local agent template"
+    )
+    create_agent_parser.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Launch interactive agent creation wizard",
+    )
+    create_agent_parser.add_argument("--agent-id", help="Agent ID (lowercase, hyphens)")
+    create_agent_parser.add_argument("--name", help="Agent display name")
+    create_agent_parser.add_argument(
+        "--model",
+        choices=["sonnet", "opus", "haiku"],
+        default="sonnet",
+        help="Model to use",
+    )
+    create_agent_parser.add_argument(
+        "--inherit-from", help="System agent to inherit from"
+    )
+
+    # Edit local agent
+    edit_agent_parser = agents_subparsers.add_parser(
+        "edit", help="Edit a local agent template"
+    )
+    edit_agent_parser.add_argument("agent_id", help="Agent ID to edit")
+    edit_agent_parser.add_argument(
+        "--interactive", "-i", action="store_true", help="Use interactive editor"
+    )
+    edit_agent_parser.add_argument(
+        "--editor", help="Editor to use (default: $EDITOR or nano)"
+    )
+
+    # Delete local agent
+    delete_agent_parser = agents_subparsers.add_parser(
+        "delete", help="Delete a local agent template"
+    )
+    delete_agent_parser.add_argument(
+        "agent_ids", nargs="+", help="Agent ID(s) to delete"
+    )
+    delete_agent_parser.add_argument(
+        "--force", "-f", action="store_true", help="Skip confirmation prompts"
+    )
+    delete_agent_parser.add_argument(
+        "--keep-deployment",
+        action="store_true",
+        help="Keep Claude Code deployment, only delete template",
+    )
+    delete_agent_parser.add_argument(
+        "--backup", action="store_true", help="Create backup before deletion"
+    )
+
+    # Manage local agents (interactive menu)
+    agents_subparsers.add_parser(
+        "manage", help="Interactive menu for managing local agents"
+    )
+
+    # Configure agent deployment settings
+    configure_agents_parser = agents_subparsers.add_parser(
+        "configure", help="Configure which agents are deployed"
+    )
+    configure_agents_parser.add_argument(
+        "--enable",
+        nargs="+",
+        metavar="AGENT_ID",
+        help="Enable specific agents for deployment",
+    )
+    configure_agents_parser.add_argument(
+        "--disable",
+        nargs="+",
+        metavar="AGENT_ID",
+        help="Disable specific agents from deployment",
+    )
+    configure_agents_parser.add_argument(
+        "--enable-all", action="store_true", help="Enable all agents for deployment"
+    )
+    configure_agents_parser.add_argument(
+        "--disable-system",
+        action="store_true",
+        help="Disable all system agents from deployment",
+    )
+    configure_agents_parser.add_argument(
+        "--enable-system",
+        action="store_true",
+        help="Enable system agents for deployment",
+    )
+    configure_agents_parser.add_argument(
+        "--disable-local",
+        action="store_true",
+        help="Disable local project agents from deployment",
+    )
+    configure_agents_parser.add_argument(
+        "--enable-local",
+        action="store_true",
+        help="Enable local project agents for deployment",
+    )
+    configure_agents_parser.add_argument(
+        "--show", action="store_true", help="Show current deployment configuration"
+    )
+    configure_agents_parser.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Interactive configuration mode",
+    )
+
     # Deploy agents
     deploy_agents_parser = agents_subparsers.add_parser(
         AgentCommands.DEPLOY.value, help="Deploy agents to target directory"
@@ -159,4 +266,13 @@ def add_agents_subparser(subparsers) -> argparse.ArgumentParser:
         help="Only show summary, not individual agents",
     )
 
+    # Auto-configuration commands (TSK-0054 Phase 5)
+    from .auto_configure_parser import (
+        add_agents_detect_subparser,
+        add_agents_recommend_subparser,
+    )
+
+    add_agents_detect_subparser(agents_subparsers)
+    add_agents_recommend_subparser(agents_subparsers)
+
     return agents_parser

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)