@sureshsankaran/ralph-wiggum 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 const STATE_FILE = ".opencode/ralph-loop.local.md";
+const LOCK_FILE = ".opencode/ralph-loop.lock";
 function parseState(content) {
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!frontmatterMatch)
@@ -43,10 +44,30 @@ function extractPromiseText(text) {
     const match = text.match(/<promise>(.*?)<\/promise>/s);
     return match ? match[1].trim().replace(/\s+/g, " ") : null;
 }
-function updateIteration(filePath, newIteration) {
-    const content = readFileSync(filePath, "utf-8");
-    const updated = content.replace(/^iteration: \d+$/m, `iteration: ${newIteration}`);
-    writeFileSync(filePath, updated);
+// Atomically increment iteration using file-based locking
+function tryIncrementIteration(stateFilePath, lockFilePath, expectedIteration) {
+    // Try to acquire lock by checking if lock file exists with different iteration
+    if (existsSync(lockFilePath)) {
+        const lockContent = readFileSync(lockFilePath, "utf-8").trim();
+        const lockedIteration = parseInt(lockContent, 10);
+        // If lock exists for same or higher iteration, someone else is handling it
+        if (!isNaN(lockedIteration) && lockedIteration >= expectedIteration) {
+            return null;
+        }
+    }
+    // Write our lock
+    const nextIteration = expectedIteration + 1;
+    writeFileSync(lockFilePath, String(nextIteration));
+    // Double-check we got the lock (simple mutex)
+    const lockCheck = readFileSync(lockFilePath, "utf-8").trim();
+    if (parseInt(lockCheck, 10) !== nextIteration) {
+        return null; // Someone else won the race
+    }
+    // Update state file
+    const content = readFileSync(stateFilePath, "utf-8");
+    const updated = content.replace(/^iteration: \d+$/m, `iteration: ${nextIteration}`);
+    writeFileSync(stateFilePath, updated);
+    return nextIteration;
 }
 /**
  * Ralph Wiggum Plugin - Iterative AI Development
@@ -62,13 +83,9 @@ function updateIteration(filePath, newIteration) {
  */
 export const RalphWiggumPlugin = async ({ client, directory }) => {
     const stateFilePath = join(directory, STATE_FILE);
-    const lockFilePath = join(directory, ".opencode/ralph-loop.lock");
+    const lockFilePath = join(directory, LOCK_FILE);
     // Track if completion was detected to prevent race conditions
     let completionDetected = false;
-    // Track the last iteration we processed to prevent duplicate handling
-    let lastProcessedIteration = 0;
-    // Lock to prevent concurrent event handling
-    let isProcessing = false;
     return {
         event: async ({ event }) => {
             // Check message.part.updated events for completion promise
@@ -87,8 +104,8 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                         }
                         const promiseText = extractPromiseText(part.text);
                         if (promiseText === state.completion_promise) {
-                            console.log(`Ralph loop: Detected <promise>${state.completion_promise}</promise> - task complete!`);
                             completionDetected = true;
+                            console.log(`\nRalph loop: Detected <promise>${state.completion_promise}</promise> - task complete!`);
                             try {
                                 unlinkSync(stateFilePath);
                             }
@@ -110,81 +127,73 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                 return;
             // If completion was already detected, don't continue
             if (completionDetected) {
+                console.log("\nRalph loop: Completion already detected, not continuing");
                 return;
             }
-            // Prevent concurrent processing
-            if (isProcessing) {
+            const sessionID = event.properties?.sessionID;
+            // Check if ralph-loop is active
+            if (!existsSync(stateFilePath))
+                return;
+            const content = readFileSync(stateFilePath, "utf-8");
+            const state = parseState(content);
+            if (!state || !state.active) {
                 return;
             }
-            isProcessing = true;
-            try {
-                const sessionID = event.properties?.sessionID;
-                // Check if ralph-loop is active
-                if (!existsSync(stateFilePath))
-                    return;
-                const content = readFileSync(stateFilePath, "utf-8");
-                const state = parseState(content);
-                if (!state || !state.active) {
-                    return;
-                }
-                // Prevent processing the same iteration multiple times
-                if (state.iteration <= lastProcessedIteration) {
-                    return;
+            // Validate numeric fields
+            if (isNaN(state.iteration) || isNaN(state.max_iterations)) {
+                console.error("\nRalph loop: State file corrupted - invalid numeric fields");
+                try {
+                    unlinkSync(stateFilePath);
                 }
-                console.log("Ralph loop: session idle, iteration " + state.iteration);
-                // Validate numeric fields
-                if (isNaN(state.iteration) || isNaN(state.max_iterations)) {
-                    console.error("Ralph loop: State file corrupted - invalid numeric fields");
-                    try {
-                        unlinkSync(stateFilePath);
-                    }
-                    catch { }
-                    return;
+                catch { }
+                try {
+                    unlinkSync(lockFilePath);
                 }
-                // Check if max iterations reached
-                if (state.max_iterations > 0 && state.iteration >= state.max_iterations) {
-                    console.log(`Ralph loop: Max iterations (${state.max_iterations}) reached.`);
-                    try {
-                        unlinkSync(stateFilePath);
-                    }
-                    catch { }
-                    try {
-                        unlinkSync(lockFilePath);
-                    }
-                    catch { }
-                    return;
+                catch { }
+                return;
+            }
+            // Check if max iterations reached
+            if (state.max_iterations > 0 && state.iteration >= state.max_iterations) {
+                console.log(`\nRalph loop: Max iterations (${state.max_iterations}) reached.`);
+                try {
+                    unlinkSync(stateFilePath);
                 }
-                // Not complete - continue loop with SAME PROMPT
-                const nextIteration = state.iteration + 1;
-                lastProcessedIteration = nextIteration;
-                updateIteration(stateFilePath, nextIteration);
-                // Build system message
-                const systemMsg = state.completion_promise
-                    ? `Ralph iteration ${nextIteration} | To stop: output <promise>${state.completion_promise}</promise> (ONLY when statement is TRUE - do not lie to exit!)`
-                    : `Ralph iteration ${nextIteration} | No completion promise set - loop runs infinitely`;
-                console.log(systemMsg);
-                // Send the same prompt back to continue the session
+                catch { }
                 try {
-                    if (sessionID) {
-                        await client.session.promptAsync({
-                            path: { id: sessionID },
-                            body: {
-                                parts: [
-                                    {
-                                        type: "text",
-                                        text: `[${systemMsg}]\n\n${state.prompt}`,
-                                    },
-                                ],
-                            },
-                        });
-                    }
+                    unlinkSync(lockFilePath);
                 }
-                catch (err) {
-                    console.error("Ralph loop: Failed to send prompt", err);
+                catch { }
+                return;
+            }
+            // Try to atomically increment - this prevents race conditions
+            const nextIteration = tryIncrementIteration(stateFilePath, lockFilePath, state.iteration);
+            if (nextIteration === null) {
+                // Another event handler won the race, skip this one
+                return;
+            }
+            console.log(`\nRalph loop: Starting iteration ${nextIteration}`);
+            // Build system message
+            const systemMsg = state.completion_promise
+                ? `Ralph iteration ${nextIteration} | To stop: output <promise>${state.completion_promise}</promise> (ONLY when statement is TRUE - do not lie to exit!)`
+                : `Ralph iteration ${nextIteration} | No completion promise set - loop runs infinitely`;
+            // Send the same prompt back to continue the session
+            try {
+                if (sessionID) {
+                    await client.session.promptAsync({
+                        path: { id: sessionID },
+                        body: {
+                            parts: [
+                                {
+                                    type: "text",
+                                    text: `[${systemMsg}]\n\n${state.prompt}`,
+                                },
+                            ],
+                        },
+                    });
                 }
             }
-            finally {
-                isProcessing = false;
+            catch (err) {
+                console.error("\nRalph loop: Failed to send prompt", err);
             }
         },
     };

package/package.json

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