claude-mpm 5.1.9__py3-none-any.whl → 5.4.48__py3-none-any.whl

claude_mpm/cli/commands/agents_detect.py

@@ -1,380 +0,0 @@
-"""
-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

@@ -1,309 +0,0 @@
-"""
-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)