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

claude_mpm/cli/startup.py

@@ -10,7 +10,6 @@ Part of cli/__init__.py refactoring to reduce file size and improve modularity.
 
 import os
 import sys
-import warnings
 from pathlib import Path
 
 
@@ -61,42 +60,11 @@ def sync_hooks_on_startup(quiet: bool = False) -> bool:
 
 
 def check_legacy_cache() -> None:
-    """Check for legacy cache/agents/ directory and warn user.
+    """Deprecated: Legacy cache checking is no longer needed.
 
-    WHY: cache/agents/ is deprecated in favor of cache/remote-agents/.
-    Research confirmed that cache/remote-agents/ is the canonical location
-    with 26 active code references, while cache/agents/ has only 7 legacy references.
-
-    DESIGN DECISIONS:
-    - Non-blocking warning: Doesn't stop execution, just informs user
-    - Migration guidance: Provides clear path to migrate
-    - One-time check: Only warns if legacy cache contains files
+    This function is kept for backward compatibility but does nothing.
+    All agent cache operations now use the standardized cache/agents/ directory.
     """
-    home = Path.home()
-    legacy_cache = home / ".claude-mpm" / "cache" / "agents"
-    canonical_cache = home / ".claude-mpm" / "cache" / "remote-agents"
-    migration_marker = home / ".claude-mpm" / "cache" / ".migrated_to_remote_agents"
-
-    # Skip if already migrated or no legacy cache
-    if migration_marker.exists() or not legacy_cache.exists():
-        return
-
-    # Check if legacy cache has actual agent files
-    legacy_files = list(legacy_cache.glob("*.md")) + list(legacy_cache.glob("*.json"))
-    if not legacy_files:
-        return
-
-    # Only warn if canonical cache doesn't exist (indicating unmigrated system)
-    if not canonical_cache.exists():
-        warnings.warn(
-            f"\n⚠️  DEPRECATION: Legacy cache directory detected\n"
-            f"   Location: {legacy_cache}\n"
-            f"   Files found: {len(legacy_files)}\n\n"
-            f"The 'cache/agents/' directory is deprecated. Please migrate to 'cache/remote-agents/'.\n"
-            f"Run: python scripts/migrate_cache_to_remote_agents.py\n",
-            DeprecationWarning,
-            stacklevel=2,
-        )
 
 
 def setup_early_environment(argv):
@@ -476,13 +444,76 @@ def sync_remote_agents_on_startup():
                 # Count agents in cache to show accurate progress
                 from pathlib import Path
 
-                cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+                cache_dir = Path.home() / ".claude-mpm" / "cache" / "agents"
                 agent_count = 0
 
                 if cache_dir.exists():
-                    # Count MD files in cache (agent markdown files from Git)
-                    # BUGFIX: Only count files in agent directories, not docs/templates/READMEs
-                    # Valid agent paths must contain "/agents/" or be in root-level category dirs
+                    # BUGFIX (cache-count-inflation): Clean up stale cache files
+                    # from old repositories before counting to prevent inflated counts.
+                    # Issue: Old caches like bobmatnyc/claude-mpm-agents/agents/
+                    # were counted alongside current agents, inflating count
+                    # from 44 to 85.
+                    #
+                    # Solution: Remove files with nested /agents/ paths
+                    # (e.g., cache/agents/user/repo/agents/...)
+                    # Keep only current agents (e.g., cache/agents/engineer/...)
+                    removed_count = 0
+                    stale_dirs = set()
+
+                    for md_file in cache_dir.rglob("*.md"):
+                        # Stale cache files have multiple /agents/ in their path
+                        # Current: ~/.claude-mpm/cache/agents/engineer/...
+                        #          (1 occurrence)
+                        # Old: ~/.claude-mpm/cache/agents/bobmatnyc/.../agents/...
+                        #      (2+ occurrences)
+                        if str(md_file).count("/agents/") > 1:
+                            # Track parent directory for cleanup
+                            # Extract subdirectory under cache/agents/
+                            # (e.g., "bobmatnyc")
+                            parts = md_file.parts
+                            cache_agents_idx = parts.index("agents")
+                            if cache_agents_idx + 1 < len(parts):
+                                stale_subdir = parts[cache_agents_idx + 1]
+                                # Only remove if it's not a known category directory
+                                if stale_subdir not in [
+                                    "engineer",
+                                    "ops",
+                                    "qa",
+                                    "universal",
+                                    "documentation",
+                                    "claude-mpm",
+                                    "security",
+                                ]:
+                                    stale_dirs.add(cache_dir / stale_subdir)
+
+                            md_file.unlink()
+                            removed_count += 1
+
+                    # Remove empty stale directories
+                    for stale_dir in stale_dirs:
+                        if stale_dir.exists() and stale_dir.is_dir():
+                            try:
+                                # Remove directory and all contents
+                                import shutil
+
+                                shutil.rmtree(stale_dir)
+                            except Exception:
+                                pass  # Ignore cleanup errors
+
+                    if removed_count > 0:
+                        from loguru import logger
+
+                        logger.info(
+                            f"Cleaned up {removed_count} stale cache files "
+                            f"from old repositories"
+                        )
+
+                    # Count MD files in cache (agent markdown files from
+                    # current repos)
+                    # BUGFIX: Only count files in agent directories,
+                    # not docs/templates/READMEs
+                    # Valid agent paths must contain "/agents/" exactly ONCE
+                    # (current structure)
                     # Exclude PM templates, BASE-AGENT, and documentation files
                     pm_templates = {
                         "base-agent.md",
@@ -505,25 +536,34 @@ def sync_remote_agents_on_startup():
                         "auto-deploy-index.md",
                     }
 
-                    # Find all markdown files
+                    # Find all markdown files (after cleanup)
                     all_md_files = list(cache_dir.rglob("*.md"))
 
                     # Filter to only agent files:
-                    # 1. Must have "/agents/" in path (from git repos)
+                    # 1. Must have "/agents/" in path exactly ONCE
+                    #    (current structure)
                     # 2. Must not be in PM templates or doc files
                     # 3. Exclude BASE-AGENT.md which is not a deployable agent
-                    # 4. Exclude build artifacts (dist/, build/, .cache/) to prevent double-counting
+                    # 4. Exclude build artifacts (dist/, build/, .cache/)
+                    #    to prevent double-counting
                     agent_files = [
                         f
                         for f in all_md_files
                         if (
-                            # Must be in an agent directory (from git repos like bobmatnyc/claude-mpm-agents/agents/)
+                            # Must be in an agent directory (from current
+                            # cache structure)
                             "/agents/" in str(f)
+                            # NEW: Only ONE /agents/ in path (excludes old
+                            # nested repos)
+                            # This prevents counting old caches like
+                            # bobmatnyc/claude-mpm-agents/agents/...
+                            and str(f).count("/agents/") == 1
                             # Exclude PM templates, doc files, and BASE-AGENT
                             and f.name.lower() not in pm_templates
                             and f.name.lower() not in doc_files
                             and f.name.lower() != "base-agent.md"
-                            # Exclude build artifacts (prevents double-counting source + built files)
+                            # Exclude build artifacts (prevents double-counting
+                            # source + built files)
                             and not any(
                                 part in str(f).split("/")
                                 for part in ["dist", "build", ".cache"]
@@ -594,27 +634,27 @@ def sync_remote_agents_on_startup():
                     )
 
                     # Show total configured agents (deployed + updated + already existing)
-                    # Include repo count for context and removed count if any
+                    # Include cache count for context and removed count if any
                     if deployed > 0 or updated > 0:
                         if removed > 0:
                             deploy_progress.finish(
                                 f"Complete: {deployed} new, {updated} updated, {skipped} unchanged, "
-                                f"{removed} removed ({total_configured} configured from {agent_count} in repo)"
+                                f"{removed} removed ({total_configured} configured from {agent_count} files in cache)"
                             )
                         else:
                             deploy_progress.finish(
                                 f"Complete: {deployed} new, {updated} updated, {skipped} unchanged "
-                                f"({total_configured} configured from {agent_count} in repo)"
+                                f"({total_configured} configured from {agent_count} files in cache)"
                             )
                     elif removed > 0:
                         deploy_progress.finish(
-                            f"Complete: {total_configured} agents ready - all unchanged, "
-                            f"{removed} removed ({agent_count} available in repo)"
+                            f"Complete: {total_configured} agents deployed, "
+                            f"{removed} removed ({agent_count} files in cache)"
                         )
                     else:
                         deploy_progress.finish(
-                            f"Complete: {total_configured} agents ready - all unchanged "
-                            f"({agent_count} available in repo)"
+                            f"Complete: {total_configured} agents deployed "
+                            f"({agent_count} files in cache)"
                         )
 
                     # Display deployment errors to user (not just logs)
@@ -677,14 +717,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 +820,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,28 +880,32 @@ 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
-                # Note: total_skill_count is from the repo, total_available is what's deployed/needed
+                # Include source indication (user_defined vs agent_referenced)
+                # Note: total_skill_count is from cache, 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} files in cache)"
                         )
                     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} files in cache)"
                         )
                 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} files in cache)"
                     )
                 else:
                     deploy_progress.finish(
-                        f"Complete: {total_available} skills deployed for agents "
-                        f"({total_skill_count} available in repo)"
+                        f"Complete: {total_available} skills {source_label} "
+                        f"({total_skill_count} files in cache)"
                     )
 
                 # Log deployment errors if any
@@ -883,6 +934,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" / "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} deployed / {available_count} cached",
+                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 +1152,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 +1162,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)