stravinsky 0.2.40__py3-none-any.whl → 0.2.67__py3-none-any.whl

mcp_bridge/hooks/git_noninteractive.py

@@ -0,0 +1,89 @@
+"""
+Git Non-Interactive Environment Hook.
+
+Prevents git interactive command hangs by prepending environment variables.
+"""
+
+import logging
+import re
+import shlex
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+# Patterns for banned interactive git commands
+BANNED_INTERACTIVE_PATTERNS = [
+    r"git\s+add\s+.*-p",  # git add -p (patch mode)
+    r"git\s+add\s+.*--patch",
+    r"git\s+commit\s+.*-v",  # git commit -v (verbose with diff)
+    r"git\s+rebase\s+.*-i",  # git rebase -i (interactive)
+    r"git\s+rebase\s+.*--interactive",
+    r"git\s+add\s+.*-i",  # git add -i (interactive)
+    r"git\s+add\s+.*--interactive",
+    r"git\s+checkout\s+.*-p",  # git checkout -p (patch mode)
+    r"git\s+reset\s+.*-p",  # git reset -p (patch mode)
+]
+
+# Environment variables to set for non-interactive git
+NON_INTERACTIVE_ENV = {
+    "GIT_TERMINAL_PROMPT": "0",
+    "GIT_EDITOR": "true",  # No-op editor
+    "GIT_PAGER": "cat",  # No paging
+}
+
+
+def escape_shell_arg(arg: str) -> str:
+    """
+    Escape shell argument for safe injection.
+    """
+    # Use shlex.quote for proper escaping
+    return shlex.quote(arg)
+
+
+async def git_noninteractive_hook(
+    tool_name: str, arguments: Dict[str, Any]
+) -> Optional[Dict[str, Any]]:
+    """
+    Pre-tool-call hook that prepends non-interactive env vars to git commands.
+
+    Detects interactive git commands and either:
+    1. Warns and blocks them (if highly interactive like -i)
+    2. Prepends env vars to make them non-interactive
+    """
+    # Only process Bash tool
+    if tool_name != "Bash":
+        return None
+
+    command = arguments.get("command", "")
+    if not command or "git" not in command.lower():
+        return None
+
+    # Check for banned interactive patterns
+    for pattern in BANNED_INTERACTIVE_PATTERNS:
+        if re.search(pattern, command, re.IGNORECASE):
+            logger.warning(
+                f"[GitNonInteractive] Detected interactive git command: {pattern}"
+            )
+            # Add warning to command output
+            warning = (
+                f"\n[WARNING] Interactive git command detected: {command}\n"
+                f"This may hang. Consider using non-interactive alternatives.\n"
+            )
+            # Don't block, just warn - user might know what they're doing
+            return None
+
+    # Prepend environment variables to make git non-interactive
+    if "git" in command.lower():
+        env_prefix = " ".join(
+            [f"{k}={escape_shell_arg(v)}" for k, v in NON_INTERACTIVE_ENV.items()]
+        )
+        modified_command = f"{env_prefix} {command}"
+
+        logger.info(f"[GitNonInteractive] Prepending non-interactive env vars to git command")
+
+        # Return modified arguments
+        modified_args = arguments.copy()
+        modified_args["command"] = modified_command
+        return modified_args
+
+    return None

mcp_bridge/hooks/keyword_detector.py

@@ -84,11 +84,41 @@ IF COMPLEX (architecture, multi-system, debugging after 2+ failures):
 SYNTHESIZE findings before proceeding.
 """
 
+ULTRATHINK_MODE = """[ultrathink-mode]
+ENGAGE MAXIMUM REASONING CAPACITY.
+
+Extended thinking mode activated with 32k token thinking budget.
+This enables exhaustive deep reasoning and multi-dimensional analysis.
+
+## REASONING PRINCIPLES
+- **Deep Analysis**: Consider edge cases, security implications, performance impacts
+- **Multi-Perspective**: Analyze from user, developer, system, and security viewpoints
+- **Strategic Planning**: Consult delphi agent for architecture decisions and hard problems
+- **Root Cause**: Don't treat symptoms - identify and address underlying causes
+- **Risk Assessment**: Evaluate trade-offs, failure modes, and mitigation strategies
+
+## THINKING WORKFLOW
+1. Problem decomposition into atomic components
+2. Parallel exploration of solution space (spawn agents for research)
+3. Consult delphi for strategic guidance on complex decisions
+4. Multi-dimensional trade-off analysis
+5. Solution synthesis with verification plan
+
+## VERIFICATION
+- Test assumptions against reality
+- Challenge your own reasoning
+- Seek disconfirming evidence
+- Consider second-order effects
+
+Use delphi agent for strategic consultation on architecture, debugging, and complex trade-offs.
+"""
+
 KEYWORD_PATTERNS = {
     r"\bironstar\b": IRONSTAR_MODE,
     r"\birs\b": IRONSTAR_MODE,
     r"\bultrawork\b": IRONSTAR_MODE,
     r"\bulw\b": IRONSTAR_MODE,
+    r"\bultrathink\b": ULTRATHINK_MODE,
     r"\bsearch\b": SEARCH_MODE,
     r"\banalyze\b": ANALYZE_MODE,
     r"\banalysis\b": ANALYZE_MODE,

mcp_bridge/hooks/manager.py

@@ -12,6 +12,13 @@ logger = logging.getLogger(__name__)
 class HookManager:
     """
     Manages the registration and execution of hooks.
+
+    Hook Types:
+    - pre_tool_call: Before tool execution (can modify args or block)
+    - post_tool_call: After tool execution (can modify output)
+    - pre_model_invoke: Before model invocation (can modify prompt/params)
+    - session_idle: When session becomes idle (can inject continuation)
+    - pre_compact: Before context compaction (can preserve critical context)
     """
 
     _instance = None
@@ -26,6 +33,13 @@ class HookManager:
         self.pre_model_invoke_hooks: List[
             Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
         ] = []
+        # New hook types based on oh-my-opencode patterns
+        self.session_idle_hooks: List[
+            Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+        ] = []
+        self.pre_compact_hooks: List[
+            Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+        ] = []
 
     @classmethod
     def get_instance(cls):
@@ -51,6 +65,18 @@ class HookManager:
         """Run before model invocation. Can modify prompt or parameters."""
         self.pre_model_invoke_hooks.append(hook)
 
+    def register_session_idle(
+        self, hook: Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+    ):
+        """Run when session becomes idle. Can inject continuation prompts."""
+        self.session_idle_hooks.append(hook)
+
+    def register_pre_compact(
+        self, hook: Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+    ):
+        """Run before context compaction. Can preserve critical context."""
+        self.pre_compact_hooks.append(hook)
+
     async def execute_pre_tool_call(
         self, tool_name: str, arguments: Dict[str, Any]
     ) -> Dict[str, Any]:
@@ -91,6 +117,30 @@ class HookManager:
                 logger.error(f"[HookManager] Error in pre_model_invoke hook {hook.__name__}: {e}")
         return current_params
 
+    async def execute_session_idle(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Executes all session idle hooks (Stop hook pattern)."""
+        current_params = params
+        for hook in self.session_idle_hooks:
+            try:
+                modified_params = await hook(current_params)
+                if modified_params is not None:
+                    current_params = modified_params
+            except Exception as e:
+                logger.error(f"[HookManager] Error in session_idle hook {hook.__name__}: {e}")
+        return current_params
+
+    async def execute_pre_compact(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Executes all pre-compact hooks (context preservation)."""
+        current_params = params
+        for hook in self.pre_compact_hooks:
+            try:
+                modified_params = await hook(current_params)
+                if modified_params is not None:
+                    current_params = modified_params
+            except Exception as e:
+                logger.error(f"[HookManager] Error in pre_compact hook {hook.__name__}: {e}")
+        return current_params
+
 
 def get_hook_manager() -> HookManager:
     return HookManager.get_instance()

mcp_bridge/hooks/notification_hook.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Notification hook for agent spawn messages.
+
+Fires on Notification events to output user-friendly messages about
+which agent was spawned, what model it uses, and what task it's doing.
+
+Format: spawned {agent_type}:{model}('{description}')
+Example: spawned delphi:gpt-5.2-medium('Debug xyz code')
+"""
+
+import json
+import sys
+from typing import Optional, Dict, Any
+
+
+# Agent display model mappings
+AGENT_DISPLAY_MODELS = {
+    "explore": "gemini-3-flash",
+    "dewey": "gemini-3-flash",
+    "document_writer": "gemini-3-flash",
+    "multimodal": "gemini-3-flash",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2-medium",
+    "planner": "opus-4.5",
+    "code-reviewer": "sonnet-4.5",
+    "debugger": "sonnet-4.5",
+    "_default": "sonnet-4.5",
+}
+
+
+def extract_agent_info(message: str) -> Optional[Dict[str, str]]:
+    """
+    Extract agent spawn information from notification message.
+
+    Looks for patterns like:
+    - "Agent explore spawned for task..."
+    - "Spawned delphi agent: description"
+    - Task tool delegation messages
+    """
+    message_lower = message.lower()
+
+    # Try to extract agent type from message
+    agent_type = None
+    description = ""
+
+    for agent in AGENT_DISPLAY_MODELS.keys():
+        if agent == "_default":
+            continue
+        if agent in message_lower:
+            agent_type = agent
+            # Extract description after agent name
+            idx = message_lower.find(agent)
+            description = message[idx + len(agent):].strip()[:60]
+            break
+
+    if not agent_type:
+        return None
+
+    # Clean up description
+    description = description.strip(":-() ")
+    if not description:
+        description = "task delegated"
+
+    display_model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+
+    return {
+        "agent_type": agent_type,
+        "model": display_model,
+        "description": description,
+    }
+
+
+def main():
+    """Main hook entry point."""
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    # Get notification message
+    message = hook_input.get("message", "")
+    notification_type = hook_input.get("notification_type", "")
+
+    # Only process agent-related notifications
+    agent_keywords = ["agent", "spawn", "delegat", "task"]
+    if not any(kw in message.lower() for kw in agent_keywords):
+        return 0
+
+    # Extract agent info
+    agent_info = extract_agent_info(message)
+    if not agent_info:
+        return 0
+
+    # Format and output
+    output = f"spawned {agent_info['agent_type']}:{agent_info['model']}('{agent_info['description']}')"
+    print(output, file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_bridge/hooks/parallel_enforcer.py

@@ -0,0 +1,127 @@
+"""
+Parallel Enforcer Hook - Enforce Parallel Agent Spawning.
+
+Detects when 2+ independent tasks exist and injects reminders
+to spawn agents in parallel rather than working sequentially.
+
+Based on oh-my-opencode's parallel execution enforcement pattern.
+"""
+
+import logging
+import re
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+# Parallel enforcement prompt
+PARALLEL_ENFORCEMENT_PROMPT = """
+[PARALLEL EXECUTION REQUIRED]
+
+You have {count} independent pending tasks. You MUST spawn agents for ALL of them simultaneously.
+
+CORRECT (Parallel - DO THIS):
+```
+agent_spawn(prompt="Task 1...", agent_type="explore", description="Task 1")
+agent_spawn(prompt="Task 2...", agent_type="explore", description="Task 2")
+agent_spawn(prompt="Task 3...", agent_type="dewey", description="Task 3")
+// All spawned in ONE response, then wait for results
+```
+
+WRONG (Sequential - DO NOT DO THIS):
+```
+Mark task 1 in_progress -> work on it -> complete
+Mark task 2 in_progress -> work on it -> complete  // TOO SLOW!
+```
+
+RULES:
+1. Spawn ALL independent tasks simultaneously using agent_spawn
+2. Do NOT mark any task as in_progress until agents are spawned
+3. Collect results with agent_output AFTER spawning
+4. Only work sequentially when tasks have dependencies
+"""
+
+# Track if enforcement was already triggered this session
+_enforcement_triggered: Dict[str, bool] = {}
+
+
+async def parallel_enforcer_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Post-tool-call hook that triggers after TodoWrite.
+
+    When 2+ pending todos are detected, injects parallel execution
+    enforcement prompt to prevent sequential work patterns.
+    """
+    tool_name = params.get("tool_name", "")
+    output = params.get("output", "")
+    session_id = params.get("session_id", "default")
+
+    # Only trigger for TodoWrite calls
+    if tool_name.lower() not in ["todowrite", "todo_write"]:
+        return None
+
+    # Count pending todos
+    pending_count = _count_pending_todos(output)
+
+    if pending_count < 2:
+        return None
+
+    # Check if already triggered recently
+    if _enforcement_triggered.get(session_id, False):
+        return None
+
+    # Mark as triggered
+    _enforcement_triggered[session_id] = True
+
+    logger.info(f"[ParallelEnforcerHook] Detected {pending_count} pending todos, enforcing parallel execution")
+
+    # Inject enforcement prompt
+    enforcement = PARALLEL_ENFORCEMENT_PROMPT.format(count=pending_count)
+    modified_output = output + "\n\n" + enforcement
+
+    return modified_output
+
+
+def _count_pending_todos(output: str) -> int:
+    """Count the number of pending todos in TodoWrite output."""
+    # Pattern matches various pending todo formats
+    patterns = [
+        r'\[pending\]',
+        r'"status":\s*"pending"',
+        r"status:\s*pending",
+        r"'status':\s*'pending'",
+    ]
+
+    total = 0
+    for pattern in patterns:
+        matches = re.findall(pattern, output, re.IGNORECASE)
+        total += len(matches)
+
+    return total
+
+
+def reset_enforcement(session_id: str = "default"):
+    """Reset enforcement state for a session."""
+    _enforcement_triggered[session_id] = False
+
+
+async def parallel_enforcer_post_tool_hook(
+    tool_name: str,
+    arguments: Dict[str, Any],
+    output: str
+) -> Optional[str]:
+    """
+    Post-tool-call hook interface for HookManager.
+
+    Wraps parallel_enforcer_hook for the standard hook signature.
+    """
+    params = {
+        "tool_name": tool_name,
+        "arguments": arguments,
+        "output": output,
+    }
+
+    result = await parallel_enforcer_hook(params)
+
+    if isinstance(result, str):
+        return result
+    return None

mcp_bridge/hooks/parallel_execution.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit hook: Pre-emptive parallel execution enforcement.
+
+Fires BEFORE response generation to inject parallel execution instructions
+when implementation tasks are detected. Eliminates timing ambiguity.
+
+CRITICAL: Also activates stravinsky mode marker when /stravinsky is invoked,
+enabling hard blocking of direct tools (Read, Grep, Bash) via stravinsky_mode.py.
+"""
+import json
+import sys
+import re
+from pathlib import Path
+
+# Marker file that enables hard blocking of direct tools
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def detect_stravinsky_invocation(prompt):
+    """Detect if /stravinsky skill is being invoked."""
+    patterns = [
+        r'/stravinsky',
+        r'<command-name>/stravinsky</command-name>',
+        r'stravinsky orchestrator',
+        r'ultrawork',
+        r'ultrathink',
+    ]
+    prompt_lower = prompt.lower()
+    return any(re.search(p, prompt_lower) for p in patterns)
+
+
+def activate_stravinsky_mode():
+    """Create marker file to enable hard blocking of direct tools."""
+    try:
+        config = {"active": True, "reason": "invoked via /stravinsky skill"}
+        STRAVINSKY_MODE_FILE.write_text(json.dumps(config))
+        return True
+    except IOError:
+        return False
+
+
+def detect_implementation_task(prompt):
+    """Detect if prompt is an implementation task requiring parallel execution."""
+    keywords = [
+        'implement', 'add', 'create', 'build', 'refactor', 'fix',
+        'update', 'modify', 'change', 'develop', 'write code',
+        'feature', 'bug fix', 'enhancement', 'integrate'
+    ]
+
+    prompt_lower = prompt.lower()
+    return any(kw in prompt_lower for kw in keywords)
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    prompt = hook_input.get("prompt", "")
+
+    # CRITICAL: Activate stravinsky mode if /stravinsky is invoked
+    # This creates the marker file that enables hard blocking of direct tools
+    is_stravinsky = detect_stravinsky_invocation(prompt)
+    if is_stravinsky:
+        activate_stravinsky_mode()
+
+    # Only inject for implementation tasks OR stravinsky invocation
+    if not detect_implementation_task(prompt) and not is_stravinsky:
+        print(prompt)
+        return 0
+
+    # Inject parallel execution instruction BEFORE prompt
+    instruction = """
+[🔄 PARALLEL EXECUTION MODE ACTIVE]
+
+When you create a TodoWrite with 2+ pending items:
+
+✅ IMMEDIATELY in THIS SAME RESPONSE (do NOT end response after TodoWrite):
+   1. Spawn Task() for EACH independent pending TODO
+   2. Use: Task(subagent_type="explore"|"Plan"|etc., prompt="...", description="...", run_in_background=true)
+   3. Fire ALL Task calls in ONE response block
+   4. Do NOT mark any TODO as in_progress until Task results return
+
+❌ DO NOT:
+   - End your response after TodoWrite
+   - Mark TODOs in_progress before spawning Tasks
+   - Spawn only ONE Task (spawn ALL independent tasks)
+   - Wait for "next response" to spawn Tasks
+
+Example pattern (all in SAME response):
+```
+TodoWrite([task1, task2, task3])
+Task(subagent_type="Explore", prompt="Task 1 details", description="Task 1", run_in_background=true)
+Task(subagent_type="Plan", prompt="Task 2 details", description="Task 2", run_in_background=true)
+Task(subagent_type="Explore", prompt="Task 3 details", description="Task 3", run_in_background=true)
+# Continue response - collect results with TaskOutput
+```
+
+---
+
+"""
+
+    modified_prompt = instruction + prompt
+    print(modified_prompt)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_bridge/hooks/pre_compact.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+PreCompact hook: Context preservation before compaction.
+
+Fires before Claude Code compacts conversation context to:
+1. Preserve critical context patterns
+2. Maintain stravinsky mode state
+3. Warn about information loss
+4. Save state for recovery
+
+Cannot block compaction (exit 2 only shows error).
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Any
+
+
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+STATE_DIR = Path.home() / ".claude" / "state"
+COMPACTION_LOG = STATE_DIR / "compaction.jsonl"
+
+# Patterns to preserve
+PRESERVE_PATTERNS = [
+    "ARCHITECTURE:",
+    "DESIGN DECISION:",
+    "CONSTRAINT:",
+    "REQUIREMENT:",
+    "MUST NOT:",
+    "NEVER:",
+    "CRITICAL ERROR:",
+    "CURRENT TASK:",
+    "BLOCKED BY:",
+    "[STRAVINSKY MODE]",
+    "PARALLEL_DELEGATION:",
+]
+
+
+def ensure_state_dir():
+    """Ensure state directory exists."""
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def get_stravinsky_mode_state() -> Dict[str, Any]:
+    """Read stravinsky mode state."""
+    if not STRAVINSKY_MODE_FILE.exists():
+        return {"active": False}
+    try:
+        content = STRAVINSKY_MODE_FILE.read_text().strip()
+        return json.loads(content) if content else {"active": True}
+    except (json.JSONDecodeError, IOError):
+        return {"active": True}
+
+
+def extract_preserved_context(prompt: str) -> List[str]:
+    """Extract context matching preservation patterns."""
+    preserved = []
+    lines = prompt.split("\n")
+
+    for i, line in enumerate(lines):
+        for pattern in PRESERVE_PATTERNS:
+            if pattern in line:
+                # Capture line + 2 more for context
+                context = "\n".join(lines[i:min(i+3, len(lines))])
+                preserved.append(context)
+                break
+
+    return preserved[:15]  # Max 15 items
+
+
+def log_compaction(preserved: List[str], stravinsky_active: bool):
+    """Log compaction event for audit."""
+    ensure_state_dir()
+
+    entry = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "preserved_count": len(preserved),
+        "stravinsky_mode": stravinsky_active,
+        "preview": [p[:50] for p in preserved[:3]],
+    }
+
+    try:
+        with COMPACTION_LOG.open("a") as f:
+            f.write(json.dumps(entry) + "\n")
+    except IOError:
+        pass
+
+
+def main():
+    """Main hook entry point."""
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    prompt = hook_input.get("prompt", "")
+    trigger = hook_input.get("trigger", "auto")
+
+    # Get stravinsky mode state
+    strav_state = get_stravinsky_mode_state()
+    stravinsky_active = strav_state.get("active", False)
+
+    # Extract preserved context
+    preserved = extract_preserved_context(prompt)
+
+    # Log compaction event
+    log_compaction(preserved, stravinsky_active)
+
+    # Output preservation warning
+    if preserved or stravinsky_active:
+        print(f"\n[PreCompact] Context compaction triggered ({trigger})", file=sys.stderr)
+        print(f"  Preserved items: {len(preserved)}", file=sys.stderr)
+        if stravinsky_active:
+            print("  [STRAVINSKY MODE ACTIVE] - State will persist", file=sys.stderr)
+        print("  Audit log: ~/.claude/state/compaction.jsonl", file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())