claude-mpm 5.4.14__py3-none-any.whl → 5.4.21__py3-none-any.whl

claude_mpm/cli/startup.py

@@ -677,14 +677,21 @@ def sync_remote_skills_on_startup():
 
     Workflow:
     1. Sync all enabled Git sources (download/cache files) - Phase 1 progress bar
-    2. Deploy skills to ~/.claude/skills/ with flat structure - Phase 2 progress bar
-    3. Log deployment results
+    2. Scan deployed agents for skill requirements → save to configuration.yaml
+    3. Resolve which skills to deploy (user_defined vs agent_referenced)
+    4. Deploy resolved skills to ~/.claude/skills/ - Phase 2 progress bar
+    5. Log deployment results with source indication
     """
     try:
         from pathlib import Path
 
         from ..config.skill_sources import SkillSourceConfiguration
         from ..services.skills.git_skill_source_manager import GitSkillSourceManager
+        from ..services.skills.selective_skill_deployer import (
+            get_required_skills_from_agents,
+            get_skills_to_deploy,
+            save_agent_skills_to_config,
+        )
         from ..utils.progress import ProgressBar
 
         config = SkillSourceConfiguration()
@@ -773,37 +780,37 @@ def sync_remote_skills_on_startup():
                 f"Complete: {downloaded} files downloaded ({total_skill_dirs} skills)"
             )
 
-        # Phase 2: Deploy skills to ~/.claude/skills/
-        # This flattens nested Git structure (e.g., collaboration/parallel-agents/SKILL.md)
-        # into flat deployment (e.g., collaboration-dispatching-parallel-agents/SKILL.md)
+        # Phase 2: Scan agents and save to configuration.yaml
+        # This step populates configuration.yaml with agent-referenced skills
         if results["synced_count"] > 0:
-            # Get required skills from deployed agents (selective deployment)
-            from ..services.skills.selective_skill_deployer import (
-                get_required_skills_from_agents,
-            )
-
             agents_dir = Path.cwd() / ".claude" / "agents"
-            required_skills = get_required_skills_from_agents(agents_dir)
+
+            # Scan agents for skill requirements
+            agent_skills = get_required_skills_from_agents(agents_dir)
+
+            # Save to project-level configuration.yaml
+            project_config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+            save_agent_skills_to_config(list(agent_skills), project_config_path)
+
+            # Phase 3: Resolve which skills to deploy (user_defined or agent_referenced)
+            skills_to_deploy, skill_source = get_skills_to_deploy(project_config_path)
 
             # Get all skills to determine counts
             all_skills = manager.get_all_skills()
             total_skill_count = len(all_skills)
 
-            # Determine skill count based on whether we have agent requirements
-            if required_skills:
-                # Selective deployment: only skills required by deployed agents
-                skill_count = len(required_skills)
-            else:
-                # No agent requirements found - deploy all skills
-                skill_count = total_skill_count
+            # Determine skill count based on resolution
+            skill_count = (
+                len(skills_to_deploy) if skills_to_deploy else total_skill_count
+            )
 
             if skill_count > 0:
-                # Deploy skills with selective filter (if agent requirements exist)
+                # Deploy skills with resolved filter
                 # Deploy to project directory (like agents), not user directory
                 deployment_result = manager.deploy_skills(
                     target_dir=Path.cwd() / ".claude" / "skills",
                     force=False,
-                    skill_filter=required_skills if required_skills else None,
+                    skill_filter=set(skills_to_deploy) if skills_to_deploy else None,
                 )
 
                 # Get actual counts from deployment result
@@ -833,27 +840,31 @@ def sync_remote_skills_on_startup():
                     deploy_progress.update(1)
 
                 # Show total available skills (deployed + already existing)
-                # Include filtered count if selective deployment was used
+                # Include source indication (user_defined vs agent_referenced)
                 # Note: total_skill_count is from the repo, total_available is what's deployed/needed
+                source_label = (
+                    "user override" if skill_source == "user_defined" else "from agents"
+                )
+
                 if deployed > 0:
                     if filtered > 0:
                         deploy_progress.finish(
                             f"Complete: {deployed} new, {skipped} unchanged "
-                            f"({total_available} required by agents, {filtered} available in repo)"
+                            f"({total_available} {source_label}, {filtered} available in repo)"
                         )
                     else:
                         deploy_progress.finish(
                             f"Complete: {deployed} new, {skipped} unchanged "
-                            f"({total_available} skills deployed from {total_skill_count} in repo)"
+                            f"({total_available} skills {source_label} from {total_skill_count} in repo)"
                         )
                 elif filtered > 0:
                     # Skills filtered means agents require fewer skills than available
                     deploy_progress.finish(
-                        f"Agents require no skills ({total_skill_count} available in repo)"
+                        f"No skills needed ({source_label}, {total_skill_count} available in repo)"
                     )
                 else:
                     deploy_progress.finish(
-                        f"Complete: {total_available} skills deployed for agents "
+                        f"Complete: {total_available} skills {source_label} "
                         f"({total_skill_count} available in repo)"
                     )
 
@@ -883,6 +894,202 @@ def sync_remote_skills_on_startup():
         # Continue execution - skill sync failure shouldn't block startup
 
 
+def show_agent_summary():
+    """
+    Display agent availability summary on startup.
+
+    WHY: Users should see at a glance how many agents are available and installed
+    without having to run /mpm-agents list.
+
+    DESIGN DECISION: Fast, non-blocking check that counts agents from the deployment
+    directory. Shows simple "X installed / Y available" format. Failures are silent
+    to avoid blocking startup.
+    """
+    try:
+        from pathlib import Path
+
+        # Count deployed agents (installed)
+        deploy_target = Path.cwd() / ".claude" / "agents"
+        installed_count = 0
+        if deploy_target.exists():
+            # Count .md files, excluding README and other docs
+            agent_files = [
+                f
+                for f in deploy_target.glob("*.md")
+                if not f.name.startswith(("README", "INSTRUCTIONS", "."))
+            ]
+            installed_count = len(agent_files)
+
+        # Count available agents in cache (from remote sources)
+        cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+        available_count = 0
+        if cache_dir.exists():
+            # Use same filtering logic as agent deployment (lines 486-533 in startup.py)
+            pm_templates = {
+                "base-agent.md",
+                "circuit_breakers.md",
+                "pm_examples.md",
+                "pm_red_flags.md",
+                "research_gate_examples.md",
+                "response_format.md",
+                "ticket_completeness_examples.md",
+                "validation_templates.md",
+                "git_file_tracking.md",
+            }
+            doc_files = {
+                "readme.md",
+                "changelog.md",
+                "contributing.md",
+                "implementation-summary.md",
+                "reorganization-plan.md",
+                "auto-deploy-index.md",
+            }
+
+            # Find all markdown files in agents/ directories
+            all_md_files = list(cache_dir.rglob("*.md"))
+            agent_files = [
+                f
+                for f in all_md_files
+                if (
+                    "/agents/" in str(f)
+                    and f.name.lower() not in pm_templates
+                    and f.name.lower() not in doc_files
+                    and f.name.lower() != "base-agent.md"
+                    and not any(
+                        part in str(f).split("/")
+                        for part in ["dist", "build", ".cache"]
+                    )
+                )
+            ]
+            available_count = len(agent_files)
+
+        # Display summary if we have agents
+        if installed_count > 0 or available_count > 0:
+            print(
+                f"✓ Agents: {installed_count} installed / {available_count} available",
+                flush=True,
+            )
+
+    except Exception as e:
+        # Silent failure - agent summary is informational only
+        from ..core.logger import get_logger
+
+        logger = get_logger("cli")
+        logger.debug(f"Failed to generate agent summary: {e}")
+
+
+def show_skill_summary():
+    """
+    Display skill availability summary on startup.
+
+    WHY: Users should see at a glance how many skills are deployed and available
+    from collections, similar to the agent summary.
+
+    DESIGN DECISION: Fast, non-blocking check that counts skills from deployment
+    directory and collection repos. Shows "X installed (Y available)" format.
+    Failures are silent to avoid blocking startup.
+    """
+    try:
+        from pathlib import Path
+
+        # Count deployed skills (installed)
+        skills_dir = Path.home() / ".claude" / "skills"
+        installed_count = 0
+        if skills_dir.exists():
+            # Count directories with SKILL.md (excludes collection repos)
+            # Exclude collection directories (obra-superpowers, etc.)
+            skill_dirs = [
+                d
+                for d in skills_dir.iterdir()
+                if d.is_dir()
+                and (d / "SKILL.md").exists()
+                and not (d / ".git").exists()  # Exclude collection repos
+            ]
+            installed_count = len(skill_dirs)
+
+        # Count available skills in collections
+        available_count = 0
+        if skills_dir.exists():
+            # Scan all collection directories (those with .git)
+            for collection_dir in skills_dir.iterdir():
+                if (
+                    not collection_dir.is_dir()
+                    or not (collection_dir / ".git").exists()
+                ):
+                    continue
+
+                # Count skill directories in this collection
+                # Skills can be nested in: skills/category/skill-name/SKILL.md
+                # or in flat structure: skill-name/SKILL.md
+                for root, dirs, files in os.walk(collection_dir):
+                    if "SKILL.md" in files:
+                        # Exclude build artifacts and hidden directories (within the collection)
+                        # Get relative path from collection_dir to avoid excluding based on .claude parent
+                        root_path = Path(root)
+                        relative_parts = root_path.relative_to(collection_dir).parts
+                        if not any(
+                            part.startswith(".")
+                            or part in ["dist", "build", "__pycache__"]
+                            for part in relative_parts
+                        ):
+                            available_count += 1
+
+        # Display summary if we have skills
+        if installed_count > 0 or available_count > 0:
+            print(
+                f"✓ Skills: {installed_count} installed ({available_count} available)",
+                flush=True,
+            )
+
+    except Exception as e:
+        # Silent failure - skill summary is informational only
+        from ..core.logger import get_logger
+
+        logger = get_logger("cli")
+        logger.debug(f"Failed to generate skill summary: {e}")
+
+
+def auto_install_chrome_devtools_on_startup():
+    """
+    Automatically install chrome-devtools-mcp on startup if enabled.
+
+    WHY: Browser automation capabilities should be available out-of-the-box without
+    manual MCP server configuration. chrome-devtools-mcp provides powerful browser
+    interaction tools for Claude Code.
+
+    DESIGN DECISION: Non-blocking installation that doesn't prevent startup if it fails.
+    Respects user configuration setting (enabled by default). Only installs if not
+    already configured in Claude.
+    """
+    try:
+        # Check if auto-install is disabled in config
+        from ..config.config_loader import ConfigLoader
+
+        config_loader = ConfigLoader()
+        try:
+            config = config_loader.load_main_config()
+            chrome_devtools_config = config.get("chrome_devtools", {})
+            if not chrome_devtools_config.get("auto_install", True):
+                # Auto-install disabled, skip silently
+                return
+        except Exception:
+            # If config loading fails, assume auto-install is enabled (default)
+            pass
+
+        # Import and run chrome-devtools installation
+        from ..cli.chrome_devtools_installer import auto_install_chrome_devtools
+
+        auto_install_chrome_devtools(quiet=False)
+
+    except Exception as e:
+        # Import logger here to avoid circular imports
+        from ..core.logger import get_logger
+
+        logger = get_logger("cli")
+        logger.debug(f"Failed to auto-install chrome-devtools-mcp: {e}")
+        # Continue execution - chrome-devtools installation failure shouldn't block startup
+
+
 def run_background_services():
     """
     Initialize all background services on startup.
@@ -905,6 +1112,7 @@ def run_background_services():
     verify_mcp_gateway_startup()
     check_for_updates_async()
     sync_remote_agents_on_startup()  # Sync agents from remote sources
+    show_agent_summary()  # Display agent counts after deployment
 
     # Skills deployment order (precedence: remote > bundled)
     # 1. Deploy bundled skills first (base layer from package)
@@ -914,9 +1122,13 @@ def run_background_services():
     deploy_bundled_skills()  # Base layer: package-bundled skills
     sync_remote_skills_on_startup()  # Override layer: Git-based skills (takes precedence)
     discover_and_link_runtime_skills()  # Discovery: user-added skills
+    show_skill_summary()  # Display skill counts after deployment
 
     deploy_output_style_on_startup()
 
+    # Auto-install chrome-devtools-mcp for browser automation
+    auto_install_chrome_devtools_on_startup()
+
 
 def setup_mcp_server_logging(args):
     """

claude_mpm/commands/mpm-config.md

@@ -262,5 +262,4 @@ default_configuration:
 - `/mpm-doctor`: Diagnose configuration issues
 - `/mpm-init`: Initialize project configuration
 - `/mpm-agents`: Manually manage agents
-- `/mpm-agents-detect`: View detected toolchain only
-- `/mpm-agents-recommend`: Show recommendations only
+- `/mpm-configure`: Unified configuration interface (includes toolchain detection and recommendations)

claude_mpm/commands/mpm-help.md

@@ -78,14 +78,8 @@ Available Commands:
 /mpm-agents [list|deploy|remove] [name]
   Manage agent deployment
 
-/mpm-auto-configure [--preview] [--yes]
-  🤖 NEW! Automatically configure agents based on your project
-
-/mpm-agents-detect
-  🤖 NEW! Detect project toolchain and frameworks
-
-/mpm-agents-recommend
-  🤖 NEW! Show recommended agents for your project
+/mpm-configure
+  🤖 Unified configuration interface for agents, skills, and project settings
 
 /mpm-config [validate|view|status]
   Manage configuration settings
@@ -184,99 +178,24 @@ Automatically detects your project's toolchain and frameworks, then recommends a
 - **Full-stack**: Combination of backend + frontend agents
 - **Testing**: playwright-qa, api-qa based on detected test tools
 
-### /mpm-agents-detect - Toolchain Detection
+## Quick Start with Configuration
 
-**Description:**
-Scans your project to detect programming languages, frameworks, tools, and configuration files.
+For new projects or first-time setup, use the unified `/mpm-configure` command which provides:
+- Toolchain detection
+- Agent recommendations
+- Skills management
+- Auto-configuration
 
 **Usage:**
 ```
-/mpm-agents-detect
-```
-
-**Output:**
-- Detected languages and versions
-- Frameworks and their configurations
-- Testing tools and test frameworks
-- Build tools and bundlers
-- Package managers
-- Deployment configurations
-
-**Example:**
+/mpm-configure
 ```
-/mpm-agents-detect
-
-Detected Project Stack:
-======================
-Languages: Python 3.11, Node.js 20.x
-Frameworks: FastAPI 0.104.0, React 18.2.0
-Testing: pytest, Playwright
-Build: Vite 5.0.0
-Package Manager: poetry, npm
-Deployment: Docker, Vercel
-```
-
-### /mpm-agents-recommend - Agent Recommendations
-
-**Description:**
-Based on detected toolchain, shows which agents are recommended for your project with explanations.
-
-**Usage:**
-```
-/mpm-agents-recommend
-```
-
-**Output:**
-- Recommended agents with rationale
-- Agent capabilities and when to use them
-- Suggested deployment order
-- Complementary agent combinations
 
-**Example:**
-```
-/mpm-agents-recommend
-
-Recommended Agents for Your Project:
-===================================
-
-Essential Agents:
-✓ fastapi-engineer - Detected FastAPI framework
-✓ python-engineer - Python 3.11 project
-✓ api-qa - API testing and validation
-
-Recommended Agents:
-○ react-engineer - React frontend detected
-○ web-qa - Web UI testing
-○ playwright-qa - Playwright tests found
-
-Optional Agents:
-○ docker-ops - Docker configuration found
-○ vercel-ops - Vercel deployment detected
-```
-
-## Quick Start with Auto-Configuration
-
-For new projects or first-time setup:
-
-1. **Preview what would be configured:**
-   ```
-   /mpm-auto-configure --preview
-   ```
-
-2. **Review recommendations:**
-   ```
-   /mpm-agents-recommend
-   ```
-
-3. **Apply configuration:**
-   ```
-   /mpm-auto-configure
-   ```
-
-Or skip straight to auto-apply:
-```
-/mpm-auto-configure --yes
-```
+The interactive menu will guide you through:
+1. Detecting your project's toolchain
+2. Viewing recommended agents
+3. Deploying agents and skills
+4. Managing configuration settings
 
 ## Supported Technology Stacks