claude-mpm 4.24.0__py3-none-any.whl → 5.4.41__py3-none-any.whl

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)

claude_mpm/cli/ticket_cli.py

@@ -1,35 +0,0 @@
-from pathlib import Path
-
-# \!/usr/bin/env python3
-"""
-Ticket CLI module for claude-mpm.
-
-This module provides the entry point for the 'ticket' alias command.
-It delegates to the scripts/ticket.py module for implementation.
-"""
-
-import sys
-
-
-def main():
-    """Main entry point for ticket CLI alias."""
-    # Import and run the main ticket CLI
-    try:
-        # Try to import from scripts
-        scripts_dir = Path(__file__).parent.parent.parent.parent / "scripts"
-        sys.path.insert(0, str(scripts_dir))
-
-        from ticket import main as ticket_main
-
-        return ticket_main()
-    except ImportError:
-        print("Error: Ticket functionality not available")
-        print("Install ai-trackdown-pytools: pip install ai-trackdown-pytools")
-        return 1
-    except Exception as e:
-        print(f"Error running ticket command: {e}")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

claude_mpm/commands/mpm-agents-detect.md

@@ -1,168 +0,0 @@
-# Detect project toolchain and frameworks
-
-Scan your project to detect programming languages, frameworks, tools, and configurations.
-
-## Usage
-
-```
-/mpm-agents-detect
-```
-
-## Description
-
-This command scans your project directory to automatically detect:
-- Programming languages and their versions
-- Web frameworks and libraries
-- Testing tools and frameworks
-- Build tools and bundlers
-- Package managers
-- Deployment configurations
-
-This is useful for understanding what Claude MPM can detect in your project before running auto-configuration.
-
-## Implementation
-
-When you run `/mpm-agents-detect`, the PM will execute:
-```bash
-claude-mpm agents detect
-```
-
-This performs a comprehensive scan of your project looking for:
-- Package manifests (package.json, requirements.txt, Cargo.toml, go.mod, pom.xml)
-- Framework-specific files (next.config.js, fastapi imports, etc.)
-- Test configurations (pytest.ini, jest.config.js, playwright.config.ts)
-- Build configurations (vite.config.js, webpack.config.js, tsconfig.json)
-- Deployment files (Dockerfile, vercel.json, railway.json)
-
-## Expected Output
-
-```
-🔍 Project Toolchain Detection
-================================
-
-Languages:
-  ✓ Python 3.11.5
-  ✓ Node.js 20.10.0
-  ✓ TypeScript 5.3.2
-
-Frameworks:
-  ✓ FastAPI 0.104.0
-  ✓ React 18.2.0
-  ✓ Next.js 14.0.4
-
-Testing:
-  ✓ pytest 7.4.3
-  ✓ Jest 29.7.0
-  ✓ Playwright 1.40.0
-
-Build Tools:
-  ✓ Vite 5.0.0
-  ✓ TypeScript Compiler
-
-Package Managers:
-  ✓ poetry (Python)
-  ✓ npm (Node.js)
-
-Deployment:
-  ✓ Docker (Dockerfile found)
-  ✓ Vercel (vercel.json found)
-  ✓ PM2 (ecosystem.config.js found)
-
-Configuration Files Detected:
-  - pyproject.toml
-  - package.json
-  - tsconfig.json
-  - next.config.js
-  - pytest.ini
-  - jest.config.js
-  - playwright.config.ts
-  - Dockerfile
-  - vercel.json
-
-Summary:
-  Full-stack project with Python backend (FastAPI) and
-  React/Next.js frontend, comprehensive testing setup,
-  and multiple deployment targets.
-```
-
-## What Gets Detected
-
-### Language Detection
-- **Python**: Looks for .py files, requirements.txt, pyproject.toml, setup.py
-- **JavaScript/TypeScript**: Looks for .js/.ts files, package.json, tsconfig.json
-- **Rust**: Looks for Cargo.toml, .rs files
-- **Go**: Looks for go.mod, .go files
-- **Java**: Looks for pom.xml, build.gradle, .java files
-
-### Framework Detection
-**Python:**
-- FastAPI (imports, decorator patterns)
-- Flask (imports, app patterns)
-- Django (settings.py, manage.py)
-
-**JavaScript/TypeScript:**
-- Next.js (next.config.js, pages/ or app/ directory)
-- React (package.json dependencies, JSX usage)
-- Vue (vue.config.js, .vue files)
-- Express (imports, app patterns)
-- Nest.js (nest-cli.json, decorators)
-
-### Testing Detection
-- pytest (pytest.ini, conftest.py)
-- unittest (test_*.py patterns)
-- Jest (jest.config.js)
-- Vitest (vitest.config.js)
-- Playwright (playwright.config.ts)
-- Cypress (cypress.json)
-
-### Build Tool Detection
-- Vite (vite.config.js/ts)
-- Webpack (webpack.config.js)
-- Rollup (rollup.config.js)
-- esbuild (esbuild configuration)
-- Turbopack (next.config.js with turbopack)
-
-### Deployment Detection
-- Docker (Dockerfile, docker-compose.yml)
-- Vercel (vercel.json, .vercel directory)
-- Railway (railway.json, railway.toml)
-- PM2 (ecosystem.config.js)
-- Kubernetes (k8s/, kubernetes/ directories)
-
-## Use Cases
-
-1. **Before Auto-Configuration**: Run this to see what will be detected
-2. **Troubleshooting**: Verify that your project setup is being recognized correctly
-3. **Documentation**: Generate a summary of your project's tech stack
-4. **Planning**: Understand what agents might be recommended
-
-## Tips
-
-1. **Run from project root**: Detection works best from your project's root directory
-2. **Check detection accuracy**: Verify detected versions match your actual setup
-3. **Missing detections**: If something isn't detected, you can still deploy agents manually
-4. **Configuration files**: Detection relies on standard configuration files being present
-
-## Common Issues
-
-**Nothing detected?**
-- Make sure you're in the project root directory
-- Check that you have standard configuration files (package.json, requirements.txt, etc.)
-- Some projects may need manual agent deployment
-
-**Wrong versions detected?**
-- Detection shows what's configured in manifest files
-- Actual runtime versions may differ
-- This doesn't affect agent functionality
-
-**Framework not detected?**
-- Some frameworks are harder to detect automatically
-- You can still use auto-configure and manually select agents
-- Or deploy specific agents manually with `/mpm-agents deploy <name>`
-
-## Related Commands
-
-- `/mpm-agents-recommend` - See agent recommendations based on detection
-- `/mpm-auto-configure` - Automatically configure agents based on detection
-- `/mpm-agents` - Manually manage agents
-- `/mpm-help auto-configure` - Learn about auto-configuration