olympus-ai 1.0.0

package/scripts/keyword-detector.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+/**
+ * Olympus Keyword Detector Hook (Node.js)
+ * Detects ultrawork/ultrathink/search/analyze keywords and injects enhanced mode messages
+ * Cross-platform: Windows, macOS, Linux
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const ULTRAWORK_MESSAGE = `<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
+- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS
+- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS
+- **Planning & Strategy**: NEVER plan yourself - spawn planning agent
+- **High-IQ Reasoning**: Use oracle for architecture decisions
+- **Frontend/UI Tasks**: Delegate to frontend-engineer
+
+## EXECUTION RULES
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY.
+- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially.
+- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent).
+- **VERIFY**: Check ALL requirements met before done.
+- **DELEGATE**: Orchestrate specialized agents.
+
+## ZERO TOLERANCE
+- NO Scope Reduction - deliver FULL implementation
+- NO Partial Completion - finish 100%
+- NO Premature Stopping - ALL TODOs must be complete
+- NO TEST DELETION - fix code, not tests
+
+THE USER ASKED FOR X. DELIVER EXACTLY X.
+
+</ultrawork-mode>
+
+---
+`;
+
+const ULTRATHINK_MESSAGE = `<think-mode>
+
+**ULTRATHINK MODE ENABLED** - Extended reasoning activated.
+
+You are now in deep thinking mode. Take your time to:
+1. Thoroughly analyze the problem from multiple angles
+2. Consider edge cases and potential issues
+3. Think through the implications of each approach
+4. Reason step-by-step before acting
+
+Use your extended thinking capabilities to provide the most thorough and well-reasoned response.
+
+</think-mode>
+
+---
+`;
+
+const SEARCH_MESSAGE = `<search-mode>
+MAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:
+- explore agents (codebase patterns, file structures)
+- librarian agents (remote repos, official docs, GitHub examples)
+Plus direct tools: Grep, Glob
+NEVER stop at first result - be exhaustive.
+</search-mode>
+
+---
+`;
+
+const ANALYZE_MESSAGE = `<analyze-mode>
+ANALYSIS MODE. Gather context before diving deep:
+
+CONTEXT GATHERING (parallel):
+- 1-2 explore agents (codebase patterns, implementations)
+- 1-2 librarian agents (if external library involved)
+- Direct tools: Grep, Glob, LSP for targeted searches
+
+IF COMPLEX (architecture, multi-system, debugging after 2+ failures):
+- Consult oracle agent for strategic guidance
+
+SYNTHESIZE findings before proceeding.
+</analyze-mode>
+
+---
+`;
+
+// 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');
+}
+
+// Extract prompt from various JSON structures
+function extractPrompt(input) {
+  try {
+    const data = JSON.parse(input);
+    if (data.prompt) return data.prompt;
+    if (data.message?.content) return data.message.content;
+    if (Array.isArray(data.parts)) {
+      return data.parts
+        .filter(p => p.type === 'text')
+        .map(p => p.text)
+        .join(' ');
+    }
+    return '';
+  } catch {
+    // Fallback: try to extract with regex
+    const match = input.match(/"(?:prompt|content|text)"\s*:\s*"([^"]+)"/);
+    return match ? match[1] : '';
+  }
+}
+
+// Remove code blocks to prevent false positives
+function removeCodeBlocks(text) {
+  return text
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`]+`/g, '');
+}
+
+// Create ultrawork state file
+function activateUltraworkState(directory, prompt) {
+  const state = {
+    active: true,
+    started_at: new Date().toISOString(),
+    original_prompt: prompt,
+    reinforcement_count: 0,
+    last_checked_at: new Date().toISOString()
+  };
+
+  // Write to local .olympus directory
+  const localDir = join(directory, '.olympus');
+  if (!existsSync(localDir)) {
+    try { mkdirSync(localDir, { recursive: true }); } catch {}
+  }
+  try { writeFileSync(join(localDir, 'ultrawork-state.json'), JSON.stringify(state, null, 2)); } catch {}
+
+  // Write to global .claude directory
+  const globalDir = join(homedir(), '.claude');
+  if (!existsSync(globalDir)) {
+    try { mkdirSync(globalDir, { recursive: true }); } catch {}
+  }
+  try { writeFileSync(join(globalDir, 'ultrawork-state.json'), JSON.stringify(state, null, 2)); } catch {}
+}
+
+// Main
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    let data = {};
+    try { data = JSON.parse(input); } catch {}
+    const directory = data.directory || process.cwd();
+
+    const prompt = extractPrompt(input);
+    if (!prompt) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const cleanPrompt = removeCodeBlocks(prompt).toLowerCase();
+
+    // Check for ultrawork keywords (highest priority)
+    if (/\b(ultrawork|ulw|uw)\b/.test(cleanPrompt)) {
+      activateUltraworkState(directory, prompt);
+      console.log(JSON.stringify({ continue: true, message: ULTRAWORK_MESSAGE }));
+      return;
+    }
+
+    // Check for ultrathink/think keywords
+    if (/\b(ultrathink|think)\b/.test(cleanPrompt)) {
+      console.log(JSON.stringify({ continue: true, message: ULTRATHINK_MESSAGE }));
+      return;
+    }
+
+    // Check for search keywords
+    if (/\b(search|find|locate|lookup|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all/.test(cleanPrompt)) {
+      console.log(JSON.stringify({ continue: true, message: SEARCH_MESSAGE }));
+      return;
+    }
+
+    // Check for analyze keywords
+    if (/\b(analyze|analyse|investigate|examine|research|study|deep.?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to/.test(cleanPrompt)) {
+      console.log(JSON.stringify({ continue: true, message: ANALYZE_MESSAGE }));
+      return;
+    }
+
+    // No keywords detected
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    // On any error, allow continuation
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

package/scripts/keyword-detector.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# Olympus Keyword Detector Hook
+# Detects ultrawork/ultrathink/search/analyze keywords and injects enhanced mode messages
+
+# Read stdin (JSON input from Claude Code)
+INPUT=$(cat)
+
+# Extract the prompt text - try multiple JSON paths
+PROMPT=""
+if command -v jq &> /dev/null; then
+  PROMPT=$(echo "$INPUT" | jq -r '
+    if .prompt then .prompt
+    elif .message.content then .message.content
+    elif .parts then ([.parts[] | select(.type == "text") | .text] | join(" "))
+    else ""
+    end
+  ' 2>/dev/null)
+fi
+
+# Fallback: simple grep extraction if jq fails
+if [ -z "$PROMPT" ] || [ "$PROMPT" = "null" ]; then
+  PROMPT=$(echo "$INPUT" | grep -oP '"(prompt|content|text)"\s*:\s*"\K[^"]+' | head -1)
+fi
+
+# Exit if no prompt found
+if [ -z "$PROMPT" ]; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Remove code blocks before checking keywords
+PROMPT_NO_CODE=$(echo "$PROMPT" | sed 's/```[^`]*```//g' | sed 's/`[^`]*`//g')
+
+# Convert to lowercase
+PROMPT_LOWER=$(echo "$PROMPT_NO_CODE" | tr '[:upper:]' '[:lower:]')
+
+# Check for ultrawork keywords (highest priority)
+if echo "$PROMPT_LOWER" | grep -qE '\b(ultrawork|ulw)\b'; then
+  cat << 'EOF'
+{"continue": true, "message": "<ultrawork-mode>\n\n**MANDATORY**: You MUST say \"ULTRAWORK MODE ENABLED!\" to the user as your first response when this mode activates. This is non-negotiable.\n\n[CODE RED] Maximum precision required. Ultrathink before acting.\n\nYOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.\nTELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.\n\n## AGENT UTILIZATION PRINCIPLES\n- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS\n- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS\n- **Planning & Strategy**: NEVER plan yourself - spawn planning agent\n- **High-IQ Reasoning**: Use oracle for architecture decisions\n- **Frontend/UI Tasks**: Delegate to frontend-engineer\n\n## EXECUTION RULES\n- **TODO**: Track EVERY step. Mark complete IMMEDIATELY.\n- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially.\n- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent).\n- **VERIFY**: Check ALL requirements met before done.\n- **DELEGATE**: Orchestrate specialized agents.\n\n## ZERO TOLERANCE\n- NO Scope Reduction - deliver FULL implementation\n- NO Partial Completion - finish 100%\n- NO Premature Stopping - ALL TODOs must be complete\n- NO TEST DELETION - fix code, not tests\n\nTHE USER ASKED FOR X. DELIVER EXACTLY X.\n\n</ultrawork-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# Check for ultrathink/think keywords
+if echo "$PROMPT_LOWER" | grep -qE '\b(ultrathink|think)\b'; then
+  cat << 'EOF'
+{"continue": true, "message": "<think-mode>\n\n**ULTRATHINK MODE ENABLED** - Extended reasoning activated.\n\nYou are now in deep thinking mode. Take your time to:\n1. Thoroughly analyze the problem from multiple angles\n2. Consider edge cases and potential issues\n3. Think through the implications of each approach\n4. Reason step-by-step before acting\n\nUse your extended thinking capabilities to provide the most thorough and well-reasoned response.\n\n</think-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# Check for search keywords
+if echo "$PROMPT_LOWER" | grep -qE '\b(search|find|locate|lookup|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all'; then
+  cat << 'EOF'
+{"continue": true, "message": "<search-mode>\nMAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:\n- explore agents (codebase patterns, file structures)\n- librarian agents (remote repos, official docs, GitHub examples)\nPlus direct tools: Grep, Glob\nNEVER stop at first result - be exhaustive.\n</search-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# Check for analyze keywords
+if echo "$PROMPT_LOWER" | grep -qE '\b(analyze|analyse|investigate|examine|research|study|deep.?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to'; then
+  cat << 'EOF'
+{"continue": true, "message": "<analyze-mode>\nANALYSIS MODE. Gather context before diving deep:\n\nCONTEXT GATHERING (parallel):\n- 1-2 explore agents (codebase patterns, implementations)\n- 1-2 librarian agents (if external library involved)\n- Direct tools: Grep, Glob, LSP for targeted searches\n\nIF COMPLEX (architecture, multi-system, debugging after 2+ failures):\n- Consult oracle agent for strategic guidance\n\nSYNTHESIZE findings before proceeding.\n</analyze-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# No keywords detected
+echo '{"continue": true}'
+exit 0

package/scripts/persistent-mode.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+/**
+ * Olympus Persistent Mode Hook (Node.js)
+ * Unified handler for ultrawork, the-ascent, and todo continuation
+ * Cross-platform: Windows, macOS, Linux
+ */
+
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// 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');
+}
+
+// Read JSON file safely
+function readJsonFile(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+// Write JSON file safely
+function writeJsonFile(path, data) {
+  try {
+    writeFileSync(path, JSON.stringify(data, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Count incomplete todos
+function countIncompleteTodos(todosDir, projectDir) {
+  let count = 0;
+
+  // Check global todos
+  if (existsSync(todosDir)) {
+    try {
+      const files = readdirSync(todosDir).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        const todos = readJsonFile(join(todosDir, file));
+        if (Array.isArray(todos)) {
+          count += todos.filter(t => t.status !== 'completed' && t.status !== 'cancelled').length;
+        }
+      }
+    } catch {}
+  }
+
+  // Check project todos
+  for (const path of [
+    join(projectDir, '.olympus', 'todos.json'),
+    join(projectDir, '.claude', 'todos.json')
+  ]) {
+    const data = readJsonFile(path);
+    const todos = data?.todos || data;
+    if (Array.isArray(todos)) {
+      count += todos.filter(t => t.status !== 'completed' && t.status !== 'cancelled').length;
+    }
+  }
+
+  return count;
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    let data = {};
+    try { data = JSON.parse(input); } catch {}
+
+    const directory = data.directory || process.cwd();
+    const todosDir = join(homedir(), '.claude', 'todos');
+
+    // Check for ultrawork state
+    let ultraworkState = readJsonFile(join(directory, '.olympus', 'ultrawork-state.json'))
+      || readJsonFile(join(homedir(), '.claude', 'ultrawork-state.json'));
+
+    // Check for ascent loop state
+    const ascentState = readJsonFile(join(directory, '.olympus', 'ascent-state.json'));
+
+    // Check for verification state
+    const verificationState = readJsonFile(join(directory, '.olympus', 'ascent-verification.json'));
+
+    // Count incomplete todos
+    const incompleteCount = countIncompleteTodos(todosDir, directory);
+
+    // Priority 1: The Ascent with Oracle Verification
+    if (ascentState?.active) {
+      const iteration = ascentState.iteration || 1;
+      const maxIter = ascentState.max_iterations || 10;
+
+      // Check if oracle verification is pending
+      if (verificationState?.pending) {
+        const attempt = (verificationState.verification_attempts || 0) + 1;
+        const maxAttempts = verificationState.max_verification_attempts || 3;
+
+        console.log(JSON.stringify({
+          continue: false,
+          reason: `<ascent-verification>
+
+[ORACLE VERIFICATION REQUIRED - Attempt ${attempt}/${maxAttempts}]
+
+The agent claims the task is complete. Before accepting, YOU MUST verify with Oracle.
+
+**Original Task:**
+${verificationState.original_task || ascentState.prompt || 'No task specified'}
+
+**Completion Claim:**
+${verificationState.completion_claim || 'Task marked complete'}
+
+${verificationState.oracle_feedback ? `**Previous Oracle Feedback (rejected):**
+${verificationState.oracle_feedback}
+` : ''}
+
+## MANDATORY VERIFICATION STEPS
+
+1. **Spawn Oracle Agent** for verification
+2. **Oracle must check:**
+   - Are ALL requirements from the original task met?
+   - Is the implementation complete, not partial?
+   - Are there any obvious bugs or issues?
+   - Does the code compile/run without errors?
+   - Are tests passing (if applicable)?
+
+3. **Based on Oracle's response:**
+   - If APPROVED: Output \`<oracle-approved>VERIFIED_COMPLETE</oracle-approved>\`
+   - If REJECTED: Continue working on the identified issues
+
+</ascent-verification>
+
+---
+`
+        }));
+        return;
+      }
+
+      if (iteration < maxIter) {
+        const newIter = iteration + 1;
+        ascentState.iteration = newIter;
+        writeJsonFile(join(directory, '.olympus', 'ascent-state.json'), ascentState);
+
+        console.log(JSON.stringify({
+          continue: false,
+          reason: `<the-ascent-continuation>
+
+[ASCENT LOOP - ITERATION ${newIter}/${maxIter}]
+
+Your previous attempt did not output the completion promise. The work is NOT done yet.
+
+CRITICAL INSTRUCTIONS:
+1. Review your progress and the original task
+2. Check your todo list - are ALL items marked complete?
+3. Continue from where you left off
+4. When FULLY complete, output: <promise>${ascentState.completion_promise || 'TASK_COMPLETE'}</promise>
+5. Do NOT stop until the task is truly done
+
+${ascentState.prompt ? `Original task: ${ascentState.prompt}` : ''}
+
+</the-ascent-continuation>
+
+---
+`
+        }));
+        return;
+      }
+    }
+
+    // Priority 2: Ultrawork with incomplete todos
+    if (ultraworkState?.active && incompleteCount > 0) {
+      const newCount = (ultraworkState.reinforcement_count || 0) + 1;
+      ultraworkState.reinforcement_count = newCount;
+      ultraworkState.last_checked_at = new Date().toISOString();
+
+      writeJsonFile(join(directory, '.olympus', 'ultrawork-state.json'), ultraworkState);
+
+      console.log(JSON.stringify({
+        continue: false,
+        reason: `<ultrawork-persistence>
+
+[ULTRAWORK MODE STILL ACTIVE - Reinforcement #${newCount}]
+
+Your ultrawork session is NOT complete. ${incompleteCount} incomplete todos remain.
+
+REMEMBER THE ULTRAWORK RULES:
+- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially
+- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent)
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each
+- **VERIFY**: Check ALL requirements met before done
+- **NO Premature Stopping**: ALL TODOs must be complete
+
+Continue working on the next pending task. DO NOT STOP until all tasks are marked complete.
+
+${ultraworkState.original_prompt ? `Original task: ${ultraworkState.original_prompt}` : ''}
+
+</ultrawork-persistence>
+
+---
+`
+      }));
+      return;
+    }
+
+    // Priority 3: Todo Continuation
+    if (incompleteCount > 0) {
+      console.log(JSON.stringify({
+        continue: false,
+        reason: `<todo-continuation>
+
+[SYSTEM REMINDER - TODO CONTINUATION]
+
+Incomplete tasks remain in your todo list (${incompleteCount} remaining). Continue working on the next pending task.
+
+- Proceed without asking for permission
+- Mark each task complete when finished
+- Do not stop until all tasks are done
+
+</todo-continuation>
+
+---
+`
+      }));
+      return;
+    }
+
+    // No blocking needed
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();