claude-mpm 5.4.95__py3-none-any.whl → 5.4.97__py3-none-any.whl

claude_mpm/cli/executor.py

@@ -237,6 +237,92 @@ def execute_command(command: str, args) -> int:
             print(f"Unknown hook-errors subcommand: {subcommand}")
             return 1
 
+    # Handle autotodos command with lazy import
+    if command == "autotodos":
+        # Lazy import to avoid loading unless needed
+        from .commands.autotodos import (
+            clear_autotodos,
+            inject_autotodos,
+            list_autotodos,
+            list_pm_violations,
+            scan_delegation_patterns,
+            show_autotodos_status,
+        )
+
+        # Get subcommand
+        subcommand = getattr(args, "autotodos_command", "status")
+        if not subcommand:
+            subcommand = "status"
+
+        # Map subcommands to functions
+        handlers = {
+            "list": list_autotodos,
+            "inject": inject_autotodos,
+            "clear": clear_autotodos,
+            "status": show_autotodos_status,
+            "scan": scan_delegation_patterns,
+            "violations": list_pm_violations,
+        }
+
+        # Get handler and call it with standalone_mode=False
+        handler = handlers.get(subcommand)
+        if handler:
+            try:
+                # Build argument list for Click command
+                click_args = []
+
+                if subcommand == "list":
+                    fmt = getattr(args, "format", "table")
+                    click_args = ["--format", fmt]
+                elif subcommand == "inject":
+                    output = getattr(args, "output", None)
+                    if output:
+                        click_args = ["--output", output]
+                elif subcommand == "clear":
+                    error_key = getattr(args, "error_key", None)
+                    event_type = getattr(args, "event_type", "all")
+                    if error_key:
+                        click_args.append("--error-key")
+                        click_args.append(error_key)
+                    if event_type != "all":
+                        click_args.append("--event-type")
+                        click_args.append(event_type)
+                    if getattr(args, "yes", False):
+                        click_args.append("-y")
+                elif subcommand == "scan":
+                    text = getattr(args, "text", None)
+                    file = getattr(args, "file", None)
+                    fmt = getattr(args, "format", "table")
+                    save = getattr(args, "save", False)
+
+                    if text:
+                        click_args.append(text)
+                    if file:
+                        click_args.extend(["--file", file])
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+                    if save:
+                        click_args.append("--save")
+                elif subcommand == "violations":
+                    fmt = getattr(args, "format", "table")
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
+                return 0
+            except SystemExit as e:
+                return e.code if e.code is not None else 0
+            except Exception as e:
+                print(f"Error: {e}")
+                import traceback
+
+                traceback.print_exc()
+                return 1
+        else:
+            print(f"Unknown autotodos subcommand: {subcommand}")
+            return 1
+
     # Map stable commands to their implementations
     command_map = {
         CLICommands.RUN.value: run_session,
@@ -287,6 +373,8 @@ def execute_command(command: str, args) -> int:
         "local-deploy",
         "skill-source",
         "agent-source",
+        "hook-errors",
+        "autotodos",
     ]
 
     suggestion = suggest_similar_commands(command, all_commands)

claude_mpm/cli/parsers/base_parser.py

@@ -125,7 +125,7 @@ def _get_enhanced_version(base_version: str) -> str:
 
         if enhanced and enhanced != base_version:
             return enhanced
-    except Exception:
+    except Exception:  # nosec B110
         # If anything fails, fall back to base version
         pass
 
@@ -607,6 +607,59 @@ def create_parser(
             help="Skip confirmation prompts",
         )
 
+        # Add autotodos command for auto-generating todos from hook errors
+        autotodos_parser = subparsers.add_parser(
+            "autotodos",
+            help="Auto-generate todos from hook errors and delegation patterns",
+        )
+        autotodos_parser.add_argument(
+            "autotodos_command",
+            nargs="?",
+            choices=["list", "inject", "clear", "status", "scan", "violations"],
+            help="AutoTodos subcommand",
+        )
+        autotodos_parser.add_argument(
+            "text",
+            nargs="?",
+            help="Text to scan for delegation patterns (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "--format",
+            choices=["table", "json"],
+            default="table",
+            help="Output format for list/scan commands",
+        )
+        autotodos_parser.add_argument(
+            "--output",
+            help="Output file path for inject command",
+        )
+        autotodos_parser.add_argument(
+            "--error-key",
+            help="Specific error key to clear",
+        )
+        autotodos_parser.add_argument(
+            "--event-type",
+            choices=["error", "violation", "all"],
+            default="all",
+            help="Type of events to clear (clear command only)",
+        )
+        autotodos_parser.add_argument(
+            "--file",
+            "-f",
+            help="Scan text from file (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "--save",
+            action="store_true",
+            help="Save detections to event log (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "-y",
+            "--yes",
+            action="store_true",
+            help="Skip confirmation prompts",
+        )
+
         # Add summarize command
         from ..commands.summarize import add_summarize_parser
 

claude_mpm/cli/startup.py

@@ -191,7 +191,8 @@ def should_skip_background_services(args, processed_argv):
     skip_commands = ["--version", "-v", "--help", "-h"]
     return any(cmd in (processed_argv or sys.argv[1:]) for cmd in skip_commands) or (
         hasattr(args, "command")
-        and args.command in ["info", "doctor", "config", "mcp", "configure"]
+        and args.command
+        in ["info", "doctor", "config", "mcp", "configure", "hook-errors", "autotodos"]
     )
 
 
@@ -315,7 +316,7 @@ def deploy_output_style_on_startup():
     Deploys all styles:
     - claude-mpm.md (professional mode)
     - claude-mpm-teacher.md (teaching mode)
-    - claude-mpm-founders.md (founders mode)
+    - claude-mpm-research.md (research mode - for codebase analysis)
     """
     try:
         from ..core.output_style_manager import OutputStyleManager

claude_mpm/core/hook_manager.py

@@ -16,13 +16,15 @@ import contextlib
 import json
 import os
 import queue
-import subprocess
+import subprocess  # nosec B404
 import threading
 import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from ..core.logger import get_logger
+from ..services.event_bus.event_bus import EventBus
+from ..services.event_log import get_event_log
 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
@@ -46,6 +48,10 @@ class HookManager:
         # Initialize error memory for tracking and preventing repeated errors
         self.error_memory = get_hook_error_memory()
 
+        # Initialize event log and event bus for event-driven architecture
+        self.event_log = get_event_log()
+        self.event_bus = EventBus.get_instance()
+
         # Initialize background hook processing for async execution
         self.performance_config = get_hook_performance_config()
         queue_config = self.performance_config.get_queue_config()
@@ -100,6 +106,45 @@ class HookManager:
         self.background_thread.start()
         self.logger.debug("Started background hook processor thread")
 
+    def _publish_error_event(
+        self, hook_type: str, error_info: Dict[str, str], suggestion: str
+    ):
+        """Publish hook error event to event log and event bus.
+
+        WHY publish events:
+        - Decouple error detection from error handling
+        - Enable autotodos CLI to read from persistent event log
+        - Support real-time notifications via event bus
+        - Maintain audit trail of all hook errors
+
+        Args:
+            hook_type: Type of hook that failed
+            error_info: Error information from error detection
+            suggestion: Fix suggestion from error memory
+        """
+        try:
+            # Prepare event payload
+            payload = {
+                "error_type": error_info["type"],
+                "hook_type": hook_type,
+                "details": error_info.get("details", ""),
+                "full_message": error_info.get("match", ""),
+                "suggested_fix": suggestion,
+                "source": "hook_manager",
+            }
+
+            # Publish to event log (persistent storage)
+            self.event_log.append_event(
+                event_type="autotodo.error", payload=payload, status="pending"
+            )
+
+            # Publish to event bus (real-time listeners)
+            self.event_bus.publish("autotodo.error", payload)
+
+        except Exception as e:
+            # Don't let event publishing break hook processing
+            self.logger.debug(f"Failed to publish error event: {e}")
+
     def _execute_hook_sync(self, hook_data: Dict[str, Any]):
         """Execute a single hook synchronously in the background thread with error detection.
 
@@ -141,7 +186,7 @@ class HookManager:
             env["CLAUDE_MPM_HOOK_DEBUG"] = "true"
 
             # Execute with timeout in background thread
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["python", str(self.hook_handler_path)],
                 input=event_json,
                 text=True,
@@ -157,7 +202,7 @@ class HookManager:
             )
 
             if error_info:
-                # Record the error
+                # Record the error in memory (for skipping repeated failures)
                 self.error_memory.record_error(error_info, hook_type)
 
                 # Get fix suggestion
@@ -165,6 +210,9 @@ class HookManager:
 
                 # Log error with suggestion
                 self.logger.warning(f"Hook {hook_type} error detected:\n{suggestion}")
+
+                # Publish event to event log for autotodos processing
+                self._publish_error_event(hook_type, error_info, suggestion)
             elif result.returncode != 0:
                 # Non-zero return without detected pattern
                 self.logger.debug(f"Hook {hook_type} returned code {result.returncode}")

claude_mpm/core/output_style_manager.py

@@ -27,7 +27,9 @@ _CACHED_CLAUDE_VERSION: Optional[str] = None
 _VERSION_DETECTED: bool = False
 
 # Output style types
-OutputStyleType = Literal["professional", "teaching", "founders"]
+OutputStyleType = Literal[
+    "professional", "teaching", "research", "founders"
+]  # "founders" is deprecated, use "research"
 
 
 class StyleConfig(TypedDict):
@@ -44,7 +46,7 @@ class OutputStyleManager:
     Supports three output styles:
     - professional: Default Claude MPM style (claude-mpm.md)
     - teaching: Adaptive teaching mode (claude-mpm-teacher.md)
-    - founders: Non-technical mode for startup founders (claude-mpm-founders.md)
+    - research: Codebase research mode for founders, PMs, and developers (claude-mpm-research.md)
     """
 
     def __init__(self) -> None:
@@ -72,12 +74,20 @@ class OutputStyleManager:
                 target=self.output_style_dir / "claude-mpm-teacher.md",
                 name="Claude MPM Teacher",
             ),
+            "research": StyleConfig(
+                source=Path(__file__).parent.parent
+                / "agents"
+                / "CLAUDE_MPM_RESEARCH_OUTPUT_STYLE.md",
+                target=self.output_style_dir / "claude-mpm-research.md",
+                name="Claude MPM Research",
+            ),
+            # Backward compatibility alias (deprecated)
             "founders": StyleConfig(
                 source=Path(__file__).parent.parent
                 / "agents"
-                / "CLAUDE_MPM_FOUNDERS_OUTPUT_STYLE.md",
-                target=self.output_style_dir / "claude-mpm-founders.md",
-                name="Claude MPM Founders",
+                / "CLAUDE_MPM_RESEARCH_OUTPUT_STYLE.md",
+                target=self.output_style_dir / "claude-mpm-research.md",
+                name="Claude MPM Research",
             ),
         }
 

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -851,6 +851,7 @@ class EventHandlers:
         - Captures response content and metadata for analysis
         - Enables tracking of conversation flow and response patterns
         - Essential for comprehensive monitoring of Claude interactions
+        - Scans for delegation anti-patterns and creates autotodos
         """
         # Track the response for logging
         try:
@@ -862,6 +863,13 @@ class EventHandlers:
             # Response tracking is optional
             pass
 
+        # Scan response for delegation anti-patterns and create autotodos
+        try:
+            self._scan_for_delegation_patterns(event)
+        except Exception as e:  # nosec B110
+            if DEBUG:
+                print(f"Delegation scanning error: {e}", file=sys.stderr)
+
         # Get working directory and git branch
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
@@ -1012,3 +1020,74 @@ class EventHandlers:
         self.hook_handler._emit_socketio_event(
             "", "subagent_start", subagent_start_data
         )
+
+    def _scan_for_delegation_patterns(self, event):
+        """Scan assistant response for delegation anti-patterns.
+
+        WHY this is needed:
+        - Detect when PM asks user to do something manually instead of delegating
+        - Flag PM behavior violations for immediate correction
+        - Enforce delegation principle in PM workflow
+        - Help PM recognize delegation opportunities
+
+        This method scans the assistant's response text for patterns like:
+        - "Make sure .env.local is in your .gitignore"
+        - "You'll need to run npm install"
+        - "Please run the tests manually"
+
+        When patterns are detected, PM violations are logged as errors/warnings
+        that should be corrected immediately, NOT as todos to delegate.
+
+        DESIGN DECISION: pm.violation vs autotodo.delegation
+        - Delegation patterns = PM doing something WRONG → pm.violation (error)
+        - Script failures = Something BROKEN → autotodo.error (todo)
+        """
+        # Only scan if delegation detector is available
+        try:
+            from claude_mpm.services.delegation_detector import get_delegation_detector
+            from claude_mpm.services.event_log import get_event_log
+        except ImportError:
+            if DEBUG:
+                print("Delegation detector or event log not available", file=sys.stderr)
+            return
+
+        response_text = event.get("response", "")
+        if not response_text:
+            return
+
+        # Get the delegation detector
+        detector = get_delegation_detector()
+
+        # Detect delegation patterns
+        detections = detector.detect_user_delegation(response_text)
+
+        if not detections:
+            return  # No patterns detected
+
+        # Get event log for violation recording
+        event_log = get_event_log()
+
+        # Create PM violation events (NOT autotodos)
+        for detection in detections:
+            # Create event log entry as pm.violation
+            event_log.append_event(
+                event_type="pm.violation",
+                payload={
+                    "violation_type": "delegation_anti_pattern",
+                    "pattern_type": detection["pattern_type"],
+                    "original_text": detection["original_text"],
+                    "suggested_action": detection["suggested_todo"],
+                    "action": detection["action"],
+                    "session_id": event.get("session_id", ""),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "severity": "warning",  # Not critical, but should be fixed
+                    "message": f"PM asked user to do something manually: {detection['original_text'][:80]}...",
+                },
+                status="pending",
+            )
+
+            if DEBUG:
+                print(
+                    f"⚠️  PM violation detected: {detection['original_text'][:60]}...",
+                    file=sys.stderr,
+                )

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -22,7 +22,7 @@ import os
 import re
 import select
 import signal
-import subprocess
+import subprocess  # nosec B404
 import sys
 import threading
 from datetime import datetime, timezone
@@ -155,7 +155,7 @@ def check_claude_version() -> Tuple[bool, Optional[str]]:
     """
     try:
         # Try to detect Claude Code version
-        result = subprocess.run(  # nosec B603 - Safe: hardcoded claude CLI with --version flag, no user input
+        result = subprocess.run(  # nosec B603 B607 - Safe: hardcoded claude CLI with --version flag, no user input
             ["claude", "--version"],
             capture_output=True,
             text=True,
@@ -246,7 +246,8 @@ class ClaudeHookHandler:
                 print(f"Auto-pause initialization failed: {e}", file=sys.stderr)
 
         # Backward compatibility properties for tests
-        self.connection_pool = self.connection_manager.connection_pool
+        # Note: HTTP-based connection manager doesn't use connection_pool
+        self.connection_pool = None  # Deprecated: No longer needed with HTTP emission
 
         # Expose state manager properties for backward compatibility
         self.active_delegations = self.state_manager.active_delegations

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -7,9 +7,14 @@ This service manages:
 DESIGN DECISION: Use stateless HTTP POST instead of persistent SocketIO
 connections because hook handlers are ephemeral processes (< 1 second lifetime).
 This eliminates disconnection issues and matches the process lifecycle.
+
+DESIGN DECISION: Synchronous HTTP POST only (no async)
+Hook handlers are too short-lived (~25ms lifecycle) to benefit from async.
+Using asyncio.run() creates event loops that close before HTTP operations complete,
+causing "Event loop is closed" errors. Synchronous HTTP POST in a thread pool
+is simpler and more reliable for ephemeral processes.
 """
 
-import asyncio
 import os
 import sys
 from concurrent.futures import ThreadPoolExecutor
@@ -27,9 +32,6 @@ except ImportError:
     REQUESTS_AVAILABLE = False
     requests = None
 
-# Import high-performance event emitter - lazy loaded in _async_emit()
-# to reduce hook handler initialization time by ~85% (792ms -> minimal)
-
 # Import EventNormalizer for consistent event formatting
 try:
     from claude_mpm.services.socketio.event_normalizer import EventNormalizer
@@ -55,10 +57,6 @@ except ImportError:
             )
 
 
-# EventBus removed - using direct HTTP POST only
-# This eliminates duplicate events and simplifies the architecture
-
-
 class ConnectionManagerService:
     """Manages connections for the Claude hook handler using HTTP POST."""
 
@@ -72,17 +70,9 @@ class ConnectionManagerService:
         self.server_port = int(os.environ.get("CLAUDE_MPM_SERVER_PORT", "8765"))
         self.http_endpoint = f"http://{self.server_host}:{self.server_port}/api/events"
 
-        # EventBus removed - using direct HTTP POST only
-
-        # For backward compatibility with tests
-        self.connection_pool = None  # No longer used
-
-        # Track async emit tasks to prevent garbage collection
-        self._emit_tasks: set = set()
-
         # Thread pool for non-blocking HTTP requests
         # WHY: Prevents HTTP POST from blocking hook processing (2s timeout → 0ms blocking)
-        # max_workers=2: Sufficient for low-frequency HTTP fallback events
+        # max_workers=2: Sufficient for low-frequency hook events
         self._http_executor = ThreadPoolExecutor(
             max_workers=2, thread_name_prefix="http-emit"
         )
@@ -94,13 +84,13 @@ class ConnectionManagerService:
             )
 
     def emit_event(self, namespace: str, event: str, data: dict):
-        """Emit event using high-performance async emitter with HTTP fallback.
+        """Emit event using HTTP POST.
 
-        WHY Hybrid approach:
-        - Direct async calls for ultra-low latency in-process events
-        - HTTP POST fallback for cross-process communication
-        - Connection pooling for memory protection
-        - Automatic routing based on availability
+        WHY HTTP POST only:
+        - Hook handlers are ephemeral (~25ms lifecycle)
+        - Async emission causes "Event loop is closed" errors
+        - HTTP POST in thread pool is simpler and more reliable
+        - Completes in 20-50ms, which is acceptable for hook handlers
         """
         # Create event data for normalization
         raw_event = {
@@ -132,62 +122,9 @@ class ConnectionManagerService:
                     file=sys.stderr,
                 )
 
-        # Try high-performance async emitter first (direct calls)
-        success = self._try_async_emit(namespace, event, claude_event_data)
-        if success:
-            return
-
-        # Fallback to HTTP POST for cross-process communication
+        # Emit via HTTP POST (non-blocking, runs in thread pool)
         self._try_http_emit(namespace, event, claude_event_data)
 
-    def _try_async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Try to emit event using high-performance async emitter."""
-        try:
-            # Run async emission in the current event loop or create one
-            loop = None
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                # No running loop, create a new one
-                pass
-
-            if loop:
-                # We're in an async context, create a task with tracking
-                task = loop.create_task(self._async_emit(namespace, event, data))
-                self._emit_tasks.add(task)
-                task.add_done_callback(self._emit_tasks.discard)
-                # Don't wait for completion to maintain low latency
-                if DEBUG:
-                    print(f"✅ Async emit scheduled: {event}", file=sys.stderr)
-                return True
-            # No event loop, run synchronously
-            success = asyncio.run(self._async_emit(namespace, event, data))
-            if DEBUG and success:
-                print(f"✅ Async emit successful: {event}", file=sys.stderr)
-            return success
-
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emit failed: {e}", file=sys.stderr)
-            return False
-
-    async def _async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Async helper for event emission."""
-        try:
-            # Lazy load event emitter to reduce initialization overhead
-            from claude_mpm.services.monitor.event_emitter import get_event_emitter
-
-            emitter = await get_event_emitter()
-            return await emitter.emit_event(namespace, "claude_event", data)
-        except ImportError:
-            if DEBUG:
-                print("⚠️ Event emitter not available", file=sys.stderr)
-            return False
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emitter error: {e}", file=sys.stderr)
-            return False
-
     def _try_http_emit(self, namespace: str, event: str, data: dict):
         """Try to emit event using HTTP POST fallback (non-blocking).