oh-my-claude-sisyphus 1.11.1 → 2.0.1

package/scripts/keyword-detector.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+/**
+ * Sisyphus 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 .sisyphus directory
+  const localDir = join(directory, '.sisyphus');
+  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/persistent-mode.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+/**
+ * Sisyphus Persistent Mode Hook (Node.js)
+ * Unified handler for ultrawork, ralph-loop, 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, '.sisyphus', '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, '.sisyphus', 'ultrawork-state.json'))
+      || readJsonFile(join(homedir(), '.claude', 'ultrawork-state.json'));
+
+    // Check for ralph loop state
+    const ralphState = readJsonFile(join(directory, '.sisyphus', 'ralph-state.json'));
+
+    // Check for verification state
+    const verificationState = readJsonFile(join(directory, '.sisyphus', 'ralph-verification.json'));
+
+    // Count incomplete todos
+    const incompleteCount = countIncompleteTodos(todosDir, directory);
+
+    // Priority 1: Ralph Loop with Oracle Verification
+    if (ralphState?.active) {
+      const iteration = ralphState.iteration || 1;
+      const maxIter = ralphState.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: `<ralph-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 || ralphState.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
+
+</ralph-verification>
+
+---
+`
+        }));
+        return;
+      }
+
+      if (iteration < maxIter) {
+        const newIter = iteration + 1;
+        ralphState.iteration = newIter;
+        writeJsonFile(join(directory, '.sisyphus', 'ralph-state.json'), ralphState);
+
+        console.log(JSON.stringify({
+          continue: false,
+          reason: `<ralph-loop-continuation>
+
+[RALPH 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>${ralphState.completion_promise || 'TASK_COMPLETE'}</promise>
+5. Do NOT stop until the task is truly done
+
+${ralphState.prompt ? `Original task: ${ralphState.prompt}` : ''}
+
+</ralph-loop-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, '.sisyphus', '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();

package/scripts/post-tool-verifier.mjs

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+/**
+ * PostToolUse Hook: Verification Reminder System (Node.js)
+ * Monitors tool execution and provides contextual guidance
+ * Cross-platform: Windows, macOS, Linux
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// State file for session tracking
+const STATE_FILE = join(homedir(), '.claude', '.session-stats.json');
+
+// Ensure state directory exists
+try {
+  const stateDir = join(homedir(), '.claude');
+  if (!existsSync(stateDir)) {
+    mkdirSync(stateDir, { recursive: true });
+  }
+} catch {}
+
+// 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');
+}
+
+// Load session statistics
+function loadStats() {
+  try {
+    if (existsSync(STATE_FILE)) {
+      return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+    }
+  } catch {}
+  return { sessions: {} };
+}
+
+// Save session statistics
+function saveStats(stats) {
+  try {
+    writeFileSync(STATE_FILE, JSON.stringify(stats, null, 2));
+  } catch {}
+}
+
+// Update stats for this session
+function updateStats(toolName, sessionId) {
+  const stats = loadStats();
+
+  if (!stats.sessions[sessionId]) {
+    stats.sessions[sessionId] = {
+      tool_counts: {},
+      last_tool: '',
+      total_calls: 0,
+      started_at: Math.floor(Date.now() / 1000)
+    };
+  }
+
+  const session = stats.sessions[sessionId];
+  session.tool_counts[toolName] = (session.tool_counts[toolName] || 0) + 1;
+  session.last_tool = toolName;
+  session.total_calls = (session.total_calls || 0) + 1;
+  session.updated_at = Math.floor(Date.now() / 1000);
+
+  saveStats(stats);
+  return session.tool_counts[toolName];
+}
+
+// Detect failures in Bash output
+function detectBashFailure(output) {
+  const errorPatterns = [
+    /error:/i,
+    /failed/i,
+    /cannot/i,
+    /permission denied/i,
+    /command not found/i,
+    /no such file/i,
+    /exit code: [1-9]/i,
+    /exit status [1-9]/i,
+    /fatal:/i,
+    /abort/i,
+  ];
+
+  return errorPatterns.some(pattern => pattern.test(output));
+}
+
+// Detect background operation
+function detectBackgroundOperation(output) {
+  const bgPatterns = [
+    /started/i,
+    /running/i,
+    /background/i,
+    /async/i,
+    /task_id/i,
+    /spawned/i,
+  ];
+
+  return bgPatterns.some(pattern => pattern.test(output));
+}
+
+// Detect write failure
+function detectWriteFailure(output) {
+  const errorPatterns = [
+    /error/i,
+    /failed/i,
+    /permission denied/i,
+    /read-only/i,
+    /not found/i,
+  ];
+
+  return errorPatterns.some(pattern => pattern.test(output));
+}
+
+// Generate contextual message
+function generateMessage(toolName, toolOutput, sessionId, toolCount) {
+  let message = '';
+
+  switch (toolName) {
+    case 'Bash':
+      if (detectBashFailure(toolOutput)) {
+        message = 'Command failed. Please investigate the error and fix before continuing.';
+      } else if (detectBackgroundOperation(toolOutput)) {
+        message = 'Background operation detected. Remember to verify results before proceeding.';
+      }
+      break;
+
+    case 'Task':
+      if (detectWriteFailure(toolOutput)) {
+        message = 'Task delegation failed. Verify agent name and parameters.';
+      } else if (detectBackgroundOperation(toolOutput)) {
+        message = 'Background task launched. Use TaskOutput to check results when needed.';
+      } else if (toolCount > 5) {
+        message = `Multiple tasks delegated (${toolCount} total). Track their completion status.`;
+      }
+      break;
+
+    case 'Edit':
+      if (detectWriteFailure(toolOutput)) {
+        message = 'Edit operation failed. Verify file exists and content matches exactly.';
+      } else {
+        message = 'Code modified. Verify changes work as expected before marking complete.';
+      }
+      break;
+
+    case 'Write':
+      if (detectWriteFailure(toolOutput)) {
+        message = 'Write operation failed. Check file permissions and directory existence.';
+      } else {
+        message = 'File written. Test the changes to ensure they work correctly.';
+      }
+      break;
+
+    case 'TodoWrite':
+      if (/created|added/i.test(toolOutput)) {
+        message = 'Todo list updated. Proceed with next task on the list.';
+      } else if (/completed|done/i.test(toolOutput)) {
+        message = 'Task marked complete. Continue with remaining todos.';
+      } else if (/in_progress/i.test(toolOutput)) {
+        message = 'Task marked in progress. Focus on completing this task.';
+      }
+      break;
+
+    case 'Read':
+      if (toolCount > 10) {
+        message = `Extensive reading (${toolCount} files). Consider using Grep for pattern searches.`;
+      }
+      break;
+
+    case 'Grep':
+      if (/^0$|no matches/i.test(toolOutput)) {
+        message = 'No matches found. Verify pattern syntax or try broader search.';
+      }
+      break;
+
+    case 'Glob':
+      if (!toolOutput.trim() || /no files/i.test(toolOutput)) {
+        message = 'No files matched pattern. Verify glob syntax and directory.';
+      }
+      break;
+  }
+
+  return message;
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+
+    const toolName = data.toolName || '';
+    const toolOutput = data.toolOutput || '';
+    const sessionId = data.sessionId || 'unknown';
+
+    // Update session statistics
+    const toolCount = updateStats(toolName, sessionId);
+
+    // Generate contextual message
+    const message = generateMessage(toolName, toolOutput, sessionId, toolCount);
+
+    // Build response
+    const response = { continue: true };
+    if (message) {
+      response.message = message;
+    }
+
+    console.log(JSON.stringify(response, null, 2));
+  } catch (error) {
+    // On error, always continue
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();