@sureshsankaran/ralph-wiggum 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 8 --promise "DONE"
+ *   ralph-loop "Your task here" --max 8 --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
+ */
+export default function ralphWiggum(input: {
+    client: any;
+    project: string;
+    worktree: string;
+    directory: string;
+    serverUrl: string;
+    $: any;
+}): Promise<{
+    command: {
+        "ralph-loop": {
+            description: string;
+            template: string;
+        };
+        "cancel-ralph": {
+            description: string;
+            template: string;
+        };
+        "ralph-status": {
+            description: string;
+            template: string;
+        };
+    };
+    tool: {
+        "cancel-ralph": {
+            description: string;
+            args: {};
+            execute(_args: {}, ctx: any): Promise<"Ralph loop cancelled" | "No active Ralph loop to cancel">;
+        };
+        "ralph-status": {
+            description: string;
+            args: {};
+            execute(_args: {}, ctx: any): Promise<string>;
+        };
+    };
+    event(input: {
+        event: any;
+    }): Promise<void>;
+    "session.stop"(hookInput: {
+        sessionID: string;
+        step: number;
+        lastAssistantText?: string;
+    }, output: {
+        stop: boolean;
+        prompt?: string;
+        systemMessage?: string;
+    }): Promise<void>;
+    "experimental.chat.system.transform"(_input: {}, output: {
+        system: string[];
+    }): Promise<void>;
+}>;

package/dist/index.js

@@ -0,0 +1,620 @@
+/**
+ * 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 8 --promise "DONE"
+ *   ralph-loop "Your task here" --max 8 --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");
+const state = {};
+// Track active review session for system prompt injection
+let activeReviewSession = null;
+/**
+ * Ensure directory exists for state file
+ */
+function ensureDir(filePath) {
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Clean up existing state file on start
+ */
+function cleanupExistingStateFile(filePath) {
+    try {
+        if (existsSync(filePath)) {
+            unlinkSync(filePath);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Write state to file for external verification
+ */
+function writeStateFile(sessionID, s) {
+    if (!s.stateFile)
+        return;
+    try {
+        ensureDir(s.stateFile);
+        const stateData = {
+            sessionID,
+            active: s.active,
+            prompt: s.prompt,
+            promise: s.promise || "DONE",
+            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,
+            // Review system fields
+            phase: s.phase,
+            reviewCount: s.reviewCount,
+            maxReviews: s.maxReviews,
+            lastReviewFeedback: s.lastReviewFeedback || null,
+        };
+        writeFileSync(s.stateFile, JSON.stringify(stateData, null, 2));
+    }
+    catch {
+        // Silently ignore write errors
+    }
+}
+/**
+ * Write final state when loop ends
+ */
+function writeFinalState(sessionID, s) {
+    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.
+ * Also handles escape sequences like \" and \\
+ */
+function tokenize(input) {
+    const tokens = [];
+    let current = "";
+    let inQuote = null;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        // Handle escape sequences
+        if (char === "\\" && i + 1 < input.length) {
+            const nextChar = input[i + 1];
+            if (nextChar === '"' || nextChar === "'" || nextChar === "\\") {
+                // Escaped quote or backslash - add the escaped character
+                current += nextChar;
+                i++; // Skip the next character
+                continue;
+            }
+        }
+        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) {
+    let input = args.trim();
+    // Handle CLI double-quoting: if the entire input is wrapped in quotes with escaped inner quotes,
+    // strip the outer quotes and unescape the inner ones
+    // e.g., "\"say hello\" --max 2" -> "say hello" --max 2
+    if (input.startsWith('"') && input.endsWith('"') && input.length > 2) {
+        // Check if this looks like double-quoted input (contains escaped quotes inside)
+        const inner = input.slice(1, -1);
+        if (inner.includes('\\"')) {
+            // Unescape the inner quotes and use that as input
+            input = inner.replace(/\\"/g, '"');
+        }
+    }
+    const tokens = tokenize(input);
+    const promptParts = [];
+    let maxIterations = 8;
+    let completionPromise;
+    let stateFile = 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] || "8", 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, expectedPromise) {
+    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;
+}
+// System prompt for REVIEW phase
+const REVIEW_SYSTEM_PROMPT = `
+<ralph-review-mode>
+## Code Review Mode Active
+
+You are in CODE REVIEW mode. Be EXTREMELY THOROUGH and CRITICAL. Do not rubber-stamp changes.
+
+### Review Philosophy
+- Assume there ARE issues until proven otherwise
+- Question every design decision
+- Look for what's missing, not just what's wrong
+- Consider maintainability, scalability, and future implications
+- A good review finds problems; an excellent review prevents future ones
+
+### 1. Retrieve and Inspect Changes
+- Run \`git diff HEAD --stat\` to see which files changed
+- Run \`git diff HEAD\` or \`git diff HEAD -- <file>\` to inspect specific changes
+- Run \`git status\` to see untracked files
+- Read full files if needed for context
+- Do NOT skip any files - review everything
+
+### 2. Design Review (Be Critical)
+- Is this the RIGHT solution, not just A solution?
+- Are there simpler approaches that were overlooked?
+- Does the architecture make sense for the problem?
+- Will this scale? Is it maintainable?
+- Are there unnecessary abstractions or missing abstractions?
+
+### 3. Spec Compliance (Be Thorough)
+- Verify EVERY requirement from the original spec is addressed
+- Check for missing functionality or incomplete implementations
+- Look for requirements that were misunderstood
+- Verify edge cases mentioned in the spec are handled
+
+### 4. Code Quality Review (Be Rigorous)
+- Look for bugs, logic errors, race conditions, edge cases
+- Check error handling - what happens when things fail?
+- Review security implications (injection, auth, data exposure)
+- Check for performance issues (N+1 queries, memory leaks, blocking calls)
+- Verify proper input validation and sanitization
+- Look for code smells and anti-patterns
+
+### 5. Test Recommendations
+Provide SPECIFIC recommendations for:
+- **Unit Tests**: Test individual functions/components in isolation
+- **E2E Tests**: Tests that verify the UX exactly like a user would interact with it
+- **Edge Cases**: Specific scenarios that MUST be tested
+
+### Required Response
+After your review, you MUST respond with ONE of:
+- <promise>APPROVED</promise> - Code meets ALL requirements, no critical/high priority issues, design is sound
+- <promise>NEEDFIX</promise> - Issues found that must be addressed
+
+If responding with NEEDFIX, list EVERY issue with priority:
+- **CRITICAL**: Bugs, security issues, data loss risks, spec violations
+- **HIGH**: Design flaws, missing error handling, performance issues
+</ralph-review-mode>
+`;
+// System prompt for FIX phase
+const FIX_SYSTEM_PROMPT = `
+<ralph-fix-mode>
+## Fix Mode Active
+
+You are addressing review comments. Your responsibilities:
+
+### 1. Address Review Issues
+- Fix all CRITICAL and HIGH priority issues identified
+- Refer to the review feedback for specific issues to address
+
+### 2. Implement Tests
+- Add recommended unit tests
+- Add recommended E2E tests that verify UX like a user would
+
+### 3. Verify Fixes
+- Run the test suite to verify fixes work correctly
+- Ensure all tests pass before marking complete
+
+### Required Response
+When all fixes are complete AND tests pass, respond with:
+<promise>DONE</promise>
+
+This will trigger a re-review of the updated changes.
+</ralph-fix-mode>
+`;
+function buildReviewUserPrompt(s) {
+    return `## Code Review Request
+
+The code implementation is complete. Please review the uncommitted changes.
+
+### Original Task/Specification:
+\`\`\`
+${s.prompt}
+\`\`\`
+
+### Instructions:
+1. Run \`git diff HEAD --stat\` to see which files were modified
+2. Run \`git diff HEAD\` or \`git diff HEAD -- <file>\` to inspect the actual changes
+3. Read full files if you need more context
+
+### Review Checklist:
+1. **Spec Compliance**: Does this implementation fulfill the original requirements?
+2. **Code Quality**: Are there bugs, logic errors, edge cases, or security issues?
+3. **Test Coverage**: What unit tests and E2E tests should be added?
+
+### Required Response:
+- If there are CRITICAL or HIGH priority issues that must be fixed: <promise>NEEDFIX</promise>
+- If the code is acceptable and meets requirements: <promise>APPROVED</promise>`;
+}
+function buildFixUserPrompt(s) {
+    return `## Fix Review Comments
+
+The code review identified issues that need to be addressed.
+
+### Review Feedback:
+${s.lastReviewFeedback}
+
+### Original Task/Specification:
+\`\`\`
+${s.prompt}
+\`\`\`
+
+### Instructions:
+1. Address all CRITICAL and HIGH priority issues from the review above
+2. Add the recommended unit tests
+3. Add the recommended E2E tests (tests that verify UX exactly like a user would)
+4. **Run the tests** to ensure they pass - do not skip this step
+5. Verify all fixes are working correctly
+
+When all fixes are complete AND tests pass, respond with:
+<promise>DONE</promise>`;
+}
+function buildReReviewUserPrompt(s) {
+    return `## Re-Review Request (Review #${s.reviewCount + 1})
+
+The previous review comments have been addressed. Please verify the fixes.
+
+### Original Task/Specification:
+\`\`\`
+${s.prompt}
+\`\`\`
+
+### Instructions:
+1. Run \`git diff HEAD --stat\` to see current changes
+2. Run \`git diff HEAD\` to inspect the updated code
+3. Verify all previous issues are resolved
+4. Check that new changes don't introduce new issues
+5. Verify tests are adequate
+
+### Required Response:
+- If more issues remain: <promise>NEEDFIX</promise>
+- If everything is acceptable: <promise>APPROVED</promise>`;
+}
+export default async function ralphWiggum(input) {
+    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) {
+                    const sessionID = ctx.sessionID;
+                    const s = state[sessionID];
+                    if (s) {
+                        s.status = "cancelled";
+                        s.active = false;
+                        writeFinalState(sessionID, s);
+                        delete state[sessionID];
+                        // Clear active review session if this was it
+                        if (activeReviewSession === sessionID) {
+                            activeReviewSession = null;
+                        }
+                        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) {
+                    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 || "DONE",
+                        iterations: s.iterations,
+                        max: s.max ?? "unlimited",
+                        remaining,
+                        phase: s.phase,
+                        reviewCount: s.reviewCount,
+                        maxReviews: s.maxReviews,
+                        reviewPromises: s.reviewPromises,
+                        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) {
+            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 || "DONE",
+                    max: args.maxIterations,
+                    iterations: 0,
+                    stateFile: args.stateFile,
+                    startedAt: now,
+                    lastUpdatedAt: now,
+                    status: "running",
+                    // Review system fields
+                    phase: "working",
+                    reviewPromises: {
+                        needFix: "NEEDFIX",
+                        approved: "APPROVED",
+                    },
+                    reviewCount: 0,
+                    maxReviews: 5,
+                };
+                // Write initial state
+                writeStateFile(sessionID, state[sessionID]);
+            }
+        },
+        // Hook: session.stop - called just before the session loop exits
+        // Modifies output.stop to control whether the loop should continue
+        async ["session.stop"](hookInput, output) {
+            const s = state[hookInput.sessionID];
+            if (!s?.active) {
+                return; // No active loop, let it stop
+            }
+            s.iterations++;
+            s.lastUpdatedAt = new Date().toISOString();
+            // WORKING PHASE
+            if (s.phase === "working") {
+                // Check for completion promise (DONE)
+                if (checkCompletionPromise(hookInput.lastAssistantText, s.promise)) {
+                    // Check if this is a git repo, auto-init if not
+                    const isGitRepo = await input.$ `git rev-parse --is-inside-work-tree`.text().catch(() => "false");
+                    if (isGitRepo.trim() !== "true") {
+                        // Auto-initialize git repo
+                        await input.$ `git init`.quiet().catch(() => { });
+                    }
+                    // Check for changes that should trigger review
+                    // Use git status --porcelain to detect staged, unstaged, and untracked files
+                    const gitStatus = await input.$ `git status --porcelain`.text().catch(() => "");
+                    const hasChanges = gitStatus.trim().length > 0;
+                    if (!hasChanges) {
+                        // No changes - exit normally
+                        s.status = "completed";
+                        s.active = false;
+                        writeFinalState(hookInput.sessionID, s);
+                        delete state[hookInput.sessionID];
+                        output.stop = true;
+                        return;
+                    }
+                    // Transition to REVIEW phase
+                    s.phase = "review";
+                    activeReviewSession = hookInput.sessionID;
+                    output.stop = false;
+                    output.systemMessage = `[Ralph - CODE REVIEW MODE]`;
+                    output.prompt = buildReviewUserPrompt(s);
+                    writeStateFile(hookInput.sessionID, s);
+                    return;
+                }
+                // Check max iterations
+                if (s.max != null && s.iterations >= s.max) {
+                    s.status = "max_reached";
+                    s.active = false;
+                    activeReviewSession = null;
+                    writeFinalState(hookInput.sessionID, s);
+                    delete state[hookInput.sessionID];
+                    output.stop = true;
+                    return;
+                }
+                // Continue working - existing logic
+                output.stop = false;
+                output.prompt = s.prompt;
+                const promiseHint = s.promise ? ` | When complete: <promise>${s.promise}</promise>` : "";
+                output.systemMessage = `[Ralph iteration ${s.iterations + 1}/${s.max ?? "∞"}${promiseHint}]`;
+                writeStateFile(hookInput.sessionID, s);
+                return;
+            }
+            // REVIEW PHASE
+            if (s.phase === "review") {
+                // Check for APPROVED
+                if (checkCompletionPromise(hookInput.lastAssistantText, s.reviewPromises.approved)) {
+                    s.status = "approved";
+                    s.active = false;
+                    activeReviewSession = null;
+                    writeFinalState(hookInput.sessionID, s);
+                    delete state[hookInput.sessionID];
+                    output.stop = true;
+                    return;
+                }
+                // Check for NEEDFIX
+                if (checkCompletionPromise(hookInput.lastAssistantText, s.reviewPromises.needFix)) {
+                    // Check max reviews limit
+                    if (s.reviewCount >= s.maxReviews) {
+                        s.status = "max_reviews_reached";
+                        s.active = false;
+                        activeReviewSession = null;
+                        writeFinalState(hookInput.sessionID, s);
+                        delete state[hookInput.sessionID];
+                        output.stop = true;
+                        return;
+                    }
+                    // Transition to FIX phase
+                    s.phase = "fix";
+                    s.lastReviewFeedback = hookInput.lastAssistantText;
+                    s.reviewCount++;
+                    output.stop = false;
+                    output.systemMessage = `[Ralph - FIX MODE (Review #${s.reviewCount})]`;
+                    output.prompt = buildFixUserPrompt(s);
+                    writeStateFile(hookInput.sessionID, s);
+                    return;
+                }
+                // Neither promise found - nudge for response
+                output.stop = false;
+                output.systemMessage = `[Ralph - REVIEW MODE - Awaiting verdict]`;
+                output.prompt = `Please complete your review by inspecting the changes with \`git diff HEAD\` and respond with:
+- <promise>APPROVED</promise> if the code meets requirements
+- <promise>NEEDFIX</promise> if there are critical/high priority issues`;
+                return;
+            }
+            // FIX PHASE
+            if (s.phase === "fix") {
+                // Check for DONE (fixes complete)
+                if (checkCompletionPromise(hookInput.lastAssistantText, s.promise)) {
+                    // Transition back to REVIEW for re-review
+                    s.phase = "review";
+                    output.stop = false;
+                    output.systemMessage = `[Ralph - RE-REVIEW MODE (Review #${s.reviewCount + 1})]`;
+                    output.prompt = buildReReviewUserPrompt(s);
+                    writeStateFile(hookInput.sessionID, s);
+                    return;
+                }
+                // Check max iterations (safety valve)
+                if (s.max != null && s.iterations >= s.max) {
+                    s.status = "max_reached";
+                    s.active = false;
+                    activeReviewSession = null;
+                    writeFinalState(hookInput.sessionID, s);
+                    delete state[hookInput.sessionID];
+                    output.stop = true;
+                    return;
+                }
+                // Continue fixing
+                output.stop = false;
+                output.systemMessage = `[Ralph - FIX MODE - Addressing review comments]`;
+                output.prompt = s.prompt;
+                return;
+            }
+        },
+        // Hook: experimental.chat.system.transform - inject system prompts for review/fix modes
+        async ["experimental.chat.system.transform"](_input, output) {
+            if (!activeReviewSession)
+                return;
+            const s = state[activeReviewSession];
+            if (!s?.active) {
+                activeReviewSession = null;
+                return;
+            }
+            if (s.phase === "review") {
+                output.system.push(REVIEW_SYSTEM_PROMPT);
+            }
+            else if (s.phase === "fix") {
+                output.system.push(FIX_SYSTEM_PROMPT);
+            }
+        },
+    };
+}

package/package.json

@@ -1,10 +1,19 @@
 {
   "name": "@sureshsankaran/ralph-wiggum",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Ralph Wiggum plugin for OpenCode - iterative, self-referential AI development loops",
   "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "opencode",
     "plugin",
@@ -21,11 +30,16 @@
     "directory": "packages/ralph-wiggum"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "tsc"
   },
   "dependencies": {},
   "devDependencies": {
     "typescript": "^5.8.3",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.0.0",
+    "@types/bun": "^1.1.0"
+  },
+  "peerDependencies": {
+    "bun": ">=1.0.0"
   }
 }

package/src/index.ts

@@ -1,361 +0,0 @@
-/**
- * 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

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