claude-mpm 5.4.75__tar.gz → 5.4.81__tar.gz

{claude_mpm-5.4.75/src/claude_mpm.egg-info → claude_mpm-5.4.81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.4.75
+Version: 5.4.81
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-5.4.75 → claude_mpm-5.4.81}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "5.4.75"
+version = "5.4.81"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -189,7 +189,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "5.4.75"
+version = "5.4.81"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-5.4.81/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+5.4.81

{claude_mpm-5.4.75 → claude_mpm-5.4.81}/src/claude_mpm/cli/commands/configure.py

@@ -26,6 +26,7 @@ from rich.prompt import Confirm, Prompt
 from rich.text import Text
 
 from ...core.config import Config
+from ...core.unified_config import UnifiedConfig
 from ...services.agents.agent_recommendation_service import AgentRecommendationService
 from ...services.version_service import VersionService
 from ...utils.agent_filters import apply_all_filters, get_deployed_agent_ids
@@ -79,6 +80,7 @@ class ConfigureCommand(BaseCommand):
         self._template_editor = None  # Lazy-initialized
         self._startup_manager = None  # Lazy-initialized
         self._recommendation_service = None  # Lazy-initialized
+        self._unified_config = None  # Lazy-initialized
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
@@ -162,6 +164,18 @@ class ConfigureCommand(BaseCommand):
             self._recommendation_service = AgentRecommendationService()
         return self._recommendation_service
 
+    @property
+    def unified_config(self) -> UnifiedConfig:
+        """Lazy-initialize unified config."""
+        if self._unified_config is None:
+            try:
+                self._unified_config = UnifiedConfig()
+            except Exception as e:
+                self.logger.warning(f"Failed to load unified config: {e}")
+                # Fallback to default config
+                self._unified_config = UnifiedConfig()
+        return self._unified_config
+
     def run(self, args) -> CommandResult:
         """Execute the configure command."""
         # Set configuration scope
@@ -805,6 +819,86 @@ class ConfigureCommand(BaseCommand):
                 self.console.print("[red]Invalid choice. Please try again.[/red]")
                 Prompt.ask("\nPress Enter to continue")
 
+    def _detect_skill_patterns(self, skills: list[dict]) -> dict[str, list[dict]]:
+        """Group skills by detected common prefixes.
+
+        Args:
+            skills: List of skill dictionaries
+
+        Returns:
+            Dict mapping pattern prefix to list of skills.
+            Skills without pattern match go under "" (empty string) key.
+        """
+        from collections import defaultdict
+
+        # Count prefix occurrences (try 1-segment and 2-segment prefixes)
+        prefix_counts = defaultdict(list)
+
+        for skill in skills:
+            skill_id = skill.get("name", skill.get("skill_id", ""))
+
+            # Try to extract prefixes (split by hyphen)
+            parts = skill_id.split("-")
+
+            if len(parts) >= 2:
+                # Try 2-segment prefix first (e.g., "toolchains-universal")
+                two_seg_prefix = f"{parts[0]}-{parts[1]}"
+                prefix_counts[two_seg_prefix].append(skill)
+
+                # Also try 1-segment prefix (e.g., "digitalocean")
+                one_seg_prefix = parts[0]
+                if one_seg_prefix != two_seg_prefix:
+                    prefix_counts[one_seg_prefix].append(skill)
+
+        # Build pattern groups (require at least 2 skills per pattern)
+        pattern_groups = defaultdict(list)
+        used_skills = set()
+
+        # Prefer longer (more specific) prefixes
+        sorted_prefixes = sorted(prefix_counts.keys(), key=lambda x: (-len(x), x))
+
+        for prefix in sorted_prefixes:
+            matching_skills = prefix_counts[prefix]
+
+            # Only create a pattern group if we have 2+ skills and they're not already grouped
+            available_skills = [s for s in matching_skills if id(s) not in used_skills]
+
+            if len(available_skills) >= 2:
+                pattern_groups[prefix] = available_skills
+                used_skills.update(id(s) for s in available_skills)
+
+        # Add ungrouped skills to "" (Other) group
+        for skill in skills:
+            if id(skill) not in used_skills:
+                pattern_groups[""].append(skill)
+
+        return dict(pattern_groups)
+
+    def _get_pattern_icon(self, prefix: str) -> str:
+        """Get icon for a pattern prefix.
+
+        Args:
+            prefix: Pattern prefix (e.g., "digitalocean", "vercel")
+
+        Returns:
+            Emoji icon for the pattern
+        """
+        pattern_icons = {
+            "digitalocean": "🌊",
+            "aws": "☁️",
+            "github": "🐙",
+            "google": "🔍",
+            "vercel": "▲",
+            "netlify": "🦋",
+            "universal-testing": "🧪",
+            "universal-debugging": "🐛",
+            "universal-security": "🔒",
+            "toolchains-python": "🐍",
+            "toolchains-typescript": "📘",
+            "toolchains-javascript": "📒",
+        }
+        return pattern_icons.get(prefix, "📦")
+
     def _manage_skill_installation(self) -> None:
         """Manage skill installation with category-based questionary checkbox selection."""
         import questionary
@@ -890,30 +984,99 @@ class ConfigureCommand(BaseCommand):
             # Show skills in category with checkbox selection
             category_skills = grouped[selected_cat]
 
-            # Build choices with current installation status
+            # Detect pattern groups within category
+            pattern_groups = self._detect_skill_patterns(category_skills)
+
+            # Build choices with pattern grouping and installation status
             skill_choices = []
-            for skill in sorted(category_skills, key=lambda x: x.get("name", "")):
-                skill_id = skill.get("name", skill.get("skill_id", "unknown"))
-                deploy_name = skill.get("deployment_name", skill_id)
-                description = skill.get("description", "")[:50]
 
-                # Check if installed
-                is_installed = deploy_name in deployed or skill_id in deployed
+            # Track which skills belong to which group for expansion later
+            group_to_skills = {}
 
-                skill_choices.append(
-                    Choice(
-                        title=f"{skill_id} - {description}",
-                        value=skill_id,
-                        checked=is_installed,
+            # Sort pattern groups: "" (Other) last, rest alphabetically
+            sorted_patterns = sorted(pattern_groups.keys(), key=lambda x: (x == "", x))
+
+            for pattern in sorted_patterns:
+                pattern_skills = pattern_groups[pattern]
+
+                # Skip empty groups
+                if not pattern_skills:
+                    continue
+
+                # Collect skill IDs in this group
+                skill_ids_in_group = []
+                for skill in pattern_skills:
+                    skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                    skill_ids_in_group.append(skill_id)
+
+                # Check if all skills in group are installed
+                all_installed = all(
+                    skill.get(
+                        "deployment_name", skill.get("name", skill.get("skill_id"))
                     )
+                    in deployed
+                    or skill.get("name", skill.get("skill_id")) in deployed
+                    for skill in pattern_skills
                 )
 
+                # Add pattern group header as selectable choice
+                if pattern:
+                    # Named pattern group
+                    pattern_icon = self._get_pattern_icon(pattern)
+                    skill_count = len(pattern_skills)
+                    group_key = f"__group__:{pattern}"
+                    group_to_skills[group_key] = skill_ids_in_group
+
+                    skill_choices.append(
+                        Choice(
+                            title=f"{pattern_icon} {pattern} ({skill_count} skills) [Select All]",
+                            value=group_key,
+                            checked=all_installed,
+                        )
+                    )
+                elif pattern_skills:
+                    # "Other" group - only show if there are skills
+                    group_key = "__group__:Other"
+                    group_to_skills[group_key] = skill_ids_in_group
+
+                    skill_choices.append(
+                        Choice(
+                            title=f"📦 Other ({len(pattern_skills)} skills) [Select All]",
+                            value=group_key,
+                            checked=all_installed,
+                        )
+                    )
+
+                # Add skills in this pattern group
+                for skill in sorted(pattern_skills, key=lambda x: x.get("name", "")):
+                    skill_id = skill.get("name", skill.get("skill_id", "unknown"))
+                    deploy_name = skill.get("deployment_name", skill_id)
+                    description = skill.get("description", "")[:50]
+
+                    # Check if installed
+                    is_installed = deploy_name in deployed or skill_id in deployed
+
+                    # Add indentation for pattern-grouped skills (all skills are indented)
+                    skill_choices.append(
+                        Choice(
+                            title=f"    {skill_id} - {description}",
+                            value=skill_id,
+                            checked=is_installed,
+                        )
+                    )
+
+                # Add spacing between pattern groups (not after last group)
+                if pattern != sorted_patterns[-1]:
+                    skill_choices.append(Separator())
+
             self.console.clear()
             self._display_header()
             self.console.print(
                 f"\n{icons.get(selected_cat, '📦')} [bold]{selected_cat.title()}[/bold]"
             )
-            self.console.print("[dim]Use spacebar to toggle, enter to confirm[/dim]\n")
+            self.console.print(
+                "[dim]Use spacebar to toggle individual skills or entire groups, enter to confirm[/dim]\n"
+            )
 
             selected = questionary.checkbox(
                 "Select skills to install:",
@@ -924,8 +1087,16 @@ class ConfigureCommand(BaseCommand):
             if selected is None:
                 continue  # User cancelled, go back to category selection
 
-            # Process changes
-            selected_set = set(selected)
+            # Process group selections - expand to individual skills
+            selected_set = set()
+            for item in selected:
+                if item.startswith("__group__:"):
+                    # Expand group selection to all skills in that group
+                    selected_set.update(group_to_skills[item])
+                else:
+                    # Individual skill selection
+                    selected_set.add(item)
+
             current_in_cat = set()
 
             # Find currently installed skills in this category
@@ -1905,18 +2076,32 @@ class ConfigureCommand(BaseCommand):
                         )
                         display_name = self._format_display_name(raw_display_name)
 
-                        # Check if agent is deployed (exists in .claude/agents/)
+                        # Check if agent is required (cannot be unchecked)
+                        required_agents = set(self.unified_config.agents.required)
+                        is_required = (
+                            agent_leaf_name in required_agents
+                            or agent_id in required_agents
+                        )
 
-                        # Format choice text (no asterisk needed)
-                        choice_text = f"    {display_name}"
+                        # Format choice text with [Required] indicator
+                        if is_required:
+                            choice_text = f"    {display_name} [Required]"
+                        else:
+                            choice_text = f"    {display_name}"
 
-                        is_selected = agent_id in current_selection
+                        # Required agents are always selected
+                        is_selected = is_required or agent_id in current_selection
+
+                        # Add to current selection if required
+                        if is_required:
+                            current_selection.add(agent_id)
 
                         choices.append(
                             Choice(
                                 title=choice_text,
                                 value=agent_id,  # Use agent_id for value
                                 checked=is_selected,
+                                disabled=is_required,  # Disable checkbox for required agents
                             )
                         )
 
@@ -1925,6 +2110,7 @@ class ConfigureCommand(BaseCommand):
             self.console.print(
                 "[dim][ ] Unchecked = Available (check to install)[/dim]"
             )
+            self.console.print("[dim][Required] = Core agents (always installed)[/dim]")
             self.console.print(
                 "[dim]Use arrow keys to navigate, space to toggle, Enter to apply[/dim]\n"
             )
@@ -2011,12 +2197,37 @@ class ConfigureCommand(BaseCommand):
 
             # No controls selected - use the individual selections as final
             final_selection = set(selected_values)
+
+            # Ensure required agents are always in the final selection
+            required_agents = set(self.unified_config.agents.required)
+            for agent in agents:
+                agent_id = getattr(agent, "agent_id", agent.name)
+                agent_leaf_name = agent_id.split("/")[-1]
+                if agent_leaf_name in required_agents or agent_id in required_agents:
+                    final_selection.add(agent_id)
+
             break
 
         # Determine changes
         to_deploy = final_selection - deployed_full_paths
         to_remove = deployed_full_paths - final_selection
 
+        # Prevent removal of required agents
+        required_agents = set(self.unified_config.agents.required)
+        to_remove_filtered = set()
+        for agent_id in to_remove:
+            agent_leaf_name = agent_id.split("/")[-1]
+            if (
+                agent_leaf_name not in required_agents
+                and agent_id not in required_agents
+            ):
+                to_remove_filtered.add(agent_id)
+            else:
+                self.console.print(
+                    f"[yellow]⚠ Cannot remove required agent: {agent_id}[/yellow]"
+                )
+        to_remove = to_remove_filtered
+
         if not to_deploy and not to_remove:
             self.console.print("[yellow]No changes needed[/yellow]")
             Prompt.ask("\nPress Enter to continue")

{claude_mpm-5.4.75 → claude_mpm-5.4.81}/src/claude_mpm/cli/startup.py

@@ -700,8 +700,7 @@ def sync_remote_agents_on_startup(force_sync: bool = False):
                     agent_files = [
                         f
                         for f in all_md_files
-                        if
-                        (
+                        if (
                             # Must be in an agent directory
                             # Supports: cache/agents/{category}/... (flat)
                             # Supports: cache/agents/{owner}/{repo}/agents/{category}/... (GitHub sync)
@@ -1467,7 +1466,9 @@ def run_background_services(force_sync: bool = False):
     check_mcp_auto_configuration()
     verify_mcp_gateway_startup()
     check_for_updates_async()
-    sync_remote_agents_on_startup(force_sync=force_sync)  # Sync agents from remote sources
+    sync_remote_agents_on_startup(
+        force_sync=force_sync
+    )  # Sync agents from remote sources
     show_agent_summary()  # Display agent counts after deployment
 
     # Skills deployment order (precedence: remote > bundled)
@@ -1476,7 +1477,9 @@ def run_background_services(force_sync: bool = False):
     # 3. Discover and link runtime skills (user-added skills)
     # This ensures remote skills take precedence over bundled skills when names conflict
     deploy_bundled_skills()  # Base layer: package-bundled skills
-    sync_remote_skills_on_startup(force_sync=force_sync)  # Override layer: Git-based skills (takes precedence)
+    sync_remote_skills_on_startup(
+        force_sync=force_sync
+    )  # Override layer: Git-based skills (takes precedence)
     discover_and_link_runtime_skills()  # Discovery: user-added skills
     show_skill_summary()  # Display skill counts after deployment
     verify_and_show_pm_skills()  # PM skills verification and status

{claude_mpm-5.4.75 → claude_mpm-5.4.81}/src/claude_mpm/core/claude_runner.py

@@ -730,7 +730,7 @@ Use these agents to delegate specialized work via the Task tool.
                     import json
 
                     settings = json.loads(settings_file.read_text())
-                    if settings.get("activeOutputStyle") == "claude-mpm":
+                    if settings.get("activeOutputStyle") == "Claude MPM":
                         # Already active, check if file exists
                         output_style_file = (
                             Path.home() / ".claude" / "output-styles" / "claude-mpm.md"
@@ -740,7 +740,7 @@ Use these agents to delegate specialized work via the Task tool.
                                 "Output style 'Claude MPM' already deployed and active"
                             )
                             return
-                except Exception:
+                except Exception:  # nosec B110
                     pass  # Continue with deployment if we can't read settings
 
             # Read the OUTPUT_STYLE.md content if it exists

{claude_mpm-5.4.75 → claude_mpm-5.4.81}/src/claude_mpm/core/interactive_session.py

@@ -12,7 +12,7 @@ of InteractiveSession without circular dependency issues.
 
 import contextlib
 import os
-import subprocess
+import subprocess  # nosec B404
 import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
@@ -359,19 +359,19 @@ class InteractiveSession:
                 osm = self.runner.framework_loader.output_style_manager
                 if osm:
                     if osm.claude_version and osm.supports_output_styles():
-                        # Check if claude-mpm style is active
+                        # Check if Claude MPM style is active
                         settings_file = osm.settings_file
                         if settings_file.exists():
                             import json
 
                             settings = json.loads(settings_file.read_text())
                             active_style = settings.get("activeOutputStyle")
-                            if active_style == "claude-mpm":
-                                return "Output Style: claude-mpm ✅"
+                            if active_style in ("Claude MPM", "Claude MPM Teacher"):
+                                return f"Output Style: {active_style} ✅"
                             return f"Output Style: {active_style or 'none'}"
                         return "Output Style: Available"
                     return "Output Style: Injected (legacy)"
-        except Exception:
+        except Exception:  # nosec B110
             pass
         return None
 
@@ -582,7 +582,7 @@ class InteractiveSession:
             )
 
         # This will not return if successful
-        os.execvpe(cmd[0], cmd, env)
+        os.execvpe(cmd[0], cmd, env)  # nosec B606
         return False  # Only reached on failure
 
     def _launch_subprocess_mode(self, cmd: list, env: dict) -> bool:
@@ -641,7 +641,7 @@ class InteractiveSession:
             cmd = environment["command"]
             env = environment["environment"]
 
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603
                 cmd, stdin=None, stdout=None, stderr=None, env=env, check=False
             )
 

{claude_mpm-5.4.75 → claude_mpm-5.4.81}/src/claude_mpm/core/output_style_manager.py

@@ -13,7 +13,7 @@ Users can change it if they want, and the system will respect their choice.
 
 import json
 import re
-import subprocess
+import subprocess  # nosec B404
 from pathlib import Path
 from typing import Any, Dict, Literal, Optional, TypedDict, cast
 
@@ -62,14 +62,14 @@ class OutputStyleManager:
                 / "agents"
                 / "CLAUDE_MPM_OUTPUT_STYLE.md",
                 target=self.output_style_dir / "claude-mpm.md",
-                name="claude-mpm",
+                name="Claude MPM",
             ),
             "teaching": StyleConfig(
                 source=Path(__file__).parent.parent
                 / "agents"
                 / "CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md",
                 target=self.output_style_dir / "claude-mpm-teacher.md",
-                name="claude-mpm-teacher",
+                name="Claude MPM Teacher",
             ),
         }
 
@@ -93,7 +93,7 @@ class OutputStyleManager:
 
         try:
             # Run claude --version command
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["claude", "--version"],
                 capture_output=True,
                 text=True,
@@ -300,12 +300,12 @@ class OutputStyleManager:
             self.logger.error(f"Failed to deploy {style} style: {e}")
             return False
 
-    def _activate_output_style(self, style_name: str = "claude-mpm") -> bool:
+    def _activate_output_style(self, style_name: str = "Claude MPM") -> bool:
         """
         Update Claude Code settings to activate a specific output style.
 
         Args:
-            style_name: Name of the style to activate (e.g., "claude-mpm", "claude-mpm-teach")
+            style_name: Name of the style to activate (e.g., "Claude MPM", "Claude MPM Teacher")
 
         Returns:
             True if activated successfully, False otherwise
@@ -443,7 +443,7 @@ class OutputStyleManager:
 
         # Activate the default style if requested
         if activate_default and results.get("professional", False):
-            self._activate_output_style("claude-mpm")
+            self._activate_output_style("Claude MPM")
 
         return results
 

{claude_mpm-5.4.75 → claude_mpm-5.4.81}/src/claude_mpm/core/unified_config.py

@@ -72,6 +72,22 @@ class AgentConfig(BaseModel):
         description="Explicit list of agent IDs to deploy (empty = use auto_discover)",
     )
 
+    # Required agents that are always deployed
+    required: List[str] = Field(
+        default_factory=lambda: [
+            "research",
+            "mpm-skills-manager",
+            "mpm-agent-manager",
+            "memory-manager",
+        ],
+        description="Agents that are always deployed (core system agents)",
+    )
+
+    include_universal: bool = Field(
+        default=True,
+        description="Auto-include all agents with 'universal' toolchain/category",
+    )
+
     auto_discover: bool = Field(
         default=False,
         description="Enable automatic agent discovery (deprecated, use enabled list)",