@sureshsankaran/ralph-wiggum 0.1.4 → 0.1.5

package/dist/index.js

@@ -1,7 +1,6 @@
 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)
@@ -44,35 +43,6 @@ function extractPromiseText(text) {
     const match = text.match(/<promise>(.*?)<\/promise>/s);
     return match ? match[1].trim().replace(/\s+/g, " ") : null;
 }
-// Atomically increment iteration using file-based locking
-// Returns the next iteration number if we won the lock, null if another handler is processing
-function tryClaimIteration(stateFilePath, lockFilePath, currentIteration) {
-    const nextIteration = currentIteration + 1;
-    // Check if lock exists for THIS specific iteration transition
-    if (existsSync(lockFilePath)) {
-        const lockContent = readFileSync(lockFilePath, "utf-8").trim();
-        // Lock format: "from:to" e.g., "1:2" means transitioning from iteration 1 to 2
-        const [fromStr, toStr] = lockContent.split(":");
-        const from = parseInt(fromStr, 10);
-        const to = parseInt(toStr, 10);
-        // If lock exists for this exact transition, someone else is handling it
-        if (from === currentIteration && to === nextIteration) {
-            return null;
-        }
-    }
-    // Write our lock with format "from:to"
-    writeFileSync(lockFilePath, `${currentIteration}:${nextIteration}`);
-    // Double-check we got the lock
-    const lockCheck = readFileSync(lockFilePath, "utf-8").trim();
-    if (lockCheck !== `${currentIteration}:${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
  *
@@ -87,9 +57,11 @@ function tryClaimIteration(stateFilePath, lockFilePath, currentIteration) {
  */
 export const RalphWiggumPlugin = async ({ client, directory }) => {
     const stateFilePath = join(directory, STATE_FILE);
-    const lockFilePath = join(directory, LOCK_FILE);
-    // Track if completion was detected to prevent race conditions
+    // In-memory state to prevent race conditions
+    // These are scoped to this plugin instance
     let completionDetected = false;
+    let processingIteration = false;
+    let lastProcessedIteration = -1;
     return {
         event: async ({ event }) => {
             // Check message.part.updated events for completion promise
@@ -114,10 +86,6 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                                 unlinkSync(stateFilePath);
                             }
                             catch { }
-                            try {
-                                unlinkSync(lockFilePath);
-                            }
-                            catch { }
                             return;
                         }
                     }
@@ -125,7 +93,7 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                 return;
             }
             // Handle session idle to continue the loop
-            // Only listen to session.status (session.idle is deprecated and fires at the same time)
+            // Only listen to session.status (session.idle is deprecated)
             const isIdle = event.type === "session.status" && event.properties?.status?.type === "idle";
             if (!isIdle)
                 return;
@@ -133,6 +101,11 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
             if (completionDetected) {
                 return;
             }
+            // If we're already processing an iteration, skip
+            // This prevents race conditions when multiple idle events fire
+            if (processingIteration) {
+                return;
+            }
             const sessionID = event.properties?.sessionID;
             // Check if ralph-loop is active
             if (!existsSync(stateFilePath))
@@ -149,10 +122,11 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                     unlinkSync(stateFilePath);
                 }
                 catch { }
-                try {
-                    unlinkSync(lockFilePath);
-                }
-                catch { }
+                return;
+            }
+            // Check if we've already processed this iteration
+            // This handles cases where the state file hasn't been updated yet
+            if (state.iteration <= lastProcessedIteration) {
                 return;
             }
             // Check if max iterations reached
@@ -162,25 +136,22 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                     unlinkSync(stateFilePath);
                 }
                 catch { }
-                try {
-                    unlinkSync(lockFilePath);
-                }
-                catch { }
                 return;
             }
-            // Try to atomically claim this iteration - this prevents race conditions
-            const nextIteration = tryClaimIteration(stateFilePath, lockFilePath, state.iteration);
-            if (nextIteration === null) {
-                // Another event handler won the race, skip this one silently
-                return;
-            }
-            // Build system message
-            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}`);
-            // Send the same prompt back to continue the session
+            // Mark as processing to prevent concurrent handling
+            processingIteration = true;
             try {
+                const nextIteration = state.iteration + 1;
+                lastProcessedIteration = nextIteration;
+                // Update state file with new iteration
+                const updated = content.replace(/^iteration: \d+$/m, `iteration: ${nextIteration}`);
+                writeFileSync(stateFilePath, updated);
+                // Build system message
+                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}`);
+                // Send the same prompt back to continue the session
                 if (sessionID) {
                     await client.session.promptAsync({
                         path: { id: sessionID },
@@ -196,7 +167,10 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                 }
             }
             catch (err) {
-                console.error("\nRalph loop: Failed to send prompt", err);
+                console.error("\nRalph loop: Failed to process iteration", err);
+            }
+            finally {
+                processingIteration = false;
             }
         },
     };

package/package.json

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