oh-my-claude-sisyphus 1.11.0 → 1.11.2

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();

package/scripts/pre-tool-enforcer.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse Hook: Sisyphus 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, '.sisyphus', '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();