stravinsky 0.2.52__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/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_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

@@ -1,224 +1,123 @@
+#!/usr/bin/env python3
 """
-PreCompact Hook - Context Preservation Before Compaction.
+PreCompact hook: Context preservation before compaction.
 
-Triggers before session compaction to preserve critical context
-that should survive summarization. Uses Gemini for intelligent
-context extraction and preservation.
+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
 
-Based on oh-my-opencode's pre-compact hook pattern.
+Cannot block compaction (exit 2 only shows error).
 """
 
-import logging
-from typing import Any, Dict, List, Optional
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Any
 
-logger = logging.getLogger(__name__)
 
-# Flag to prevent recursive calls during Gemini invocation
-_in_preservation = False
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+STATE_DIR = Path.home() / ".claude" / "state"
+COMPACTION_LOG = STATE_DIR / "compaction.jsonl"
 
-# Critical context patterns to preserve
+# Patterns to preserve
 PRESERVE_PATTERNS = [
-    # Architecture decisions
     "ARCHITECTURE:",
     "DESIGN DECISION:",
-    "## Architecture",
-
-    # Important constraints
     "CONSTRAINT:",
     "REQUIREMENT:",
     "MUST NOT:",
     "NEVER:",
-
-    # Session state
+    "CRITICAL ERROR:",
     "CURRENT TASK:",
     "BLOCKED BY:",
-    "WAITING FOR:",
-
-    # Critical errors
-    "CRITICAL ERROR:",
-    "SECURITY ISSUE:",
-    "BREAKING CHANGE:",
+    "[STRAVINSKY MODE]",
+    "PARALLEL_DELEGATION:",
 ]
 
-# Memory anchors to inject into compaction
-MEMORY_ANCHORS: List[str] = []
-
-
-def register_memory_anchor(anchor: str, priority: str = "normal"):
-    """
-    Register a memory anchor to preserve during compaction.
-
-    Args:
-        anchor: The text to preserve
-        priority: "critical" or "normal"
-    """
-    if priority == "critical":
-        MEMORY_ANCHORS.insert(0, f"[CRITICAL] {anchor}")
-    else:
-        MEMORY_ANCHORS.append(anchor)
-
-    # Limit to 10 anchors to prevent bloat
-    while len(MEMORY_ANCHORS) > 10:
-        MEMORY_ANCHORS.pop()
-
-
-def clear_memory_anchors():
-    """Clear all registered memory anchors."""
-    MEMORY_ANCHORS.clear()
-
-
-async def pre_compact_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    """
-    Pre-model-invoke hook that runs before context compaction.
-
-    Uses Gemini to intelligently extract and preserve critical context
-    that should survive summarization.
-    """
-    global _in_preservation
-
-    # Prevent recursive calls
-    if _in_preservation:
-        return None
-
-    prompt = params.get("prompt", "")
-
-    # Only activate for compaction-related prompts
-    if not _is_compaction_prompt(prompt):
-        return None
-
-    # Collect pattern-matched context
-    preserved_context = _extract_preserved_context(prompt)
-    preserved_context.extend(MEMORY_ANCHORS)
-
-    # Use Gemini for intelligent context extraction if prompt is long
-    if len(prompt) > 50000:
-        try:
-            _in_preservation = True
-            gemini_context = await _extract_context_with_gemini(prompt)
-            if gemini_context:
-                preserved_context.extend(gemini_context)
-        except Exception as e:
-            logger.warning(f"[PreCompactHook] Gemini extraction failed: {e}")
-        finally:
-            _in_preservation = False
-
-    if not preserved_context:
-        return None
-
-    # Build preservation section
-    preservation_section = _build_preservation_section(preserved_context)
-
-    logger.info(f"[PreCompactHook] Preserving {len(preserved_context)} context items")
-
-    # Inject into prompt
-    modified_prompt = prompt + "\n\n" + preservation_section
-
-    return {**params, "prompt": modified_prompt}
 
+def ensure_state_dir():
+    """Ensure state directory exists."""
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
 
-async def _extract_context_with_gemini(prompt: str) -> List[str]:
-    """
-    Use Gemini to intelligently extract critical context to preserve.
 
-    Args:
-        prompt: The full conversation/context to analyze
-
-    Returns:
-        List of critical context items to preserve
-    """
+def get_stravinsky_mode_state() -> Dict[str, Any]:
+    """Read stravinsky mode state."""
+    if not STRAVINSKY_MODE_FILE.exists():
+        return {"active": False}
     try:
-        from ..tools.model_invoke import invoke_gemini_impl
-
-        # Truncate prompt if too long for Gemini
-        max_chars = 100000
-        truncated = prompt[:max_chars] if len(prompt) > max_chars else prompt
-
-        extraction_prompt = f"""Analyze this conversation and extract ONLY the most critical information that MUST be preserved during summarization.
-
-Focus on:
-1. Architecture decisions and their rationale
-2. Critical constraints or requirements
-3. Important error patterns or debugging insights
-4. Key file paths and their purposes
-5. Unfinished tasks or blocking issues
-
-Return a bullet list of critical items (max 10). Be extremely concise.
-
-CONVERSATION:
-{truncated}
+        content = STRAVINSKY_MODE_FILE.read_text().strip()
+        return json.loads(content) if content else {"active": True}
+    except (json.JSONDecodeError, IOError):
+        return {"active": True}
 
-CRITICAL ITEMS TO PRESERVE:"""
 
-        result = await invoke_gemini_impl(
-            prompt=extraction_prompt,
-            model="gemini-3-flash",
-            max_tokens=2000,
-            temperature=0.1,
-        )
+def extract_preserved_context(prompt: str) -> List[str]:
+    """Extract context matching preservation patterns."""
+    preserved = []
+    lines = prompt.split("\n")
 
-        if not result:
-            return []
+    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
 
-        # Parse bullet points from response
-        lines = result.strip().split("\n")
-        items = []
-        for line in lines:
-            line = line.strip()
-            if line.startswith(("-", "*", "•")) or (len(line) > 1 and line[0].isdigit() and line[1] in ".):"):
-                # Clean up the bullet
-                item = line.lstrip("-*•0123456789.): ").strip()
-                if item and len(item) > 10:
-                    items.append(item)
+    return preserved[:15]  # Max 15 items
 
-        return items[:10]  # Max 10 items
 
-    except Exception as e:
-        logger.warning(f"[PreCompactHook] Gemini context extraction error: {e}")
-        return []
+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]],
+    }
 
-def _is_compaction_prompt(prompt: str) -> bool:
-    """Detect if this is a compaction/summarization prompt."""
-    compaction_signals = [
-        "summarize the conversation",
-        "compact the context",
-        "reduce context size",
-        "context window",
-        "summarization",
-    ]
+    try:
+        with COMPACTION_LOG.open("a") as f:
+            f.write(json.dumps(entry) + "\n")
+    except IOError:
+        pass
 
-    prompt_lower = prompt.lower()
-    return any(signal in prompt_lower for signal in compaction_signals)
 
+def main():
+    """Main hook entry point."""
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
 
-def _extract_preserved_context(prompt: str) -> List[str]:
-    """Extract context matching preservation patterns."""
-    preserved = []
-    lines = prompt.split("\n")
+    prompt = hook_input.get("prompt", "")
+    trigger = hook_input.get("trigger", "auto")
 
-    for i, line in enumerate(lines):
-        for pattern in PRESERVE_PATTERNS:
-            if pattern in line:
-                # Capture the line and next 2 lines for context
-                context_lines = lines[i:i+3]
-                preserved.append("\n".join(context_lines))
-                break
+    # Get stravinsky mode state
+    strav_state = get_stravinsky_mode_state()
+    stravinsky_active = strav_state.get("active", False)
 
-    return preserved
+    # Extract preserved context
+    preserved = extract_preserved_context(prompt)
 
+    # Log compaction event
+    log_compaction(preserved, stravinsky_active)
 
-def _build_preservation_section(context_items: List[str]) -> str:
-    """Build the preservation section to inject."""
-    section = """
-## CRITICAL CONTEXT TO PRESERVE
+    # 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)
 
-The following information MUST be preserved in any summarization:
+    return 0
 
-"""
-    for i, item in enumerate(context_items, 1):
-        section += f"{i}. {item}\n\n"
 
-    section += """
-When summarizing, ensure these items are included verbatim or with minimal paraphrasing.
-"""
-    return section
+if __name__ == "__main__":
+    sys.exit(main())