claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/cli/parsers/source_parser.py

@@ -0,0 +1,138 @@
+"""Source command parser for agent repository management.
+
+WHY: This module provides CLI commands for managing agent source repositories
+(Git repositories containing agent markdown files). Extracted into its own
+module to support the single-tier deployment migration (Phase 2).
+
+DESIGN DECISION: Source management is separate from agent deployment to
+maintain clear separation of concerns:
+- source commands: Manage repository configuration
+- agents commands: Deploy and manage agents themselves
+"""
+
+import argparse
+
+from .base_parser import add_common_arguments
+
+
+def add_source_subparser(subparsers) -> argparse.ArgumentParser:
+    """Add the source subparser with all repository management commands.
+
+    WHY: Agent sources (Git repositories) need their own command group
+    for managing repository configuration, priorities, and synchronization.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured source subparser
+    """
+    # Source command with subcommands
+    source_parser = subparsers.add_parser(
+        "source",
+        help="Manage agent source repositories",
+    )
+    add_common_arguments(source_parser)
+
+    source_subparsers = source_parser.add_subparsers(
+        dest="source_command",
+        help="Source repository commands",
+        metavar="SUBCOMMAND",
+    )
+
+    # Add repository
+    add_parser = source_subparsers.add_parser(
+        "add",
+        help="Add a new agent source repository",
+    )
+    add_parser.add_argument(
+        "url",
+        help="GitHub repository URL (e.g., https://github.com/owner/repo)",
+    )
+    add_parser.add_argument(
+        "--subdirectory",
+        "--subdir",
+        help="Subdirectory path within repository (e.g., 'agents')",
+    )
+    add_parser.add_argument(
+        "--priority",
+        type=int,
+        default=100,
+        help="Priority for conflict resolution (lower = higher precedence, default: 100)",
+    )
+    add_parser.add_argument(
+        "--disabled",
+        action="store_true",
+        help="Add repository but keep it disabled",
+    )
+
+    # Remove repository
+    remove_parser = source_subparsers.add_parser(
+        "remove",
+        help="Remove an agent source repository",
+    )
+    remove_parser.add_argument(
+        "identifier",
+        help="Repository identifier (e.g., 'owner/repo' or 'owner/repo/subdirectory')",
+    )
+
+    # List repositories
+    list_parser = source_subparsers.add_parser(
+        "list",
+        help="List configured agent source repositories",
+    )
+    list_parser.add_argument(
+        "--all",
+        action="store_true",
+        dest="show_all",
+        help="Show disabled repositories (default: only enabled)",
+    )
+
+    # Enable repository
+    enable_parser = source_subparsers.add_parser(
+        "enable",
+        help="Enable a disabled repository",
+    )
+    enable_parser.add_argument(
+        "identifier",
+        help="Repository identifier to enable",
+    )
+
+    # Disable repository
+    disable_parser = source_subparsers.add_parser(
+        "disable",
+        help="Disable a repository",
+    )
+    disable_parser.add_argument(
+        "identifier",
+        help="Repository identifier to disable",
+    )
+
+    # Disable system repository
+    disable_system_parser = source_subparsers.add_parser(
+        "disable-system",
+        help="Disable or enable the default system repository",
+    )
+    disable_system_parser.add_argument(
+        "--enable",
+        action="store_true",
+        help="Re-enable system repository instead of disabling",
+    )
+
+    # Sync repositories
+    sync_parser = source_subparsers.add_parser(
+        "sync",
+        help="Sync agent sources from Git",
+    )
+    sync_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force sync even if cache is fresh (ignore ETags)",
+    )
+    sync_parser.add_argument(
+        "identifier",
+        nargs="?",
+        help="Optional: Sync only this repository (default: sync all)",
+    )
+
+    return source_parser

claude_mpm/cli/shared/argument_patterns.py

@@ -7,78 +7,85 @@ across multiple CLI commands.
 
 import argparse
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, ClassVar, Dict, List, Optional
 
 
 class CommonArguments:
     """Registry of common argument patterns used across CLI commands."""
 
     # Logging arguments
-    VERBOSE = {
+    VERBOSE: ClassVar[Dict[str, Any]] = {
         "flags": ["-v", "--verbose"],
         "action": "store_true",
         "help": "Enable verbose output",
     }
 
-    QUIET = {
+    QUIET: ClassVar[Dict[str, Any]] = {
         "flags": ["-q", "--quiet"],
         "action": "store_true",
         "help": "Suppress non-error output",
     }
 
-    DEBUG = {
+    DEBUG: ClassVar[Dict[str, Any]] = {
         "flags": ["--debug"],
         "action": "store_true",
         "help": "Enable debug logging",
     }
 
     # Configuration arguments
-    CONFIG_FILE = {
+    CONFIG_FILE: ClassVar[Dict[str, Any]] = {
         "flags": ["-c", "--config"],
         "type": Path,
         "help": "Path to configuration file",
     }
 
-    CONFIG_DIR = {
+    CONFIG_DIR: ClassVar[Dict[str, Any]] = {
         "flags": ["--config-dir"],
         "type": Path,
         "help": "Configuration directory path",
     }
 
     # Output arguments
-    OUTPUT_FORMAT = {
+    OUTPUT_FORMAT: ClassVar[Dict[str, Any]] = {
         "flags": ["-f", "--format"],
         "choices": ["json", "yaml", "table", "text"],
         "default": "text",
         "help": "Output format",
     }
 
-    OUTPUT_FILE = {
+    OUTPUT_FILE: ClassVar[Dict[str, Any]] = {
         "flags": ["-o", "--output"],
         "type": Path,
         "help": "Output file path",
     }
 
     # Common flags
-    FORCE = {
+    FORCE: ClassVar[Dict[str, Any]] = {
         "flags": ["--force"],
         "action": "store_true",
         "help": "Force operation without confirmation",
     }
 
-    DRY_RUN = {
+    DRY_RUN: ClassVar[Dict[str, Any]] = {
         "flags": ["--dry-run"],
         "action": "store_true",
         "help": "Show what would be done without executing",
     }
 
     # Agent-related arguments
-    AGENT_NAME = {"flags": ["--agent"], "help": "Agent name or pattern"}
+    AGENT_NAME: ClassVar[Dict[str, Any]] = {
+        "flags": ["--agent"],
+        "help": "Agent name or pattern",
+    }
 
-    AGENT_DIR = {"flags": ["--agent-dir"], "type": Path, "help": "Agent directory path"}
+    AGENT_DIR: ClassVar[Dict[str, Any]] = {
+        "flags": ["--agent-dir"],
+        "type": Path,
+        "help": "Agent directory path",
+    }
 
     # Memory-related arguments
-    MEMORY_DIR = {
+    MEMORY_DIR: ClassVar[Dict[str, Any]] = {
         "flags": ["--memory-dir"],
         "type": Path,
         "help": "Memory directory path",

claude_mpm/cli/shared/base_command.py

@@ -73,7 +73,7 @@ class BaseCommand(ABC):
         """Get working directory (respects CLAUDE_MPM_USER_PWD)."""
         if self._working_dir is None:
             # Use CLAUDE_MPM_USER_PWD if available (when called via shell script)
-            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", os.getcwd())
+            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", Path.cwd())
             self._working_dir = Path(user_pwd)
         return self._working_dir
 
@@ -183,7 +183,7 @@ class BaseCommand(ABC):
 
         if hasattr(args, "output") and args.output:
             # Write to file
-            with open(args.output, "w") as f:
+            with args.output.open("w") as f:
                 f.write(formatted_output)
             self.logger.info(f"Output written to {args.output}")
         else:

claude_mpm/cli/shared/output_formatters.py

@@ -7,6 +7,8 @@ from typing import Any, Dict, List, Optional, Union
 
 import yaml
 
+from claude_mpm.core.enums import OutputFormat
+
 
 class OutputFormatter:
     """Handles formatting output in different formats."""
@@ -104,13 +106,13 @@ class OutputFormatter:
         return str(data)
 
 
-def format_output(data: Any, format_type: str = "text", **kwargs) -> str:
+def format_output(data: Any, format_type: str = OutputFormat.TEXT, **kwargs) -> str:
     """
     Format data according to the specified format.
 
     Args:
         data: Data to format
-        format_type: Output format ('json', 'yaml', 'table', 'text')
+        format_type: Output format (use OutputFormat enum or string)
         **kwargs: Additional formatting options
 
     Returns:
@@ -118,20 +120,23 @@ def format_output(data: Any, format_type: str = "text", **kwargs) -> str:
     """
     formatter = OutputFormatter()
 
-    if format_type == "json":
+    # Convert to string for comparison (handles both enum and string inputs)
+    fmt = str(format_type).lower()
+
+    if fmt == OutputFormat.JSON:
         return formatter.format_json(data, **kwargs)
-    if format_type == "yaml":
+    if fmt == OutputFormat.YAML:
         return formatter.format_yaml(data)
-    if format_type == "table":
+    if fmt == OutputFormat.TABLE:
         return formatter.format_table(data, **kwargs)
-    if format_type == "text":
+    if fmt == OutputFormat.TEXT:
         return formatter.format_text(data)
     # Fallback to text format
     return formatter.format_text(data)
 
 
 def format_success_message(
-    message: str, data: Any = None, format_type: str = "text"
+    message: str, data: Any = None, format_type: str = OutputFormat.TEXT
 ) -> str:
     """
     Format a success message with optional data.
@@ -139,12 +144,13 @@ def format_success_message(
     Args:
         message: Success message
         data: Optional data to include
-        format_type: Output format
+        format_type: Output format (use OutputFormat enum or string)
 
     Returns:
         Formatted success message
     """
-    if format_type in ("json", "yaml"):
+    fmt = str(format_type).lower()
+    if fmt in (OutputFormat.JSON, OutputFormat.YAML):
         result = {"success": True, "message": message}
         if data is not None:
             result["data"] = data
@@ -158,7 +164,7 @@ def format_success_message(
 
 
 def format_error_message(
-    message: str, details: Any = None, format_type: str = "text"
+    message: str, details: Any = None, format_type: str = OutputFormat.TEXT
 ) -> str:
     """
     Format an error message with optional details.
@@ -166,12 +172,13 @@ def format_error_message(
     Args:
         message: Error message
         details: Optional error details
-        format_type: Output format
+        format_type: Output format (use OutputFormat enum or string)
 
     Returns:
         Formatted error message
     """
-    if format_type in ("json", "yaml"):
+    fmt = str(format_type).lower()
+    if fmt in (OutputFormat.JSON, OutputFormat.YAML):
         result = {"success": False, "error": message}
         if details is not None:
             result["details"] = details
@@ -187,7 +194,7 @@ def format_error_message(
 def format_list_output(
     items: List[Any],
     title: Optional[str] = None,
-    format_type: str = "text",
+    format_type: str = OutputFormat.TEXT,
     headers: Optional[List[str]] = None,
 ) -> str:
     """
@@ -196,29 +203,31 @@ def format_list_output(
     Args:
         items: List of items to format
         title: Optional title for the list
-        format_type: Output format
+        format_type: Output format (use OutputFormat enum or string)
         headers: Optional headers for table format
 
     Returns:
         Formatted list output
     """
+    fmt = str(format_type).lower()
+
     if not items:
         empty_msg = f"No {title.lower() if title else 'items'} found"
-        if format_type in ("json", "yaml"):
+        if fmt in (OutputFormat.JSON, OutputFormat.YAML):
             return format_output({"items": [], "message": empty_msg}, format_type)
         return empty_msg
 
-    if format_type in ("json", "yaml"):
+    if fmt in (OutputFormat.JSON, OutputFormat.YAML):
         result = {"items": items}
         if title:
             result["title"] = title
         return format_output(result, format_type)
 
-    if format_type == "table":
+    if fmt == OutputFormat.TABLE:
         output = ""
         if title:
             output += f"{title}\n{'=' * len(title)}\n\n"
-        output += format_output(items, "table", headers=headers)
+        output += format_output(items, OutputFormat.TABLE, headers=headers)
         return output
 
     # Text format
@@ -228,5 +237,5 @@ def format_list_output(
         lines.append("=" * len(title))
         lines.append("")
 
-    lines.append(format_output(items, "text"))
+    lines.append(format_output(items, OutputFormat.TEXT))
     return "\n".join(lines)