claude-mpm 3.1.1__py3-none-any.whl → 3.1.3__py3-none-any.whl

claude_mpm/cli/commands/info.py

@@ -0,0 +1,94 @@
+"""
+Info command implementation for claude-mpm.
+
+WHY: This module provides system information and configuration details to help
+users understand their claude-mpm setup and troubleshoot issues.
+"""
+
+import shutil
+from pathlib import Path
+
+from claude_mpm.utils.imports import safe_import
+
+# Import logger using safe_import pattern
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+
+
+def show_info(args):
+    """
+    Show framework and configuration information.
+    
+    WHY: Users need to verify their installation, check dependencies, and understand
+    what agents are available. This command provides a comprehensive overview of
+    the claude-mpm environment.
+    
+    DESIGN DECISION: We check for all major components and dependencies, showing
+    both what's working (✓) and what's missing (✗) to help with troubleshooting.
+    
+    Args:
+        args: Parsed command line arguments
+    """
+    # Import FrameworkLoader using safe_import pattern
+    FrameworkLoader = safe_import(
+        'claude_mpm.core.framework_loader',
+        None,
+        ['FrameworkLoader']
+    )
+    
+    print("Claude MPM - Multi-Agent Project Manager")
+    print("=" * 50)
+    
+    # Framework info
+    loader = FrameworkLoader(args.framework_path)
+    if loader.framework_content["loaded"]:
+        print(f"Framework: claude-multiagent-pm")
+        print(f"Version: {loader.framework_content['version']}")
+        print(f"Path: {loader.framework_path}")
+        print(f"Agents: {', '.join(loader.get_agent_list())}")
+    else:
+        print("Framework: Not found (using minimal instructions)")
+    
+    print()
+    
+    # Configuration
+    print("Configuration:")
+    print(f"  Log directory: {args.log_dir or '~/.claude-mpm/logs'}")
+    print(f"  Debug mode: {args.debug}")
+    
+    # Show agent hierarchy
+    if loader.agent_registry:
+        hierarchy = loader.agent_registry.get_agent_hierarchy()
+        print("\nAgent Hierarchy:")
+        print(f"  Project agents: {len(hierarchy['project'])}")
+        print(f"  User agents: {len(hierarchy['user'])}")
+        print(f"  System agents: {len(hierarchy['system'])}")
+        
+        # Show core agents
+        core_agents = loader.agent_registry.get_core_agents()
+        print(f"\nCore Agents: {', '.join(core_agents)}")
+    
+    # Check dependencies
+    print("\nDependencies:")
+    
+    # Check Claude CLI
+    claude_path = shutil.which("claude")
+    if claude_path:
+        print(f"  ✓ Claude CLI: {claude_path}")
+    else:
+        print("  ✗ Claude CLI: Not found in PATH")
+    
+    # Check ai-trackdown-pytools
+    try:
+        import ai_trackdown_pytools
+        print("  ✓ ai-trackdown-pytools: Installed")
+    except ImportError:
+        print("  ✗ ai-trackdown-pytools: Not installed")
+    
+    # Check Claude Code hooks
+    claude_settings = Path.home() / ".claude" / "settings.json"
+    if claude_settings.exists():
+        print("  ✓ Claude Code Hooks: Installed")
+        print("     Use /mpm commands in Claude Code")
+    else:
+        print("  ✗ Claude Code Hooks: Not installed")
+        print("     Run: python scripts/install_hooks.py")

claude_mpm/cli/commands/run.py

@@ -0,0 +1,95 @@
+"""
+Run command implementation for claude-mpm.
+
+WHY: This module handles the main 'run' command which starts Claude sessions.
+It's the most commonly used command and handles both interactive and non-interactive modes.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+from claude_mpm.utils.imports import safe_import
+
+# Import with safe_import pattern for better error handling
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+LogLevel = safe_import('claude_mpm.constants', None, ['LogLevel'])
+get_user_input, list_agent_versions_at_startup = safe_import(
+    'claude_mpm.cli.utils', 
+    None, 
+    ['get_user_input', 'list_agent_versions_at_startup']
+)
+
+
+def run_session(args):
+    """
+    Run a simplified Claude session.
+    
+    WHY: This is the primary command that users interact with. It sets up the
+    environment, optionally deploys agents, and launches Claude with the MPM framework.
+    
+    DESIGN DECISION: We use SimpleClaudeRunner to handle the complexity of
+    subprocess management and hook integration, keeping this function focused
+    on high-level orchestration.
+    
+    Args:
+        args: Parsed command line arguments
+    """
+    import os
+    logger = get_logger("cli")
+    if args.logging != LogLevel.OFF.value:
+        logger.info("Starting Claude MPM session")
+        # Log working directory context
+        logger.info(f"Working directory: {os.getcwd()}")
+        if args.debug:
+            logger.debug(f"User PWD (from env): {os.environ.get('CLAUDE_MPM_USER_PWD', 'Not set')}")
+            logger.debug(f"Framework path: {os.environ.get('CLAUDE_MPM_FRAMEWORK_PATH', 'Not set')}")
+    
+    # Import SimpleClaudeRunner using safe_import pattern
+    SimpleClaudeRunner, create_simple_context = safe_import(
+        'claude_mpm.core.simple_runner',
+        None,
+        ['SimpleClaudeRunner', 'create_simple_context']
+    )
+    
+    # Skip native agents if disabled
+    if getattr(args, 'no_native_agents', False):
+        print("Native agents disabled")
+    else:
+        # List deployed agent versions at startup
+        list_agent_versions_at_startup()
+    
+    # Create simple runner
+    enable_tickets = not args.no_tickets
+    claude_args = getattr(args, 'claude_args', []) or []
+    runner = SimpleClaudeRunner(
+        enable_tickets=enable_tickets,
+        log_level=args.logging,
+        claude_args=claude_args
+    )
+    
+    # Create basic context
+    context = create_simple_context()
+    
+    # Run session based on mode
+    if args.non_interactive or args.input:
+        # Non-interactive mode
+        user_input = get_user_input(args.input, logger)
+        success = runner.run_oneshot(user_input, context)
+        if not success:
+            logger.error("Session failed")
+    else:
+        # Interactive mode
+        if getattr(args, 'intercept_commands', False):
+            # Use the interactive wrapper for command interception
+            # WHY: Command interception requires special handling of stdin/stdout
+            # which is better done in a separate Python script
+            wrapper_path = Path(__file__).parent.parent.parent.parent.parent / "scripts" / "interactive_wrapper.py"
+            if wrapper_path.exists():
+                print("Starting interactive session with command interception...")
+                subprocess.run([sys.executable, str(wrapper_path)])
+            else:
+                logger.warning("Interactive wrapper not found, falling back to normal mode")
+                runner.run_interactive(context)
+        else:
+            runner.run_interactive(context)

claude_mpm/cli/commands/tickets.py

@@ -0,0 +1,70 @@
+"""
+Tickets command implementation for claude-mpm.
+
+WHY: This module handles ticket listing functionality, allowing users to view
+recent tickets created during Claude sessions.
+"""
+
+from claude_mpm.utils.imports import safe_import
+
+# Import logger using safe_import pattern
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+
+
+def list_tickets(args):
+    """
+    List recent tickets.
+    
+    WHY: Users need to review tickets created during Claude sessions. This command
+    provides a quick way to see recent tickets with their status and metadata.
+    
+    DESIGN DECISION: We show tickets in a compact format with emoji status indicators
+    for better visual scanning. The limit is configurable to allow users to see more
+    or fewer tickets as needed.
+    
+    Args:
+        args: Parsed command line arguments with 'limit' attribute
+    """
+    logger = get_logger("cli")
+    
+    # Import TicketManager using safe_import pattern
+    TicketManager = safe_import(
+        '...services.ticket_manager',
+        'claude_mpm.services.ticket_manager',
+        ['TicketManager']
+    )
+    
+    if not TicketManager:
+        logger.error("ai-trackdown-pytools not installed")
+        print("Error: ai-trackdown-pytools not installed")
+        print("Install with: pip install ai-trackdown-pytools")
+        return
+    
+    try:
+        ticket_manager = TicketManager()
+        tickets = ticket_manager.list_recent_tickets(limit=args.limit)
+        
+        if not tickets:
+            print("No tickets found")
+            return
+        
+        print(f"Recent tickets (showing {len(tickets)}):")
+        print("-" * 80)
+        
+        for ticket in tickets:
+            # Use emoji to indicate status visually
+            status_emoji = {
+                "open": "🔵",
+                "in_progress": "🟡",
+                "done": "🟢",
+                "closed": "⚫"
+            }.get(ticket['status'], "⚪")
+            
+            print(f"{status_emoji} [{ticket['id']}] {ticket['title']}")
+            print(f"   Priority: {ticket['priority']} | Tags: {', '.join(ticket['tags'])}")
+            print(f"   Created: {ticket['created_at']}")
+            print()
+            
+    except Exception as e:
+        logger.error(f"Error listing tickets: {e}")
+        print(f"Error: {e}")

claude_mpm/cli/commands/ui.py

@@ -0,0 +1,79 @@
+"""
+UI command implementation for claude-mpm.
+
+WHY: This module provides terminal UI functionality for users who prefer a
+visual interface over command-line interaction.
+"""
+
+from claude_mpm.utils.imports import safe_import
+
+# Import logger using safe_import pattern
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+
+
+def run_terminal_ui(args):
+    """
+    Run the terminal UI.
+    
+    WHY: Some users prefer a visual interface with multiple panes showing different
+    aspects of the system. This command launches either a rich terminal UI or a
+    basic curses UI depending on availability and user preference.
+    
+    DESIGN DECISION: We try the rich UI first as it provides a better experience,
+    but fall back to curses if rich is not available. This ensures the UI works
+    on all systems.
+    
+    Args:
+        args: Parsed command line arguments with optional 'mode' attribute
+    """
+    logger = get_logger("cli")
+    
+    ui_mode = getattr(args, 'mode', 'terminal')
+    
+    try:
+        if ui_mode == 'terminal':
+            # Try rich UI first using safe_import
+            run_rich_ui = safe_import(
+                '...ui.rich_terminal_ui',
+                'claude_mpm.ui.rich_terminal_ui',
+                ['main']
+            )
+            
+            if run_rich_ui:
+                logger.info("Starting rich terminal UI...")
+                run_rich_ui()
+            else:
+                # Fallback to curses UI
+                logger.info("Rich not available, falling back to curses UI...")
+                TerminalUI = safe_import(
+                    '...ui.terminal_ui',
+                    'claude_mpm.ui.terminal_ui',
+                    ['TerminalUI']
+                )
+                if TerminalUI:
+                    ui = TerminalUI()
+                    ui.run()
+                else:
+                    logger.error("UI module not found")
+                    print("Error: Terminal UI requires 'curses' (built-in) or 'rich' (pip install rich)")
+                    return 1
+        else:
+            # Use curses UI explicitly
+            TerminalUI = safe_import(
+                '...ui.terminal_ui',
+                'claude_mpm.ui.terminal_ui',
+                ['TerminalUI']
+            )
+            if TerminalUI:
+                ui = TerminalUI()
+                ui.run()
+            else:
+                logger.error("UI module not found")
+                print("Error: Terminal UI not available")
+                return 1
+    except Exception as e:
+        logger.error(f"Error running terminal UI: {e}")
+        print(f"Error: {e}")
+        return 1
+    
+    return 0

claude_mpm/cli/parser.py

@@ -0,0 +1,337 @@
+"""
+Argument parser for claude-mpm CLI.
+
+WHY: This module centralizes all argument parsing logic to avoid duplication and provide
+a single source of truth for CLI arguments. It uses inheritance to share common arguments
+across commands while keeping command-specific args organized.
+
+DESIGN DECISION: We use a base parser factory pattern to create parsers with common
+arguments, then extend them for specific commands. This reduces duplication while
+maintaining flexibility.
+"""
+
+import argparse
+from pathlib import Path
+from typing import Optional, List
+
+from ..constants import CLICommands, CLIPrefix, AgentCommands, LogLevel
+
+
+def add_common_arguments(parser: argparse.ArgumentParser, version: str = None) -> None:
+    """
+    Add common arguments that apply to all commands.
+    
+    WHY: These arguments are needed across multiple commands, so we centralize them
+    to ensure consistency and avoid duplication.
+    
+    Args:
+        parser: The argument parser to add arguments to
+        version: Version string to display (only needed for main parser)
+    """
+    # Version - only add to main parser, not subparsers
+    if version is not None:
+        parser.add_argument(
+            "--version",
+            action="version",
+            version=f"%(prog)s {version}"
+        )
+    
+    # Logging arguments
+    logging_group = parser.add_argument_group('logging options')
+    logging_group.add_argument(
+        "-d", "--debug",
+        action="store_true",
+        help="Enable debug logging (deprecated, use --logging DEBUG)"
+    )
+    logging_group.add_argument(
+        "--logging",
+        choices=[level.value for level in LogLevel],
+        default=LogLevel.INFO.value,
+        help="Logging level (default: INFO)"
+    )
+    logging_group.add_argument(
+        "--log-dir",
+        type=Path,
+        help="Custom log directory (default: ~/.claude-mpm/logs)"
+    )
+    
+    # Framework configuration
+    framework_group = parser.add_argument_group('framework options')
+    framework_group.add_argument(
+        "--framework-path",
+        type=Path,
+        help="Path to claude-mpm framework"
+    )
+    framework_group.add_argument(
+        "--agents-dir",
+        type=Path,
+        help="Custom agents directory to use"
+    )
+
+
+def add_run_arguments(parser: argparse.ArgumentParser) -> None:
+    """
+    Add arguments specific to the run command.
+    
+    WHY: The run command has specific arguments for controlling how Claude sessions
+    are executed, including hook management, ticket creation, and interaction modes.
+    
+    Args:
+        parser: The argument parser to add arguments to
+    """
+    run_group = parser.add_argument_group('run options')
+    
+    run_group.add_argument(
+        "--no-hooks",
+        action="store_true",
+        help="Disable hook service (runs without hooks)"
+    )
+    run_group.add_argument(
+        "--no-tickets",
+        action="store_true",
+        help="Disable automatic ticket creation"
+    )
+    run_group.add_argument(
+        "--intercept-commands",
+        action="store_true",
+        help="Enable command interception in interactive mode (intercepts /mpm: commands)"
+    )
+    run_group.add_argument(
+        "--no-native-agents",
+        action="store_true",
+        help="Disable deployment of Claude Code native agents"
+    )
+    
+    # Input/output options
+    io_group = parser.add_argument_group('input/output options')
+    io_group.add_argument(
+        "-i", "--input",
+        type=str,
+        help="Input text or file path (for non-interactive mode)"
+    )
+    io_group.add_argument(
+        "--non-interactive",
+        action="store_true",
+        help="Run in non-interactive mode (read from stdin or --input)"
+    )
+    
+    # Claude CLI arguments
+    parser.add_argument(
+        "claude_args",
+        nargs=argparse.REMAINDER,
+        help="Additional arguments to pass to Claude CLI (use -- before Claude args)"
+    )
+
+
+def create_parser(prog_name: str = "claude-mpm", version: str = "0.0.0") -> argparse.ArgumentParser:
+    """
+    Create the main argument parser with all subcommands.
+    
+    WHY: This factory function creates a complete parser with all commands and their
+    arguments. It's the single entry point for creating the CLI parser, ensuring
+    consistency across the application.
+    
+    DESIGN DECISION: We use subparsers for commands to provide a clean, git-like
+    interface while maintaining backward compatibility with the original CLI.
+    
+    Args:
+        prog_name: The program name to use
+        version: The version string to display
+        
+    Returns:
+        Configured ArgumentParser instance
+    """
+    # Main parser
+    parser = argparse.ArgumentParser(
+        prog=prog_name,
+        description=f"Claude Multi-Agent Project Manager v{version} - Orchestrate Claude with agent delegation and ticket tracking",
+        epilog="By default, runs an orchestrated Claude session. Use 'claude-mpm' for interactive mode or 'claude-mpm -i \"prompt\"' for non-interactive mode.\n\nTo pass arguments to Claude CLI, use -- separator: claude-mpm run -- --model sonnet --temperature 0.1",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    # Add common arguments to main parser with version
+    add_common_arguments(parser, version=version)
+    
+    # Add run-specific arguments at top level for default behavior
+    # WHY: This maintains backward compatibility - users can run `claude-mpm -i "prompt"`
+    # without specifying the 'run' command
+    # NOTE: We don't add claude_args here because REMAINDER interferes with subcommands
+    run_group = parser.add_argument_group('run options (when no command specified)')
+    
+    run_group.add_argument(
+        "--no-hooks",
+        action="store_true",
+        help="Disable hook service (runs without hooks)"
+    )
+    run_group.add_argument(
+        "--no-tickets",
+        action="store_true",
+        help="Disable automatic ticket creation"
+    )
+    run_group.add_argument(
+        "--intercept-commands",
+        action="store_true",
+        help="Enable command interception in interactive mode (intercepts /mpm: commands)"
+    )
+    run_group.add_argument(
+        "--no-native-agents",
+        action="store_true",
+        help="Disable deployment of Claude Code native agents"
+    )
+    
+    # Input/output options
+    io_group = parser.add_argument_group('input/output options (when no command specified)')
+    io_group.add_argument(
+        "-i", "--input",
+        type=str,
+        help="Input text or file path (for non-interactive mode)"
+    )
+    io_group.add_argument(
+        "--non-interactive",
+        action="store_true",
+        help="Run in non-interactive mode (read from stdin or --input)"
+    )
+    
+    # Create subparsers for commands
+    subparsers = parser.add_subparsers(
+        dest="command",
+        help="Available commands",
+        metavar="COMMAND"
+    )
+    
+    # Run command (explicit)
+    run_parser = subparsers.add_parser(
+        CLICommands.RUN.value,
+        help="Run orchestrated Claude session (default)",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    add_common_arguments(run_parser)
+    add_run_arguments(run_parser)
+    
+    # Tickets command
+    tickets_parser = subparsers.add_parser(
+        CLICommands.TICKETS.value,
+        help="List recent tickets"
+    )
+    add_common_arguments(tickets_parser)
+    tickets_parser.add_argument(
+        "-n", "--limit",
+        type=int,
+        default=10,
+        help="Number of tickets to show"
+    )
+    
+    # Info command
+    info_parser = subparsers.add_parser(
+        CLICommands.INFO.value,
+        help="Show framework and configuration info"
+    )
+    add_common_arguments(info_parser)
+    
+    # UI command
+    ui_parser = subparsers.add_parser(
+        CLICommands.UI.value,
+        help="Launch terminal UI with multiple panes"
+    )
+    add_common_arguments(ui_parser)
+    ui_parser.add_argument(
+        "--mode",
+        choices=["terminal", "curses"],
+        default="terminal",
+        help="UI mode to launch (default: terminal)"
+    )
+    
+    # Agents command with subcommands
+    agents_parser = subparsers.add_parser(
+        CLICommands.AGENTS.value,
+        help="Manage Claude Code native agents"
+    )
+    add_common_arguments(agents_parser)
+    
+    agents_subparsers = agents_parser.add_subparsers(
+        dest="agents_command",
+        help="Agent commands",
+        metavar="SUBCOMMAND"
+    )
+    
+    # List agents
+    list_agents_parser = agents_subparsers.add_parser(
+        AgentCommands.LIST.value,
+        help="List available agents"
+    )
+    list_agents_parser.add_argument(
+        "--system",
+        action="store_true",
+        help="List system agents"
+    )
+    list_agents_parser.add_argument(
+        "--deployed",
+        action="store_true", 
+        help="List deployed agents"
+    )
+    
+    # Deploy agents
+    deploy_agents_parser = agents_subparsers.add_parser(
+        AgentCommands.DEPLOY.value,
+        help="Deploy system agents"
+    )
+    deploy_agents_parser.add_argument(
+        "--target",
+        type=Path,
+        help="Target directory (default: .claude/agents/)"
+    )
+    
+    # Force deploy agents
+    force_deploy_parser = agents_subparsers.add_parser(
+        AgentCommands.FORCE_DEPLOY.value,
+        help="Force deploy all system agents"
+    )
+    force_deploy_parser.add_argument(
+        "--target",
+        type=Path,
+        help="Target directory (default: .claude/agents/)"
+    )
+    
+    # Clean agents
+    clean_agents_parser = agents_subparsers.add_parser(
+        AgentCommands.CLEAN.value,
+        help="Remove deployed system agents"
+    )
+    clean_agents_parser.add_argument(
+        "--target",
+        type=Path,
+        help="Target directory (default: .claude/)"
+    )
+    
+    return parser
+
+
+def preprocess_args(argv: Optional[List[str]] = None) -> List[str]:
+    """
+    Preprocess arguments to handle --mpm: prefix commands.
+    
+    WHY: We support both --mpm:command and regular command syntax for flexibility
+    and backward compatibility. This function normalizes the input.
+    
+    Args:
+        argv: List of command line arguments, or None to use sys.argv[1:]
+        
+    Returns:
+        Processed list of arguments with prefixes removed
+    """
+    import sys
+    
+    if argv is None:
+        argv = sys.argv[1:]
+    
+    # Convert --mpm:command to command for argparse compatibility
+    processed_args = []
+    for arg in argv:
+        if arg.startswith(CLIPrefix.MPM.value):
+            # Extract command after prefix
+            command = arg[len(CLIPrefix.MPM.value):]
+            processed_args.append(command)
+        else:
+            processed_args.append(arg)
+    
+    return processed_args