@sureshsankaran/ralph-wiggum 0.1.12 → 0.2.0

package/package.json

@@ -1,47 +1,31 @@
 {
   "name": "@sureshsankaran/ralph-wiggum",
-  "version": "0.1.12",
-  "description": "Ralph Wiggum iterative AI development plugin for OpenCode - continuously loops the same prompt until task completion",
+  "version": "0.2.0",
+  "description": "Ralph Wiggum plugin for OpenCode - iterative, self-referential AI development loops",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "commands",
-    "scripts"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "postinstall": "node scripts/postinstall.js"
-  },
+  "main": "src/index.ts",
+  "types": "src/index.ts",
   "keywords": [
     "opencode",
     "plugin",
     "ralph-wiggum",
-    "ai",
     "iterative",
-    "automation"
+    "ai",
+    "development"
   ],
-  "author": "",
+  "author": "sureshsankaran",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/anomalyco/opencode.git",
-    "directory": "plugins/ralph-wiggum"
+    "url": "https://github.com/sureshsankaran/opencode.git",
+    "directory": "packages/ralph-wiggum"
   },
-  "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.0.0"
+  "scripts": {
+    "typecheck": "tsc --noEmit"
   },
+  "dependencies": {},
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.224",
-    "@types/node": "^22.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.8.3",
+    "@types/node": "^20.0.0"
   }
 }

package/src/index.ts

@@ -0,0 +1,361 @@
+/**
+ * Ralph Wiggum Plugin for OpenCode
+ * Implements the Ralph Wiggum technique for iterative, self-referential AI development loops.
+ *
+ * Based on: https://github.com/anthropics/claude-code/tree/main/plugins/ralph-wiggum
+ *
+ * Usage:
+ *   ralph-loop "Your task here" --max 10 --promise "DONE"
+ *   ralph-loop "Your task here" --max 10 --promise "DONE" --state-file /custom/path.json
+ *   ralph-loop "Your task here" --no-state  # Disable state file
+ *
+ * The loop will:
+ * 1. Execute the prompt
+ * 2. Continue iterating until max iterations OR completion promise is found
+ * 3. Feed the SAME original prompt back each iteration
+ * 4. Show iteration count in system message
+ * 5. Write state to ~/.config/opencode/state/ralph-wiggum.json (or custom path) for verification
+ */
+
+import { writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs"
+import { homedir } from "os"
+import { join, dirname } from "path"
+
+// Default state file path
+const DEFAULT_STATE_DIR = join(homedir(), ".config", "opencode", "state")
+const DEFAULT_STATE_FILE = join(DEFAULT_STATE_DIR, "ralph-wiggum.json")
+
+type RalphState = {
+  active: boolean
+  prompt: string
+  promise?: string
+  max?: number
+  iterations: number
+  stateFile: string | null
+  startedAt: string
+  lastUpdatedAt: string
+  status: "running" | "completed" | "cancelled" | "max_reached"
+}
+
+const state: Record<string, RalphState> = {}
+
+/**
+ * Ensure directory exists for state file
+ */
+function ensureDir(filePath: string): void {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true })
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Clean up existing state file on start
+ */
+function cleanupExistingStateFile(filePath: string): void {
+  try {
+    if (existsSync(filePath)) {
+      unlinkSync(filePath)
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Write state to file for external verification
+ */
+function writeStateFile(sessionID: string, s: RalphState): void {
+  if (!s.stateFile) return
+  try {
+    ensureDir(s.stateFile)
+    const stateData = {
+      sessionID,
+      active: s.active,
+      prompt: s.prompt,
+      promise: s.promise || null,
+      iterations: s.iterations,
+      max: s.max ?? null,
+      remaining: s.max != null ? s.max - s.iterations : null,
+      startedAt: s.startedAt,
+      lastUpdatedAt: new Date().toISOString(),
+      status: s.status,
+    }
+    writeFileSync(s.stateFile, JSON.stringify(stateData, null, 2))
+  } catch {
+    // Silently ignore write errors
+  }
+}
+
+/**
+ * Write final state when loop ends
+ */
+function writeFinalState(sessionID: string, s: RalphState): void {
+  if (!s.stateFile) return
+  s.lastUpdatedAt = new Date().toISOString()
+  writeStateFile(sessionID, s)
+}
+
+/**
+ * Tokenize a string respecting quoted strings.
+ * Handles both single and double quotes, preserving content within quotes as single tokens.
+ */
+function tokenize(input: string): string[] {
+  const tokens: string[] = []
+  let current = ""
+  let inQuote: '"' | "'" | null = null
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i]
+
+    if (inQuote) {
+      if (char === inQuote) {
+        // End of quoted section
+        inQuote = null
+      } else {
+        current += char
+      }
+    } else if (char === '"' || char === "'") {
+      // Start of quoted section
+      inQuote = char
+    } else if (char === " " || char === "\t") {
+      // Whitespace outside quotes - token boundary
+      if (current) {
+        tokens.push(current)
+        current = ""
+      }
+    } else {
+      current += char
+    }
+  }
+
+  // Don't forget the last token
+  if (current) {
+    tokens.push(current)
+  }
+
+  return tokens
+}
+
+// Parse arguments from command invocation
+// Supports: ralph-loop "prompt text with spaces" --max 5 --promise "DONE" --state-file /tmp/ralph.json --no-state
+function parseArgs(args: string): {
+  prompt: string
+  maxIterations: number
+  completionPromise?: string
+  stateFile: string | null
+} {
+  const tokens = tokenize(args.trim())
+  const promptParts: string[] = []
+  let maxIterations = 10
+  let completionPromise: string | undefined
+  let stateFile: string | null = DEFAULT_STATE_FILE
+  let noState = false
+
+  let i = 0
+  while (i < tokens.length) {
+    const token = tokens[i]
+    if (token === "--max" || token === "--max-iterations") {
+      maxIterations = parseInt(tokens[++i] || "10", 10)
+    } else if (token === "--promise" || token === "--completion-promise") {
+      completionPromise = tokens[++i]
+    } else if (token === "--state-file" || token === "--state") {
+      stateFile = tokens[++i] || DEFAULT_STATE_FILE
+    } else if (token === "--no-state") {
+      noState = true
+    } else {
+      // Accumulate as prompt
+      promptParts.push(token)
+    }
+    i++
+  }
+
+  return {
+    prompt: promptParts.join(" ") || "Continue working on the task",
+    maxIterations,
+    completionPromise,
+    stateFile: noState ? null : stateFile,
+  }
+}
+
+/**
+ * Check if the assistant's response contains the completion promise.
+ * Looks for <promise>TEXT</promise> pattern where TEXT matches the expected promise.
+ */
+function checkCompletionPromise(text: string | undefined, expectedPromise: string | undefined): boolean {
+  if (!text || !expectedPromise) return false
+
+  // Look for <promise>TEXT</promise> pattern
+  const promiseRegex = /<promise>([\s\S]*?)<\/promise>/gi
+  const matches = text.matchAll(promiseRegex)
+
+  for (const match of matches) {
+    const promiseText = match[1].trim()
+    if (promiseText === expectedPromise) {
+      return true
+    }
+  }
+
+  return false
+}
+
+export default async function ralphWiggum(input: {
+  client: any
+  project: string
+  worktree: string
+  directory: string
+  serverUrl: string
+  $: any
+}) {
+  return {
+    command: {
+      "ralph-loop": {
+        description:
+          "Start a self-referential Ralph loop. Usage: ralph-loop <prompt> --max <iterations> --promise <text> --state-file <path>",
+        template: `You are now in a Ralph Wiggum iterative development loop.
+
+The user wants you to work on the following task iteratively:
+$ARGUMENTS
+
+Instructions:
+1. Work on the task step by step
+2. After each iteration, the loop will automatically continue
+3. The loop will stop when max iterations is reached OR you output <promise>TEXT</promise> where TEXT matches the completion promise
+4. Focus on making progress with each iteration
+5. When you believe the task is complete, output <promise>COMPLETION_PROMISE_TEXT</promise>
+
+Begin working on the task now.`,
+      },
+      "cancel-ralph": {
+        description: "Cancel the active Ralph loop",
+        template: "The Ralph loop has been cancelled. Stop the current iteration.",
+      },
+      "ralph-status": {
+        description: "Show the current Ralph loop status",
+        template: "Show the current Ralph loop status for this session.",
+      },
+    },
+
+    tool: {
+      "cancel-ralph": {
+        description: "Cancel the active Ralph loop for the current session",
+        args: {},
+        async execute(_args: {}, ctx: any) {
+          const sessionID = ctx.sessionID
+          const s = state[sessionID]
+          if (s) {
+            s.status = "cancelled"
+            s.active = false
+            writeFinalState(sessionID, s)
+            delete state[sessionID]
+            return "Ralph loop cancelled"
+          }
+          return "No active Ralph loop to cancel"
+        },
+      },
+      "ralph-status": {
+        description: "Get the current Ralph loop status for the session",
+        args: {},
+        async execute(_args: {}, ctx: any) {
+          const sessionID = ctx.sessionID
+          const s = state[sessionID]
+          if (!s?.active) {
+            return "No active Ralph loop"
+          }
+          const remaining = s.max != null ? s.max - s.iterations : "unlimited"
+          return JSON.stringify(
+            {
+              active: s.active,
+              prompt: s.prompt,
+              promise: s.promise || "none",
+              iterations: s.iterations,
+              max: s.max ?? "unlimited",
+              remaining,
+              stateFile: s.stateFile || "none",
+              startedAt: s.startedAt,
+              status: s.status,
+            },
+            null,
+            2,
+          )
+        },
+      },
+    },
+
+    // Hook: Listen for command execution to set up the loop state
+    async ["event"](input: { event: any }): Promise<void> {
+      const event = input.event
+      if (event?.type === "command.executed" && event?.properties?.name === "ralph-loop") {
+        const sessionID = event.properties.sessionID
+        const args = parseArgs(event.properties.arguments || "")
+        const now = new Date().toISOString()
+
+        // Clean up existing state file on start
+        if (args.stateFile) {
+          cleanupExistingStateFile(args.stateFile)
+        }
+
+        state[sessionID] = {
+          active: true,
+          prompt: args.prompt,
+          promise: args.completionPromise,
+          max: args.maxIterations,
+          iterations: 0,
+          stateFile: args.stateFile,
+          startedAt: now,
+          lastUpdatedAt: now,
+          status: "running",
+        }
+        // Write initial state
+        writeStateFile(sessionID, state[sessionID])
+      }
+    },
+
+    // Hook: session.stop - called just before the session loop exits (SYNCHRONOUS)
+    // Modifies output.stop to control whether the loop should continue
+    ["session.stop"](
+      hookInput: { sessionID: string; step: number; lastAssistantText?: string },
+      output: { stop: boolean; prompt?: string; systemMessage?: string },
+    ): void {
+      const s = state[hookInput.sessionID]
+      if (!s?.active) {
+        return // No active loop, let it stop
+      }
+
+      s.iterations++
+      s.lastUpdatedAt = new Date().toISOString()
+
+      // Check for completion promise in assistant's response
+      if (checkCompletionPromise(hookInput.lastAssistantText, s.promise)) {
+        s.status = "completed"
+        s.active = false
+        writeFinalState(hookInput.sessionID, s)
+        delete state[hookInput.sessionID]
+        output.stop = true
+        return
+      }
+
+      // Check max iterations
+      if (s.max != null && s.iterations >= s.max) {
+        s.status = "max_reached"
+        s.active = false
+        writeFinalState(hookInput.sessionID, s)
+        delete state[hookInput.sessionID]
+        output.stop = true
+        return
+      }
+
+      // Continue the loop - feed back the SAME original prompt
+      output.stop = false
+      output.prompt = s.prompt
+
+      // Write state update
+      writeStateFile(hookInput.sessionID, s)
+
+      // Add system message with iteration info
+      const promiseHint = s.promise ? ` | To complete: output <promise>${s.promise}</promise>` : ""
+      output.systemMessage = `[Ralph iteration ${s.iterations + 1}/${s.max ?? "∞"}${promiseHint}]`
+    },
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "types": ["bun"]
+  },
+  "include": ["src"]
+}

package/README.md

@@ -1,243 +0,0 @@
-# Ralph Wiggum Plugin
-
-Implementation of the Ralph Wiggum technique for iterative, self-referential AI development loops in OpenCode.
-
-## What is Ralph?
-
-Ralph is a development methodology based on continuous AI agent loops. As Geoffrey Huntley describes it: **"Ralph is a Bash loop"** - a simple `while true` that repeatedly feeds an AI agent a prompt file, allowing it to iteratively improve its work until completion.
-
-The technique is named after Ralph Wiggum from The Simpsons, embodying the philosophy of persistent iteration despite setbacks.
-
-### Core Concept
-
-This plugin implements Ralph using a **session.idle hook** that intercepts session completion:
-
-```bash
-# You run ONCE:
-/ralph-loop "Your task description" --completion-promise "DONE"
-
-# Then OpenCode automatically:
-# 1. Works on the task
-# 2. Session becomes idle
-# 3. session.idle hook intercepts
-# 4. Hook feeds the SAME prompt back
-# 5. Repeat until completion
-```
-
-The loop happens **inside your current session** - you don't need external bash loops. The plugin creates a self-referential feedback loop by intercepting session idle events.
-
-This creates a **self-referential feedback loop** where:
-
-- The prompt never changes between iterations
-- Previous work persists in files
-- Each iteration sees modified files and git history
-- OpenCode autonomously improves by reading its own past work in files
-
-## Installation
-
-### Option 1: NPM Package (Recommended)
-
-```bash
-npm install opencode-ralph-wiggum
-```
-
-The postinstall script automatically copies the command files to `~/.config/opencode/command/`.
-
-Then add the plugin to your `opencode.json`:
-
-```json
-{
-  "plugin": ["opencode-ralph-wiggum"]
-}
-```
-
-### Option 2: Manual Installation
-
-Copy the files from this plugin to your opencode config:
-
-```bash
-# Copy plugin
-cp plugins/ralph-wiggum/src/index.ts ~/.config/opencode/plugin/ralph-wiggum.ts
-
-# Copy commands
-cp plugins/ralph-wiggum/commands/*.md ~/.config/opencode/command/
-```
-
-Then configure in your `opencode.json`:
-
-```json
-{
-  "plugin": ["~/.config/opencode/plugin/ralph-wiggum.ts"]
-}
-```
-
-## Quick Start
-
-```bash
-/ralph-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. Output <promise>COMPLETE</promise> when done." --completion-promise "COMPLETE" --max-iterations 50
-```
-
-OpenCode will:
-
-- Implement the API iteratively
-- Run tests and see failures
-- Fix bugs based on test output
-- Iterate until all requirements met
-- Output the completion promise when done
-
-## Commands
-
-### /ralph-loop
-
-Start a Ralph loop in your current session.
-
-**Usage:**
-
-```bash
-/ralph-loop "<prompt>" --max-iterations <n> --completion-promise "<text>"
-```
-
-**Options:**
-
-- `--max-iterations <n>` - Stop after N iterations (default: unlimited)
-- `--completion-promise <text>` - Phrase that signals completion
-
-### /cancel-ralph
-
-Cancel the active Ralph loop.
-
-**Usage:**
-
-```bash
-/cancel-ralph
-```
-
-### /help
-
-Get detailed help on the Ralph Wiggum technique and commands.
-
-**Usage:**
-
-```bash
-/help
-```
-
-## Prompt Writing Best Practices
-
-### 1. Clear Completion Criteria
-
-Bad: "Build a todo API and make it good."
-
-Good:
-
-```markdown
-Build a REST API for todos.
-
-When complete:
-
-- All CRUD endpoints working
-- Input validation in place
-- Tests passing (coverage > 80%)
-- README with API docs
-- Output: <promise>COMPLETE</promise>
-```
-
-### 2. Incremental Goals
-
-Bad: "Create a complete e-commerce platform."
-
-Good:
-
-```markdown
-Phase 1: User authentication (JWT, tests)
-Phase 2: Product catalog (list/search, tests)
-Phase 3: Shopping cart (add/remove, tests)
-
-Output <promise>COMPLETE</promise> when all phases done.
-```
-
-### 3. Self-Correction
-
-Bad: "Write code for feature X."
-
-Good:
-
-```markdown
-Implement feature X following TDD:
-
-1. Write failing tests
-2. Implement feature
-3. Run tests
-4. If any fail, debug and fix
-5. Refactor if needed
-6. Repeat until all green
-7. Output: <promise>COMPLETE</promise>
-```
-
-### 4. Escape Hatches
-
-Always use `--max-iterations` as a safety net to prevent infinite loops on impossible tasks:
-
-```bash
-# Recommended: Always set a reasonable iteration limit
-/ralph-loop "Try to implement feature X" --max-iterations 20
-
-# In your prompt, include what to do if stuck:
-# "After 15 iterations, if not complete:
-#  - Document what's blocking progress
-#  - List what was attempted
-#  - Suggest alternative approaches"
-```
-
-**Note**: The `--completion-promise` uses exact string matching, so you cannot use it for multiple completion conditions (like "SUCCESS" vs "BLOCKED"). Always rely on `--max-iterations` as your primary safety mechanism.
-
-## Philosophy
-
-Ralph embodies several key principles:
-
-### 1. Iteration > Perfection
-
-Don't aim for perfect on first try. Let the loop refine the work.
-
-### 2. Failures Are Data
-
-"Deterministically bad" means failures are predictable and informative. Use them to tune prompts.
-
-### 3. Operator Skill Matters
-
-Success depends on writing good prompts, not just having a good model.
-
-### 4. Persistence Wins
-
-Keep trying until success. The loop handles retry logic automatically.
-
-## When to Use Ralph
-
-**Good for:**
-
-- Well-defined tasks with clear success criteria
-- Tasks requiring iteration and refinement (e.g., getting tests to pass)
-- Greenfield projects where you can walk away
-- Tasks with automatic verification (tests, linters)
-
-**Not good for:**
-
-- Tasks requiring human judgment or design decisions
-- One-shot operations
-- Tasks with unclear success criteria
-- Production debugging (use targeted debugging instead)
-
-## Real-World Results
-
-- Successfully generated 6 repositories overnight in Y Combinator hackathon testing
-- One $50k contract completed for $297 in API costs
-- Created entire programming language ("cursed") over 3 months using this approach
-
-## Learn More
-
-- Original technique: https://ghuntley.com/ralph/
-- Ralph Orchestrator: https://github.com/mikeyobrien/ralph-orchestrator
-
-## For Help
-
-Run `/help` in OpenCode for detailed command reference and examples.

package/commands/cancel-ralph.md

@@ -1,16 +0,0 @@
----
-description: "Cancel active Ralph Wiggum loop"
----
-
-# Cancel Ralph
-
-To cancel the Ralph loop:
-
-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 `~/.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

@@ -1,15 +0,0 @@
----
-description: "Start Ralph Wiggum loop in current session"
----
-
-# Ralph Loop Command
-
-!`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.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.
-
-To complete the loop, output: `<promise>YOUR_COMPLETION_PROMISE</promise>`

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin";
-export declare const RalphWiggumPlugin: Plugin;
-export default RalphWiggumPlugin;

package/dist/index.js

@@ -1,188 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, appendFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-function getStateFilePath() {
-    const configDir = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-    const stateDir = join(configDir, "opencode", "state");
-    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(), last_processed_id: null };
-    for (const line of lines) {
-        const [key, ...valueParts] = line.split(":");
-        if (!key)
-            continue;
-        const value = valueParts.join(":").trim();
-        switch (key.trim()) {
-            case "active":
-                state.active = value === "true";
-                break;
-            case "iteration":
-                state.iteration = parseInt(value, 10);
-                break;
-            case "max_iterations":
-                state.max_iterations = parseInt(value, 10);
-                break;
-            case "completion_promise":
-                state.completion_promise = value === "null" ? null : value.replace(/^"|"$/g, "");
-                break;
-            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 ||
-        state.iteration === undefined ||
-        state.max_iterations === undefined ||
-        !state.prompt) {
-        return null;
-    }
-    return state;
-}
-function extractPromiseText(text) {
-    const match = text.match(/<promise>(.*?)<\/promise>/s);
-    return match ? match[1].trim().replace(/\s+/g, " ") : null;
-}
-export const RalphWiggumPlugin = async ({ client }) => {
-    const version = "0.1.12";
-    log(`Plugin loaded, version=${version}`);
-    const stateFilePath = getStateFilePath();
-    // Clear log file on plugin load
-    try {
-        writeFileSync(getLogPath(), "");
-    }
-    catch { }
-    let completionDetected = false;
-    let lastProcessedId = null;
-    let iterationInProgress = false;
-    let callCount = 0;
-    log(`Plugin initialized`);
-    const hooks = {
-        "experimental.session.stop": async (input, output) => {
-            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) {
-                log(`[${myCallId}] No active state`);
-                return;
-            }
-            if (completionDetected) {
-                log(`[${myCallId}] Completion already detected`);
-                return;
-            }
-            // 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;
-                }
-                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}"`);
-                }
-                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;
-            }
-        },
-    };
-    return hooks;
-};
-export default RalphWiggumPlugin;

package/scripts/postinstall.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-
-import { copyFileSync, mkdirSync, existsSync } from "node:fs"
-import { join, dirname } from "node:path"
-import { homedir } from "node:os"
-import { fileURLToPath } from "node:url"
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const packageRoot = join(__dirname, "..")
-
-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
-const commands = ["ralph-loop.md", "cancel-ralph.md"]
-const commandsDir = join(packageRoot, "commands")
-
-for (const cmd of commands) {
-  const src = join(commandsDir, cmd)
-  const dest = join(commandDir, cmd)
-
-  if (existsSync(src)) {
-    copyFileSync(src, dest)
-    console.log(`Installed command: ${cmd}`)
-  } else {
-    console.warn(`Warning: Command file not found: ${src}`)
-  }
-}
-
-// 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("")
-console.log("Next step: Add the plugin to your opencode config:")
-console.log("")
-console.log("  In opencode.json:")
-console.log("  {")
-console.log('    "plugin": ["@sureshsankaran/ralph-wiggum"]')
-console.log("  }")
-console.log("")
-console.log("Usage:")
-console.log('  /ralph-loop "Your task" --max-iterations 10 --completion-promise "DONE"')
-console.log("  /cancel-ralph")
-console.log("")

package/scripts/setup-loop.js

@@ -1,71 +0,0 @@
-#!/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)