claude-mpm 4.14.6__py3-none-any.whl → 4.21.0__py3-none-any.whl

claude_mpm/cli/parsers/skills_parser.py

@@ -0,0 +1,137 @@
+"""
+Skills command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to skills management commands,
+providing CLI access to the Skills Integration system.
+
+DESIGN DECISION: Skills commands expose the SkillsService functionality via CLI
+for listing, deploying, validating, updating, and configuring Claude Code skills.
+"""
+
+import argparse
+
+from ...constants import CLICommands, SkillsCommands
+from .base_parser import add_common_arguments
+
+
+def add_skills_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the skills subparser with all skills management commands.
+
+    WHY: Skills management has multiple subcommands for discovery, deployment,
+    validation, updates, and configuration that need their own argument structures.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured skills subparser
+    """
+    # Skills command with subcommands
+    skills_parser = subparsers.add_parser(
+        CLICommands.SKILLS.value, help="Manage Claude Code skills"
+    )
+    add_common_arguments(skills_parser)
+
+    skills_subparsers = skills_parser.add_subparsers(
+        dest="skills_command", help="Skills commands", metavar="SUBCOMMAND"
+    )
+
+    # List command
+    list_parser = skills_subparsers.add_parser(
+        SkillsCommands.LIST.value, help="List available skills"
+    )
+    list_parser.add_argument(
+        "--category",
+        help="Filter by category (e.g., development, infrastructure, web-development)",
+    )
+    list_parser.add_argument(
+        "--agent", help="Show skills for specific agent (e.g., engineer, pm)"
+    )
+    list_parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed skill information",
+    )
+
+    # Deploy command
+    deploy_parser = skills_subparsers.add_parser(
+        SkillsCommands.DEPLOY.value, help="Deploy bundled skills to project"
+    )
+    deploy_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force redeployment of already deployed skills",
+    )
+    deploy_parser.add_argument(
+        "--skill",
+        action="append",
+        dest="skills",
+        help="Deploy specific skill(s) only (can be used multiple times)",
+    )
+
+    # Validate command
+    validate_parser = skills_subparsers.add_parser(
+        SkillsCommands.VALIDATE.value, help="Validate skill structure and metadata"
+    )
+    validate_parser.add_argument("skill_name", help="Name of the skill to validate")
+    validate_parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Use strict validation (treat warnings as errors)",
+    )
+
+    # Update command
+    update_parser = skills_subparsers.add_parser(
+        SkillsCommands.UPDATE.value, help="Check for and install skill updates"
+    )
+    update_parser.add_argument(
+        "skill_names",
+        nargs="*",
+        help="Specific skills to update (default: all)",
+    )
+    update_parser.add_argument(
+        "--check-only",
+        action="store_true",
+        help="Check for updates without installing them",
+    )
+    update_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force update even if versions match",
+    )
+
+    # Info command
+    info_parser = skills_subparsers.add_parser(
+        SkillsCommands.INFO.value, help="Show detailed skill information"
+    )
+    info_parser.add_argument("skill_name", help="Name of the skill")
+    info_parser.add_argument(
+        "--show-content",
+        action="store_true",
+        help="Show full skill content (SKILL.md)",
+    )
+
+    # Config command
+    config_parser = skills_subparsers.add_parser(
+        SkillsCommands.CONFIG.value, help="View or edit skills configuration"
+    )
+    config_parser.add_argument(
+        "--scope",
+        choices=["system", "user", "project"],
+        default="project",
+        help="Configuration scope (default: project)",
+    )
+    config_parser.add_argument(
+        "--edit",
+        action="store_true",
+        help="Open configuration in $EDITOR",
+    )
+    config_parser.add_argument(
+        "--path",
+        action="store_true",
+        help="Show configuration file path",
+    )
+
+    return skills_parser

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)