stravinsky 0.4.18__py3-none-any.whl → 0.4.66__py3-none-any.whl

stravinsky_claude_assets/hooks/stravinsky_mode.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+Stravinsky Mode Enforcer Hook
+
+This PreToolUse hook blocks native file reading tools (Read, Search, Grep, Bash)
+when stravinsky orchestrator mode is active, forcing use of Task tool for native
+subagent delegation.
+
+Stravinsky mode is activated by creating a marker file:
+  ~/.stravinsky_mode
+
+The /stravinsky command should create this file, and it should be
+removed when the task is complete.
+
+Exit codes:
+  0 = Allow the tool to execute
+  2 = Block the tool (reason sent via stderr)
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+# Marker file that indicates stravinsky mode is active
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+# Tools to block when in stravinsky mode
+BLOCKED_TOOLS = {
+    "Read",
+    "Search",
+    "Grep",
+    "Bash",
+    "MultiEdit",
+    "Edit",
+}
+
+# Tools that are always allowed
+ALLOWED_TOOLS = {
+    "TodoRead",
+    "TodoWrite",
+    "Task",  # Native subagent delegation
+    "Agent",  # MCP agent tools
+    "mcp__stravinsky__invoke_gemini",  # Direct Gemini invocation
+    "mcp__stravinsky__invoke_openai",  # Direct OpenAI invocation
+}
+
+# Agent routing recommendations
+AGENT_ROUTES = {
+    "Read": "explore",
+    "Grep": "explore",
+    "Search": "explore",
+    "Bash": "explore",
+    "Edit": "code-reviewer",
+    "MultiEdit": "code-reviewer",
+}
+
+
+def is_stravinsky_mode_active() -> bool:
+    """Check if stravinsky orchestrator mode is active."""
+    return STRAVINSKY_MODE_FILE.exists()
+
+
+def read_stravinsky_mode_config() -> dict:
+    """Read the stravinsky mode configuration if it exists."""
+    if not STRAVINSKY_MODE_FILE.exists():
+        return {}
+    try:
+        return json.loads(STRAVINSKY_MODE_FILE.read_text())
+    except (json.JSONDecodeError, IOError):
+        return {"active": True}
+
+
+def main():
+    # Read hook input from stdin
+    try:
+        hook_input = json.loads(sys.stdin.read())
+    except json.JSONDecodeError:
+        # If we can't parse input, allow the tool
+        sys.exit(0)
+
+    tool_name = hook_input.get("toolName", hook_input.get("tool_name", ""))
+    params = hook_input.get("params", {})
+
+    # Always allow certain tools
+    if tool_name in ALLOWED_TOOLS:
+        sys.exit(0)
+
+    # Check if stravinsky mode is active
+    if not is_stravinsky_mode_active():
+        # Not in stravinsky mode, allow all tools
+        sys.exit(0)
+
+    config = read_stravinsky_mode_config()
+
+    # Check if this tool should be blocked
+    if tool_name in BLOCKED_TOOLS:
+        # Determine which agent to delegate to
+        agent = AGENT_ROUTES.get(tool_name, "explore")
+
+        # Get tool context for better messaging
+        context = ""
+        if tool_name == "Grep":
+            pattern = params.get("pattern", "")
+            context = f" (searching for '{pattern[:30]}')"
+        elif tool_name == "Read":
+            file_path = params.get("file_path", "")
+            context = f" (reading {os.path.basename(file_path)})" if file_path else ""
+
+        # User-friendly delegation message
+        print(f"🎭 {agent}('Delegating {tool_name}{context}')", file=sys.stderr)
+
+        # Block the tool and tell Claude why
+        reason = f"""⚠️ STRAVINSKY MODE ACTIVE - {tool_name} BLOCKED
+
+You are in Stravinsky orchestrator mode. Native tools are disabled.
+
+Instead of using {tool_name}, you MUST use Task tool for native subagent delegation:
+  - Task(subagent_type="explore", ...) for file reading/searching
+  - Task(subagent_type="dewey", ...) for documentation research
+  - Task(subagent_type="code-reviewer", ...) for code analysis
+  - Task(subagent_type="debugger", ...) for error investigation
+  - Task(subagent_type="frontend", ...) for UI/UX work
+  - Task(subagent_type="delphi", ...) for strategic architecture decisions
+
+Example:
+  Task(
+    subagent_type="explore",
+    prompt="Read and analyze the authentication module",
+    description="Analyze auth"
+  )
+
+To exit stravinsky mode, run:
+  rm ~/.stravinsky_mode
+"""
+        # Send reason to stderr (Claude sees this)
+        print(reason, file=sys.stderr)
+        # Exit with code 2 to block the tool
+        sys.exit(2)
+
+    # Tool not in block list, allow it
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

stravinsky_claude_assets/hooks/subagent_stop.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+SubagentStop hook: Handler for agent/subagent completion events.
+
+Fires when a Claude Code subagent (Task tool) finishes to:
+1. Output completion status messages
+2. Verify agent produced expected output
+3. Block completion if critical validation fails
+4. Integrate with TODO tracking
+
+Exit codes:
+  0 = Allow completion
+  2 = Block completion (force continuation)
+"""
+
+import json
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def is_stravinsky_mode() -> bool:
+    """Check if stravinsky mode is active."""
+    return STRAVINSKY_MODE_FILE.exists()
+
+
+def extract_subagent_info(hook_input: dict) -> Tuple[str, str, str]:
+    """
+    Extract subagent information from hook input.
+
+    Returns: (agent_type, description, status)
+    """
+    # Try to get from tool parameters or response
+    params = hook_input.get("tool_input", hook_input.get("params", {}))
+    response = hook_input.get("tool_response", "")
+
+    agent_type = params.get("subagent_type", "unknown")
+    description = params.get("description", "")[:50]
+
+    # Determine status from response
+    status = "completed"
+    response_lower = response.lower() if isinstance(response, str) else ""
+    if "error" in response_lower or "failed" in response_lower:
+        status = "failed"
+    elif "timeout" in response_lower:
+        status = "timeout"
+
+    return agent_type, description, status
+
+
+def format_completion_message(agent_type: str, description: str, status: str) -> str:
+    """Format user-friendly completion message."""
+    icon = "✓" if status == "completed" else "✗"
+    return f"{icon} Subagent {agent_type} {status}: {description}"
+
+
+def should_block(status: str, agent_type: str) -> bool:
+    """
+    Determine if we should block completion.
+
+    Block if:
+    - Agent failed AND stravinsky mode active AND critical agent type
+    """
+    if status != "completed" and is_stravinsky_mode():
+        critical_agents = {"delphi", "code-reviewer", "debugger"}
+        if agent_type in critical_agents:
+            return True
+    return False
+
+
+def main():
+    """Main hook entry point."""
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    # Extract subagent info
+    agent_type, description, status = extract_subagent_info(hook_input)
+
+    # Output completion message
+    message = format_completion_message(agent_type, description, status)
+    print(message, file=sys.stderr)
+
+    # Check if we should block
+    if should_block(status, agent_type):
+        print(f"\n⚠️ CRITICAL SUBAGENT FAILURE - {agent_type} failed", file=sys.stderr)
+        print("Review the error and retry or delegate to delphi.", file=sys.stderr)
+        return 2
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/todo_continuation.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit hook: Todo Continuation Enforcer
+
+Checks if there are incomplete todos (in_progress or pending) and injects
+a reminder to continue working on them before starting new work.
+
+Aligned with oh-my-opencode's [SYSTEM REMINDER - TODO CONTINUATION] pattern.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def get_todo_state() -> dict:
+    """Try to get current todo state from Claude Code session or local cache."""
+    # Claude Code stores todo state - we can check via session files
+    # For now, we'll use a simple file-based approach
+    cwd = Path(os.environ.get("CLAUDE_CWD", "."))
+    todo_cache = cwd / ".claude" / "todo_state.json"
+
+    if todo_cache.exists():
+        try:
+            return json.loads(todo_cache.read_text())
+        except Exception:
+            pass
+
+    return {"todos": []}
+
+
+def main():
+    try:
+        data = json.load(sys.stdin)
+        prompt = data.get("prompt", "")
+    except Exception:
+        return 0
+
+    # Get current todo state
+    state = get_todo_state()
+    todos = state.get("todos", [])
+
+    if not todos:
+        # No todos tracked, pass through
+        print(prompt)
+        return 0
+
+    # Count incomplete todos
+    in_progress = [t for t in todos if t.get("status") == "in_progress"]
+    pending = [t for t in todos if t.get("status") == "pending"]
+
+    if not in_progress and not pending:
+        # All todos complete, pass through
+        print(prompt)
+        return 0
+
+    # Build AGGRESSIVE reminder with RALPH loop activation
+    reminder_parts = [
+        "",
+        "=" * 80,
+        "🔄 RALPH LOOP: INCOMPLETE WORK DETECTED",
+        "=" * 80,
+        "",
+    ]
+
+    if in_progress:
+        reminder_parts.append(f"📌 IN_PROGRESS ({len(in_progress)} items):")
+        for t in in_progress:
+            reminder_parts.append(f"   • {t.get('content', 'Unknown task')}")
+        reminder_parts.append("")
+
+    if pending:
+        reminder_parts.append(f"📋 PENDING ({len(pending)} items):")
+        for t in pending[:5]:  # Show max 5 pending
+            reminder_parts.append(f"   • {t.get('content', 'Unknown task')}")
+        if len(pending) > 5:
+            reminder_parts.append(f"   ... and {len(pending) - 5} more")
+        reminder_parts.append("")
+
+    reminder_parts.extend(
+        [
+            "⚡ MANDATORY CONTINUATION PROTOCOL:",
+            "",
+            "YOU MUST CONTINUE WORKING IMMEDIATELY. DO NOT WAIT FOR USER INPUT.",
+            "",
+            "1. If IN_PROGRESS todo exists → Complete it NOW",
+            "2. If blocked → Explain why and mark as pending, move to next",
+            "3. Pick next PENDING todo → Mark as in_progress → Execute",
+            "4. Repeat until ALL todos are completed",
+            "",
+            "🚫 DO NOT:",
+            '   - Ask user "Should I continue?" (YES, ALWAYS CONTINUE)',
+            "   - Wait for user confirmation (CONTINUE AUTOMATICALLY)",
+            "   - Stop with pending work (COMPLETE EVERYTHING)",
+            "   - Start new work before finishing todos (FINISH FIRST)",
+            "",
+            "THIS IS AN AUTO-CONTINUATION. PROCEED IMMEDIATELY.",
+            "",
+            "=" * 80,
+            "",
+        ]
+    )
+
+    reminder = "\n".join(reminder_parts)
+    print(reminder + prompt)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/todo_delegation.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for TodoWrite: CRITICAL parallel execution enforcer.
+
+This hook fires AFTER TodoWrite completes. If there are 2+ pending items,
+it outputs a STRONG reminder that Task tool must be used for delegation.
+
+Exit code 2 is used to signal a HARD BLOCK - Claude should see this as
+a failure condition requiring immediate correction.
+
+NOTE: This hook enforces the NATIVE SUBAGENT PATTERN.
+Use Task() tool for Claude Code native agents, not agent_spawn (legacy MCP tool).
+
+Works in tandem with:
+- parallel_execution.py (UserPromptSubmit): Pre-emptive instruction injection
+- stravinsky_mode.py (PreToolUse): Hard blocking of Read/Grep/Bash tools
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Check if stravinsky mode is active (hard blocking enabled)
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def is_stravinsky_mode():
+    """Check if hard blocking mode is active."""
+    return STRAVINSKY_MODE_FILE.exists()
+
+
+def main():
+    # Read hook input from stdin
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+
+    if tool_name != "TodoWrite":
+        return 0
+
+    # Get the todos that were just written
+    tool_input = hook_input.get("tool_input", {})
+    todos = tool_input.get("todos", [])
+
+    # Count pending todos
+    pending_count = sum(1 for t in todos if t.get("status") == "pending")
+
+    if pending_count < 2:
+        return 0
+
+    # Check if stravinsky mode is active
+    stravinsky_active = is_stravinsky_mode()
+
+    # CRITICAL: Output urgent reminder for parallel delegation via Task tool
+    # Native subagent pattern: Always use Task() for delegation
+    mode_warning = ""
+    if stravinsky_active:
+        mode_warning = """
+⚠️ STRAVINSKY MODE ACTIVE - Direct tools (Read, Grep, Bash) are BLOCKED.
+   You MUST use Task(subagent_type="explore", ...) for ALL file operations.
+"""
+
+    error_message = f"""
+🚨 PARALLEL DELEGATION REQUIRED 🚨
+
+TodoWrite created {pending_count} pending items.
+{mode_warning}
+You MUST delegate to Task tool for ALL independent TODOs in THIS SAME RESPONSE.
+
+Required pattern (IMMEDIATELY after this message):
+Task(subagent_type="explore", prompt="TODO 1...", description="TODO 1")
+Task(subagent_type="dewey", prompt="TODO 2...", description="TODO 2")
+Task(subagent_type="code-reviewer", prompt="TODO 3...", description="TODO 3")
+...
+
+DO NOT:
+- End your response without Task() calls
+- Mark TODOs in_progress before delegating
+- Use Read/Grep/Bash directly (BLOCKED in stravinsky mode)
+- Work on TODOs sequentially yourself
+
+Your NEXT action MUST be multiple Task() calls, one for each independent TODO.
+Task tool returns results directly - synthesize and mark complete.
+"""
+    print(error_message)
+
+    # Exit code 2 = HARD BLOCK in stravinsky mode
+    # Exit code 1 = WARNING otherwise
+    return 2 if stravinsky_active else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())