@sureshsankaran/ralph-wiggum 0.1.11 → 0.1.12

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.11",
+  "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/setup-loop.js

@@ -54,6 +54,7 @@ const lines = [
   `max_iterations: ${maxIterations}`,
   `completion_promise: ${cpYaml}`,
   `started_at: "${new Date().toISOString()}"`,
+  "last_processed_id: null",
   "---",
   "",
   prompt,