claude-mpm 4.7.4__py3-none-any.whl → 4.18.2__py3-none-any.whl

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)

claude_mpm/cli/commands/agents_recommend.py

@@ -0,0 +1,309 @@
+"""
+Agents Recommend CLI Command for Claude MPM Framework
+======================================================
+
+WHY: This module provides a CLI interface for getting agent recommendations
+based on project toolchain without deploying anything. Useful for reviewing
+recommendations before committing to deployment.
+
+DESIGN DECISION: Focused on recommendation display with detailed reasoning,
+showing users why each agent was recommended. Supports JSON output for
+integration with other tools.
+
+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.panel import Panel
+    from rich.table import Table
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+from ...services.agents.recommender import AgentRecommenderService
+from ...services.agents.registry import AgentRegistry
+from ...services.project.toolchain_analyzer import ToolchainAnalyzerService
+from ..shared import BaseCommand, CommandResult
+
+
+class AgentsRecommendCommand(BaseCommand):
+    """
+    Handle agents recommend CLI command.
+
+    This command analyzes the project toolchain and recommends appropriate
+    agents without deploying them. Shows detailed reasoning for each
+    recommendation.
+    """
+
+    def __init__(self):
+        """Initialize the agents recommend command."""
+        super().__init__("agents-recommend")
+        self.console = Console() if RICH_AVAILABLE else None
+        self._toolchain_analyzer = None
+        self._agent_recommender = 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
+
+    @property
+    def agent_recommender(self) -> AgentRecommenderService:
+        """Get agent recommender (lazy loaded)."""
+        if self._agent_recommender is None:
+            agent_registry = AgentRegistry()
+            self._agent_recommender = AgentRecommenderService(
+                agent_registry=agent_registry
+            )
+        return self._agent_recommender
+
+    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}"
+
+        # Validate min_confidence range
+        if hasattr(args, "min_confidence") and args.min_confidence:
+            if not 0.0 <= args.min_confidence <= 1.0:
+                return "min_confidence must be between 0.0 and 1.0"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """
+        Execute agents recommend 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()
+            )
+            min_confidence = (
+                args.min_confidence
+                if hasattr(args, "min_confidence") and args.min_confidence
+                else 0.8
+            )
+            json_output = args.json if hasattr(args, "json") and args.json else False
+            show_reasoning = (
+                args.show_reasoning
+                if hasattr(args, "show_reasoning") and args.show_reasoning
+                else True
+            )
+
+            # 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))
+
+            # Get recommendations
+            if self.console and not json_output:
+                with self.console.status(
+                    "[bold green]Generating agent recommendations..."
+                ):
+                    recommendations = self.agent_recommender.recommend_agents(
+                        analysis, min_confidence
+                    )
+            else:
+                recommendations = self.agent_recommender.recommend_agents(
+                    analysis, min_confidence
+                )
+
+            # Output results
+            if json_output:
+                return self._output_json(recommendations, analysis)
+            return self._display_results(recommendations, analysis, show_reasoning)
+
+        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("Agent recommendation failed")
+            error_msg = f"Agent recommendation 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, recommendations, analysis, show_reasoning: bool
+    ) -> CommandResult:
+        """Display agent recommendations with Rich formatting."""
+        if not self.console:
+            return self._display_results_plain(
+                recommendations, analysis, show_reasoning
+            )
+
+        # Display header
+        self.console.print("\n🤖 Agent Recommendations", style="bold blue")
+        self.console.print(f"Project: {analysis.project_path}\n")
+
+        # Display quick summary
+        if recommendations:
+            summary_text = (
+                f"Found {len(recommendations)} recommended agent(s) "
+                f"for your project based on detected toolchain."
+            )
+            panel = Panel(summary_text, border_style="green")
+            self.console.print(panel)
+        else:
+            panel = Panel(
+                "No agents recommended for this project.\n"
+                "Try lowering the confidence threshold with --min-confidence",
+                border_style="yellow",
+            )
+            self.console.print(panel)
+            return CommandResult.success_result()
+
+        # Display recommendations table
+        self.console.print("\n📋 Recommended Agents:", style="bold green")
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Agent ID", style="cyan")
+        table.add_column("Confidence", style="green")
+        table.add_column("Priority", style="yellow")
+        if show_reasoning:
+            table.add_column("Reasoning", style="dim", no_wrap=False)
+
+        for rec in recommendations:
+            confidence_pct = int(rec.confidence * 100)
+            bar = "█" * (confidence_pct // 10) + "░" * (10 - confidence_pct // 10)
+            confidence_str = f"{bar} {confidence_pct}%"
+
+            if show_reasoning:
+                table.add_row(
+                    rec.agent_id,
+                    confidence_str,
+                    str(rec.priority),
+                    rec.reasoning,
+                )
+            else:
+                table.add_row(rec.agent_id, confidence_str, str(rec.priority))
+
+        self.console.print(table)
+
+        # Display match details if reasoning enabled
+        if show_reasoning:
+            self.console.print("\n🔍 Match Details:", style="bold blue")
+            for rec in recommendations:
+                self.console.print(f"\n[bold cyan]{rec.agent_id}[/bold cyan]")
+                self.console.print(f"  Confidence: {int(rec.confidence * 100)}%")
+                self.console.print(f"  Priority: {rec.priority}")
+                self.console.print(f"  Reasoning: {rec.reasoning}")
+
+                if rec.matched_capabilities:
+                    self.console.print("  Matched capabilities:", style="green")
+                    for cap in rec.matched_capabilities[:5]:
+                        self.console.print(f"    • {cap}", style="dim")
+                    if len(rec.matched_capabilities) > 5:
+                        remaining = len(rec.matched_capabilities) - 5
+                        self.console.print(f"    ... and {remaining} more", style="dim")
+
+        # Display next steps
+        self.console.print("\n💡 Next Steps:", style="bold yellow")
+        self.console.print("  1. Review the recommendations and their reasoning")
+        self.console.print(
+            "  2. Deploy agents with: [bold]claude-mpm auto-configure[/bold]"
+        )
+        self.console.print(
+            "  3. Or preview deployment with: [bold]claude-mpm auto-configure --preview[/bold]"
+        )
+
+        return CommandResult.success_result()
+
+    def _display_results_plain(
+        self, recommendations, analysis, show_reasoning: bool
+    ) -> CommandResult:
+        """Display results in plain text (fallback)."""
+        print("\n🤖 Agent Recommendations")
+        print(f"Project: {analysis.project_path}\n")
+
+        if not recommendations:
+            print("No agents recommended for this project.")
+            print("Try lowering the confidence threshold with --min-confidence")
+            return CommandResult.success_result()
+
+        print(f"Found {len(recommendations)} recommended agent(s) for your project:\n")
+
+        for rec in recommendations:
+            confidence_pct = int(rec.confidence * 100)
+            print(f"• {rec.agent_id} ({confidence_pct}% confidence)")
+
+            if show_reasoning:
+                print(f"  Priority: {rec.priority}")
+                print(f"  Reasoning: {rec.reasoning}")
+
+                if rec.matched_capabilities:
+                    print("  Matched capabilities:")
+                    for cap in rec.matched_capabilities[:5]:
+                        print(f"    - {cap}")
+                    if len(rec.matched_capabilities) > 5:
+                        remaining = len(rec.matched_capabilities) - 5
+                        print(f"    ... and {remaining} more")
+                print()
+
+        print("\nNext Steps:")
+        print("  1. Review the recommendations and their reasoning")
+        print("  2. Deploy agents with: claude-mpm auto-configure")
+        print("  3. Or preview deployment with: claude-mpm auto-configure --preview")
+
+        return CommandResult.success_result()
+
+    def _output_json(self, recommendations, analysis) -> CommandResult:
+        """Output recommendations as JSON."""
+        output = {
+            "project_path": analysis.project_path,
+            "recommendations": [
+                {
+                    "agent_id": rec.agent_id,
+                    "confidence": rec.confidence,
+                    "priority": rec.priority,
+                    "reasoning": rec.reasoning,
+                    "matched_capabilities": rec.matched_capabilities,
+                    "requirements": rec.requirements,
+                }
+                for rec in recommendations
+            ],
+            "toolchain_summary": {
+                "languages": len(analysis.languages),
+                "frameworks": len(analysis.frameworks),
+                "deployment_targets": len(analysis.deployment_targets),
+            },
+        }
+
+        print(json.dumps(output, indent=2))
+        return CommandResult.success_result(data=output)