claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/cli/parsers/tickets_parser.py

@@ -0,0 +1,203 @@
+"""
+Tickets command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to ticket management commands,
+extracted from the monolithic parser.py for better organization.
+
+DESIGN DECISION: Ticket commands have their own complex subcommand structure
+that warrants a dedicated module.
+"""
+
+import argparse
+
+from ...constants import CLICommands, TicketCommands
+from .base_parser import add_common_arguments
+
+
+def add_tickets_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the tickets subparser with all ticket management commands.
+
+    WHY: Ticket management has multiple subcommands (create, list, view, etc.)
+    that need their own argument structures.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured tickets subparser
+    """
+    # Tickets command with subcommands
+    tickets_parser = subparsers.add_parser(
+        CLICommands.TICKETS.value, help="Manage tickets and tracking"
+    )
+    add_common_arguments(tickets_parser)
+
+    tickets_subparsers = tickets_parser.add_subparsers(
+        dest="tickets_command", help="Ticket commands", metavar="SUBCOMMAND"
+    )
+
+    # Create ticket
+    create_ticket_parser = tickets_subparsers.add_parser(
+        TicketCommands.CREATE.value, help="Create a new ticket"
+    )
+    create_ticket_parser.add_argument("title", help="Ticket title")
+    create_ticket_parser.add_argument(
+        "-t",
+        "--type",
+        default="task",
+        choices=["task", "bug", "feature", "issue", "epic"],
+        help="Ticket type (default: task)",
+    )
+    create_ticket_parser.add_argument(
+        "-p",
+        "--priority",
+        default="medium",
+        choices=["low", "medium", "high", "critical"],
+        help="Priority level (default: medium)",
+    )
+    create_ticket_parser.add_argument(
+        "-d",
+        "--description",
+        nargs="*",
+        help="Ticket description (multiple words allowed)",
+    )
+    create_ticket_parser.add_argument("--tags", help="Comma-separated list of tags")
+    create_ticket_parser.add_argument(
+        "--parent-epic", help="Parent epic ID for this ticket"
+    )
+    create_ticket_parser.add_argument(
+        "--parent-issue", help="Parent issue ID for this ticket"
+    )
+
+    # List tickets
+    list_tickets_parser = tickets_subparsers.add_parser(
+        TicketCommands.LIST.value, help="List tickets"
+    )
+    list_tickets_parser.add_argument(
+        "-t",
+        "--type",
+        choices=["task", "bug", "feature", "issue", "epic"],
+        help="Filter by ticket type",
+    )
+    list_tickets_parser.add_argument(
+        "-s",
+        "--status",
+        choices=["open", "in_progress", "closed", "all"],
+        default="open",
+        help="Filter by status (default: open)",
+    )
+    list_tickets_parser.add_argument(
+        "-p",
+        "--priority",
+        choices=["low", "medium", "high", "critical"],
+        help="Filter by priority",
+    )
+    list_tickets_parser.add_argument(
+        "--limit",
+        type=int,
+        default=20,
+        help="Maximum number of tickets to show (default: 20)",
+    )
+    list_tickets_parser.add_argument(
+        "--page", type=int, default=1, help="Page number for pagination (default: 1)"
+    )
+    list_tickets_parser.add_argument(
+        "--page-size",
+        type=int,
+        default=20,
+        help="Number of tickets per page (default: 20)",
+    )
+    list_tickets_parser.add_argument(
+        "--verbose", action="store_true", help="Show detailed ticket information"
+    )
+
+    # View ticket
+    view_ticket_parser = tickets_subparsers.add_parser(
+        TicketCommands.VIEW.value, help="View ticket details"
+    )
+    view_ticket_parser.add_argument("ticket_id", help="Ticket ID to view")
+    view_ticket_parser.add_argument(
+        "--with-comments", action="store_true", help="Include comments in the view"
+    )
+
+    # Update ticket
+    update_ticket_parser = tickets_subparsers.add_parser(
+        TicketCommands.UPDATE.value, help="Update ticket"
+    )
+    update_ticket_parser.add_argument("ticket_id", help="Ticket ID to update")
+    update_ticket_parser.add_argument(
+        "-p",
+        "--priority",
+        choices=["low", "medium", "high", "critical"],
+        help="Update priority",
+    )
+    update_ticket_parser.add_argument(
+        "-s",
+        "--status",
+        choices=["open", "in_progress", "closed"],
+        help="Update status",
+    )
+    update_ticket_parser.add_argument("--title", help="Update title")
+    update_ticket_parser.add_argument("--description", help="Update description")
+    update_ticket_parser.add_argument("--add-tags", help="Comma-separated tags to add")
+    update_ticket_parser.add_argument(
+        "--remove-tags", help="Comma-separated tags to remove"
+    )
+
+    # Close ticket
+    close_ticket_parser = tickets_subparsers.add_parser(
+        TicketCommands.CLOSE.value, help="Close ticket"
+    )
+    close_ticket_parser.add_argument("ticket_id", help="Ticket ID to close")
+    close_ticket_parser.add_argument("--comment", help="Closing comment")
+
+    # Delete ticket
+    delete_ticket_parser = tickets_subparsers.add_parser(
+        TicketCommands.DELETE.value, help="Delete ticket"
+    )
+    delete_ticket_parser.add_argument("ticket_id", help="Ticket ID to delete")
+    delete_ticket_parser.add_argument(
+        "--force", action="store_true", help="Force deletion without confirmation"
+    )
+    delete_ticket_parser.add_argument(
+        "--archive", action="store_true", help="Archive instead of permanent deletion"
+    )
+
+    # Search tickets
+    search_tickets_parser = tickets_subparsers.add_parser(
+        TicketCommands.SEARCH.value, help="Search tickets"
+    )
+    search_tickets_parser.add_argument(
+        "query", help="Search query (searches title and description)"
+    )
+    search_tickets_parser.add_argument(
+        "-t",
+        "--type",
+        choices=["task", "bug", "feature", "issue", "epic"],
+        help="Filter by ticket type",
+    )
+    search_tickets_parser.add_argument(
+        "--limit", type=int, default=10, help="Maximum number of results (default: 10)"
+    )
+
+    # Comment on ticket
+    comment_ticket_parser = tickets_subparsers.add_parser(
+        TicketCommands.COMMENT.value, help="Add comment to ticket"
+    )
+    comment_ticket_parser.add_argument("ticket_id", help="Ticket ID to comment on")
+    comment_ticket_parser.add_argument("comment", help="Comment text")
+
+    # Workflow management
+    workflow_ticket_parser = tickets_subparsers.add_parser(
+        TicketCommands.WORKFLOW.value, help="Manage ticket workflow"
+    )
+    workflow_ticket_parser.add_argument("ticket_id", help="Ticket ID")
+    workflow_ticket_parser.add_argument(
+        "state",
+        choices=["open", "in_progress", "review", "testing", "closed"],
+        help="New workflow state",
+    )
+    workflow_ticket_parser.add_argument("--comment", help="Workflow transition comment")
+
+    return tickets_parser

claude_mpm/cli/ticket_cli.py

@@ -1,4 +1,6 @@
-#\!/usr/bin/env python3
+from pathlib import Path
+
+# \!/usr/bin/env python3
 """
 Ticket CLI module for claude-mpm.
 
@@ -7,7 +9,7 @@ It delegates to the scripts/ticket.py module for implementation.
 """
 
 import sys
-from pathlib import Path
+
 
 def main():
     """Main entry point for ticket CLI alias."""
@@ -16,8 +18,9 @@ def main():
         # Try to import from scripts
         scripts_dir = Path(__file__).parent.parent.parent.parent / "scripts"
         sys.path.insert(0, str(scripts_dir))
-        
+
         from ticket import main as ticket_main
+
         return ticket_main()
     except ImportError:
         print("Error: Ticket functionality not available")
@@ -27,5 +30,6 @@ def main():
         print(f"Error running ticket command: {e}")
         return 1
 
+
 if __name__ == "__main__":
     sys.exit(main())

claude_mpm/cli/utils.py

@@ -7,7 +7,6 @@ for common CLI operations.
 """
 
 import sys
-from pathlib import Path
 from typing import Optional
 
 from ..core.logger import get_logger
@@ -16,19 +15,19 @@ from ..core.logger import get_logger
 def get_user_input(input_arg: Optional[str], logger) -> str:
     """
     Get user input based on command line arguments.
-    
+
     WHY: This function handles the three ways users can provide input:
     1. Direct text via -i/--input
     2. File path via -i/--input
     3. stdin (for piping)
-    
+
     DESIGN DECISION: We check if the input is a file path first, then fall back
     to treating it as direct text. This allows maximum flexibility.
-    
+
     Args:
         input_arg: The value of the -i/--input argument
         logger: Logger instance for output
-        
+
     Returns:
         The user input as a string
     """
@@ -50,64 +49,74 @@ def get_user_input(input_arg: Optional[str], logger) -> str:
 def get_agent_versions_display() -> Optional[str]:
     """
     Get formatted agent versions display as a string.
-    
+
     WHY: This function provides a single source of truth for agent version
     information that can be displayed both at startup and on-demand via the
     /mpm agents command. This ensures consistency in how agent versions are
     presented to users.
-    
+
     Returns:
         Formatted string containing agent version information, or None if failed
     """
     try:
-        from ..services import AgentDeploymentService
         import os
         from pathlib import Path
-        
+
+        from ..services import AgentDeploymentService
+
         # Determine the user's working directory from environment
         user_working_dir = None
-        if 'CLAUDE_MPM_USER_PWD' in os.environ:
-            user_working_dir = Path(os.environ['CLAUDE_MPM_USER_PWD'])
-        
+        if "CLAUDE_MPM_USER_PWD" in os.environ:
+            user_working_dir = Path(os.environ["CLAUDE_MPM_USER_PWD"])
+
         deployment_service = AgentDeploymentService(working_directory=user_working_dir)
-        
+
         # Get deployed agents
         verification = deployment_service.verify_deployment()
         if not verification.get("agents_found"):
             return None
-            
+
         output_lines = []
         output_lines.append("\nDeployed Agent Versions:")
         output_lines.append("-" * 40)
-        
+
         # Sort agents by name for consistent display
-        agents = sorted(verification["agents_found"], key=lambda x: x.get('name', x.get('file', '')))
-        
+        agents = sorted(
+            verification["agents_found"], key=lambda x: x.get("name", x.get("file", ""))
+        )
+
         for agent in agents:
-            name = agent.get('name', 'unknown')
-            version = agent.get('version', 'unknown')
+            name = agent.get("name", "unknown")
+            version = agent.get("version", "unknown")
             # Format: name (version)
             output_lines.append(f"  {name:<20} {version}")
-        
+
         # Add base agent version info
         try:
             import json
+
             base_agent_path = deployment_service.base_agent_path
             if base_agent_path.exists():
                 base_data = json.loads(base_agent_path.read_text())
                 # Parse version the same way as AgentDeploymentService
-                raw_version = base_data.get('base_version') or base_data.get('version', 0)
+                raw_version = base_data.get("base_version") or base_data.get(
+                    "version", 0
+                )
                 base_version_tuple = deployment_service._parse_version(raw_version)
-                base_version_str = deployment_service._format_version_display(base_version_tuple)
+                base_version_str = deployment_service._format_version_display(
+                    base_version_tuple
+                )
                 output_lines.append(f"\n  Base Agent Version:  {base_version_str}")
         except:
             pass
-        
+
         # Check for agents needing migration
         if verification.get("agents_needing_migration"):
-            output_lines.append(f"\n  ⚠️  {len(verification['agents_needing_migration'])} agent(s) need migration to semantic versioning")
+            output_lines.append(
+                f"\n  ⚠️  {len(verification['agents_needing_migration'])} agent(s) need migration to semantic versioning"
+            )
             output_lines.append(f"     Run 'claude-mpm agents deploy' to update")
-            
+
         output_lines.append("-" * 40)
         return "\n".join(output_lines)
     except Exception as e:
@@ -120,7 +129,7 @@ def get_agent_versions_display() -> Optional[str]:
 def list_agent_versions_at_startup() -> None:
     """
     List deployed agent versions at startup.
-    
+
     WHY: Users want to see what agents are available when they start a session.
     This provides immediate feedback about the deployed agent environment.
     """
@@ -133,47 +142,56 @@ def list_agent_versions_at_startup() -> None:
 def setup_logging(args) -> object:
     """
     Set up logging based on parsed arguments.
-    
+
     WHY: This centralizes logging setup logic, handling the deprecated --debug flag
     and the new --logging argument consistently across all commands.
-    
+
     Args:
         args: Parsed command line arguments
-        
+
     Returns:
         Logger instance
     """
-    from ..core.logger import setup_logging as core_setup_logging, get_logger
     from ..constants import LogLevel
-    
+    from ..core.logger import get_logger
+    from ..core.logger import setup_logging as core_setup_logging
+
+    # Set default logging level if not specified
+    if not hasattr(args, "logging") or args.logging is None:
+        args.logging = LogLevel.INFO.value
+
     # Handle deprecated --debug flag
-    if hasattr(args, 'debug') and args.debug and args.logging == LogLevel.INFO.value:
+    if hasattr(args, "debug") and args.debug and args.logging == LogLevel.INFO.value:
         args.logging = LogLevel.DEBUG.value
-    
+
     # Only setup logging if not OFF
     if args.logging != LogLevel.OFF.value:
-        logger = core_setup_logging(level=args.logging, log_dir=args.log_dir)
+        logger = core_setup_logging(
+            level=args.logging, log_dir=getattr(args, "log_dir", None)
+        )
     else:
         # Minimal logger for CLI feedback
         import logging
+
         logger = logging.getLogger("cli")
         logger.setLevel(logging.WARNING)
-    
+
     return logger
 
 
 def ensure_directories() -> None:
     """
     Ensure required directories exist on first run.
-    
+
     WHY: Claude-mpm needs certain directories to function properly. Rather than
     failing when they don't exist, we create them automatically for a better
     user experience.
     """
     try:
         from ..init import ensure_directories as init_ensure_directories
+
         init_ensure_directories()
     except Exception:
         # Continue even if initialization fails
         # The individual commands will handle missing directories as needed
-        pass
+        pass

claude_mpm/cli_module/__init__.py

@@ -5,11 +5,11 @@ to reduce complexity in the main CLI function.
 """
 
 from .args import ArgumentRegistry
-from .commands import CommandRegistry, CommandDefinition, register_standard_commands
+from .commands import CommandDefinition, CommandRegistry, register_standard_commands
 
 __all__ = [
-    'ArgumentRegistry',
-    'CommandRegistry',
-    'CommandDefinition',
-    'register_standard_commands'
-]
+    "ArgumentRegistry",
+    "CommandRegistry",
+    "CommandDefinition",
+    "register_standard_commands",
+]