olympus-ai 1.0.0

package/scripts/post-tool-verifier.sh

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+
+"""
+PostToolUse Hook: Verification Reminder System
+Monitors tool execution and provides contextual guidance
+"""
+
+import sys
+import json
+import re
+import os
+from pathlib import Path
+from datetime import datetime
+
+# State file for session tracking
+STATE_FILE = Path.home() / ".claude" / ".session-stats.json"
+STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+def load_stats():
+    """Load session statistics from state file."""
+    if STATE_FILE.exists():
+        try:
+            with open(STATE_FILE, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {"sessions": {}}
+
+def save_stats(stats):
+    """Save session statistics to state file."""
+    try:
+        with open(STATE_FILE, 'w') as f:
+            json.dump(stats, f, indent=2)
+    except IOError:
+        pass  # Fail silently
+
+def update_stats(tool_name, session_id):
+    """Update execution count for this session and tool."""
+    stats = load_stats()
+
+    if session_id not in stats["sessions"]:
+        stats["sessions"][session_id] = {
+            "tool_counts": {},
+            "last_tool": "",
+            "total_calls": 0,
+            "started_at": int(datetime.now().timestamp())
+        }
+
+    session = stats["sessions"][session_id]
+    session["tool_counts"][tool_name] = session["tool_counts"].get(tool_name, 0) + 1
+    session["last_tool"] = tool_name
+    session["total_calls"] = session.get("total_calls", 0) + 1
+    session["updated_at"] = int(datetime.now().timestamp())
+
+    save_stats(stats)
+    return session["tool_counts"][tool_name]
+
+def detect_bash_failure(output):
+    """Detect failures in Bash tool output."""
+    error_patterns = [
+        r"error:",
+        r"failed",
+        r"cannot",
+        r"permission denied",
+        r"command not found",
+        r"no such file",
+        r"exit code: [1-9]",
+        r"exit status [1-9]",
+        r"fatal:",
+        r"abort",
+    ]
+
+    output_lower = output.lower()
+    for pattern in error_patterns:
+        if re.search(pattern, output_lower, re.IGNORECASE):
+            return True
+    return False
+
+def detect_background_operation(output):
+    """Detect if output suggests a background operation."""
+    bg_patterns = [
+        r"started",
+        r"running",
+        r"background",
+        r"async",
+        r"task_id",
+        r"spawned",
+    ]
+
+    output_lower = output.lower()
+    for pattern in bg_patterns:
+        if re.search(pattern, output_lower, re.IGNORECASE):
+            return True
+    return False
+
+def detect_write_failure(output):
+    """Detect failures in Write/Edit operations."""
+    error_patterns = [
+        r"error",
+        r"failed",
+        r"permission denied",
+        r"read-only",
+        r"not found",
+    ]
+
+    output_lower = output.lower()
+    for pattern in error_patterns:
+        if re.search(pattern, output_lower, re.IGNORECASE):
+            return True
+    return False
+
+def generate_message(tool_name, tool_output, session_id, tool_count):
+    """Generate contextual message based on tool usage."""
+    message = ""
+
+    if tool_name == "Bash":
+        if detect_bash_failure(tool_output):
+            message = "Command failed. Please investigate the error and fix before continuing."
+        elif detect_background_operation(tool_output):
+            message = "Background operation detected. Remember to verify results before proceeding."
+
+    elif tool_name == "Task":
+        if detect_write_failure(tool_output):
+            message = "Task delegation failed. Verify agent name and parameters."
+        elif detect_background_operation(tool_output):
+            message = "Background task launched. Use TaskOutput to check results when needed."
+        elif tool_count > 5:
+            message = f"Multiple tasks delegated ({tool_count} total). Track their completion status."
+
+    elif tool_name == "Edit":
+        if detect_write_failure(tool_output):
+            message = "Edit operation failed. Verify file exists and content matches exactly."
+        else:
+            message = "Code modified. Verify changes work as expected before marking complete."
+
+    elif tool_name == "Write":
+        if detect_write_failure(tool_output):
+            message = "Write operation failed. Check file permissions and directory existence."
+        else:
+            message = "File written. Test the changes to ensure they work correctly."
+
+    elif tool_name == "TodoWrite":
+        output_lower = tool_output.lower()
+        if re.search(r"created|added", output_lower):
+            message = "Todo list updated. Proceed with next task on the list."
+        elif re.search(r"completed|done", output_lower):
+            message = "Task marked complete. Continue with remaining todos."
+        elif re.search(r"in_progress", output_lower):
+            message = "Task marked in progress. Focus on completing this task."
+
+    elif tool_name == "Read":
+        if tool_count > 10:
+            message = f"Extensive reading ({tool_count} files). Consider using Grep for pattern searches."
+
+    elif tool_name == "Grep":
+        if re.search(r"^0$|no matches", tool_output):
+            message = "No matches found. Verify pattern syntax or try broader search."
+
+    elif tool_name == "Glob":
+        if not tool_output.strip() or re.search(r"no files", tool_output.lower()):
+            message = "No files matched pattern. Verify glob syntax and directory."
+
+    return message
+
+def main():
+    """Main hook execution."""
+    try:
+        # Read JSON input from stdin
+        input_data = json.load(sys.stdin)
+
+        tool_name = input_data.get("toolName", "")
+        tool_output = input_data.get("toolOutput", "")
+        session_id = input_data.get("sessionId", "unknown")
+        directory = input_data.get("directory", "")
+
+        # Update session statistics
+        tool_count = update_stats(tool_name, session_id)
+
+        # Generate contextual message
+        message = generate_message(tool_name, tool_output, session_id, tool_count)
+
+        # Build response JSON (always continue for post-tool hooks)
+        response = {"continue": True}
+        if message:
+            response["message"] = message
+
+        # Output response
+        print(json.dumps(response, indent=2))
+
+    except Exception as e:
+        # On error, always continue with no message
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

package/scripts/pre-tool-enforcer.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse Hook: Olympus Reminder Enforcer (Node.js)
+ * Injects contextual reminders before every tool execution
+ * Cross-platform: Windows, macOS, Linux
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+// Read all stdin
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+// Simple JSON field extraction
+function extractJsonField(input, field, defaultValue = '') {
+  try {
+    const data = JSON.parse(input);
+    return data[field] ?? defaultValue;
+  } catch {
+    // Fallback regex extraction
+    const match = input.match(new RegExp(`"${field}"\\s*:\\s*"([^"]*)"`, 'i'));
+    return match ? match[1] : defaultValue;
+  }
+}
+
+// Get todo status from project
+function getTodoStatus(directory) {
+  const todoFile = join(directory, '.olympus', 'todos.json');
+
+  if (!existsSync(todoFile)) {
+    return '';
+  }
+
+  try {
+    const content = readFileSync(todoFile, 'utf-8');
+    const data = JSON.parse(content);
+    const todos = data.todos || data;
+
+    if (!Array.isArray(todos)) {
+      return '';
+    }
+
+    const pending = todos.filter(t => t.status === 'pending').length;
+    const inProgress = todos.filter(t => t.status === 'in_progress').length;
+
+    if (pending + inProgress > 0) {
+      return `[${inProgress} active, ${pending} pending] `;
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return '';
+}
+
+// Generate contextual message based on tool type
+function generateMessage(toolName, todoStatus) {
+  const messages = {
+    TodoWrite: `${todoStatus}Mark todos in_progress BEFORE starting, completed IMMEDIATELY after finishing.`,
+    Bash: `${todoStatus}Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests).`,
+    Task: `${todoStatus}Launch multiple agents in parallel when tasks are independent. Use run_in_background for long operations.`,
+    Edit: `${todoStatus}Verify changes work after editing. Test functionality before marking complete.`,
+    Write: `${todoStatus}Verify changes work after editing. Test functionality before marking complete.`,
+    Read: `${todoStatus}Read multiple files in parallel when possible for faster analysis.`,
+    Grep: `${todoStatus}Combine searches in parallel when investigating multiple patterns.`,
+    Glob: `${todoStatus}Combine searches in parallel when investigating multiple patterns.`,
+  };
+
+  return messages[toolName] || `${todoStatus}The boulder never stops. Continue until all tasks complete.`;
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+
+    const toolName = extractJsonField(input, 'toolName', 'unknown');
+    const directory = extractJsonField(input, 'directory', process.cwd());
+
+    const todoStatus = getTodoStatus(directory);
+    const message = generateMessage(toolName, todoStatus);
+
+    console.log(JSON.stringify({
+      continue: true,
+      message: message
+    }, null, 2));
+  } catch (error) {
+    // On error, always continue
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

package/scripts/pre-tool-enforcer.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+
+# PreToolUse Hook: Olympus Reminder Enforcer
+# Injects contextual reminders before every tool execution
+
+set -euo pipefail
+
+# Read JSON input from stdin
+input=$(cat)
+
+# Simple JSON extraction using grep/sed (avoids jq dependency)
+extract_json_field() {
+    local field=$1
+    local default=${2:-""}
+    echo "$input" | grep -o "\"$field\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" | sed 's/.*"\([^"]*\)".*/\1/' || echo "$default"
+}
+
+toolName=$(extract_json_field "toolName" "unknown")
+directory=$(extract_json_field "directory" "")
+
+# Try to get todo count from todo list file (if exists)
+todo_file="${directory}/.olympus/todos.json"
+todo_status=""
+if [[ -f "$todo_file" ]] && command -v jq &> /dev/null; then
+    pending=$(jq -r '[.todos[] | select(.status == "pending")] | length' "$todo_file" 2>/dev/null || echo "0")
+    in_progress=$(jq -r '[.todos[] | select(.status == "in_progress")] | length' "$todo_file" 2>/dev/null || echo "0")
+    if [[ $((pending + in_progress)) -gt 0 ]]; then
+        todo_status="[${in_progress} active, ${pending} pending] "
+    fi
+fi
+
+# Generate contextual reminder based on tool type
+message=""
+
+case "$toolName" in
+    TodoWrite)
+        message="${todo_status}Mark todos in_progress BEFORE starting, completed IMMEDIATELY after finishing."
+        ;;
+
+    Bash)
+        message="${todo_status}Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+        ;;
+
+    Task)
+        message="${todo_status}Launch multiple agents in parallel when tasks are independent. Use run_in_background for long operations."
+        ;;
+
+    Edit|Write)
+        message="${todo_status}Verify changes work after editing. Test functionality before marking complete."
+        ;;
+
+    Read)
+        message="${todo_status}Read multiple files in parallel when possible for faster analysis."
+        ;;
+
+    Grep|Glob)
+        message="${todo_status}Combine searches in parallel when investigating multiple patterns."
+        ;;
+
+    *)
+        message="${todo_status}The boulder never stops. Continue until all tasks complete."
+        ;;
+esac
+
+# Return JSON response (always continue, just remind)
+# Escape message for JSON (replace " with \", newlines with \n)
+escaped_message=$(echo "$message" | sed 's/\\/\\\\/g' | sed 's/"/\\"/g' | tr '\n' ' ')
+
+cat <<EOF
+{
+    "continue": true,
+    "message": "$escaped_message"
+}
+EOF
+
+exit 0

package/scripts/sisyphus-aliases.sh

@@ -0,0 +1,18 @@
+# Olympus Mode Aliases for Claude CLI
+# Add these to your ~/.bashrc or ~/.zshrc
+
+# Primary Olympus alias - enforces task completion discipline
+alias claude-s='/home/bellman/.claude/claude-olympus.sh'
+
+# Work mode alias - shorter alternative
+alias claudew='/home/bellman/.claude/claude-olympus.sh'
+
+# Usage examples:
+#   claude-s "Refactor the API layer"
+#   claudew "Fix all failing tests"
+#   claude-s --model opus "Debug this complex issue"
+
+# Installation:
+# 1. Add the aliases above to your shell config (~/.bashrc or ~/.zshrc)
+# 2. Reload: source ~/.bashrc  (or source ~/.zshrc)
+# 3. Use: claude-s "your task here"

package/scripts/stop-continuation.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Olympus Stop Continuation Hook
+# Checks for incomplete todos and injects continuation prompt
+
+# Read stdin
+INPUT=$(cat)
+
+# Check for incomplete todos in the Claude todos directory
+TODOS_DIR="$HOME/.claude/todos"
+if [ -d "$TODOS_DIR" ]; then
+  INCOMPLETE_COUNT=0
+  for todo_file in "$TODOS_DIR"/*.json; do
+    if [ -f "$todo_file" ]; then
+      if command -v jq &> /dev/null; then
+        COUNT=$(jq '[.[] | select(.status != "completed" and .status != "cancelled")] | length' "$todo_file" 2>/dev/null || echo "0")
+        INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+      fi
+    fi
+  done
+
+  if [ "$INCOMPLETE_COUNT" -gt 0 ]; then
+    cat << EOF
+{"continue": false, "reason": "[SYSTEM REMINDER - TODO CONTINUATION]\n\nIncomplete tasks remain in your todo list ($INCOMPLETE_COUNT remaining). Continue working on the next pending task.\n\n- Proceed without asking for permission\n- Mark each task complete when finished\n- Do not stop until all tasks are done"}
+EOF
+    exit 0
+  fi
+fi
+
+# No incomplete todos - allow stop
+echo '{"continue": true}'
+exit 0