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

claude_mpm/commands/mpm-config.md

@@ -0,0 +1,266 @@
+---
+namespace: mpm/config
+command: config
+aliases: [mpm-config]
+migration_target: /mpm/config
+category: config
+deprecated_aliases: [mpm-config-view]
+description: Unified configuration management with auto-detection and manual viewing
+---
+# Unified configuration management
+
+Manage Claude MPM configuration with auto-detection, manual viewing, validation, and status checks.
+
+## Usage
+
+```
+/mpm-config [subcommand] [options]
+/mpm-config              # No args = auto (detect + recommend + preview)
+/mpm-config view         # Show current config
+/mpm-config auto         # Auto-configure: detect → recommend → deploy (with confirmation)
+/mpm-config auto --yes   # Auto-deploy without confirmation
+```
+
+## Description
+
+This unified command provides comprehensive configuration management:
+
+1. **Auto-configuration** (default): Detect toolchain and recommend agents/skills
+2. **Manual viewing**: Display current configuration settings
+3. **Validation**: Ensure configuration correctness
+4. **Status checks**: Show system health
+
+## Subcommands
+
+### Auto-Configure (Default)
+
+Automatically detect project toolchain and configure appropriate agents and skills.
+
+```
+/mpm-config              # Preview recommendations (default)
+/mpm-config auto         # Same as no args - detect and preview
+/mpm-config auto --yes   # Auto-deploy without confirmation
+```
+
+**What it does:**
+1. Scans project to detect programming languages, frameworks, and tools
+2. Recommends agents for your stack (e.g., fastapi-engineer, react-engineer)
+3. Recommends skills based on agent types
+4. Shows preview of what will be configured
+5. Deploys with confirmation (unless `--yes` is used)
+
+**Options:**
+- `--yes`: Automatically deploy without prompting
+- `--preview`: Show recommendations without deploying (default when no args)
+- `--min-confidence FLOAT`: Minimum confidence threshold (default: 0.8)
+- `--agents-only`: Only configure agents, skip skills
+- `--skills-only`: Only configure skills, skip agents
+- `--json`: Output results in JSON format
+
+**Examples:**
+```
+/mpm-config                    # Preview auto-configuration
+/mpm-config auto               # Same as above
+/mpm-config auto --yes         # Deploy automatically
+/mpm-config auto --min-confidence 0.7  # Lower threshold
+```
+
+**Detection Capabilities:**
+
+**Languages:**
+- Python (CPython, PyPy)
+- JavaScript/TypeScript (Node.js, Deno, Bun)
+- Rust, Go, Java
+
+**Python Frameworks:**
+- FastAPI, Flask, Django, Starlette, Pyramid
+
+**JavaScript/TypeScript Frameworks:**
+- Next.js, React, Vue, Svelte, Angular
+- Express, Nest.js, Fastify
+
+**Testing Tools:**
+- pytest, unittest (Python)
+- Jest, Vitest (JavaScript)
+- Playwright, Cypress (Browser)
+
+**Example Output:**
+```
+📊 Detected Toolchain:
+  ✓ Python 3.11 (100% confidence)
+  ✓ FastAPI 0.104.0 (95% confidence)
+  ✓ pytest 7.4.0 (90% confidence)
+
+🤖 Recommended Agents:
+  ✓ fastapi-engineer (95% confidence)
+    Reason: FastAPI framework detected
+  ✓ python-engineer (90% confidence)
+    Reason: Python project support
+  ✓ api-qa (85% confidence)
+    Reason: API testing and validation
+
+🎯 Recommended Skills:
+  ✓ toolchains-python-frameworks-fastapi
+  ✓ toolchains-python-testing-pytest
+  ✓ toolchains-universal-api-testing
+
+Deploy 3 agent(s) and 3 skill(s)? (y/n/s for select):
+```
+
+### View Configuration
+
+Display current configuration settings.
+
+```
+/mpm-config view [--section SECTION] [--format FORMAT] [--show-defaults]
+```
+
+**Options:**
+- `--section SECTION`: Specific configuration section to view
+- `--format FORMAT`: Output format (yaml, json, table)
+- `--show-defaults`: Include default values in output
+
+**Examples:**
+```
+/mpm-config view
+/mpm-config view --section agents --format json
+/mpm-config view --show-defaults
+```
+
+### Validate Configuration
+
+Validate configuration files for correctness and completeness.
+
+```
+/mpm-config validate [--config-file PATH] [--strict] [--fix]
+```
+
+**Options:**
+- `--config-file PATH`: Validate specific config file (default: all)
+- `--strict`: Use strict validation rules
+- `--fix`: Attempt to fix validation errors automatically
+
+**Example:**
+```
+/mpm-config validate --strict
+/mpm-config validate --config-file .claude/config.yaml --fix
+```
+
+**Expected Output:**
+```
+Validating configuration files...
+
+✓ .claude/config.yaml: Valid
+✓ .claude/agents/config.yaml: Valid
+✓ Configuration schema: Valid
+
+Configuration is valid and ready to use.
+```
+
+### Configuration Status
+
+Show configuration health and status.
+
+```
+/mpm-config status [--verbose]
+```
+
+**Options:**
+- `--verbose`: Show detailed status information
+
+**Example:**
+```
+/mpm-config status --verbose
+```
+
+**Expected Output:**
+```
+Configuration Status
+====================
+
+Files Found: 2
+  ✓ .claude/config.yaml
+  ✓ .claude/agents/config.yaml
+
+Validation: Passed
+Schema Version: 4.5
+Last Modified: 2025-01-15 14:30:22
+
+Active Settings:
+  - WebSocket Port: 8765
+  - Agent Deploy Mode: project
+  - Logging Level: INFO
+```
+
+## Implementation
+
+This command executes:
+```bash
+claude-mpm config [subcommand] [options]
+```
+
+The slash command passes through to the actual CLI configuration management system.
+
+## Configuration Categories
+
+Configuration is organized into sections:
+
+- **agents**: Agent deployment and management settings
+- **memory**: Memory system configuration
+- **websocket**: WebSocket server settings (port, host)
+- **hooks**: Hook service configuration
+- **logging**: Logging levels and output
+- **tickets**: Ticket tracking settings
+- **monitor**: Dashboard and monitoring settings
+
+## Workflow Examples
+
+### Quick Start (New Project)
+```
+/mpm-config                    # Preview recommendations
+# Review output, then:
+/mpm-config auto --yes         # Deploy recommended agents and skills
+```
+
+### Check Current State
+```
+/mpm-config view               # See current settings
+/mpm-config status             # Verify health
+```
+
+### Validate After Manual Edits
+```
+/mpm-config validate --strict
+```
+
+### Reconfigure After Stack Changes
+```
+/mpm-config auto --force       # Re-run auto-detection
+```
+
+## Default Configuration Fallback
+
+When auto-configuration cannot detect your project's toolchain, it falls back to sensible defaults:
+
+**Default Agents** (moderate confidence 0.7):
+- engineer (general-purpose)
+- research (code exploration)
+- qa (testing)
+- ops (infrastructure)
+- documentation (technical writing)
+
+**Disable defaults:**
+Edit `.claude-mpm/config/agent_capabilities.yaml`:
+```yaml
+default_configuration:
+  enabled: false  # Disable default fallback
+```
+
+## Related Commands
+
+- `/mpm-status`: Show overall system status
+- `/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

claude_mpm/commands/{mpm-ticket-organize.md → mpm-organize.md}

@@ -1,10 +1,9 @@
 ---
-namespace: mpm/ticket
+namespace: mpm/system
 command: organize
-aliases: [mpm-ticket-organize]
-migration_target: /mpm/ticket:organize
-category: tickets
-deprecated_aliases: [mpm-organize]
+aliases: [mpm-organize]
+migration_target: /mpm/system:organize
+category: system
 description: Organize project files into proper directories with intelligent pattern detection
 ---
 # /mpm-organize

claude_mpm/config/agent_sources.py

@@ -316,6 +316,33 @@ class AgentSourceConfiguration:
 
         return errors
 
+    def list_sources(self) -> list[dict]:
+        """Return list of source configurations as dictionaries.
+
+        This method converts GitRepository objects to dictionaries for CLI
+        and API compatibility. Called by GitSourceManager and CLI commands.
+
+        Returns:
+            List of dicts with keys: identifier, url, subdirectory, enabled, priority
+
+        Example:
+            >>> config = AgentSourceConfiguration()
+            >>> sources = config.list_sources()
+            >>> for source in sources:
+            ...     print(f"{source['identifier']} (priority: {source['priority']})")
+        """
+        repos = self.get_enabled_repositories()
+        return [
+            {
+                "identifier": repo.identifier,
+                "url": repo.url,
+                "subdirectory": repo.subdirectory,
+                "enabled": repo.enabled,
+                "priority": repo.priority,
+            }
+            for repo in repos
+        ]
+
     def __repr__(self) -> str:
         """Return string representation of configuration."""
         return (

claude_mpm/core/framework/formatters/content_formatter.py

@@ -100,19 +100,9 @@ class ContentFormatter:
                 instructions += framework_content["actual_memories"]
                 instructions += "\n"
 
-            # Add agent memories if available
-            if framework_content.get("agent_memories"):
-                agent_memories = framework_content["agent_memories"]
-                if agent_memories:
-                    instructions += "\n\n## Agent Memories\n\n"
-                    instructions += "**The following are accumulated memories from specialized agents:**\n\n"
-
-                    for agent_name in sorted(agent_memories.keys()):
-                        memory_content = agent_memories[agent_name]
-                        if memory_content:
-                            instructions += f"### {agent_name.replace('_', ' ').title()} Agent Memory\n\n"
-                            instructions += memory_content
-                            instructions += "\n\n"
+            # NOTE: Agent memories are now injected at agent deployment time
+            # in agent_template_builder.py, not in PM instructions.
+            # This ensures each agent gets its own memory, not all memories embedded in PM.
 
             # Add dynamic agent capabilities section
             instructions += capabilities_section

claude_mpm/core/framework/loaders/agent_loader.py

@@ -115,7 +115,11 @@ class AgentLoader:
         return agents
 
     def discover_local_json_templates(self) -> Dict[str, Dict[str, Any]]:
-        """Discover local JSON agent templates from .claude-mpm/agents/ directories.
+        """Discover local JSON agent templates.
+
+        NOTE: This method is kept for backward compatibility but is deprecated.
+        The new architecture uses SOURCE (~/.claude-mpm/cache/remote-agents/)
+        and DEPLOYMENT (.claude/agents/) locations only.
 
         Returns:
             Dictionary mapping agent IDs to agent metadata
@@ -125,11 +129,10 @@ class AgentLoader:
         local_agents = {}
 
         # Check for local JSON templates in priority order
+        # NOTE: These directories are deprecated in the simplified architecture
         template_dirs = [
-            Path.cwd()
-            / ".claude-mpm"
-            / "agents",  # Project local agents (highest priority)
-            Path.home() / ".claude-mpm" / "agents",  # User local agents
+            Path.cwd() / ".claude-mpm" / "agents",  # Deprecated: Project local agents
+            Path.home() / ".claude-mpm" / "agents",  # Deprecated: User local agents
         ]
 
         for priority, template_dir in enumerate(template_dirs):

claude_mpm/core/framework_loader.py

@@ -255,10 +255,12 @@ class FrameworkLoader:
         """Load actual memories using the MemoryManager service."""
         memories = self._memory_manager.load_memories()
 
+        # Only load PM memories (PM.md)
+        # Agent memories are loaded at deployment time in agent_template_builder.py
         if "actual_memories" in memories:
             content["actual_memories"] = memories["actual_memories"]
-        if "agent_memories" in memories:
-            content["agent_memories"] = memories["agent_memories"]
+        # NOTE: agent_memories are no longer loaded for PM instructions
+        # They are injected per-agent at deployment time
 
     # === Agent Discovery Methods ===
 

claude_mpm/core/logger.py

@@ -175,6 +175,19 @@ def setup_logging(
     Returns:
         Configured logger
     """
+    # Detect deployment context for install-type-aware defaults
+    if level == "INFO":  # Only override default, not explicit settings
+        from claude_mpm.core.unified_paths import DeploymentContext, PathContext
+
+        context = PathContext.detect_deployment_context()
+        if context in (
+            DeploymentContext.DEVELOPMENT,
+            DeploymentContext.EDITABLE_INSTALL,
+        ):
+            level = "INFO"  # Development: verbose logging
+        else:
+            level = "OFF"  # Production installs: silent by default
+
     logger = logging.getLogger(name)
 
     # Handle OFF level

claude_mpm/core/socketio_pool.py

@@ -55,8 +55,8 @@ class CircuitState(Enum):
 class ConnectionStats:
     """Connection statistics for monitoring."""
 
-    created_at: datetime = field(default_factory=datetime.now)
-    last_used: datetime = field(default_factory=datetime.now)
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    last_used: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     events_sent: int = 0
     errors: int = 0
     consecutive_errors: int = 0
@@ -70,7 +70,7 @@ class BatchEvent:
     namespace: str
     event: str
     data: Dict[str, Any]
-    timestamp: datetime = field(default_factory=datetime.now)
+    timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
 
 
 class CircuitBreaker:

claude_mpm/core/unified_agent_registry.py

@@ -174,26 +174,16 @@ class UnifiedAgentRegistry:
         if project_path.exists():
             self.discovery_paths.append(project_path)
 
-        # Also check for local JSON templates in .claude-mpm/agents/
-        local_project_path = self.path_manager.project_root / ".claude-mpm" / "agents"
-        if (
-            local_project_path.exists()
-            and local_project_path not in self.discovery_paths
-        ):
-            self.discovery_paths.append(local_project_path)
-            logger.debug(f"Added local project templates path: {local_project_path}")
+        # NOTE: .claude-mpm/agents/ is deprecated in the simplified architecture
+        # Source agents come from ~/.claude-mpm/cache/remote-agents/
+        # Deployed agents go to .claude/agents/
 
-        # User-level agents
+        # User-level agents (deprecated in simplified architecture)
+        # Keeping for backward compatibility but not actively used
         user_path = self.path_manager.get_user_agents_dir()
         if user_path.exists():
             self.discovery_paths.append(user_path)
 
-        # Also check for user JSON templates in ~/.claude-mpm/agents/
-        local_user_path = Path.home() / ".claude-mpm" / "agents"
-        if local_user_path.exists() and local_user_path not in self.discovery_paths:
-            self.discovery_paths.append(local_user_path)
-            logger.debug(f"Added local user templates path: {local_user_path}")
-
         # System-level agents (includes templates as a subdirectory)
         system_path = self.path_manager.get_system_agents_dir()
         if system_path.exists():

claude_mpm/hooks/claude_hooks/correlation_manager.py

@@ -0,0 +1,60 @@
+"""Cross-process correlation storage using .claude-mpm directory."""
+
+import json
+import time
+from pathlib import Path
+
+
+def get_correlation_dir() -> Path:
+    """Get correlation directory in project's .claude-mpm folder."""
+    # Use CWD's .claude-mpm directory (where hooks run from)
+    cwd = Path.cwd()
+    return cwd / ".claude-mpm" / "correlations"
+
+
+TTL_SECONDS = 3600  # 1 hour
+
+
+class CorrelationManager:
+    """Manages correlation IDs across separate hook processes."""
+
+    @staticmethod
+    def store(session_id: str, tool_call_id: str, tool_name: str) -> None:
+        """Store correlation data for later retrieval by post_tool."""
+        correlation_dir = get_correlation_dir()
+        correlation_dir.mkdir(parents=True, exist_ok=True)
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        data = {
+            "tool_call_id": tool_call_id,
+            "tool_name": tool_name,
+            "timestamp": time.time(),
+        }
+        filepath.write_text(json.dumps(data))
+
+    @staticmethod
+    def retrieve(session_id: str) -> str | None:
+        """Retrieve and delete correlation data from temp file."""
+        correlation_dir = get_correlation_dir()
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        if not filepath.exists():
+            return None
+        try:
+            data = json.loads(filepath.read_text())
+            filepath.unlink()  # Delete after reading
+            return data.get("tool_call_id")
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    @staticmethod
+    def cleanup_old() -> None:
+        """Remove correlation files older than TTL."""
+        correlation_dir = get_correlation_dir()
+        if not correlation_dir.exists():
+            return
+        now = time.time()
+        for filepath in correlation_dir.glob("correlation_*.json"):
+            try:
+                if now - filepath.stat().st_mtime > TTL_SECONDS:
+                    filepath.unlink()
+            except OSError:
+                pass