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

claude_mpm/cli/commands/agents_cleanup.py

@@ -0,0 +1,210 @@
+"""Agent cleanup command for syncing, installing, and removing old underscore-named agents.
+
+WHY: After standardizing template filenames from underscores to dashes, users need
+a way to sync the latest agents, install them with correct names, and remove old
+underscore-named duplicates.
+
+DESIGN DECISION: Three-phase cleanup process:
+1. Sync agents from remote repository (download latest)
+2. Deploy synced agents to target directory (force overwrite)
+3. Remove old underscore-named agents that have dash equivalents
+
+IMPLEMENTATION NOTE: Uses name similarity matching to identify old agents that
+should be removed (e.g., python_engineer.md → python-engineer.md).
+"""
+
+import logging
+from pathlib import Path
+from typing import List
+
+from ...config.agent_sources import AgentSourceConfiguration
+from ...services.agents.sources.git_source_sync_service import GitSourceSyncService
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize_agent_name(name: str) -> str:
+    """Normalize agent name by removing extensions and converting to lowercase.
+
+    Args:
+        name: Agent filename (e.g., "python_engineer.md" or "python-engineer.md")
+
+    Returns:
+        Normalized name (e.g., "pythonengineer")
+    """
+    # Remove file extension
+    name = name.replace(".md", "").replace(".json", "")
+    # Remove dashes and underscores for comparison
+    name = name.replace("-", "").replace("_", "")
+    return name.lower()
+
+
+def _find_old_underscore_agents(
+    deployed_agents: List[Path], new_agents: List[str]
+) -> List[Path]:
+    """Find old underscore-named agents that have dash-named equivalents.
+
+    Args:
+        deployed_agents: List of paths to deployed agent files
+        new_agents: List of new agent filenames (with dashes)
+
+    Returns:
+        List of paths to old agents that should be removed
+    """
+    # Normalize new agent names for comparison
+    normalized_new = {_normalize_agent_name(agent) for agent in new_agents}
+
+    old_agents = []
+    for agent_path in deployed_agents:
+        agent_name = agent_path.name
+
+        # Check if this is an underscore-named agent
+        if "_" in agent_name and "-" not in agent_name:
+            normalized = _normalize_agent_name(agent_name)
+
+            # If we have a dash-named equivalent, mark for removal
+            if normalized in normalized_new:
+                old_agents.append(agent_path)
+
+    return old_agents
+
+
+def handle_agents_cleanup(args) -> int:
+    """Handle the 'claude-mpm agents cleanup' command.
+
+    This command performs a complete agent cleanup:
+    1. Syncs agents from remote repository
+    2. Deploys agents with new naming convention (force overwrite)
+    3. Removes old underscore-named agents that have dash equivalents
+
+    Args:
+        args: Parsed command-line arguments with:
+            - dry_run: Show what would be done without doing it
+            - target: Target directory for deployment
+            - global_deployment: Deploy to global ~/.claude/agents/
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        dry_run = args.dry_run
+
+        # Determine target directory
+        if args.global_deployment:
+            target_dir = Path.home() / ".claude" / "agents"
+        elif args.target:
+            target_dir = args.target
+        else:
+            target_dir = Path.cwd() / ".claude-mpm" / "agents"
+
+        print("\n🧹 Agent Cleanup")
+        print(f"{'=' * 60}")
+
+        if dry_run:
+            print("🔍 DRY RUN MODE - No changes will be made\n")
+
+        # Phase 1: Sync agents from remote
+        print("📥 Phase 1: Syncing agents from remote repository...")
+
+        config = AgentSourceConfiguration.load()
+        repositories = config.get_enabled_repositories()
+
+        if not repositories:
+            print(
+                "⚠️  No agent sources configured. Run 'claude-mpm agent-source add' first."
+            )
+            return 1
+
+        sync_service = GitSourceSyncService()
+        synced_count = 0
+
+        for repo in repositories:
+            print(f"  Syncing from {repo.url}...")
+            try:
+                result = sync_service.sync_agents(show_progress=False)
+                synced_count += result.get("total_downloaded", 0)
+                print(f"  ✓ Synced {result.get('total_downloaded', 0)} agents")
+            except Exception as e:
+                print(f"  ✗ Failed to sync: {e}")
+                continue
+
+        if synced_count == 0:
+            print(
+                "⚠️  No agents synced. Check your network connection or agent sources."
+            )
+            return 1
+
+        print(f"\n✓ Synced {synced_count} agents total")
+
+        # Phase 2: Deploy agents (force overwrite)
+        print(f"\n📦 Phase 2: Deploying agents to {target_dir}...")
+
+        if not dry_run:
+            target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Get list of agents from cache
+        cache_dir = sync_service.get_cached_agents_dir()
+        cached_agents = list(cache_dir.glob("*.md"))
+        new_agent_names = [agent.name for agent in cached_agents]
+
+        if not dry_run:
+            result = sync_service.deploy_agents_to_project(Path.cwd(), force=True)
+            deployed_count = len(result.get("deployed", [])) + len(
+                result.get("updated", [])
+            )
+            print(f"✓ Deployed {deployed_count} agents")
+        else:
+            print(f"  Would deploy {len(cached_agents)} agents:")
+            for agent in cached_agents[:10]:  # Show first 10
+                print(f"    - {agent.name}")
+            if len(cached_agents) > 10:
+                print(f"    ... and {len(cached_agents) - 10} more")
+
+        # Phase 3: Remove old underscore-named agents
+        print("\n🗑️  Phase 3: Removing old underscore-named agents...")
+
+        # Find deployed agents
+        deployed_agents = list(target_dir.glob("*.md"))
+        old_agents = _find_old_underscore_agents(deployed_agents, new_agent_names)
+
+        if not old_agents:
+            print("✓ No old underscore-named agents found")
+        else:
+            print(f"  Found {len(old_agents)} old agents to remove:")
+            for agent in old_agents:
+                # Find the new equivalent name
+                normalized = _normalize_agent_name(agent.name)
+                dash_equiv = [
+                    name
+                    for name in new_agent_names
+                    if _normalize_agent_name(name) == normalized
+                ]
+                equiv_str = f" → {dash_equiv[0]}" if dash_equiv else ""
+
+                print(f"    - {agent.name}{equiv_str}")
+
+                if not dry_run:
+                    agent.unlink()
+
+            if not dry_run:
+                print(f"✓ Removed {len(old_agents)} old agents")
+            else:
+                print(f"  Would remove {len(old_agents)} old agents")
+
+        # Summary
+        print(f"\n{'=' * 60}")
+        print("✅ Cleanup complete!")
+        print("\nSummary:")
+        print(f"  • Synced: {synced_count} agents")
+        print(f"  • Deployed: {len(cached_agents)} agents")
+        print(f"  • Removed: {len(old_agents)} old agents")
+
+        if dry_run:
+            print("\n💡 Run without --dry-run to apply changes")
+
+        return 0
+
+    except Exception as e:
+        logger.exception("Agent cleanup failed")
+        print(f"\n❌ Error: {e}")
+        return 1

claude_mpm/cli/commands/agents_detect.py

@@ -0,0 +1,380 @@
+"""
+Agents Detect CLI Command for Claude MPM Framework
+===================================================
+
+WHY: This module provides a CLI interface for detecting project toolchain
+without making any changes. Useful for debugging and verification of the
+toolchain detection system.
+
+DESIGN DECISION: Focused solely on detection and display, with no side effects.
+Supports multiple output formats for different use cases (human-readable,
+JSON for scripting).
+
+Part of TSK-0054: Auto-Configuration Feature - Phase 5
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+from ...services.project.toolchain_analyzer import ToolchainAnalyzerService
+from ..shared import BaseCommand, CommandResult
+
+
+class AgentsDetectCommand(BaseCommand):
+    """
+    Handle agents detect CLI command.
+
+    This command analyzes the project to detect languages, frameworks,
+    and deployment targets without making any configuration changes.
+    """
+
+    def __init__(self):
+        """Initialize the agents detect command."""
+        super().__init__("agents-detect")
+        self.console = Console() if RICH_AVAILABLE else None
+        self._toolchain_analyzer = None
+
+    @property
+    def toolchain_analyzer(self) -> ToolchainAnalyzerService:
+        """Get toolchain analyzer (lazy loaded)."""
+        if self._toolchain_analyzer is None:
+            self._toolchain_analyzer = ToolchainAnalyzerService()
+        return self._toolchain_analyzer
+
+    def validate_args(self, args) -> Optional[str]:
+        """Validate command arguments."""
+        # Validate project path
+        project_path = (
+            Path(args.project_path)
+            if hasattr(args, "project_path") and args.project_path
+            else Path.cwd()
+        )
+        if not project_path.exists():
+            return f"Project path does not exist: {project_path}"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """
+        Execute agents detect command.
+
+        Returns:
+            CommandResult with success status and exit code
+        """
+        try:
+            # Setup logging
+            self.setup_logging(args)
+
+            # Validate arguments
+            error = self.validate_args(args)
+            if error:
+                return CommandResult.error_result(error)
+
+            # Get configuration options
+            project_path = (
+                Path(args.project_path)
+                if hasattr(args, "project_path") and args.project_path
+                else Path.cwd()
+            )
+            json_output = args.json if hasattr(args, "json") and args.json else False
+            verbose = (
+                args.verbose if hasattr(args, "verbose") and args.verbose else False
+            )
+
+            # Analyze toolchain
+            if self.console and not json_output:
+                with self.console.status("[bold green]Analyzing project toolchain..."):
+                    analysis = self.toolchain_analyzer.analyze_project(
+                        str(project_path)
+                    )
+            else:
+                analysis = self.toolchain_analyzer.analyze_project(str(project_path))
+
+            # Output results
+            if json_output:
+                return self._output_json(analysis, verbose)
+            return self._display_results(analysis, verbose)
+
+        except KeyboardInterrupt:
+            if self.console:
+                self.console.print("\n\n❌ Operation cancelled by user")
+            else:
+                print("\n\nOperation cancelled by user")
+            return CommandResult.error_result("Operation cancelled", exit_code=130)
+
+        except Exception as e:
+            self.logger.exception("Toolchain detection failed")
+            error_msg = f"Toolchain detection failed: {e!s}"
+            if self.console:
+                self.console.print(f"\n❌ {error_msg}")
+            else:
+                print(f"\n{error_msg}")
+            return CommandResult.error_result(error_msg)
+
+    def _display_results(self, analysis, verbose: bool) -> CommandResult:
+        """Display toolchain analysis results with Rich formatting."""
+        if not self.console:
+            return self._display_results_plain(analysis, verbose)
+
+        # Display header
+        self.console.print("\n📊 Project Toolchain Analysis", style="bold blue")
+        self.console.print(f"Project: {analysis.project_path}\n")
+
+        # Display detected languages
+        if analysis.languages:
+            self.console.print("🔤 Detected Languages:", style="bold green")
+            lang_table = Table(show_header=True, header_style="bold")
+            lang_table.add_column("Language", style="cyan")
+            lang_table.add_column("Version", style="yellow")
+            lang_table.add_column("Confidence", style="green")
+            if verbose:
+                lang_table.add_column("Evidence", style="dim")
+
+            for lang in analysis.languages:
+                confidence_pct = int(lang.confidence * 100)
+                bar = "█" * (confidence_pct // 10) + "░" * (10 - confidence_pct // 10)
+                confidence_str = f"{bar} {confidence_pct}%"
+
+                if verbose:
+                    evidence = ", ".join(lang.evidence[:3])  # First 3 items
+                    if len(lang.evidence) > 3:
+                        evidence += f" (+{len(lang.evidence) - 3} more)"
+                    lang_table.add_row(
+                        lang.language,
+                        lang.version or "Unknown",
+                        confidence_str,
+                        evidence,
+                    )
+                else:
+                    lang_table.add_row(
+                        lang.language, lang.version or "Unknown", confidence_str
+                    )
+
+            self.console.print(lang_table)
+        else:
+            self.console.print("  No languages detected", style="yellow")
+
+        # Display detected frameworks
+        if analysis.frameworks:
+            self.console.print("\n🏗️  Detected Frameworks:", style="bold green")
+            fw_table = Table(show_header=True, header_style="bold")
+            fw_table.add_column("Framework", style="cyan")
+            fw_table.add_column("Version", style="yellow")
+            fw_table.add_column("Category", style="magenta")
+            fw_table.add_column("Confidence", style="green")
+
+            for fw in analysis.frameworks:
+                confidence_pct = int(fw.confidence * 100)
+                bar = "█" * (confidence_pct // 10) + "░" * (10 - confidence_pct // 10)
+                confidence_str = f"{bar} {confidence_pct}%"
+
+                fw_table.add_row(
+                    fw.name,
+                    fw.version or "Unknown",
+                    (
+                        fw.category.value
+                        if hasattr(fw.category, "value")
+                        else str(fw.category)
+                    ),
+                    confidence_str,
+                )
+
+            self.console.print(fw_table)
+        else:
+            self.console.print("\n  No frameworks detected", style="yellow")
+
+        # Display deployment targets
+        if analysis.deployment_targets:
+            self.console.print("\n🚀 Deployment Targets:", style="bold green")
+            dt_table = Table(show_header=True, header_style="bold")
+            dt_table.add_column("Target", style="cyan")
+            dt_table.add_column("Confidence", style="green")
+            if verbose:
+                dt_table.add_column("Evidence", style="dim")
+
+            for target in analysis.deployment_targets:
+                confidence_pct = int(target.confidence * 100)
+                bar = "█" * (confidence_pct // 10) + "░" * (10 - confidence_pct // 10)
+                confidence_str = f"{bar} {confidence_pct}%"
+
+                if verbose:
+                    evidence = ", ".join(target.evidence[:3])
+                    if len(target.evidence) > 3:
+                        evidence += f" (+{len(target.evidence) - 3} more)"
+                    dt_table.add_row(
+                        (
+                            target.target_type.value
+                            if hasattr(target.target_type, "value")
+                            else str(target.target_type)
+                        ),
+                        confidence_str,
+                        evidence,
+                    )
+                else:
+                    dt_table.add_row(
+                        (
+                            target.target_type.value
+                            if hasattr(target.target_type, "value")
+                            else str(target.target_type)
+                        ),
+                        confidence_str,
+                    )
+
+            self.console.print(dt_table)
+        else:
+            self.console.print("\n  No deployment targets detected", style="yellow")
+
+        # Display all components summary
+        if analysis.components:
+            self.console.print("\n📦 All Components:", style="bold blue")
+            comp_table = Table(show_header=True, header_style="bold")
+            comp_table.add_column("Type", style="cyan")
+            comp_table.add_column("Name", style="yellow")
+            comp_table.add_column("Version", style="magenta")
+            comp_table.add_column("Confidence", style="green")
+
+            for comp in analysis.components:
+                confidence_pct = int(comp.confidence * 100)
+                bar = "█" * (confidence_pct // 10) + "░" * (10 - confidence_pct // 10)
+                confidence_str = f"{bar} {confidence_pct}%"
+
+                comp_table.add_row(
+                    comp.type.value if hasattr(comp.type, "value") else str(comp.type),
+                    comp.name or "-",
+                    comp.version or "Unknown",
+                    confidence_str,
+                )
+
+            self.console.print(comp_table)
+
+        # Summary
+        self.console.print(
+            f"\n✅ Analysis complete: {len(analysis.languages)} language(s), "
+            f"{len(analysis.frameworks)} framework(s), "
+            f"{len(analysis.deployment_targets)} deployment target(s)",
+            style="bold green",
+        )
+
+        return CommandResult.success_result()
+
+    def _display_results_plain(self, analysis, verbose: bool) -> CommandResult:
+        """Display results in plain text (fallback)."""
+        print("\n📊 Project Toolchain Analysis")
+        print(f"Project: {analysis.project_path}\n")
+
+        # Languages
+        if analysis.languages:
+            print("Detected Languages:")
+            for lang in analysis.languages:
+                confidence_pct = int(lang.confidence * 100)
+                print(
+                    f"  - {lang.language} {lang.version or 'Unknown'} ({confidence_pct}%)"
+                )
+                if verbose:
+                    print(f"    Evidence: {', '.join(lang.evidence[:5])}")
+        else:
+            print("No languages detected")
+
+        # Frameworks
+        if analysis.frameworks:
+            print("\nDetected Frameworks:")
+            for fw in analysis.frameworks:
+                confidence_pct = int(fw.confidence * 100)
+                print(
+                    f"  - {fw.name} {fw.version or 'Unknown'} ({fw.category}) ({confidence_pct}%)"
+                )
+        else:
+            print("\nNo frameworks detected")
+
+        # Deployment targets
+        if analysis.deployment_targets:
+            print("\nDeployment Targets:")
+            for target in analysis.deployment_targets:
+                confidence_pct = int(target.confidence * 100)
+                print(f"  - {target.target_type} ({confidence_pct}%)")
+                if verbose:
+                    print(f"    Evidence: {', '.join(target.evidence[:5])}")
+        else:
+            print("\nNo deployment targets detected")
+
+        print(
+            f"\nAnalysis complete: {len(analysis.languages)} language(s), "
+            f"{len(analysis.frameworks)} framework(s), "
+            f"{len(analysis.deployment_targets)} deployment target(s)"
+        )
+
+        return CommandResult.success_result()
+
+    def _output_json(self, analysis, verbose: bool) -> CommandResult:
+        """Output toolchain analysis as JSON."""
+        output = {
+            "project_path": analysis.project_path,
+            "analysis_time": analysis.analysis_time,
+            "languages": [
+                {
+                    "language": lang.language,
+                    "version": lang.version,
+                    "confidence": lang.confidence,
+                    "evidence": lang.evidence if verbose else None,
+                }
+                for lang in analysis.languages
+            ],
+            "frameworks": [
+                {
+                    "name": fw.name,
+                    "version": fw.version,
+                    "category": (
+                        fw.category.value
+                        if hasattr(fw.category, "value")
+                        else str(fw.category)
+                    ),
+                    "confidence": fw.confidence,
+                    "config_file": fw.config_file,
+                }
+                for fw in analysis.frameworks
+            ],
+            "deployment_targets": [
+                {
+                    "target_type": (
+                        target.target_type.value
+                        if hasattr(target.target_type, "value")
+                        else str(target.target_type)
+                    ),
+                    "confidence": target.confidence,
+                    "evidence": target.evidence if verbose else None,
+                }
+                for target in analysis.deployment_targets
+            ],
+            "components": [
+                {
+                    "type": (
+                        comp.type.value
+                        if hasattr(comp.type, "value")
+                        else str(comp.type)
+                    ),
+                    "name": comp.name,
+                    "version": comp.version,
+                    "confidence": comp.confidence,
+                }
+                for comp in analysis.components
+            ],
+        }
+
+        # Remove None values if not verbose
+        if not verbose:
+            for lang in output["languages"]:
+                lang.pop("evidence", None)
+            for target in output["deployment_targets"]:
+                target.pop("evidence", None)
+
+        print(json.dumps(output, indent=2))
+        return CommandResult.success_result(data=output)