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

stravinsky_claude_assets/hooks/ralph_loop.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+PostAssistantMessage hook: RALPH Loop (Relentless Autonomous Labor Protocol with Hardening Loop)
+
+Automatically continues working on pending todos after assistant completes a response.
+Prevents the assistant from stopping with incomplete work.
+
+SAFETY: Maximum 10 auto-continuations per session to prevent infinite loops.
+
+Named after the mythological Sisyphus who relentlessly pushed the boulder uphill.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+
+# 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", "."))
+
+
+# State tracking for RALPH loop safety
+RALPH_STATE_FILE = get_project_dir() / ".claude" / "ralph_state.json"
+
+
+def get_ralph_state() -> dict:
+    """Get current RALPH loop state."""
+    if RALPH_STATE_FILE.exists():
+        try:
+            return json.loads(RALPH_STATE_FILE.read_text())
+        except Exception:
+            pass
+
+    return {
+        "continuation_count": 0,
+        "last_reset": datetime.now().isoformat(),
+        "max_continuations": 10,
+    }
+
+
+def save_ralph_state(state: dict):
+    """Save RALPH loop state."""
+    try:
+        RALPH_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        RALPH_STATE_FILE.write_text(json.dumps(state, indent=2))
+    except Exception:
+        pass
+
+
+def reset_ralph_state_if_needed(state: dict) -> dict:
+    """Reset continuation count if last reset was >1 hour ago."""
+    try:
+        last_reset = datetime.fromisoformat(state.get("last_reset", datetime.now().isoformat()))
+        hours_since_reset = (datetime.now() - last_reset).total_seconds() / 3600
+
+        if hours_since_reset > 1:
+            state["continuation_count"] = 0
+            state["last_reset"] = datetime.now().isoformat()
+    except Exception:
+        pass
+
+    return state
+
+
+def get_todo_state() -> dict:
+    """Get current todo state from Claude Code session or local cache."""
+    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 main():
+    try:
+        # Read hook input from stdin
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    # Get RALPH state and reset if needed
+    ralph_state = get_ralph_state()
+    ralph_state = reset_ralph_state_if_needed(ralph_state)
+
+    # Safety check: prevent infinite loops
+    if ralph_state["continuation_count"] >= ralph_state["max_continuations"]:
+        print(
+            f"\n⚠️ RALPH Loop safety limit reached ({ralph_state['max_continuations']} auto-continuations).\n",
+            file=sys.stderr,
+        )
+        print(f"Stopping auto-continuation. Will resume on next user prompt.\n", file=sys.stderr)
+        # Reset for next session
+        ralph_state["continuation_count"] = 0
+        ralph_state["last_reset"] = datetime.now().isoformat()
+        save_ralph_state(ralph_state)
+        return 0
+
+    # Get current todo state
+    todo_state = get_todo_state()
+    todos = todo_state.get("todos", [])
+
+    if not todos:
+        # No todos tracked, nothing to continue
+        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, reset RALPH state
+        ralph_state["continuation_count"] = 0
+        ralph_state["last_reset"] = datetime.now().isoformat()
+        save_ralph_state(ralph_state)
+        return 0
+
+    # There are incomplete todos - trigger auto-continuation
+    ralph_state["continuation_count"] += 1
+    save_ralph_state(ralph_state)
+
+    # Build continuation message
+    continuation_msg = [
+        "",
+        "═" * 80,
+        f"🔄 RALPH Loop: Auto-Continuation {ralph_state['continuation_count']}/{ralph_state['max_continuations']}",
+        "═" * 80,
+        "",
+    ]
+
+    if in_progress:
+        continuation_msg.append(f"📌 IN_PROGRESS ({len(in_progress)} items):")
+        for t in in_progress:
+            continuation_msg.append(f"   • {t.get('content', 'Unknown task')}")
+        continuation_msg.append("")
+
+    if pending:
+        continuation_msg.append(f"📋 PENDING ({len(pending)} items):")
+        for t in pending[:5]:  # Show max 5 pending
+            continuation_msg.append(f"   • {t.get('content', 'Unknown task')}")
+        if len(pending) > 5:
+            continuation_msg.append(f"   ... and {len(pending) - 5} more")
+        continuation_msg.append("")
+
+    continuation_msg.extend(
+        [
+            "⚡ CONTINUE WORKING:",
+            "   1. Mark current IN_PROGRESS todo as COMPLETED if done",
+            "   2. Move to next PENDING todo",
+            "   3. DO NOT stop until all todos are complete",
+            "",
+            "═" * 80,
+            "",
+        ]
+    )
+
+    # Inject continuation as a system message that triggers another assistant response
+    print("\n".join(continuation_msg), file=sys.stderr)
+
+    # Return non-zero to signal that work is incomplete and should continue
+    # This tells Claude Code to prompt the assistant for another response
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/session_recovery.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: Session Recovery (oh-my-opencode parity)
+
+Detects API failures, thinking block errors, and rate limits.
+Logs recovery events and provides guidance for auto-retry.
+
+This hook monitors tool responses for error patterns and:
+1. Logs errors to ~/.claude/state/recovery.jsonl
+2. Injects recovery guidance when errors are detected
+3. Tracks failure patterns for debugging
+
+Exit codes:
+- 0: Always (this hook only observes and logs)
+"""
+
+import json
+import sys
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# State directory for recovery logs
+STATE_DIR = Path.home() / ".claude" / "state"
+RECOVERY_LOG = STATE_DIR / "recovery.jsonl"
+
+# Error patterns to detect
+ERROR_PATTERNS = {
+    "thinking_block": [
+        r"thinking block",
+        r"extended thinking",
+        r"thinking budget exceeded",
+        r"thinking timeout",
+    ],
+    "rate_limit": [
+        r"rate limit",
+        r"too many requests",
+        r"429",
+        r"quota exceeded",
+        r"throttl",
+    ],
+    "api_timeout": [
+        r"timeout",
+        r"timed out",
+        r"connection reset",
+        r"connection refused",
+        r"ETIMEDOUT",
+        r"ECONNRESET",
+    ],
+    "api_error": [
+        r"API error",
+        r"internal server error",
+        r"500",
+        r"502",
+        r"503",
+        r"504",
+        r"service unavailable",
+    ],
+    "context_overflow": [
+        r"context length",
+        r"token limit",
+        r"max tokens",
+        r"context window",
+        r"too long",
+    ],
+    "auth_error": [
+        r"unauthorized",
+        r"401",
+        r"403",
+        r"forbidden",
+        r"authentication failed",
+        r"token expired",
+    ],
+}
+
+# Recovery suggestions for each error type
+RECOVERY_SUGGESTIONS = {
+    "thinking_block": """
+**Thinking Block Error Detected**
+
+The model's extended thinking was interrupted. Recovery options:
+1. Retry the same request (often works on second attempt)
+2. Break the task into smaller steps
+3. Reduce thinking budget if explicitly set
+
+Automatic retry recommended.
+""",
+    "rate_limit": """
+**Rate Limit Hit**
+
+You've hit the API rate limit. Recovery options:
+1. Wait 30-60 seconds before retrying
+2. Reduce parallel agent spawns
+3. Use cheaper models (gemini-3-flash) for exploration
+
+Exponential backoff recommended: wait 30s, then 60s, then 120s.
+""",
+    "api_timeout": """
+**API Timeout**
+
+The API request timed out. Recovery options:
+1. Retry immediately (network glitch)
+2. Check internet connection
+3. Reduce request complexity
+
+Retry recommended.
+""",
+    "api_error": """
+**API Error**
+
+The API returned an error. Recovery options:
+1. Wait 10 seconds and retry
+2. Check API status page
+3. Try a different model
+
+Retry with backoff recommended.
+""",
+    "context_overflow": """
+**Context Window Overflow**
+
+The request exceeded the context limit. Recovery options:
+1. Use /compact to reduce context
+2. Break the task into smaller steps
+3. Focus on specific files rather than entire codebase
+
+Context reduction required before retry.
+""",
+    "auth_error": """
+**Authentication Error**
+
+Authentication failed. Recovery options:
+1. Run `stravinsky-auth login gemini` or `stravinsky-auth login openai`
+2. Check if tokens have expired
+3. Verify API credentials
+
+Re-authentication required.
+""",
+}
+
+
+def ensure_state_dir():
+    """Ensure the state directory exists."""
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def detect_error_type(text: str) -> Optional[str]:
+    """
+    Detect the type of error from response text.
+    Returns the error type or None if no error detected.
+    """
+    text_lower = text.lower()
+
+    for error_type, patterns in ERROR_PATTERNS.items():
+        for pattern in patterns:
+            if re.search(pattern, text_lower, re.IGNORECASE):
+                return error_type
+
+    return None
+
+
+def log_recovery_event(
+    error_type: str, tool_name: str, response_snippet: str, session_id: Optional[str] = None
+):
+    """Log a recovery event to the JSONL file."""
+    ensure_state_dir()
+
+    event = {
+        "timestamp": datetime.now().isoformat(),
+        "error_type": error_type,
+        "tool_name": tool_name,
+        "response_snippet": response_snippet[:500],  # Truncate
+        "session_id": session_id,
+    }
+
+    try:
+        with open(RECOVERY_LOG, "a") as f:
+            f.write(json.dumps(event) + "\n")
+    except Exception:
+        pass  # Don't fail on logging errors
+
+
+def get_recent_failures(minutes: int = 5) -> int:
+    """Count recent failures within the specified time window."""
+    if not RECOVERY_LOG.exists():
+        return 0
+
+    cutoff = datetime.now().timestamp() - (minutes * 60)
+    count = 0
+
+    try:
+        with open(RECOVERY_LOG, "r") as f:
+            for line in f:
+                try:
+                    event = json.loads(line)
+                    event_time = datetime.fromisoformat(event["timestamp"]).timestamp()
+                    if event_time > cutoff:
+                        count += 1
+                except (json.JSONDecodeError, KeyError, ValueError):
+                    continue
+    except Exception:
+        pass
+
+    return count
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+    tool_response = hook_input.get("tool_response", "")
+    session_id = hook_input.get("session_id")
+
+    # Convert response to string if needed
+    if isinstance(tool_response, dict):
+        response_text = json.dumps(tool_response)
+    else:
+        response_text = str(tool_response)
+
+    # Detect error type
+    error_type = detect_error_type(response_text)
+
+    if error_type:
+        # Log the event
+        log_recovery_event(
+            error_type=error_type,
+            tool_name=tool_name,
+            response_snippet=response_text[:500],
+            session_id=session_id,
+        )
+
+        # Check for repeated failures
+        recent_count = get_recent_failures(minutes=5)
+
+        # Output recovery suggestion
+        suggestion = RECOVERY_SUGGESTIONS.get(error_type, "")
+
+        output = {
+            "error_detected": True,
+            "error_type": error_type,
+            "recent_failures": recent_count,
+            "suggestion": suggestion.strip(),
+        }
+
+        # If many recent failures, add escalation notice
+        if recent_count >= 3:
+            output["escalation"] = (
+                f"⚠️ {recent_count} failures in last 5 minutes. "
+                "Consider pausing and investigating the root cause."
+            )
+
+        # Print as JSON for downstream processing
+        print(json.dumps(output))
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky_claude_assets/hooks/stop_hook.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env -S uv run --script
+
+# /// script
+# requires-python = ">=3.8"
+# dependencies = [
+#     "anthropic",
+#     "python-dotenv",
+# ]
+
+"""
+Fix Stop Hook - Calls stravinsky_metrics.py on Stop events.
+
+This hook is triggered by .claude/settings.json on Stop/SubagentStop.
+It queries Stravinsky's cost tracker and sends a StravinskyMetrics event to the dashboard.
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+# Add hooks directory to path for script imports
+hooks_dir = Path(__file__).parent
+sys.path.insert(0, str(hooks_dir))
+
+
+def send_stravinsky_metrics(session_id: str) -> bool:
+    """Call stravinsky_metrics.py to query and send metrics to dashboard."""
+    script_path = hooks_dir / "stravinsky_metrics.py"
+
+    if not script_path.exists():
+        print(f"Error: stravinsky_metrics.py not found at {script_path}", file=sys.stderr)
+        return False
+
+    try:
+        # Build command
+        cmd = [
+            "uv",
+            "run",
+            "--script",
+            str(script_path),
+            "--session-id",
+            session_id,
+            "--summarize",  # Generate summary and send as event
+        ]
+
+        # Run command
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=10, check=False)
+
+        if result.returncode != 0:
+            print(
+                f"Error: stravinsky_metrics.py failed with exit code {result.returncode}",
+                file=sys.stderr,
+            )
+            print(f"stderr: {result.stderr}", file=sys.stderr)
+            return False
+
+        return True
+
+    except subprocess.TimeoutExpired:
+        print(f"Error: stravinsky_metrics.py timed out after 10 seconds", file=sys.stderr)
+        return False
+
+    except Exception as e:
+        print(f"Error: stravinsky_metrics.py execution failed: {e}", file=sys.stderr)
+        return False
+
+
+def main():
+    # Get session_id from environment or use default
+    session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+
+    # Determine hook type
+    hook_type = os.environ.get("CLAUDE_HOOK_EVENT_TYPE", "Stop")
+
+    # Send metrics to dashboard
+    success = send_stravinsky_metrics(session_id)
+
+    if not success:
+        sys.exit(1)
+
+    print(
+        f"✓ Successfully sent Stravinsky metrics for session {session_id} to dashboard",
+        file=sys.stderr,
+    )
+
+
+if __name__ == "__main__":
+    main()

stravinsky_claude_assets/hooks/stravinsky_metrics.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+Stravinsky Metrics Hook Script
+
+Queries Stravinsky's internal metrics and sends them to the observability dashboard.
+This hook is triggered on Stop/SubagentStop events.
+
+Usage:
+    stravinsky_metrics.py --session-id <session_id>
+
+Environment Variables:
+    CLAUDE_SESSION_ID: Fallback session ID if --session-id not provided
+
+Output:
+    Sends StravinskyMetrics event to dashboard via send_event.py
+
+Metrics Collected:
+    - Total session cost (USD)
+    - Total tokens used
+    - Per-agent cost and token breakdown
+    - Per-model cost and token breakdown (TODO)
+    - Agent count (active/total) (TODO)
+
+Error Handling:
+    Returns non-zero exit code on error to prevent blocking Claude Code operations.
+"""
+
+import sys
+import os
+import json
+import argparse
+import subprocess
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any
+from mcp_bridge.metrics.cost_tracker import CostTracker
+
+
+def load_usage_data(session_id: str) -> Dict[str, Any]:
+    """
+    Load usage data from Stravinsky's cost tracker.
+    
+    Uses CostTracker.get_session_summary() to get metrics for a session.
+
+    Args:
+        session_id: Claude Code session ID
+
+    Returns:
+        Dictionary with metrics data
+    """
+    summary = CostTracker.get_instance().get_session_summary(session_id)
+    
+    # Transform CostTracker summary to expected format
+    metrics = {
+        "total_cost": summary.get("total_cost", 0),
+        "total_tokens": summary.get("total_tokens", 0),
+        "by_agent": summary.get("by_agent", {}),
+        "by_model": {},  # Extract from summary if available
+    }
+    
+    return metrics
+
+
+
+
+def send_metrics_event(session_id: str, metrics: Dict[str, Any]) -> bool:
+    """
+    Send metrics event to observability dashboard via send_event.py.
+
+    Args:
+        session_id: Claude Code session ID
+        metrics: Metrics data dictionary
+
+    Returns:
+        True if successful, False otherwise
+    """
+    hook_dir = Path(__file__).parent
+    send_event_script = hook_dir / "send_event.py"
+
+    if not send_event_script.exists():
+        print(f"Error: send_event.py not found at {send_event_script}", file=sys.stderr)
+        return False
+
+    event_data = {
+        "session_id": session_id,
+        "metrics": metrics,
+        "timestamp": datetime.now().isoformat(),
+    }
+
+    cmd = [
+        "uv",
+        "run",
+        str(send_event_script),
+        "--source-app",
+        "stravinsky",
+        "--event-type",
+        "StravinskyMetrics",
+        "--summarize",
+    ]
+
+    try:
+        result = subprocess.run(
+            cmd, input=json.dumps(event_data), capture_output=True, text=True, timeout=10
+        )
+
+        if result.returncode != 0:
+            print(f"Error from send_event.py: {result.stderr}", file=sys.stderr)
+            return False
+
+        return True
+
+    except subprocess.TimeoutExpired:
+        print("Error: send_event.py timed out", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"Error running send_event.py: {e}", file=sys.stderr)
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Query Stravinsky metrics and send to dashboard")
+    parser.add_argument(
+        "--session-id", help="Claude Code session ID (falls back to CLAUDE_SESSION_ID env var)"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print metrics without sending to dashboard (for testing)",
+    )
+
+    args = parser.parse_args()
+
+    session_id = args.session_id or os.environ.get("CLAUDE_SESSION_ID", "default")
+
+    if not session_id or session_id == "default":
+        print("Warning: No session ID provided, using 'default'", file=sys.stderr)
+
+    metrics = load_usage_data(session_id)
+
+    if metrics is None:
+        print("Error: Failed to load metrics", file=sys.stderr)
+        sys.exit(1)
+
+    if args.dry_run:
+        print(json.dumps(metrics, indent=2))
+        sys.exit(0)
+
+    print(f"Stravinsky Metrics for session {session_id}:", file=sys.stderr)
+    print(f"  Total Cost: ${metrics['total_cost']:.6f}", file=sys.stderr)
+    print(f"  Total Tokens: {metrics['total_tokens']:,}", file=sys.stderr)
+    print(f"  Agents: {len(metrics['by_agent'])}", file=sys.stderr)
+
+    success = send_metrics_event(session_id, metrics)
+
+    if success:
+        print("Metrics sent to dashboard successfully", file=sys.stderr)
+        sys.exit(0)
+    else:
+        print("Failed to send metrics to dashboard", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()