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

stravinsky_claude_assets/hooks/comment_checker.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Comment Quality Enforcer (oh-my-opencode parity)
+
+Fires BEFORE git commit/push operations to check for low-quality comments.
+Challenges comments that just restate what the code does.
+
+Exit codes:
+- 0: Allow the operation to proceed
+- 2: Block the operation (hard block)
+
+Trigger: PreToolUse on Bash tool when command contains 'git commit' or 'git push'
+"""
+
+import json
+import sys
+import re
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+# Patterns that indicate low-quality comments
+LOW_QUALITY_PATTERNS = [
+    # Comments that just describe what code literally does
+    r"#\s*(?:set|get|return|call|create|initialize|init)\s+\w+",
+    # Comments that are just variable/function names repeated
+    r"#\s*\w+\s*$",
+    # Empty or trivial comments
+    r"#\s*(?:TODO|FIXME|XXX|HACK)?\s*$",
+    # Comments that state the obvious
+    r"#\s*(?:loop|iterate|check|if|else|for|while)\s+(?:through|over|if|the)?\s*\w*\s*$",
+    # Comments like "# increment i" or "# add 1 to x"
+    r"#\s*(?:increment|decrement|add|subtract|multiply|divide)\s+\w+",
+]
+
+# Patterns for GOOD comments we should NOT flag
+GOOD_COMMENT_PATTERNS = [
+    # Docstrings and multi-line comments explaining WHY
+    r'""".*"""',
+    r"'''.*'''",
+    # Comments explaining business logic or reasoning
+    r"#\s*(?:because|since|note|important|warning|caution|reason|why|rationale)",
+    # Comments with URLs or references
+    r"#\s*(?:see|ref|https?://|link)",
+    # Type hints or type comments
+    r"#\s*type:",
+    # Pragma or directive comments
+    r"#\s*(?:noqa|type:|pragma|pylint|flake8)",
+]
+
+
+def is_low_quality_comment(comment: str) -> bool:
+    """Check if a comment is low-quality (just restates code)."""
+    comment_lower = comment.lower().strip()
+
+    # Skip if it matches a good pattern
+    for pattern in GOOD_COMMENT_PATTERNS:
+        if re.search(pattern, comment_lower, re.IGNORECASE):
+            return False
+
+    # Check against low-quality patterns
+    for pattern in LOW_QUALITY_PATTERNS:
+        if re.search(pattern, comment_lower, re.IGNORECASE):
+            return True
+
+    # Very short comments (< 10 chars after #) are often low quality
+    content = comment.replace("#", "").strip()
+    if len(content) < 10 and not any(c in content for c in ["!", "?", ":", "TODO", "FIXME"]):
+        return True
+
+    return False
+
+
+def extract_added_comments_from_diff(diff_text: str) -> List[Tuple[str, str]]:
+    """
+    Extract newly added comments from a git diff.
+    Returns list of (filename, comment) tuples.
+    """
+    added_comments = []
+    current_file = None
+
+    for line in diff_text.split("\n"):
+        # Track which file we're in
+        if line.startswith("+++ b/"):
+            current_file = line[6:]
+        # Only look at added lines (starting with +, but not +++)
+        elif line.startswith("+") and not line.startswith("+++"):
+            content = line[1:]  # Remove the leading +
+            # Check for Python comments
+            if "#" in content and not content.strip().startswith("#!"):
+                # Extract the comment part
+                comment_match = re.search(r"#.*$", content)
+                if comment_match:
+                    comment = comment_match.group(0)
+                    if current_file:
+                        added_comments.append((current_file, comment))
+
+    return added_comments
+
+
+def check_staged_diff() -> Optional[str]:
+    """
+    Check the staged diff for low-quality comments.
+    Returns a warning message if issues found, None otherwise.
+    """
+    import subprocess
+
+    try:
+        # Get the staged diff
+        result = subprocess.run(
+            ["git", "diff", "--cached", "--unified=0"], capture_output=True, text=True, timeout=10
+        )
+
+        if result.returncode != 0:
+            return None  # Can't get diff, allow commit
+
+        diff_text = result.stdout
+        if not diff_text:
+            return None  # No staged changes
+
+        # Extract and check comments
+        added_comments = extract_added_comments_from_diff(diff_text)
+        low_quality = []
+
+        for filename, comment in added_comments:
+            if is_low_quality_comment(comment):
+                low_quality.append((filename, comment))
+
+        if low_quality:
+            warning = "⚠️ **Comment Quality Check Failed**\n\n"
+            warning += "The following comments appear to just restate the code:\n\n"
+            for filename, comment in low_quality[:5]:  # Limit to 5 examples
+                warning += f"- `{filename}`: `{comment[:50]}...`\n"
+            warning += "\n**Good comments explain WHY, not WHAT.**\n"
+            warning += "Consider removing or improving these comments.\n\n"
+            warning += "To proceed anyway, use: `git commit --no-verify`"
+            return warning
+
+        return None
+
+    except subprocess.TimeoutExpired:
+        return None  # Timeout, allow commit
+    except FileNotFoundError:
+        return None  # Git not found, allow commit
+    except Exception:
+        return None  # Any other error, allow commit
+
+
+def is_git_commit_command(command: str) -> bool:
+    """Check if the command is a git commit or push."""
+    command_lower = command.lower()
+    return any(
+        pattern in command_lower
+        for pattern in [
+            "git commit",
+            "git push",
+        ]
+    )
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+    tool_input = hook_input.get("tool_input", {})
+
+    # Only check Bash commands
+    if tool_name != "Bash":
+        return 0
+
+    command = tool_input.get("command", "")
+
+    # Only check git commit/push commands
+    if not is_git_commit_command(command):
+        return 0
+
+    # Check for low-quality comments in staged diff
+    warning = check_staged_diff()
+
+    if warning:
+        # Output warning to stderr (shown to user)
+        print(warning, file=sys.stderr)
+        # Return 0 to allow but warn, or 2 to block
+        # We'll warn but allow - users can use --no-verify to skip
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/context.py

@@ -0,0 +1,38 @@
+import os
+import sys
+import json
+from pathlib import Path
+
+def main():
+    try:
+        data = json.load(sys.stdin)
+        prompt = data.get("prompt", "")
+    except Exception:
+        return
+
+    cwd = Path(os.environ.get("CLAUDE_CWD", "."))
+    
+    # Files to look for
+    context_files = ["AGENTS.md", "README.md", "CLAUDE.md"]
+    found_context = ""
+
+    for f in context_files:
+        path = cwd / f
+        if path.exists():
+            try:
+                content = path.read_text()
+                found_context += f"\n\n--- LOCAL CONTEXT: {f} ---\n{content}\n"
+                break # Only use one for brevity
+            except Exception:
+                pass
+
+    if found_context:
+        # Prepend context to prompt
+        # We wrap the user prompt to distinguish it
+        new_prompt = f"{found_context}\n\n[USER PROMPT]\n{prompt}"
+        print(new_prompt)
+    else:
+        print(prompt)
+
+if __name__ == "__main__":
+    main()

stravinsky_claude_assets/hooks/context_monitor.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+Context Monitor Hook - Pre-emptive Compact at 70%
+
+Fires on UserPromptSubmit to monitor context usage.
+At 70%: Generates a pre-emptive compact summary.
+At 85%: Critical warning.
+
+This hook provides PROACTIVE context management, not reactive.
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# Context estimation constants
+MAX_CONTEXT_TOKENS = 200000
+CHARS_PER_TOKEN = 4
+PREEMPTIVE_THRESHOLD = 0.70  # 70%
+CRITICAL_THRESHOLD = 0.85    # 85%
+
+# State tracking
+STATE_DIR = Path.home() / ".claude" / "state"
+CONTEXT_STATE_FILE = STATE_DIR / "context_monitor.json"
+
+
+def estimate_tokens(text: str) -> int:
+    """Estimate token count from character count."""
+    return len(text) // CHARS_PER_TOKEN
+
+
+def get_usage_percentage(text: str) -> float:
+    """Calculate context window usage as percentage."""
+    tokens = estimate_tokens(text)
+    return tokens / MAX_CONTEXT_TOKENS
+
+
+def ensure_state_dir():
+    """Ensure state directory exists."""
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def get_last_compact_tokens() -> int:
+    """Get token count at last compact recommendation."""
+    try:
+        if CONTEXT_STATE_FILE.exists():
+            state = json.loads(CONTEXT_STATE_FILE.read_text())
+            return state.get("last_compact_tokens", 0)
+    except (json.JSONDecodeError, IOError):
+        pass
+    return 0
+
+
+def set_last_compact_tokens(tokens: int):
+    """Record token count at compact recommendation."""
+    ensure_state_dir()
+    try:
+        state = {"last_compact_tokens": tokens, "timestamp": datetime.now(timezone.utc).isoformat()}
+        CONTEXT_STATE_FILE.write_text(json.dumps(state))
+    except IOError:
+        pass
+
+
+def generate_compact_summary_prompt(conversation: str, usage_pct: float) -> str:
+    """Generate the summary request to inject into response."""
+    return f"""
+<system-reminder>
+**[PRE-EMPTIVE CONTEXT OPTIMIZATION - {usage_pct:.1%} USAGE]**
+
+Context window at {usage_pct:.1%} capacity. To prevent forced truncation, generate a summary NOW.
+
+REQUIRED: Before continuing, output a structured summary:
+
+```
+## Context Summary (Pre-emptive Compact)
+
+### Current Task
+[What are we working on right now?]
+
+### Key Decisions Made
+- [Decision 1]
+- [Decision 2]
+
+### Files Modified/Created
+- [file1.py]: [what changed]
+- [file2.py]: [what changed]
+
+### Critical Constraints
+- [Any MUST NOT or NEVER rules]
+- [Architectural decisions]
+
+### Next Steps
+1. [Immediate next action]
+2. [Following action]
+```
+
+This summary will be preserved when automatic compaction occurs.
+</system-reminder>
+"""
+
+
+def main():
+    """Main hook entry point."""
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    # Get the full conversation/prompt
+    conversation = hook_input.get("prompt", "")
+    if not conversation:
+        return 0
+
+    # Calculate usage
+    tokens = estimate_tokens(conversation)
+    usage = get_usage_percentage(conversation)
+
+    # Check if we already triggered at this token level (avoid spam)
+    last_compact = get_last_compact_tokens()
+
+    # Only trigger once per ~10% increase
+    token_threshold = int(MAX_CONTEXT_TOKENS * 0.10)  # ~20k tokens
+    already_triggered = (tokens - last_compact) < token_threshold
+
+    if usage >= CRITICAL_THRESHOLD:
+        # Critical warning - always show
+        print(f"\n⚠️ **CRITICAL: Context at {usage:.1%}** - Forced compaction imminent!", file=sys.stderr)
+        print("  Generate summary NOW or context will be truncated.", file=sys.stderr)
+
+        if not already_triggered:
+            set_last_compact_tokens(tokens)
+            # Inject summary request
+            summary_prompt = generate_compact_summary_prompt(conversation, usage)
+            print(summary_prompt, file=sys.stderr)
+
+    elif usage >= PREEMPTIVE_THRESHOLD:
+        # Pre-emptive optimization
+        if not already_triggered:
+            print(f"\n📊 **Context at {usage:.1%}** - Pre-emptive optimization recommended", file=sys.stderr)
+            print(f"  Estimated tokens: {tokens:,} / {MAX_CONTEXT_TOKENS:,}", file=sys.stderr)
+            print("  Headroom remaining: ~{:.0f}%".format((1 - usage) * 100), file=sys.stderr)
+
+            set_last_compact_tokens(tokens)
+            # Inject summary request
+            summary_prompt = generate_compact_summary_prompt(conversation, usage)
+            print(summary_prompt, file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/dependency_tracker.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def get_project_dir():
+    return Path(os.environ.get("CLAUDE_CWD", "."))
+
+
+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 save_dependency_graph(graph):
+    graph_file = get_project_dir() / ".claude/task_dependencies.json"
+    graph_file.parent.mkdir(parents=True, exist_ok=True)
+    graph_file.write_text(json.dumps(graph, indent=2))
+
+
+DEPENDENCY_KEYWORDS = ["after", "depends on", "requires", "once", "when", "then"]
+PARALLEL_KEYWORDS = ["also", "meanwhile", "simultaneously", "and", "plus"]
+
+
+def parse_todo_dependencies(todos):
+    dependencies = {}
+
+    for todo in todos:
+        todo_id = todo.get("id")
+        content = todo.get("content", "").lower()
+
+        has_dependency = any(kw in content for kw in DEPENDENCY_KEYWORDS)
+        is_parallel = any(kw in content for kw in PARALLEL_KEYWORDS)
+
+        dependencies[todo_id] = {
+            "deps": [],
+            "independent": not has_dependency,
+            "parallel_safe": is_parallel or not has_dependency,
+        }
+
+    return dependencies
+
+
+def main():
+    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
+
+    tool_input = hook_input.get("tool_input", {})
+    todos = tool_input.get("todos", [])
+
+    graph = get_dependency_graph()
+    dependencies = parse_todo_dependencies(todos)
+    graph["dependencies"] = dependencies
+    save_dependency_graph(graph)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/edit_recovery.py

@@ -0,0 +1,46 @@
+import os
+import sys
+import json
+import re
+
+def main():
+    # Claude Code PostToolUse inputs via Environment Variables
+    tool_name = os.environ.get("CLAUDE_TOOL_NAME")
+    
+    # We only care about Edit/MultiEdit
+    if tool_name not in ["Edit", "MultiEdit"]:
+        return
+
+    # Read from stdin (Claude Code passes the tool response via stdin for some hook types, 
+    # but for PostToolUse it's often better to check the environment variable if available.
+    # Actually, the summary says input is a JSON payload.
+    try:
+        data = json.load(sys.stdin)
+        tool_response = data.get("tool_response", "")
+    except Exception:
+        # Fallback to direct string if not JSON
+        return
+
+    # Error patterns
+    error_patterns = [
+        r"oldString not found",
+        r"oldString matched multiple times",
+        r"line numbers out of range"
+    ]
+
+    recovery_needed = any(re.search(p, tool_response, re.IGNORECASE) for p in error_patterns)
+
+    if recovery_needed:
+        correction = (
+            "\n\n[SYSTEM RECOVERY] It appears the Edit tool failed to find the target string. "
+            "Please call 'Read' on the file again to verify the current content, "
+            "then ensure your 'oldString' is an EXACT match including all whitespace."
+        )
+        # For PostToolUse, stdout is captured and appended/replaces output
+        print(tool_response + correction)
+    else:
+        # No change
+        print(tool_response)
+
+if __name__ == "__main__":
+    main()

stravinsky_claude_assets/hooks/execution_state_tracker.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+
+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 {
+        "last_10_tools": [],
+        "last_task_spawn_index": -1,
+        "pending_todos": 0,
+        "parallel_mode_active": False,
+        "last_updated": None,
+    }
+
+
+def save_execution_state(state):
+    state_file = get_project_dir() / ".claude/execution_state.json"
+    state_file.parent.mkdir(parents=True, exist_ok=True)
+    state["last_updated"] = datetime.now().isoformat()
+    state_file.write_text(json.dumps(state, indent=2))
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+
+    state = get_execution_state()
+    state["last_10_tools"].append(tool_name)
+    state["last_10_tools"] = state["last_10_tools"][-10:]
+
+    if tool_name == "Task":
+        try:
+            index = len(state["last_10_tools"]) - 1
+            state["last_task_spawn_index"] = index
+        except:
+            pass
+
+    if tool_name == "TodoWrite":
+        tool_input = hook_input.get("tool_input", {})
+        todos = tool_input.get("todos", [])
+        pending = sum(1 for t in todos if t.get("status") == "pending")
+        state["pending_todos"] = pending
+        state["parallel_mode_active"] = pending >= 2
+
+    save_execution_state(state)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/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())