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

stravinsky_claude_assets/hooks/notification_hook_v2.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+import json
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "utils"))
+
+try:
+    from colors import get_agent_color, Color
+    from console_format import format_agent_spawn
+except ImportError:
+
+    def get_agent_color(agent_type):
+        return ("", "⚪")
+
+    def format_agent_spawn(agent_type, model, description, color_code, emoji):
+        lines = [f"{emoji} {agent_type.upper()} → {model}", f"   Task: {description}", ""]
+        return "\n".join(lines)
+
+
+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):
+    message_lower = message.lower()
+    agent_type = None
+    description = ""
+
+    for agent in AGENT_DISPLAY_MODELS.keys():
+        if agent == "_default":
+            continue
+        if agent in message_lower:
+            agent_type = agent
+            idx = message_lower.find(agent)
+            description = message[idx + len(agent) :].strip()[:80]
+            break
+
+    if not agent_type:
+        return None
+
+    description = description.strip(":-() ")
+    if not description:
+        description = "task delegated"
+
+    model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+    color_code, emoji = get_agent_color(agent_type)
+
+    return {
+        "agent_type": agent_type,
+        "model": model,
+        "description": description,
+        "color_code": color_code,
+        "emoji": emoji,
+    }
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    message = hook_input.get("message", "")
+    agent_keywords = ["agent", "spawn", "delegat", "task"]
+    if not any(kw in message.lower() for kw in agent_keywords):
+        return 0
+
+    agent_info = extract_agent_info(message)
+    if not agent_info:
+        return 0
+
+    formatted = format_agent_spawn(
+        agent_info["agent_type"],
+        agent_info["model"],
+        agent_info["description"],
+        agent_info["color_code"],
+        agent_info["emoji"],
+    )
+    print(formatted, file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/parallel_execution.py

@@ -0,0 +1,241 @@
+#!/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.
+
+ULTRAWORK MODE (oh-my-opencode parity):
+When "ultrawork" is detected in prompt (case insensitive):
+- Injects aggressive parallelization instructions
+- Forces maximum agent concurrency
+- Enables 32k thinking budget guidance
+- All async agents fire immediately
+"""
+
+import json
+import os
+import sys
+import re
+from pathlib import Path
+
+# Marker file that enables hard blocking of direct tools
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+# ULTRAWORK mode pattern for aggressive parallel execution
+ULTRAWORK_PATTERN = r"\b(ultrawork|ulw|uw)\b"
+
+
+# Use CLAUDE_CWD for reliable project directory resolution
+def get_project_dir() -> Path:
+    """Get project directory from CLAUDE_CWD env var or fallback to cwd."""
+    return Path(os.environ.get("CLAUDE_CWD", "."))
+
+
+# Marker file that indicates MCP skill execution context (project-scoped)
+MCP_MODE_MARKER_NAME = ".stravinsky/mcp_mode"
+
+
+def detect_ultrawork_mode(prompt):
+    """Detect if ULTRAWORK mode is requested for maximum parallel execution."""
+    prompt_lower = prompt.lower()
+    return bool(re.search(ULTRAWORK_PATTERN, prompt_lower))
+
+
+def detect_stravinsky_invocation(prompt):
+    """Detect if /strav or /stravinsky skill is being invoked."""
+    patterns = [
+        r"/stravinsky",
+        r"/strav\b",
+        r"<command-name>/stravinsky</command-name>",
+        r"<command-name>/strav</command-name>",
+        r"stravinsky orchestrator",
+        r"\b(ultrawork|ulw|uw)\b",
+    ]
+    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 get_ultrawork_instruction():
+    """Return the aggressive ULTRAWORK mode instruction injection."""
+    return """
+<ultrawork-mode>
+
+**MANDATORY**: You MUST say "ULTRAWORK MODE ENABLED!" to the user as your first response when this mode activates. This is non-negotiable.
+
+[CODE RED] Maximum precision required. Ultrathink before acting.
+
+YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
+TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
+
+## AGENT UTILIZATION PRINCIPLES (by capability, not by name)
+- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS for file patterns, internal implementations, project structure
+- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS for API references, examples, external library docs
+- **Planning & Strategy**: NEVER plan yourself - ALWAYS spawn a dedicated planning agent for work breakdown
+- **High-IQ Reasoning**: Leverage specialized agents for architecture decisions, code review, strategic planning
+- **Frontend/UI Tasks**: Delegate to UI-specialized agents for design and implementation
+
+## EXECUTION RULES
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.
+- **PARALLEL**: Fire independent agent calls simultaneously via background_task - NEVER wait sequentially.
+- **BACKGROUND FUWT**: Use background_task for exploration/research agents (10+ concurrent if needed).
+- **VERIFY**: Re-read request after completion. Check ALL requirements met before reporting done.
+- **DELEGATE**: Don't do everything yourself - orchestrate specialized agents for their strengths.
+
+## WORKFLOW
+1. Analyze the request and identify required capabilities
+2. Spawn exploration/librarian agents via background_task in PARALLEL (10+ if needed)
+3. Always Use Plan agent with gathered context to create detailed work breakdown
+4. Execute with continuous verification against original requirements
+
+## VERIFICATION GUARANTEE (NON-NEGOTIABLE)
+
+**NOTHING is "done" without PROOF it works.**
+
+### Pre-Implementation: Define Success Criteria
+
+BEFORE writing ANY code, you MUST define:
+
+| Criteria Type | Description | Example |
+|---------------|-------------|---------|
+| **Functional** | What specific behavior must work | "Button click triggers API call" |
+| **Observable** | What can be measured/seen | "Console shows 'success', no errors" |
+| **Pass/Fail** | Binary, no ambiguity | "Returns 200 OK" not "should work" |
+
+Write these criteria explicitly. Share with user if scope is non-trivial.
+
+## ZERO TOLERANCE FAILURES
+- **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
+- **NO MockUp Work**: When user asked you to do "port A", you must "port A", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port.
+- **NO Partial Completion**: Never stop at 60-80% saying "you can extend this..." - finish 100%
+- **NO Assumed Shortcuts**: Never skip requirements you deem "optional" or "can be added later"
+- **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified
+- **NO TEST DELETION**: Never delete or skip failing tests to make the build pass. Fix the code, not the tests.
+
+THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
+
+</ultrawork-mode>
+
+---
+
+"""
+
+
+def get_parallel_instruction():
+    """Return the standard parallel execution instruction."""
+    return """
+<user-prompt-submit-hook>
+[🔄 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"|"dewey"|"code-reviewer"|etc., prompt="...", description="...")
+   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 agents
+   - Spawn only ONE agent (spawn ALL independent tasks)
+   - Wait for "next response" to spawn agents
+   - Use Read/Grep/Bash for exploratory work (use explore agents)
+
+**Exploratory queries (NO TodoWrite needed):**
+For "Find X", "Explain where Y", "Search for Z" → SKIP TodoWrite, spawn agents immediately:
+```
+Task(subagent_type="explore", prompt="Find X...", description="Find X")
+Task(subagent_type="explore", prompt="Find Y...", description="Find Y")
+# Continue response - synthesize results
+```
+
+**Implementation tasks (TodoWrite + agents):**
+```
+TodoWrite([task1, task2, task3])
+Task(subagent_type="explore", prompt="Task 1 details", description="Task 1")
+Task(subagent_type="dewey", prompt="Task 2 details", description="Task 2")
+Task(subagent_type="code-reviewer", prompt="Task 3 details", description="Task 3")
+# Continue response - synthesize results from Task tool responses
+```
+</user-prompt-submit-hook>
+
+---
+
+"""
+
+
+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()
+
+    # Check for ULTRAWORK mode - maximum parallel execution
+    is_ultrawork = detect_ultrawork_mode(prompt)
+
+    # Only inject for implementation tasks, stravinsky invocation, or ULTRAWORK
+    if not detect_implementation_task(prompt) and not is_stravinsky and not is_ultrawork:
+        print(prompt)
+        return 0
+
+    # Select instruction based on mode
+    if is_ultrawork:
+        # ULTRAWORK mode: aggressive parallelization + verification
+        instruction = get_ultrawork_instruction()
+    else:
+        # Standard parallel execution mode
+        instruction = get_parallel_instruction()
+
+    modified_prompt = instruction + prompt
+    print(modified_prompt)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/parallel_reinforcement.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+[DEPRECATED] UserPromptSubmit hook: Parallel execution reinforcement for subsequent prompts.
+
+⚠️ This hook is DEPRECATED in favor of parallel_reinforcement_v2.py
+
+**Deprecation Details**:
+- Deprecated on: 2026-01-11
+- Replacement: parallel_reinforcement_v2.py (state-based with smart degradation detection)
+- Reason: Static reminder approach degrades after turn 3+ despite independent tasks
+- Migration path: Use parallel_reinforcement_v2.py which tracks execution history
+
+**Original Purpose**:
+When Stravinsky mode is active, this hook reinforces parallel execution requirements
+on EVERY subsequent prompt (not just the initial invocation).
+
+**Why it was replaced**:
+- No state tracking across turns (ephemeral instructions)
+- No degradation detection (always fires same message)
+- No dependency awareness (doesn't check if tasks are actually independent)
+- Lower success rate (20% parallel execution at turn 5+ vs 85% with v2)
+
+Works with:
+- parallel_execution.py: Initial activation and instruction injection
+- todo_delegation.py: PostToolUse reminder after TodoWrite
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def get_project_dir() -> Path:
+    return Path(os.environ.get("CLAUDE_CWD", "."))
+
+
+def get_todo_state() -> dict:
+    todo_cache = get_project_dir() / ".claude" / "todo_state.json"
+    if todo_cache.exists():
+        try:
+            return json.loads(todo_cache.read_text())
+        except Exception:
+            pass
+    return {"todos": []}
+
+
+def has_pending_todos() -> bool:
+    state = get_todo_state()
+    todos = state.get("todos", [])
+    pending = [t for t in todos if t.get("status") == "pending"]
+    return len(pending) >= 2
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    prompt = hook_input.get("prompt", "")
+
+    # DEPRECATED: This hook is disabled. Use parallel_reinforcement_v2.py instead.
+    # Remove this hook from .claude/settings.json and use parallel_reinforcement_v2.py
+    print(prompt)
+    return 0
+
+    # Original logic (now disabled):
+    # if not STRAVINSKY_MODE_FILE.exists():
+    #     print(prompt)
+    #     return 0
+    #
+    # if not has_pending_todos():
+    #     print(prompt)
+    #     return 0
+    #
+    # reinforcement = """
+    # <user-prompt-submit-hook>
+    # [SYSTEM REMINDER - PARALLEL EXECUTION ACTIVE]
+    #
+    # You have 2+ pending TODOs. When proceeding:
+    #
+    # ✅ SPAWN agents for ALL independent tasks in PARALLEL
+    # ✅ Use agent_spawn(agent_type="explore"|"dewey"|"frontend", prompt="...", description="...")
+    # ✅ Fire ALL agent_spawn calls in ONE response block
+    # ✅ Collect results with agent_output(task_id, block=true) after spawning
+    #
+    # ❌ DO NOT work sequentially on one task at a time
+    # ❌ DO NOT mark TODOs in_progress before spawning agents
+    # ❌ DO NOT use Task() tool (wrong for /strav - use agent_spawn)
+    # ❌ DO NOT use Read/Grep/Bash (use explore agents)
+    #
+    # PARALLEL FUWT, then synthesize results.
+    # </user-prompt-submit-hook>
+    #
+    # ---
+    #
+    # """
+    # print(reinforcement + prompt)
+    # return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/parallel_reinforcement_v2.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+from pathlib import Path
+
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def get_project_dir():
+    return Path(os.environ.get("CLAUDE_CWD", "."))
+
+
+def get_execution_state():
+    state_file = get_project_dir() / ".claude/execution_state.json"
+    if state_file.exists():
+        try:
+            return json.loads(state_file.read_text())
+        except Exception:
+            pass
+    return {
+        "parallel_mode_active": False,
+        "last_task_spawn_index": -1,
+        "last_10_tools": [],
+        "pending_todos": 0,
+    }
+
+
+def get_dependency_graph():
+    graph_file = get_project_dir() / ".claude/task_dependencies.json"
+    if graph_file.exists():
+        try:
+            return json.loads(graph_file.read_text())
+        except Exception:
+            pass
+    return {"dependencies": {}}
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    prompt = hook_input.get("prompt", "")
+
+    if not STRAVINSKY_MODE_FILE.exists():
+        print(prompt)
+        return 0
+
+    state = get_execution_state()
+
+    if not state.get("parallel_mode_active", False):
+        print(prompt)
+        return 0
+
+    last_task_index = state.get("last_task_spawn_index", -1)
+    current_index = len(state.get("last_10_tools", []))
+    turns_since_task = current_index - last_task_index - 1
+
+    if turns_since_task < 2:
+        print(prompt)
+        return 0
+
+    graph = get_dependency_graph()
+    dependencies = graph.get("dependencies", {})
+    independent_tasks = [
+        tid for tid, info in dependencies.items() if info.get("independent", False)
+    ]
+
+    if len(independent_tasks) < 2:
+        print(prompt)
+        return 0
+
+    reinforcement = f"""
+<user-prompt-submit-hook>
+[SYSTEM REMINDER - PARALLEL EXECUTION DEGRADATION DETECTED]
+
+Analysis:
+- {state.get("pending_todos", 0)} pending TODOs
+- {len(independent_tasks)} independent tasks identified
+- {turns_since_task} turns since last Task() spawn
+- Risk: Sequential execution fallback
+
+REQUIRED ACTION - Spawn agents for ALL independent tasks NOW:
+
+Independent tasks: {", ".join(independent_tasks[:5])}
+
+Pattern:
+```
+Task(subagent_type="explore", prompt="...", description="task_1")
+Task(subagent_type="dewey", prompt="...", description="task_2")
+...
+```
+
+DO NOT:
+- Mark TODOs in_progress before spawning agents
+- Work sequentially on one task at a time
+- Use Read/Grep/Bash directly (BLOCKED in stravinsky mode)
+
+SPAWN ALL TASK() AGENTS IN THIS SAME RESPONSE.
+</user-prompt-submit-hook>
+
+---
+
+"""
+    print(reinforcement + prompt)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/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.now(timezone.utc).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())