claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/core/oneshot_session.py

@@ -2,17 +2,32 @@
 
 This module encapsulates the logic for running one-time Claude commands,
 breaking down the monolithic run_oneshot method into focused, testable components.
+
+DEPENDENCY INJECTION:
+This module uses protocol-based dependency injection to break circular imports.
+Instead of importing ClaudeRunner directly, it uses ClaudeRunnerProtocol which
+defines the interface it needs.
 """
 
 import contextlib
 import os
 import subprocess
+import tempfile
 import time
 import uuid
-from typing import Any, Dict, Optional, Tuple
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
 
+from claude_mpm.core.enums import OperationResult, ServiceState
 from claude_mpm.core.logger import get_logger
 
+# Protocol imports for type checking without circular dependencies
+if TYPE_CHECKING:
+    from claude_mpm.core.protocols import ClaudeRunnerProtocol
+else:
+    # At runtime, accept any object with matching interface
+    ClaudeRunnerProtocol = Any
+
 
 class OneshotSession:
     """Manages a single oneshot Claude execution session.
@@ -24,17 +39,18 @@ class OneshotSession:
     complexity < 10 and lines < 80, making the code easier to test and modify.
     """
 
-    def __init__(self, runner):
+    def __init__(self, runner: "ClaudeRunnerProtocol"):
         """Initialize the oneshot session with a reference to the runner.
 
         Args:
-            runner: The ClaudeRunner instance that owns this session
+            runner: The ClaudeRunner instance (or any object matching ClaudeRunnerProtocol)
         """
-        self.runner = runner
+        self.runner: ClaudeRunnerProtocol = runner
         self.logger = get_logger("oneshot_session")
         self.start_time = None
         self.session_id = None
         self.original_cwd = None
+        self.temp_system_prompt_file = None
 
     def initialize_session(self, prompt: str) -> Tuple[bool, Optional[str]]:
         """Initialize the oneshot session.
@@ -97,7 +113,7 @@ class OneshotSession:
             infrastructure["env"]["CLAUDE_WORKSPACE"] = user_pwd
 
             try:
-                self.original_cwd = os.getcwd()
+                self.original_cwd = Path.cwd()
                 os.chdir(user_pwd)
                 infrastructure["working_dir_changed"] = True
                 self.logger.info(f"Changed working directory to: {user_pwd}")
@@ -132,7 +148,13 @@ class OneshotSession:
     def _build_final_command(
         self, prompt: str, context: Optional[str], infrastructure: Dict[str, Any]
     ) -> list:
-        """Build the final command with prompt and system instructions."""
+        """Build the final command with prompt and system instructions.
+
+        Uses file-based caching to avoid Linux ARG_MAX limits:
+        - Linux MAX_ARG_STRLEN: 128 KB per argument
+        - System prompt size: ~138.7 KB (exceeds limit by 7.7 KB)
+        - Solution: Write to temp file, pass file path (~60 bytes)
+        """
         full_prompt = f"{context}\n\n{prompt}" if context else prompt
         cmd = infrastructure["cmd"] + ["--print", full_prompt]
 
@@ -146,9 +168,38 @@ class OneshotSession:
                 self.logger.warning("System prompt contains Python code references!")
 
         if system_prompt and system_prompt != self._get_simple_context():
-            # The problem might be with insert positioning
-            # Let's add system prompt differently
-            cmd.extend(["--append-system-prompt", system_prompt])
+            # Use file-based loading to avoid ARG_MAX limits (1M-485)
+            # Create temp file for system prompt
+            try:
+                # Create temp file in system temp directory
+                temp_fd, temp_path = tempfile.mkstemp(
+                    suffix=".md", prefix="claude_mpm_system_prompt_"
+                )
+
+                # Write system prompt to temp file
+                with os.fdopen(temp_fd, "w", encoding="utf-8") as f:
+                    f.write(system_prompt)
+
+                # Store temp file path for cleanup
+                self.temp_system_prompt_file = temp_path
+
+                # Use --system-prompt-file flag (matches interactive mode pattern)
+                cmd.extend(["--system-prompt-file", temp_path])
+
+                # User-visible notification
+                print(f"📄 Reading system prompt from: {temp_path}")
+
+                self.logger.info(
+                    f"Using file-based system prompt loading: {temp_path} "
+                    f"({len(system_prompt) / 1024:.1f} KB)"
+                )
+
+            except Exception as e:
+                # Fallback to inline if file creation fails
+                self.logger.warning(
+                    f"Failed to create temp file for system prompt, using inline: {e}"
+                )
+                cmd.extend(["--append-system-prompt", system_prompt])
 
         return cmd
 
@@ -161,7 +212,7 @@ class OneshotSession:
 
         if self.runner.websocket_server:
             self.runner.websocket_server.claude_status_changed(
-                status="running", message="Executing Claude oneshot command"
+                status=ServiceState.RUNNING, message="Executing Claude oneshot command"
             )
 
     def _run_subprocess(
@@ -201,6 +252,20 @@ class OneshotSession:
 
     def cleanup_session(self) -> None:
         """Clean up the session and restore state."""
+        # Clean up temp system prompt file
+        if self.temp_system_prompt_file:
+            try:
+                temp_file_path = Path(self.temp_system_prompt_file)
+                if temp_file_path.exists():
+                    temp_file_path.unlink()
+                    self.logger.debug(
+                        f"Cleaned up temp system prompt file: {self.temp_system_prompt_file}"
+                    )
+            except Exception as e:
+                self.logger.warning(f"Failed to clean up temp system prompt file: {e}")
+            finally:
+                self.temp_system_prompt_file = None
+
         # Restore original working directory
         if self.original_cwd:
             with contextlib.suppress(Exception):
@@ -221,7 +286,7 @@ class OneshotSession:
         # End WebSocket session
         if self.runner.websocket_server:
             self.runner.websocket_server.claude_status_changed(
-                status="stopped", message="Session completed"
+                status=ServiceState.STOPPED, message="Session completed"
             )
             self.runner.websocket_server.session_ended()
 
@@ -242,7 +307,7 @@ class OneshotSession:
             self.runner.websocket_server.session_started(
                 session_id=self.session_id,
                 launch_method="oneshot",
-                working_dir=os.getcwd(),
+                working_dir=Path.cwd(),
             )
         except (ImportError, ConnectionError, Exception) as e:
             self.logger.warning(f"Socket.IO connection failed: {e}")
@@ -260,14 +325,53 @@ class OneshotSession:
 
     def _build_command(self) -> list:
         """Build the base Claude command."""
-        cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+        cmd = ["claude", "--dangerously-skip-permissions"]
 
         # Add custom arguments
         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)
@@ -298,7 +402,9 @@ class OneshotSession:
                 agent_name = self.runner._extract_agent_from_response(response)
                 if agent_name:
                     self.runner.websocket_server.agent_delegated(
-                        agent=agent_name, task=prompt[:100], status="detected"
+                        agent=agent_name,
+                        task=prompt[:100],
+                        status=OperationResult.PENDING,
                     )
 
         # Log completion
@@ -334,7 +440,8 @@ class OneshotSession:
         if self.runner.websocket_server:
             self.runner.websocket_server.claude_output(error_msg, "stderr")
             self.runner.websocket_server.claude_status_changed(
-                status="error", message=f"Command failed with code {return_code}"
+                status=ServiceState.ERROR,
+                message=f"Command failed with code {return_code}",
             )
 
         # Log error

claude_mpm/core/optimized_agent_loader.py

@@ -22,7 +22,7 @@ import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 try:
@@ -111,7 +111,7 @@ class OptimizedAgentLoader:
         try:
             mtime = file_path.stat().st_mtime
             return f"agent:{file_path}:{mtime}"
-        except:
+        except Exception:
             return f"agent:{file_path}"
 
     def _load_agent_file(self, file_path: Path) -> Optional[Dict[str, Any]]:
@@ -154,7 +154,7 @@ class OptimizedAgentLoader:
 
             # Add metadata
             agent_data["_file_path"] = str(file_path)
-            agent_data["_loaded_at"] = datetime.now().isoformat()
+            agent_data["_loaded_at"] = datetime.now(timezone.utc).isoformat()
 
             # Cache the result
             self.cache.put(cache_key, agent_data, ttl=self.cache_ttl)
@@ -188,7 +188,7 @@ class OptimizedAgentLoader:
                 data = yaml.safe_load(frontmatter) or {}
                 data["instructions"] = body
                 return data
-            except:
+            except Exception:
                 pass
 
         # No frontmatter, treat as pure instructions
@@ -236,7 +236,7 @@ class OptimizedAgentLoader:
 
         self.metrics.total_time = time.time() - start_time
 
-        self.logger.info(
+        self.logger.debug(
             f"Loaded {self.metrics.loaded_agents}/{self.metrics.total_agents} agents "
             f"in {self.metrics.total_time:.2f}s "
             f"(cache hits: {self.metrics.cache_hits}, misses: {self.metrics.cache_misses})"
@@ -286,7 +286,7 @@ class OptimizedAgentLoader:
 
         self.metrics.total_time = time.time() - start_time
 
-        self.logger.info(
+        self.logger.debug(
             f"Async loaded {self.metrics.loaded_agents}/{self.metrics.total_agents} agents "
             f"in {self.metrics.total_time:.2f}s"
         )
@@ -322,7 +322,7 @@ class OptimizedAgentLoader:
 
             # Add metadata
             agent_data["_file_path"] = str(file_path)
-            agent_data["_loaded_at"] = datetime.now().isoformat()
+            agent_data["_loaded_at"] = datetime.now(timezone.utc).isoformat()
 
             # Cache the result
             self.cache.put(cache_key, agent_data, ttl=self.cache_ttl)
@@ -366,7 +366,7 @@ class OptimizedAgentLoader:
                     "template": template,
                     "variables": self._extract_variables(template),
                     "sections": self._extract_sections(template),
-                    "compiled_at": datetime.now().isoformat(),
+                    "compiled_at": datetime.now(timezone.utc).isoformat(),
                 }
 
                 # Cache compiled template
@@ -418,7 +418,7 @@ class OptimizedAgentLoader:
         Args:
             agent_dirs: List of directories containing agents
         """
-        self.logger.info(f"Preloading agents from {len(agent_dirs)} directories")
+        self.logger.debug(f"Preloading agents from {len(agent_dirs)} directories")
 
         all_paths = []
         for dir_path in agent_dirs:

claude_mpm/core/optimized_startup.py

@@ -227,7 +227,7 @@ class OptimizedStartup:
         """Parse configuration file."""
         import yaml
 
-        with open(path) as f:
+        with path.open() as f:
             return yaml.safe_load(f) or {}
 
     def _store_config(self, config: Dict[str, Any]):

claude_mpm/core/output_style_manager.py

@@ -160,203 +160,23 @@ class OutputStyleManager:
 
     def extract_output_style_content(self, framework_loader=None) -> str:
         """
-        Extract output style content from framework instructions.
-
-        This extracts PM delegation behavior, tone, communication standards,
-        response formats, TodoWrite requirements, and workflow rules from:
-        - INSTRUCTIONS.md
-        - BASE_PM.md
+        Read output style content from OUTPUT_STYLE.md.
 
         Args:
-            framework_loader: Optional FrameworkLoader instance to reuse loaded content
+            framework_loader: Optional framework loader (kept for compatibility, not used)
 
         Returns:
-            Formatted output style content in YAML frontmatter + markdown format
+            Complete output style content from file
         """
-        # Build the content sections
-        sections = []
-
-        # Add YAML frontmatter
-        sections.append("---")
-        sections.append("name: Claude MPM")
-        sections.append(
-            "description: Multi-Agent Project Manager orchestration mode for delegation and coordination"
-        )
-        sections.append("---")
-        sections.append("")
-
-        # Header
-        sections.append(
-            "You are Claude Multi-Agent PM, a PROJECT MANAGER whose SOLE PURPOSE is to delegate work to specialized agents."
-        )
-        sections.append("")
-
-        # Extract from INSTRUCTIONS.md
-        if framework_loader and framework_loader.framework_content.get(
-            "framework_instructions"
-        ):
-            instructions = framework_loader.framework_content["framework_instructions"]
-            sections.extend(self._extract_instructions_sections(instructions))
-        else:
-            # Load from file if no framework_loader provided
-            instructions_path = (
-                Path(__file__).parent.parent / "agents" / "INSTRUCTIONS.md"
-            )
-            if instructions_path.exists():
-                instructions = instructions_path.read_text()
-                sections.extend(self._extract_instructions_sections(instructions))
-
-        # Extract from BASE_PM.md
-        if framework_loader and framework_loader.framework_content.get(
-            "base_pm_instructions"
-        ):
-            base_pm = framework_loader.framework_content["base_pm_instructions"]
-            sections.extend(self._extract_base_pm_sections(base_pm))
-        else:
-            # Load from file if no framework_loader provided
-            base_pm_path = Path(__file__).parent.parent / "agents" / "BASE_PM.md"
-            if base_pm_path.exists():
-                base_pm = base_pm_path.read_text()
-                sections.extend(self._extract_base_pm_sections(base_pm))
-
-        return "\n".join(sections)
-
-    def _extract_instructions_sections(self, content: str) -> list:
-        """Extract relevant sections from INSTRUCTIONS.md."""
-        sections = []
-
-        # Extract Primary Directive
-        if "## 🔴 PRIMARY DIRECTIVE" in content:
-            sections.append("## 🔴 PRIMARY DIRECTIVE - MANDATORY DELEGATION 🔴")
-            sections.append("")
-            sections.append(
-                "**YOU ARE STRICTLY FORBIDDEN FROM DOING ANY WORK DIRECTLY.**"
-            )
-            sections.append("")
-            sections.append(
-                "Direct implementation is ABSOLUTELY PROHIBITED unless the user EXPLICITLY overrides with phrases like:"
-            )
-            sections.append('- "do this yourself"')
-            sections.append('- "don\'t delegate"')
-            sections.append('- "implement directly"')
-            sections.append('- "you do it"')
-            sections.append('- "no delegation"')
-            sections.append("")
-
-        # Extract Core Identity and Rules
-        if "## Core Identity" in content:
-            sections.append("## Core Operating Rules")
-            sections.append("")
-            sections.append("**DEFAULT BEHAVIOR - ALWAYS DELEGATE**:")
-            sections.append(
-                "- 🔴 You MUST delegate 100% of ALL work to specialized agents by default"
-            )
-            sections.append(
-                "- 🔴 Direct action is STRICTLY FORBIDDEN without explicit user override"
-            )
-            sections.append(
-                "- 🔴 Even the simplest tasks MUST be delegated - NO EXCEPTIONS"
-            )
-            sections.append("- 🔴 When in doubt, ALWAYS DELEGATE - never act directly")
-            sections.append("")
-            sections.append("**Allowed Tools**:")
-            sections.append("- **Task** for delegation (YOUR PRIMARY FUNCTION)")
-            sections.append("- **TodoWrite** for tracking delegation progress ONLY")
-            sections.append(
-                "- **WebSearch/WebFetch** for gathering context BEFORE delegation"
-            )
-            sections.append(
-                "- **Direct answers** ONLY for questions about PM capabilities"
-            )
-            sections.append("")
-
-        # Extract Communication Standards
-        if "## Communication Standards" in content:
-            sections.append("## Communication Standards")
-            sections.append("")
-            sections.append("- **Tone**: Professional, neutral by default")
-            sections.append('- **Use**: "Understood", "Confirmed", "Noted"')
-            sections.append("- **No simplification** without explicit user request")
-            sections.append("- **No mocks** outside test environments")
-            sections.append("- **Complete implementations** only - no placeholders")
-            sections.append(
-                '- **FORBIDDEN**: Overeager enthusiasm ("Excellent!", "Perfect!", "Amazing!")'
-            )
-            sections.append("")
-
-        # Extract Error Handling
-        if "## Error Handling Protocol" in content:
-            sections.append("## Error Handling Protocol")
-            sections.append("")
-            sections.append("**3-Attempt Process**:")
-            sections.append("1. **First Failure**: Re-delegate with enhanced context")
-            sections.append(
-                '2. **Second Failure**: Mark "ERROR - Attempt 2/3", escalate if needed'
-            )
-            sections.append(
-                "3. **Third Failure**: TodoWrite escalation with user decision required"
-            )
-            sections.append("")
-
-        # Extract Standard Operating Procedure
-        if "## Standard Operating Procedure" in content:
-            sections.append("## Standard Operating Procedure")
-            sections.append("")
-            sections.append("1. **Analysis**: Parse request, assess context (NO TOOLS)")
-            sections.append(
-                "2. **Planning**: Agent selection, task breakdown, priority assignment"
-            )
-            sections.append("3. **Delegation**: Task Tool with enhanced format")
-            sections.append("4. **Monitoring**: Track progress via TodoWrite")
-            sections.append("5. **Integration**: Synthesize results, validate, report")
-            sections.append("")
-
-        return sections
-
-    def _extract_base_pm_sections(self, content: str) -> list:
-        """Extract relevant sections from BASE_PM.md."""
-        sections = []
-
-        # Extract TodoWrite Requirements
-        if "## TodoWrite Framework Requirements" in content:
-            sections.append("## TodoWrite Requirements")
-            sections.append("")
-            sections.append("### Mandatory [Agent] Prefix Rules")
-            sections.append("")
-            sections.append("**ALWAYS use [Agent] prefix for delegated tasks**:")
-            sections.append("- ✅ `[Research] Analyze authentication patterns`")
-            sections.append("- ✅ `[Engineer] Implement user registration`")
-            sections.append("- ✅ `[QA] Test payment flow`")
-            sections.append("- ✅ `[Documentation] Update API docs`")
-            sections.append("")
-            sections.append("**NEVER use [PM] prefix for implementation tasks**")
-            sections.append("")
-            sections.append("### Task Status Management")
-            sections.append("")
-            sections.append("- `pending` - Task not yet started")
-            sections.append(
-                "- `in_progress` - Currently being worked on (ONE at a time)"
-            )
-            sections.append("- `completed` - Task finished successfully")
-            sections.append("")
-
-        # Extract PM Response Format
-        if "## PM Response Format" in content:
-            sections.append("## Response Format")
-            sections.append("")
-            sections.append(
-                "When completing delegations, provide structured summaries including:"
-            )
-            sections.append("- Request summary")
-            sections.append("- Agents used and task counts")
-            sections.append("- Tasks completed with [Agent] prefixes")
-            sections.append("- Files affected across all agents")
-            sections.append("- Blockers encountered and resolutions")
-            sections.append("- Next steps for user")
-            sections.append("- Key information to remember")
-            sections.append("")
-
-        return sections
+        # Always read from the complete OUTPUT_STYLE.md file
+        if self.mpm_output_style_path.exists():
+            content = self.mpm_output_style_path.read_text()
+            self.logger.info(f"Read OUTPUT_STYLE.md directly ({len(content)} chars)")
+            return content
+        # Fallback error
+        error_msg = f"OUTPUT_STYLE.md not found at {self.mpm_output_style_path}"
+        self.logger.error(error_msg)
+        raise FileNotFoundError(error_msg)
 
     def save_output_style(self, content: str) -> Path:
         """

claude_mpm/core/pm_hook_interceptor.py

@@ -14,7 +14,7 @@ WHY this is needed:
 import functools
 import threading
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 from ..core.hook_manager import get_hook_manager
@@ -139,10 +139,13 @@ class PMHookInterceptor:
 
         # Look for todos in positional args
         for arg in args:
-            if isinstance(arg, list) and arg and isinstance(arg[0], dict):
-                # Check if this looks like a todos list
-                if "content" in arg[0] or "id" in arg[0]:
-                    return arg
+            if (
+                isinstance(arg, list)
+                and arg
+                and isinstance(arg[0], dict)
+                and ("content" in arg[0] or "id" in arg[0])
+            ):
+                return arg
 
         return []
 
@@ -168,11 +171,14 @@ class PMHookInterceptor:
         # Update positional args if todos was passed positionally
         args_list = list(args)
         for i, arg in enumerate(args_list):
-            if isinstance(arg, list) and arg and isinstance(arg[0], dict):
-                # Check if this looks like a todos list
-                if "content" in arg[0] or "id" in arg[0]:
-                    args_list[i] = modified_todos
-                    return tuple(args_list), kwargs
+            if (
+                isinstance(arg, list)
+                and arg
+                and isinstance(arg[0], dict)
+                and ("content" in arg[0] or "id" in arg[0])
+            ):
+                args_list[i] = modified_todos
+                return tuple(args_list), kwargs
 
         # If we can't find where todos was passed, add as keyword argument
         kwargs = kwargs.copy()
@@ -195,7 +201,7 @@ class PMHookInterceptor:
                 {
                     "todos": todos,
                     "source": "PM_Manual",
-                    "timestamp": datetime.utcnow().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                 },
             )
 
@@ -210,7 +216,7 @@ class PMHookInterceptor:
                     "todos_count": len(todos),
                     "source": "PM_Manual",
                     "success": True,
-                    "timestamp": datetime.utcnow().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                 },
             )
 

claude_mpm/core/protocols/__init__.py

@@ -0,0 +1,23 @@
+"""Protocol interfaces for dependency injection.
+
+This module defines Protocol interfaces to break circular dependencies
+using Python's typing.Protocol feature for structural subtyping.
+"""
+
+from claude_mpm.core.protocols.runner_protocol import (
+    ClaudeRunnerProtocol,
+    SystemPromptProvider,
+)
+from claude_mpm.core.protocols.session_protocol import (
+    InteractiveSessionProtocol,
+    OneshotSessionProtocol,
+    SessionManagementProtocol,
+)
+
+__all__ = [
+    "ClaudeRunnerProtocol",
+    "InteractiveSessionProtocol",
+    "OneshotSessionProtocol",
+    "SessionManagementProtocol",
+    "SystemPromptProvider",
+]