claude-mpm 4.20.3__py3-none-any.whl → 4.25.10__py3-none-any.whl

claude_mpm/core/hook_manager.py

@@ -23,6 +23,7 @@ from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from ..core.logger import get_logger
+from .hook_error_memory import get_hook_error_memory
 from .hook_performance_config import get_hook_performance_config
 from .unified_paths import get_package_root
 
@@ -42,6 +43,9 @@ class HookManager:
         self.session_id = self._get_or_create_session_id()
         self.hook_handler_path = self._find_hook_handler()
 
+        # Initialize error memory for tracking and preventing repeated errors
+        self.error_memory = get_hook_error_memory()
+
         # Initialize background hook processing for async execution
         self.performance_config = get_hook_performance_config()
         queue_config = self.performance_config.get_queue_config()
@@ -97,11 +101,31 @@ class HookManager:
         self.logger.debug("Started background hook processor thread")
 
     def _execute_hook_sync(self, hook_data: Dict[str, Any]):
-        """Execute a single hook synchronously in the background thread."""
+        """Execute a single hook synchronously in the background thread with error detection.
+
+        WHY error detection:
+        - Prevents repeated execution of failing hooks
+        - Provides actionable error messages to users
+        - Learns from failures to improve system reliability
+        - Reduces log noise from repeated errors
+        """
         try:
             hook_type = hook_data["hook_type"]
             event_data = hook_data["event_data"]
 
+            # Check if this hook is known to fail repeatedly
+            if self.error_memory.should_skip_hook(hook_type):
+                known_error = self.error_memory.is_known_failing_hook(hook_type)
+                if known_error:
+                    # Log warning but don't spam - only on first skip
+                    if known_error["count"] == 2:  # First time we're skipping
+                        self.logger.warning(
+                            f"⚠️  Skipping {hook_type} hook - failed {known_error['count']} times previously\n"
+                            f"Error: {known_error['match']}\n"
+                            f"To retry: rm {self.error_memory.memory_file}"
+                        )
+                return
+
             # Create the hook event
             hook_event = {
                 "hook_event_name": hook_type,
@@ -127,7 +151,22 @@ class HookManager:
                 check=False,
             )
 
-            if result.returncode != 0:
+            # Detect errors in the output
+            error_info = self.error_memory.detect_error(
+                result.stdout or "", result.stderr or "", result.returncode
+            )
+
+            if error_info:
+                # Record the error
+                self.error_memory.record_error(error_info, hook_type)
+
+                # Get fix suggestion
+                suggestion = self.error_memory.suggest_fix(error_info)
+
+                # Log error with suggestion
+                self.logger.warning(f"Hook {hook_type} error detected:\n{suggestion}")
+            elif result.returncode != 0:
+                # Non-zero return without detected pattern
                 self.logger.debug(f"Hook {hook_type} returned code {result.returncode}")
                 if result.stderr:
                     self.logger.debug(f"Hook stderr: {result.stderr}")

claude_mpm/core/interactive_session.py

@@ -85,8 +85,8 @@ class InteractiveSession:
                     self.logger.warning(f"WebSocket initialization failed: {error}")
                     # Continue without WebSocket - not a fatal error
 
-            # Display welcome message
-            self._display_welcome_message()
+            # Banner now displayed in CLI startup - see startup_display.py
+            # Removed duplicate _display_welcome_message() to consolidate with main banner
 
             # Log session start
             if self.runner.project_logger:
@@ -293,7 +293,12 @@ class InteractiveSession:
             return False, f"Unexpected error with Socket.IO: {e}"
 
     def _display_welcome_message(self) -> None:
-        """Display the interactive session welcome message."""
+        """Display the interactive session welcome message.
+
+        DEPRECATED: This method is kept for backward compatibility with tests.
+        The main banner is now displayed in startup_display.py during CLI startup.
+        This consolidated approach prevents duplicate banners.
+        """
         version_str = self.runner._get_version()
 
         # Get output style status
@@ -383,6 +388,14 @@ class InteractiveSession:
             self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
             cmd.extend(self.runner.claude_args)
 
+        # Add --agents flag if native agents mode is enabled
+        if getattr(self.runner, "use_native_agents", False):
+            agents_flag = self._build_agents_flag()
+            if agents_flag:
+                # Add --agents JSON directly (already properly formatted)
+                cmd.extend(agents_flag)
+                self.logger.info("✓ Native agents mode: Using --agents CLI flag")
+
         # Add system instructions
         from claude_mpm.core.claude_runner import create_simple_context
 
@@ -402,6 +415,38 @@ class InteractiveSession:
 
         return cmd
 
+    def _build_agents_flag(self) -> Optional[list]:
+        """Build --agents flag with all MPM agents.
+
+        Returns:
+            List with ["--agents", "<json>"] or None if conversion fails
+        """
+        try:
+            from claude_mpm.services.native_agent_converter import NativeAgentConverter
+
+            converter = NativeAgentConverter()
+            agents = converter.load_agents_from_templates()
+
+            if not agents:
+                self.logger.warning("No agents loaded for native mode")
+                return None
+
+            # Generate JSON for --agents flag
+            agents_json = converter.generate_agents_json(agents)
+            summary = converter.get_conversion_summary(agents)
+
+            self.logger.info(
+                f"Native agents: {summary['total_agents']} agents, "
+                f"{summary['json_size_kb']} KB JSON"
+            )
+
+            # Return as list: ["--agents", "<json>"]
+            return ["--agents", agents_json]
+
+        except Exception as e:
+            self.logger.error(f"Failed to build --agents flag: {e}", exc_info=True)
+            return None
+
     def _prepare_environment(self) -> dict:
         """Prepare clean environment variables for Claude."""
         clean_env = os.environ.copy()

claude_mpm/core/interfaces.py

@@ -33,7 +33,62 @@ from pathlib import Path
 from typing import Any, Dict, Generic, List, Optional, Tuple, TypeVar
 
 # Re-export everything from the new location for backward compatibility
-from claude_mpm.services.core.interfaces import *
+from claude_mpm.services.core.interfaces import (  # noqa: F401
+    AgentCapabilitiesInterface,
+    AgentDeploymentInterface,
+    AgentMetadata,
+    CacheEntry,
+    CommandHandlerInterface,
+    HealthStatus,
+    HookServiceInterface,
+    IAgentRecommender,
+    IAgentRegistry,
+    IAutoConfigManager,
+    ICacheService,
+    IConfigurationManager,
+    IConfigurationService,
+    ICrashDetector,
+    IDeploymentStateManager,
+    IErrorHandler,
+    IEventBus,
+    IHealthCheck,
+    IHealthCheckManager,
+    IHealthMonitor,
+    ILocalProcessManager,
+    ILogMonitor,
+    IMemoryLeakDetector,
+    IModelProvider,
+    IModelRouter,
+    InterfaceRegistry,
+    IPerformanceMonitor,
+    IPromptCache,
+    IResourceMonitor,
+    IRestartManager,
+    IRestartPolicy,
+    IServiceContainer,
+    IServiceFactory,
+    IServiceLifecycle,
+    IStructuredLogger,
+    ITemplateManager,
+    IToolchainAnalyzer,
+    MemoryHookInterface,
+    MemoryServiceInterface,
+    ModelCapability,
+    ModelProvider,
+    ModelResponse,
+    ProjectAnalyzerInterface,
+    RunnerConfigurationInterface,
+    ServiceType,
+    SessionManagementInterface,
+    SocketIOServiceInterface,
+    SubprocessLauncherInterface,
+    SystemInstructionsInterface,
+    T,
+    TemplateRenderContext,
+    TicketManagerInterface,
+    UtilityServiceInterface,
+    VersionServiceInterface,
+)
 
 # Type variables for generic interfaces
 T = TypeVar("T")

claude_mpm/core/logger.py

@@ -225,7 +225,9 @@ def setup_logging(
 
             # Use rotating file handler
             file_handler = logging.handlers.RotatingFileHandler(
-                log_file, maxBytes=10 * 1024 * 1024, backupCount=5  # 10 MB
+                log_file,
+                maxBytes=10 * 1024 * 1024,
+                backupCount=5,  # 10 MB
             )
         else:
             # Use default log directory

claude_mpm/core/oneshot_session.py

@@ -268,8 +268,47 @@ class OneshotSession:
         if self.runner.claude_args:
             cmd.extend(self.runner.claude_args)
 
+        # Add --agents flag if native agents mode is enabled
+        if getattr(self.runner, "use_native_agents", False):
+            agents_flag = self._build_agents_flag()
+            if agents_flag:
+                cmd.extend(agents_flag)
+                self.logger.info("✓ Native agents mode: Using --agents CLI flag")
+
         return cmd
 
+    def _build_agents_flag(self) -> Optional[list]:
+        """Build --agents flag with all MPM agents.
+
+        Returns:
+            List with ["--agents", "<json>"] or None if conversion fails
+        """
+        try:
+            from claude_mpm.services.native_agent_converter import NativeAgentConverter
+
+            converter = NativeAgentConverter()
+            agents = converter.load_agents_from_templates()
+
+            if not agents:
+                self.logger.warning("No agents loaded for native mode")
+                return None
+
+            # Generate JSON for --agents flag
+            agents_json = converter.generate_agents_json(agents)
+            summary = converter.get_conversion_summary(agents)
+
+            self.logger.info(
+                f"Native agents: {summary['total_agents']} agents, "
+                f"{summary['json_size_kb']} KB JSON"
+            )
+
+            # Return as list: ["--agents", "<json>"]
+            return ["--agents", agents_json]
+
+        except Exception as e:
+            self.logger.error(f"Failed to build --agents flag: {e}", exc_info=True)
+            return None
+
     def _handle_successful_response(self, response: str, prompt: str) -> None:
         """Process a successful Claude response."""
         print(response)

claude_mpm/d2/.gitignore

@@ -0,0 +1,22 @@
+# Dependencies
+node_modules/
+package-lock.json
+
+# Build output
+dist/
+
+# Development
+.vite/
+.DS_Store
+*.log
+
+# Editor
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Temporary files
+*.tmp
+.cache/

claude_mpm/d2/ARCHITECTURE_COMPARISON.md

@@ -0,0 +1,273 @@
+# Before vs After: Store Architecture
+
+## The Problem (Before)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ Module Load Time (Outside Component Context)               │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  stores/socket.svelte.js                                    │
+│  ┌─────────────────────────────────────────────────────┐   │
+│  │ function createSocketStore() {                      │   │
+│  │   let connected = $state(false)         ❌ ERROR   │   │
+│  │   let statusText = $derived(...)        ❌ ERROR   │   │
+│  │                                                     │   │
+│  │   // Runes created outside component!              │   │
+│  │   // → effect_orphan error                         │   │
+│  │   // → App fails to mount                          │   │
+│  │   // → Black screen                                │   │
+│  │ }                                                   │   │
+│  │                                                     │   │
+│  │ export const socketStore = createSocketStore()     │   │
+│  │                              ▲                      │   │
+│  │                              │                      │   │
+│  │                        Called at import time!       │   │
+│  └─────────────────────────────────────────────────────┘   │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+                            │
+                            │
+                            ▼
+                     ❌ effect_orphan
+                     ❌ Black Screen
+                     ❌ No UI
+```
+
+## The Solution (After)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ Module Load Time (Outside Component Context)               │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  stores/socket.js                                           │
+│  ┌─────────────────────────────────────────────────────┐   │
+│  │ import { writable, derived } from 'svelte/store'    │   │
+│  │                                                     │   │
+│  │ function createSocketStore() {                      │   │
+│  │   const connected = writable(false)     ✅ OK      │   │
+│  │   const statusText = derived(...)       ✅ OK      │   │
+│  │                                                     │   │
+│  │   // Traditional stores work at module level!      │   │
+│  │   // → No effect_orphan error                      │   │
+│  │   // → App mounts successfully                     │   │
+│  │   // → UI renders                                  │   │
+│  │                                                     │   │
+│  │   return {                                          │   │
+│  │     connected: { subscribe: connected.subscribe }, │   │
+│  │     statusText: { subscribe: statusText.subscribe }│   │
+│  │   }                                                 │   │
+│  │ }                                                   │   │
+│  │                                                     │   │
+│  │ export const socketStore = createSocketStore()     │   │
+│  └─────────────────────────────────────────────────────┘   │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+                            │
+                            │
+                            ▼
+┌─────────────────────────────────────────────────────────────┐
+│ Component Context                                           │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  App.svelte                                                 │
+│  ┌─────────────────────────────────────────────────────┐   │
+│  │ <script>                                            │   │
+│  │   import { socketStore } from './stores/socket.js'  │   │
+│  │                                                     │   │
+│  │   // Auto-subscription with $ prefix               │   │
+│  │ </script>                                           │   │
+│  │                                                     │   │
+│  │ <Header                                             │   │
+│  │   statusText={$socketStore.statusText}  ✅ OK      │   │
+│  │   statusColor={$socketStore.statusColor} ✅ OK     │   │
+│  │ />                                                  │   │
+│  └─────────────────────────────────────────────────────┘   │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+                            │
+                            │
+                            ▼
+                     ✅ App renders
+                     ✅ Stores reactive
+                     ✅ UI updates
+```
+
+## Data Flow Comparison
+
+### Before (Broken)
+
+```
+┌──────────────┐
+│ Module Load  │
+└──────┬───────┘
+       │
+       ▼
+┌──────────────────────┐
+│ createSocketStore()  │
+│                      │
+│ $state() → ❌ FAIL  │ → effect_orphan error
+│ $derived() → ❌ FAIL│ → Black screen
+└──────────────────────┘
+```
+
+### After (Fixed)
+
+```
+┌──────────────┐
+│ Module Load  │
+└──────┬───────┘
+       │
+       ▼
+┌────────────────────────┐
+│ createSocketStore()    │
+│                        │
+│ writable() → ✅ Store │
+│ derived() → ✅ Store  │
+└────────┬───────────────┘
+         │
+         ▼
+┌─────────────────────┐
+│ Component Mounts    │
+└─────────┬───────────┘
+          │
+          ▼
+┌──────────────────────┐
+│ $ Auto-Subscription  │
+│                      │
+│ $store.value → ✅   │ → UI renders
+│                      │ → Reactive updates work
+└──────────────────────┘
+```
+
+## Code Comparison
+
+### Store Definition
+
+#### Before (socket.svelte.js)
+```javascript
+function createSocketStore() {
+  let connected = $state(false);           // ❌ Orphan effect
+  let statusText = $derived(               // ❌ Orphan effect
+    connected ? 'Connected' : 'Disconnected'
+  );
+
+  return {
+    get connected() { return connected; },
+    get statusText() { return statusText; }
+  };
+}
+```
+
+#### After (socket.js)
+```javascript
+import { writable, derived } from 'svelte/store';
+
+function createSocketStore() {
+  const connected = writable(false);       // ✅ Valid store
+  const statusText = derived(              // ✅ Valid store
+    connected,
+    ($connected) => $connected ? 'Connected' : 'Disconnected'
+  );
+
+  return {
+    connected: { subscribe: connected.subscribe },
+    statusText: { subscribe: statusText.subscribe }
+  };
+}
+```
+
+### Component Usage
+
+#### Before (App.svelte)
+```svelte
+<script>
+  import { socketStore } from './stores/socket.svelte.js';
+</script>
+
+<Header
+  statusText={socketStore.statusText}     <!-- ❌ Not reactive -->
+  statusColor={socketStore.statusColor}   <!-- ❌ Not reactive -->
+/>
+```
+
+#### After (App.svelte)
+```svelte
+<script>
+  import { socketStore } from './stores/socket.js';
+</script>
+
+<Header
+  statusText={$socketStore.statusText}    <!-- ✅ Reactive -->
+  statusColor={$socketStore.statusColor}  <!-- ✅ Reactive -->
+/>
+```
+
+## Reactivity Flow
+
+### Before (Broken)
+```
+User Action → Store Method → Rune Update → ❌ No Component Update
+                                          → ❌ UI Frozen
+```
+
+### After (Fixed)
+```
+User Action → Store Method → Store Update → Component Subscription
+                                          ↓
+                                   ✅ UI Updates Automatically
+```
+
+## Performance Impact
+
+| Metric | Before | After | Change |
+|--------|--------|-------|--------|
+| Build Time | N/A (failed) | 322ms | ✅ Working |
+| Bundle Size | N/A (failed) | 81KB | ✅ Optimal |
+| Runtime | Black screen | Normal | ✅ Fixed |
+| Memory | Orphaned effects | Clean | ✅ Improved |
+
+## Architecture Decision Matrix
+
+| Scenario | Use Runes | Use Stores | Why |
+|----------|-----------|------------|-----|
+| Component local state | ✅ | ❌ | Simpler syntax, fine-grained reactivity |
+| Module-level state | ❌ | ✅ | Avoids effect_orphan, proper lifecycle |
+| Shared between components | ❌ | ✅ | Subscribe pattern, broadcast updates |
+| Derived from props | ✅ | ❌ | Component-scoped, auto-cleanup |
+| Global app state | ❌ | ✅ | Module-level singleton required |
+
+## Migration Summary
+
+```
+Files Renamed:
+  socket.svelte.js  → socket.js
+  events.svelte.js  → events.js
+
+Imports Changed:
+  - import { writable, derived } from 'svelte/store'
+  + Uses traditional Svelte store API
+
+Store Creation:
+  - let x = $state(0)
+  + const x = writable(0)
+
+  - let y = $derived(x * 2)
+  + const y = derived(x, $x => $x * 2)
+
+Store Updates:
+  - x = 5
+  + x.set(5)
+
+  - x++
+  + x.update(n => n + 1)
+
+Component Usage:
+  - {store.value}
+  + {$store.value}
+```
+
+---
+
+**Summary**: Moving from Svelte 5 runes (component-scoped) to traditional Svelte stores (module-scoped) resolved the `effect_orphan` error and enabled proper reactive state management at the application level.