@sureshsankaran/ralph-wiggum 0.1.6 → 0.1.8

package/commands/cancel-ralph.md

@@ -6,11 +6,11 @@ description: "Cancel active Ralph Wiggum loop"
 
 To cancel the Ralph loop:
 
-1. Check if `.opencode/ralph-loop.local.md` exists using Bash: `test -f .opencode/ralph-loop.local.md && echo "EXISTS" || echo "NOT_FOUND"`
+1. Check if `~/.config/opencode/state/ralph-loop.local.md` exists using Bash: `test -f ~/.config/opencode/state/ralph-loop.local.md && echo "EXISTS" || echo "NOT_FOUND"`
 
 2. **If NOT_FOUND**: Say "No active Ralph loop found."
 
 3. **If EXISTS**:
-   - Read `.opencode/ralph-loop.local.md` to get the current iteration number from the `iteration:` field
-   - Remove the file using Bash: `rm .opencode/ralph-loop.local.md`
+   - Read `~/.config/opencode/state/ralph-loop.local.md` to get the current iteration number from the `iteration:` field
+   - Remove the file using Bash: `rm ~/.config/opencode/state/ralph-loop.local.md`
    - Report: "Cancelled Ralph loop (was at iteration N)" where N is the iteration value

package/commands/ralph-loop.md

@@ -46,7 +46,8 @@ console.log('Usage: /ralph-loop \"<prompt>\" [--max-iterations N] [--completion-
 process.exit(1);
 }
 
-var dir = '.opencode';
+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 + '\"';

package/dist/index.js

@@ -63,81 +63,48 @@ function extractPromiseText(text) {
  *
  * The AI should output <promise>DONE</promise> when the task is complete.
  */
-export const RalphWiggumPlugin = async ({ client, directory }) => {
+export const RalphWiggumPlugin = async ({ client }) => {
     const stateFilePath = getStateFilePath();
-    // In-memory state to prevent race conditions
-    // These are scoped to this plugin instance
+    // In-memory state to prevent double-processing
     let completionDetected = false;
-    let processingIteration = false;
     let lastProcessedIteration = -1;
-    return {
-        event: async ({ event }) => {
-            // Check message.part.updated events for completion promise
-            // This happens BEFORE session goes idle, so we can detect early
-            if (event.type === "message.part.updated") {
-                const props = event.properties;
-                const part = props?.part;
-                // Only check text parts with completed status (time.end is set)
-                if (part?.type === "text" && part?.text && part?.time?.end && existsSync(stateFilePath)) {
-                    const content = readFileSync(stateFilePath, "utf-8");
-                    const state = parseState(content);
-                    if (state?.completion_promise && !completionDetected) {
-                        // Skip if this text is part of the user's prompt
-                        if (part.text.includes(state.prompt.slice(0, 30))) {
-                            return;
-                        }
-                        const promiseText = extractPromiseText(part.text);
-                        if (promiseText === state.completion_promise) {
-                            completionDetected = true;
-                            console.log(`\nRalph loop complete! Detected <promise>${state.completion_promise}</promise>`);
-                            try {
-                                unlinkSync(stateFilePath);
-                            }
-                            catch { }
-                            return;
-                        }
-                    }
-                }
-                return;
-            }
-            // Handle session idle to continue the loop
-            // Only listen to session.status (session.idle is deprecated)
-            const isIdle = event.type === "session.status" && event.properties?.status?.type === "idle";
-            if (!isIdle)
-                return;
-            // If completion was already detected, silently ignore
-            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
+    // Cast to extended hooks type that includes experimental.session.stop
+    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))
                 return;
             const content = readFileSync(stateFilePath, "utf-8");
             const state = parseState(content);
-            if (!state || !state.active) {
+            if (!state || !state.active)
                 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);
-                }
-                catch { }
+            // If completion already detected, allow normal exit
+            if (completionDetected)
                 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) {
+            // 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;
+            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 { }
+                    return;
+                }
             }
-            // Check if max iterations reached
+            // Max-iteration safety
             if (state.max_iterations > 0 && state.iteration >= state.max_iterations) {
                 console.log(`\nRalph loop: Max iterations (${state.max_iterations}) reached.`);
                 try {
@@ -146,41 +113,34 @@ export const RalphWiggumPlugin = async ({ client, directory }) => {
                 catch { }
                 return;
             }
-            // 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 },
-                        body: {
-                            parts: [
-                                {
-                                    type: "text",
-                                    text: `[${systemMsg}]\n\n${state.prompt}`,
-                                },
-                            ],
+            // Check if we've already advanced this iteration
+            if (state.iteration <= lastProcessedIteration)
+                return;
+            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);
+            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}`,
                         },
-                    });
-                }
-            }
-            catch (err) {
-                console.error("\nRalph loop: Failed to process iteration", err);
-            }
-            finally {
-                processingIteration = false;
-            }
+                    ],
+                },
+            });
+            // Block loop exit so we can continue iterating
+            output.decision = "block";
         },
     };
+    return hooks;
 };
 export default RalphWiggumPlugin;

package/package.json

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