@sureshsankaran/ralph-wiggum 0.1.9 → 0.1.12

package/commands/ralph-loop.md

@@ -4,78 +4,11 @@ description: "Start Ralph Wiggum loop in current session"
 
 # Ralph Loop Command
 
-!`export RALPH_ARGS='$ARGUMENTS' && node -e "
-var args = process.env.RALPH_ARGS || '';
-var fs = require('fs');
-var path = require('path');
-
-// Unescape the CLI escaping - remove outer quotes and unescape inner quotes
-args = args.trim();
-if ((args.startsWith('\"') && args.endsWith('\"')) || (args.startsWith(\"'\") && args.endsWith(\"'\"))) {
-args = args.slice(1, -1);
-}
-args = args.replace(/\\\\\"/g, '\"');
-
-var maxIterations = 0;
-var completionPromise = 'null';
-var prompt = args;
-
-var maxMatch = args.match(/--max-iterations\s+(\d+)/);
-if (maxMatch) {
-maxIterations = parseInt(maxMatch[1], 10);
-prompt = prompt.replace(/--max-iterations\s+\d+/, '');
-}
-
-var cpMatch = args.match(/--completion-promise\s+\"([^\"]+)\"/);
-if (cpMatch) {
-completionPromise = cpMatch[1];
-prompt = prompt.replace(/--completion-promise\s+\"[^\"]+\"/, '');
-} else {
-var cpMatch2 = args.match(/--completion-promise\s+(\S+)/);
-if (cpMatch2) {
-completionPromise = cpMatch2[1];
-prompt = prompt.replace(/--completion-promise\s+\S+/, '');
-}
-}
-
-prompt = prompt.trim().replace(/^\"|\"$/g, '');
-
-if (!prompt) {
-console.log('Error: No prompt provided.');
-console.log('Usage: /ralph-loop \"<prompt>\" [--max-iterations N] [--completion-promise TEXT]');
-process.exit(1);
-}
-
-var configDir = process.env.XDG_CONFIG_HOME || path.join(require('os').homedir(), '.config');
-var dir = path.join(configDir, 'opencode', 'state');
-fs.mkdirSync(dir, { recursive: true });
-
-var cpYaml = completionPromise === 'null' ? 'null' : '\"' + completionPromise + '\"';
-var lines = [
-'---',
-'active: true',
-'iteration: 1',
-'max_iterations: ' + maxIterations,
-'completion_promise: ' + cpYaml,
-'started_at: \"' + new Date().toISOString() + '\"',
-'---',
-'',
-prompt
-];
-
-fs.writeFileSync(path.join(dir, 'ralph-loop.local.md'), lines.join('\n') + '\n');
-
-console.log('Ralph loop activated!');
-console.log('Iteration: 1');
-console.log('Max iterations: ' + (maxIterations > 0 ? maxIterations : 'unlimited'));
-console.log('Completion promise: ' + (completionPromise !== 'null' ? completionPromise : 'none'));
-console.log('');
-console.log(prompt);
-"`
+!`node ~/.config/opencode/scripts/ralph-wiggum/setup-loop.js $ARGUMENTS`
 
 Please work on the task described above. The Ralph loop is now active.
 
-When the session becomes idle, the session.idle hook will feed the SAME PROMPT back to you for the next iteration. You'll see your previous work in files and git history, allowing you to iterate and improve.
+When the session becomes idle, the session.stop hook will feed the SAME PROMPT back to you for the next iteration. You'll see your previous work in files and git history, allowing you to iterate and improve.
 
 CRITICAL RULE: If a completion promise is set, you may ONLY output it when the statement is completely and unequivocally TRUE. Do not output false promises to escape the loop, even if you think you're stuck or should exit for other reasons. The loop is designed to continue until genuine completion.
 

package/dist/index.d.ts

@@ -1,15 +1,3 @@
 import type { Plugin } from "@opencode-ai/plugin";
-/**
- * Ralph Wiggum Plugin - Iterative AI Development
- *
- * This plugin implements the Ralph Wiggum technique: continuously feeding
- * the same prompt to the AI until the task is complete.
- *
- * Usage:
- * 1. Start a loop: /ralph-loop "Your task description" --max-iterations 10 --completion-promise "DONE"
- * 2. Cancel a loop: /cancel-ralph
- *
- * The AI should output <promise>DONE</promise> when the task is complete.
- */
 export declare const RalphWiggumPlugin: Plugin;
 export default RalphWiggumPlugin;

package/dist/index.js

@@ -1,21 +1,27 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-// Use a global state directory that won't be affected by project snapshot/revert
 function getStateFilePath() {
     const configDir = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
     const stateDir = join(configDir, "opencode", "state");
-    // Ensure directory exists
     mkdirSync(stateDir, { recursive: true });
     return join(stateDir, "ralph-loop.local.md");
 }
+function getLogPath() {
+    const configDir = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    return join(configDir, "opencode", "state", "ralph-debug.log");
+}
+function log(msg) {
+    const ts = new Date().toISOString();
+    appendFileSync(getLogPath(), `[${ts}] ${msg}\n`);
+}
 function parseState(content) {
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!frontmatterMatch)
         return null;
     const [, frontmatter, prompt] = frontmatterMatch;
     const lines = frontmatter.split("\n");
-    const state = { prompt: prompt.trim() };
+    const state = { prompt: prompt.trim(), last_processed_id: null };
     for (const line of lines) {
         const [key, ...valueParts] = line.split(":");
         if (!key)
@@ -37,6 +43,9 @@ function parseState(content) {
             case "started_at":
                 state.started_at = value.replace(/^"|"$/g, "");
                 break;
+            case "last_processed_id":
+                state.last_processed_id = value === "null" ? null : value.replace(/^"|"$/g, "");
+                break;
         }
     }
     if (state.active === undefined ||
@@ -51,100 +60,127 @@ function extractPromiseText(text) {
     const match = text.match(/<promise>(.*?)<\/promise>/s);
     return match ? match[1].trim().replace(/\s+/g, " ") : null;
 }
-/**
- * Ralph Wiggum Plugin - Iterative AI Development
- *
- * This plugin implements the Ralph Wiggum technique: continuously feeding
- * the same prompt to the AI until the task is complete.
- *
- * Usage:
- * 1. Start a loop: /ralph-loop "Your task description" --max-iterations 10 --completion-promise "DONE"
- * 2. Cancel a loop: /cancel-ralph
- *
- * The AI should output <promise>DONE</promise> when the task is complete.
- */
 export const RalphWiggumPlugin = async ({ client }) => {
+    const version = "0.1.12";
+    log(`Plugin loaded, version=${version}`);
     const stateFilePath = getStateFilePath();
-    // In-memory state to prevent double-processing
+    // Clear log file on plugin load
+    try {
+        writeFileSync(getLogPath(), "");
+    }
+    catch { }
     let completionDetected = false;
-    let pendingIteration = -1; // Track iteration we're currently processing/waiting for
-    let lastAssistantId = ""; // Track last assistant message to detect new responses
-    // Cast to extended hooks type that includes experimental.session.stop
+    let lastProcessedId = null;
+    let iterationInProgress = false;
+    let callCount = 0;
+    log(`Plugin initialized`);
     const hooks = {
-        // Stop hook: called when main session loop is about to exit
         "experimental.session.stop": async (input, output) => {
-            // Only handle main session loop, not subtasks
-            if (!existsSync(stateFilePath))
+            const myCallId = ++callCount;
+            log(`[${myCallId}] Hook entry - iterationInProgress=${iterationInProgress}, lastProcessedId=${lastProcessedId}`);
+            // FIRST: Check lock synchronously before any async operations
+            if (iterationInProgress) {
+                log(`[${myCallId}] Blocked by lock`);
+                output.decision = "block";
                 return;
+            }
+            if (!existsSync(stateFilePath)) {
+                log(`[${myCallId}] No state file`);
+                return;
+            }
             const content = readFileSync(stateFilePath, "utf-8");
             const state = parseState(content);
-            if (!state || !state.active)
-                return;
-            // If completion already detected, allow normal exit
-            if (completionDetected)
+            if (!state || !state.active) {
+                log(`[${myCallId}] No active state`);
                 return;
-            // Fetch last assistant message text for this session
-            const messages = await client.session.messages({ path: { id: input.sessionID } }).then((res) => res.data ?? []);
-            const lastAssistant = [...messages]
-                .reverse()
-                .find((m) => m.info.role === "assistant" && m.parts.some((p) => p.type === "text"));
-            if (!lastAssistant)
-                return;
-            // Prevent double-triggering: if we already sent a prompt for this iteration
-            // and haven't seen a new assistant message, skip
-            if (pendingIteration === state.iteration && lastAssistant.info.id === lastAssistantId) {
-                output.decision = "block"; // Still block, we're waiting for AI to respond
+            }
+            if (completionDetected) {
+                log(`[${myCallId}] Completion already detected`);
                 return;
             }
-            // Update tracking
-            lastAssistantId = lastAssistant.info.id;
-            const textParts = lastAssistant.parts.filter((p) => p.type === "text");
-            const fullText = textParts.map((p) => p.text).join("\n");
-            // Check completion promise
-            if (state.completion_promise) {
-                const promiseText = extractPromiseText(fullText);
-                if (promiseText === state.completion_promise) {
-                    completionDetected = true;
-                    console.log(`\nRalph loop complete! Detected <promise>${state.completion_promise}</promise>`);
+            // Acquire lock BEFORE async operation
+            iterationInProgress = true;
+            log(`[${myCallId}] Lock acquired, state.iteration=${state.iteration}`);
+            try {
+                const messages = await client.session.messages({ path: { id: input.sessionID } }).then((res) => res.data ?? []);
+                const lastAssistant = [...messages]
+                    .reverse()
+                    .find((m) => m.info.role === "assistant" && m.parts.some((p) => p.type === "text"));
+                if (!lastAssistant) {
+                    log(`[${myCallId}] No assistant message, releasing lock`);
+                    iterationInProgress = false;
+                    output.decision = "block";
+                    return;
+                }
+                const assistantId = lastAssistant.info.id;
+                log(`[${myCallId}] Found assistant id=${assistantId}, lastProcessedId=${lastProcessedId}`);
+                // Check if we already processed this message
+                if (lastProcessedId === assistantId) {
+                    log(`[${myCallId}] Already processed, keeping lock, blocking`);
+                    output.decision = "block";
+                    return;
+                }
+                // Mark this message as processed IMMEDIATELY
+                lastProcessedId = assistantId;
+                log(`[${myCallId}] Processing new message, set lastProcessedId=${assistantId}`);
+                const textParts = lastAssistant.parts.filter((p) => p.type === "text");
+                const fullText = textParts.map((p) => p.text).join("\n");
+                // Check completion promise
+                if (state.completion_promise) {
+                    const promiseText = extractPromiseText(fullText);
+                    if (promiseText === state.completion_promise) {
+                        completionDetected = true;
+                        console.log(`\nRalph loop complete! Detected <promise>${state.completion_promise}</promise>`);
+                        try {
+                            unlinkSync(stateFilePath);
+                        }
+                        catch { }
+                        iterationInProgress = false;
+                        log(`[${myCallId}] Completion detected, allowing exit`);
+                        return;
+                    }
+                }
+                // Max-iteration safety
+                if (state.max_iterations > 0 && state.iteration >= state.max_iterations) {
+                    console.log(`\nRalph loop: Max iterations (${state.max_iterations}) reached.`);
                     try {
                         unlinkSync(stateFilePath);
                     }
                     catch { }
+                    iterationInProgress = false;
+                    log(`[${myCallId}] Max iterations reached, allowing exit`);
                     return;
                 }
-            }
-            // Max-iteration safety
-            if (state.max_iterations > 0 && state.iteration >= state.max_iterations) {
-                console.log(`\nRalph loop: Max iterations (${state.max_iterations}) reached.`);
-                try {
-                    unlinkSync(stateFilePath);
+                const nextIteration = state.iteration + 1;
+                log(`[${myCallId}] Advancing to iteration ${nextIteration}`);
+                // Update state file
+                let updatedContent = content.replace(/^iteration: \d+$/m, `iteration: ${nextIteration}`);
+                if (updatedContent.includes("last_processed_id:")) {
+                    updatedContent = updatedContent.replace(/^last_processed_id: .*$/m, `last_processed_id: "${assistantId}"`);
                 }
-                catch { }
-                return;
+                else {
+                    updatedContent = updatedContent.replace(/^(started_at: .*)$/m, `$1\nlast_processed_id: "${assistantId}"`);
+                }
+                writeFileSync(stateFilePath, updatedContent);
+                const systemMsg = state.completion_promise
+                    ? `Ralph iteration ${nextIteration} | To stop: output <promise>${state.completion_promise}</promise> (ONLY when TRUE)`
+                    : `Ralph iteration ${nextIteration} | No completion promise set`;
+                console.log(`\n${systemMsg}`);
+                await client.session.promptAsync({
+                    path: { id: input.sessionID },
+                    body: {
+                        parts: [{ type: "text", text: `[${systemMsg}]\n\n${state.prompt}` }],
+                    },
+                });
+                iterationInProgress = false;
+                log(`[${myCallId}] Prompt sent, lock released, blocking exit`);
+                output.decision = "block";
+            }
+            catch (err) {
+                log(`[${myCallId}] Error: ${err}`);
+                iterationInProgress = false;
+                throw err;
             }
-            const nextIteration = state.iteration + 1;
-            pendingIteration = nextIteration;
-            // Update state file with new iteration
-            const updated = content.replace(/^iteration: \d+$/m, `iteration: ${nextIteration}`);
-            writeFileSync(stateFilePath, updated);
-            const systemMsg = state.completion_promise
-                ? `Ralph iteration ${nextIteration} | To stop: output <promise>${state.completion_promise}</promise> (ONLY when TRUE)`
-                : `Ralph iteration ${nextIteration} | No completion promise set`;
-            console.log(`\n${systemMsg}`);
-            // Enqueue next iteration by sending same prompt back into main session
-            await client.session.promptAsync({
-                path: { id: input.sessionID },
-                body: {
-                    parts: [
-                        {
-                            type: "text",
-                            text: `[${systemMsg}]\n\n${state.prompt}`,
-                        },
-                    ],
-                },
-            });
-            // Block loop exit so we can continue iterating
-            output.decision = "block";
         },
     };
     return hooks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sureshsankaran/ralph-wiggum",
-  "version": "0.1.9",
+  "version": "0.1.12",
   "description": "Ralph Wiggum iterative AI development plugin for OpenCode - continuously loops the same prompt until task completion",
   "type": "module",
   "main": "dist/index.js",

package/scripts/postinstall.js

@@ -8,12 +8,16 @@ import { fileURLToPath } from "node:url"
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const packageRoot = join(__dirname, "..")
 
-const configDir = join(homedir(), ".config", "opencode", "command")
-
-// Create command directory if it doesn't exist
-if (!existsSync(configDir)) {
-  mkdirSync(configDir, { recursive: true })
-  console.log(`Created directory: ${configDir}`)
+const configBase = join(homedir(), ".config", "opencode")
+const commandDir = join(configBase, "command")
+const scriptsDir = join(configBase, "scripts", "ralph-wiggum")
+
+// Create directories if they don't exist
+for (const dir of [commandDir, scriptsDir]) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+    console.log(`Created directory: ${dir}`)
+  }
 }
 
 // Copy command files
@@ -22,7 +26,7 @@ const commandsDir = join(packageRoot, "commands")
 
 for (const cmd of commands) {
   const src = join(commandsDir, cmd)
-  const dest = join(configDir, cmd)
+  const dest = join(commandDir, cmd)
 
   if (existsSync(src)) {
     copyFileSync(src, dest)
@@ -32,6 +36,17 @@ for (const cmd of commands) {
   }
 }
 
+// Copy setup script
+const setupSrc = join(packageRoot, "scripts", "setup-loop.js")
+const setupDest = join(scriptsDir, "setup-loop.js")
+
+if (existsSync(setupSrc)) {
+  copyFileSync(setupSrc, setupDest)
+  console.log(`Installed script: setup-loop.js`)
+} else {
+  console.warn(`Warning: Script file not found: ${setupSrc}`)
+}
+
 console.log("")
 console.log("Ralph Wiggum commands installed!")
 console.log("")
@@ -39,7 +54,7 @@ console.log("Next step: Add the plugin to your opencode config:")
 console.log("")
 console.log("  In opencode.json:")
 console.log("  {")
-console.log('    "plugin": ["opencode-ralph-wiggum"]')
+console.log('    "plugin": ["@sureshsankaran/ralph-wiggum"]')
 console.log("  }")
 console.log("")
 console.log("Usage:")

package/scripts/setup-loop.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Ralph Loop Setup Script
+ *
+ * Called by the ralph-loop command template to initialize the loop state.
+ * Arguments are passed directly to this script (not via shell substitution).
+ */
+
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+// Get arguments from command line (skip node and script name)
+const rawArgs = process.argv.slice(2)
+
+// Parse arguments
+let maxIterations = 0
+let completionPromise = null
+let promptParts = []
+
+for (let i = 0; i < rawArgs.length; i++) {
+  const arg = rawArgs[i]
+
+  if (arg === "--max-iterations" && i + 1 < rawArgs.length) {
+    maxIterations = parseInt(rawArgs[i + 1], 10) || 0
+    i++ // skip next arg
+  } else if (arg === "--completion-promise" && i + 1 < rawArgs.length) {
+    completionPromise = rawArgs[i + 1]
+    i++ // skip next arg
+  } else if (!arg.startsWith("--")) {
+    promptParts.push(arg)
+  }
+}
+
+const prompt = promptParts.join(" ").trim()
+
+if (!prompt) {
+  console.log("Error: No prompt provided.")
+  console.log('Usage: --command ralph-loop "<prompt>" --max-iterations N --completion-promise TEXT')
+  process.exit(1)
+}
+
+// Determine state directory
+const configDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config")
+const stateDir = path.join(configDir, "opencode", "state")
+fs.mkdirSync(stateDir, { recursive: true })
+
+// Build state file content
+const cpYaml = completionPromise ? `"${completionPromise}"` : "null"
+const lines = [
+  "---",
+  "active: true",
+  "iteration: 1",
+  `max_iterations: ${maxIterations}`,
+  `completion_promise: ${cpYaml}`,
+  `started_at: "${new Date().toISOString()}"`,
+  "last_processed_id: null",
+  "---",
+  "",
+  prompt,
+]
+
+const stateFilePath = path.join(stateDir, "ralph-loop.local.md")
+fs.writeFileSync(stateFilePath, lines.join("\n") + "\n")
+
+console.log("Ralph loop activated!")
+console.log(`Iteration: 1`)
+console.log(`Max iterations: ${maxIterations > 0 ? maxIterations : "unlimited"}`)
+console.log(`Completion promise: ${completionPromise || "none"}`)
+console.log("")
+console.log(prompt)