claude-mpm 4.13.1__py3-none-any.whl → 4.14.0__py3-none-any.whl

claude_mpm/cli/parsers/local_deploy_parser.py

@@ -0,0 +1,227 @@
+"""
+Local Deploy parser module for claude-mpm CLI.
+
+WHY: Provides argument parsing for local deployment management commands.
+Extracted from the monolithic parser.py for better organization.
+
+DESIGN DECISION: Supports multiple subcommands (start, stop, restart, status, etc.)
+with command-specific arguments for comprehensive process management.
+"""
+
+from pathlib import Path
+
+
+def add_local_deploy_arguments(subparsers) -> None:
+    """
+    Add local-deploy command and its subcommands to the parser.
+
+    WHY: Provides a comprehensive CLI for managing local development deployments
+    with process monitoring, health checks, and auto-restart capabilities.
+
+    Args:
+        subparsers: The subparsers object to add commands to
+    """
+    # Main local-deploy command
+    local_deploy_parser = subparsers.add_parser(
+        "local-deploy",
+        help="Manage local development deployments with process monitoring",
+        description=(
+            "Manage local development deployments with comprehensive process management, "
+            "health monitoring, and auto-restart capabilities."
+        ),
+    )
+
+    # Create subparsers for local-deploy subcommands
+    local_deploy_subparsers = local_deploy_parser.add_subparsers(
+        dest="local_deploy_command",
+        help="Local deployment commands",
+    )
+
+    # ===== START command =====
+    start_parser = local_deploy_subparsers.add_parser(
+        "start",
+        help="Start a new local deployment",
+        description="Start a new local deployment with process monitoring and optional auto-restart",
+    )
+    start_parser.add_argument(
+        "--command",
+        "-c",
+        required=True,
+        help="Command to execute (e.g., 'npm run dev' or 'python manage.py runserver')",
+    )
+    start_parser.add_argument(
+        "--working-directory",
+        "-d",
+        type=Path,
+        help="Working directory for the process (default: current directory)",
+    )
+    start_parser.add_argument(
+        "--port",
+        "-p",
+        type=int,
+        help="Port number for the deployment",
+    )
+    start_parser.add_argument(
+        "--auto-find-port",
+        action="store_true",
+        default=True,
+        help="Automatically find alternative port if specified port is unavailable (default: enabled)",
+    )
+    start_parser.add_argument(
+        "--no-auto-find-port",
+        action="store_false",
+        dest="auto_find_port",
+        help="Disable automatic port finding",
+    )
+    start_parser.add_argument(
+        "--auto-restart",
+        action="store_true",
+        help="Enable automatic restart on crashes",
+    )
+    start_parser.add_argument(
+        "--log-file",
+        type=Path,
+        help="Path to log file for monitoring error patterns",
+    )
+    start_parser.add_argument(
+        "--env",
+        "-e",
+        action="append",
+        help="Environment variables in KEY=VALUE format (can be specified multiple times)",
+    )
+
+    # ===== STOP command =====
+    stop_parser = local_deploy_subparsers.add_parser(
+        "stop",
+        help="Stop a running deployment",
+        description="Stop a running deployment with graceful shutdown",
+    )
+    stop_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to stop",
+    )
+    stop_parser.add_argument(
+        "--timeout",
+        "-t",
+        type=int,
+        default=10,
+        help="Timeout in seconds for graceful shutdown (default: 10)",
+    )
+    stop_parser.add_argument(
+        "--force",
+        "-f",
+        action="store_true",
+        help="Force kill immediately without graceful shutdown",
+    )
+
+    # ===== RESTART command =====
+    restart_parser = local_deploy_subparsers.add_parser(
+        "restart",
+        help="Restart a deployment",
+        description="Restart a deployment with the same configuration",
+    )
+    restart_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to restart",
+    )
+    restart_parser.add_argument(
+        "--timeout",
+        "-t",
+        type=int,
+        default=10,
+        help="Timeout in seconds for graceful shutdown (default: 10)",
+    )
+
+    # ===== STATUS command =====
+    status_parser = local_deploy_subparsers.add_parser(
+        "status",
+        help="Show comprehensive deployment status",
+        description="Show comprehensive status including process info, health, and restart history",
+    )
+    status_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to check",
+    )
+    status_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output status in JSON format",
+    )
+
+    # ===== HEALTH command =====
+    health_parser = local_deploy_subparsers.add_parser(
+        "health",
+        help="Show health status",
+        description="Show health check status including HTTP, process, and resource checks",
+    )
+    health_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to check",
+    )
+
+    # ===== LIST command =====
+    list_parser = local_deploy_subparsers.add_parser(
+        "list",
+        help="List all deployments",
+        description="List all local deployments with their status",
+    )
+    list_parser.add_argument(
+        "--status",
+        "-s",
+        choices=["running", "stopped", "crashed", "stopping"],
+        help="Filter deployments by status",
+    )
+
+    # ===== MONITOR command =====
+    monitor_parser = local_deploy_subparsers.add_parser(
+        "monitor",
+        help="Live monitoring dashboard",
+        description="Display live monitoring dashboard for a deployment",
+    )
+    monitor_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to monitor",
+    )
+    monitor_parser.add_argument(
+        "--refresh",
+        "-r",
+        type=int,
+        default=2,
+        help="Refresh interval in seconds (default: 2)",
+    )
+
+    # ===== HISTORY command =====
+    history_parser = local_deploy_subparsers.add_parser(
+        "history",
+        help="Show restart history",
+        description="Show restart history and statistics for a deployment",
+    )
+    history_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to check",
+    )
+
+    # ===== ENABLE-AUTO-RESTART command =====
+    enable_auto_restart_parser = local_deploy_subparsers.add_parser(
+        "enable-auto-restart",
+        help="Enable auto-restart for a deployment",
+        description="Enable automatic restart on crashes for a deployment",
+    )
+    enable_auto_restart_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to enable auto-restart for",
+    )
+
+    # ===== DISABLE-AUTO-RESTART command =====
+    disable_auto_restart_parser = local_deploy_subparsers.add_parser(
+        "disable-auto-restart",
+        help="Disable auto-restart for a deployment",
+        description="Disable automatic restart on crashes for a deployment",
+    )
+    disable_auto_restart_parser.add_argument(
+        "deployment_id",
+        help="Deployment ID to disable auto-restart for",
+    )
+
+
+__all__ = ["add_local_deploy_arguments"]

claude_mpm/commands/mpm-agents-detect.md

@@ -0,0 +1,168 @@
+# 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

claude_mpm/commands/mpm-agents-recommend.md

@@ -0,0 +1,214 @@
+# Show recommended agents for detected project stack
+
+Get intelligent agent recommendations based on your project's detected toolchain.
+
+## Usage
+
+```
+/mpm-agents-recommend
+```
+
+## Description
+
+This command analyzes your detected project stack and recommends the most appropriate agents, organized by priority:
+- **Essential agents**: Core agents required for your primary stack
+- **Recommended agents**: Complementary agents for full functionality
+- **Optional agents**: Specialized agents for detected tools
+
+Each recommendation includes an explanation of why that agent is suggested.
+
+## Implementation
+
+When you run `/mpm-agents-recommend`, the PM will execute:
+```bash
+claude-mpm agents recommend
+```
+
+This runs the detection phase and then applies recommendation rules to suggest the best agents for your specific technology stack.
+
+## Expected Output
+
+```
+🤖 Agent Recommendations
+=========================
+
+Based on detected stack:
+  Python 3.11, FastAPI 0.104.0, pytest, Docker, Vercel
+
+Essential Agents (Must Have):
+  ✓ fastapi-engineer
+    Reason: FastAPI framework detected - specialized agent for FastAPI development
+    Capabilities: FastAPI routes, Pydantic models, async endpoints, dependency injection
+
+  ✓ python-engineer
+    Reason: Python project - general Python development support
+    Capabilities: Python code, testing, debugging, package management
+
+  ✓ api-qa
+    Reason: API testing for FastAPI backend
+    Capabilities: API endpoint testing, validation, load testing, contract testing
+
+Recommended Agents (Strongly Suggested):
+  ○ docker-ops
+    Reason: Docker configuration detected
+    Capabilities: Docker builds, container management, docker-compose orchestration
+
+  ○ vercel-ops
+    Reason: Vercel deployment configuration found
+    Capabilities: Vercel deployments, serverless functions, domain management
+
+  ○ playwright-qa
+    Reason: Comprehensive E2E testing capability
+    Capabilities: Browser automation, visual testing, API testing
+
+Optional Agents (Nice to Have):
+  ○ local-ops-agent
+    Reason: Local development and PM2 process management
+    Capabilities: Local server management, port handling, PM2 operations
+
+  ○ security-agent
+    Reason: Security scanning and best practices
+    Capabilities: Dependency scanning, code security, auth patterns
+
+Summary:
+  Recommended: 3 essential + 2 recommended = 5 agents
+  Optional: 2 additional agents for enhanced capabilities
+
+  Total recommended deployment: 5 agents
+  Maximum useful deployment: 7 agents
+
+Next Steps:
+  1. Review recommendations above
+  2. Run '/mpm-auto-configure --preview' to see deployment plan
+  3. Run '/mpm-auto-configure' to deploy recommended agents
+  4. Or deploy individually: '/mpm-agents deploy <agent-name>'
+```
+
+## Recommendation Logic
+
+### Python Projects
+
+**If FastAPI detected:**
+- Essential: fastapi-engineer, python-engineer, api-qa
+- Recommended: docker-ops (if Docker), vercel-ops (if Vercel)
+
+**If Flask detected:**
+- Essential: flask-engineer, python-engineer, api-qa
+- Recommended: docker-ops (if Docker)
+
+**If Django detected:**
+- Essential: django-engineer, python-engineer, api-qa
+- Recommended: docker-ops (if Docker)
+
+**If pytest detected:**
+- Add to recommended: api-qa, playwright-qa
+
+### JavaScript/TypeScript Projects
+
+**If Next.js detected:**
+- Essential: nextjs-engineer, react-engineer, web-qa
+- Recommended: playwright-qa, vercel-ops (if Vercel)
+
+**If React detected (without Next.js):**
+- Essential: react-engineer, web-qa
+- Recommended: playwright-qa
+
+**If Vue detected:**
+- Essential: vue-engineer, web-qa
+- Recommended: playwright-qa
+
+**If Express detected:**
+- Essential: node-engineer, api-qa
+- Recommended: docker-ops (if Docker)
+
+**If Nest.js detected:**
+- Essential: nestjs-engineer, node-engineer, api-qa
+- Recommended: docker-ops (if Docker)
+
+### Full-Stack Projects
+
+**Python backend + React frontend:**
+- Essential: fastapi-engineer (or flask-engineer), python-engineer, react-engineer, api-qa, web-qa
+- Recommended: playwright-qa, docker-ops, local-ops-agent
+
+**Node.js backend + React frontend:**
+- Essential: node-engineer, react-engineer, api-qa, web-qa
+- Recommended: playwright-qa, docker-ops
+
+### Testing-Focused Projects
+
+**If Playwright detected:**
+- Add to recommended: playwright-qa
+
+**If Jest/Vitest detected:**
+- Ensure web-qa or api-qa in recommended
+
+### Deployment-Focused Projects
+
+**If Vercel detected:**
+- Add to recommended: vercel-ops
+
+**If Railway detected:**
+- Add to recommended: railway-ops
+
+**If Docker detected:**
+- Add to recommended: docker-ops
+
+**If PM2 detected:**
+- Add to recommended: local-ops-agent
+
+## Agent Descriptions
+
+### Backend Specialists
+- **fastapi-engineer**: FastAPI expert - routes, Pydantic, async, websockets
+- **flask-engineer**: Flask expert - blueprints, extensions, templates
+- **django-engineer**: Django expert - models, views, ORM, admin
+- **node-engineer**: Node.js expert - Express, async, streams
+- **nestjs-engineer**: NestJS expert - modules, decorators, DI
+
+### Frontend Specialists
+- **nextjs-engineer**: Next.js expert - app router, server components, SSR
+- **react-engineer**: React expert - hooks, state, components
+- **vue-engineer**: Vue expert - composition API, components
+
+### QA Specialists
+- **api-qa**: API testing expert - REST, GraphQL, validation
+- **web-qa**: Web testing expert - fetch, integration, E2E
+- **playwright-qa**: Browser automation expert - UI testing, visual regression
+
+### Ops Specialists
+- **docker-ops**: Docker expert - builds, compose, containers
+- **vercel-ops**: Vercel deployment expert - serverless, edge
+- **railway-ops**: Railway deployment expert
+- **local-ops-agent**: Local development expert - PM2, ports, processes
+
+## Use Cases
+
+1. **Planning**: Understand what agents you should deploy before starting work
+2. **Validation**: Verify that auto-configuration will suggest the right agents
+3. **Learning**: Discover what capabilities are available for your stack
+4. **Optimization**: Find additional agents that could enhance your workflow
+
+## Tips
+
+1. **Start here**: Run this before `/mpm-auto-configure` to preview recommendations
+2. **Essential vs Optional**: Focus on essential agents first, add others as needed
+3. **Stack-specific**: Recommendations are tailored to YOUR detected stack
+4. **Flexible**: You can always deploy additional agents later or skip some
+5. **Explanations**: Pay attention to the "Reason" for each recommendation
+
+## Customizing Recommendations
+
+After seeing recommendations, you can:
+1. **Accept all**: Run `/mpm-auto-configure` to deploy all recommended agents
+2. **Pick and choose**: Deploy specific agents with `/mpm-agents deploy <name>`
+3. **Skip optional**: Deploy only essential and recommended agents
+4. **Add more**: Deploy additional agents not in recommendations
+
+## Related Commands
+
+- `/mpm-agents-detect` - See what was detected in your project
+- `/mpm-auto-configure` - Automatically deploy recommended agents
+- `/mpm-agents deploy <name>` - Deploy specific agents manually
+- `/mpm-agents` - View all available and deployed agents
+- `/mpm-help agents` - Learn more about agent management

claude_mpm/commands/mpm-agents.md

@@ -45,4 +45,78 @@ This will display all deployed agents that are currently available for use.
 Alternatively, you can use these variations:
 - `claude-mpm agents list --system` - Show system agents
 - `claude-mpm agents list --by-tier` - Group agents by precedence tier
-- `claude-mpm agents list --all` - Show all agents including undeployed
+- `claude-mpm agents list --all` - Show all agents including undeployed
+
+## Auto-Configuration Subcommands (NEW!)
+
+### Quick Agent Setup
+
+Claude MPM now includes intelligent auto-configuration that detects your project and recommends the right agents:
+
+#### `agents detect`
+Scan your project to detect toolchain and frameworks:
+```bash
+claude-mpm agents detect
+```
+
+Shows detected:
+- Programming languages (Python, Node.js, Rust, Go, etc.)
+- Frameworks (FastAPI, Next.js, React, Express, etc.)
+- Testing tools (pytest, Jest, Playwright, etc.)
+- Build tools and package managers
+- Deployment configurations
+
+#### `agents recommend`
+Get agent recommendations based on detected toolchain:
+```bash
+claude-mpm agents recommend
+```
+
+Shows:
+- Essential agents for your stack
+- Recommended complementary agents
+- Optional specialized agents
+- Rationale for each recommendation
+
+#### `auto-configure`
+Automatically detect, recommend, and deploy agents:
+```bash
+claude-mpm auto-configure --preview  # See what would be configured
+claude-mpm auto-configure            # Interactive configuration
+claude-mpm auto-configure --yes      # Auto-apply without prompts
+```
+
+**Example workflow:**
+1. Run `claude-mpm agents detect` to see what's detected
+2. Run `claude-mpm agents recommend` to see suggestions
+3. Run `claude-mpm auto-configure` to apply configuration
+4. Or skip straight to `claude-mpm auto-configure --yes`
+
+### Supported Stacks
+
+**Python:**
+- FastAPI, Flask, Django → fastapi-engineer, python-engineer
+- pytest, unittest → api-qa, python-qa
+
+**JavaScript/TypeScript:**
+- Next.js → nextjs-engineer, react-engineer
+- React, Vue, Svelte → react-engineer, web-qa
+- Express, Nest.js → node-engineer, api-qa
+- Jest, Vitest, Playwright → playwright-qa, web-qa
+
+**Full-Stack Projects:**
+Automatically recommends both frontend and backend agents based on your complete stack.
+
+**Deployment:**
+- Vercel → vercel-ops
+- Railway → railway-ops
+- Docker → docker-ops
+- PM2 → local-ops-agent
+
+## Related Commands
+
+For more information on auto-configuration:
+- `/mpm-help auto-configure` - Detailed auto-configuration help
+- `/mpm-agents-detect` - Run detection via slash command
+- `/mpm-agents-recommend` - Show recommendations via slash command
+- `/mpm-auto-configure` - Run auto-configuration via slash command