@th0rgal/ralph-wiggum 1.0.1 → 1.0.2

package/README.md

@@ -142,6 +142,9 @@ Options:
   --max-iterations N       Stop after N iterations (default: unlimited)
   --completion-promise T   Text that signals completion (default: COMPLETE)
   --model MODEL            OpenCode model to use
+  --prompt-file, --file, -f  Read prompt content from a file
+  --no-stream              Buffer OpenCode output and print at the end
+  --verbose-tools          Print every tool line (disable compact tool summary)
   --no-plugins             Disable non-auth OpenCode plugins for this run
   --no-commit              Don't auto-commit after iterations
   --help                   Show help
@@ -176,6 +179,15 @@ Remove `ralph-wiggum` from your OpenCode `plugin` list (opencode.json), or run:
 ralph "Your task" --no-plugins
 ```
 
+### "Cannot find module '@opencode-ai/plugin'"
+
+OpenCode is loading the `@th0rgal/ralph-wiggum` npm package, but its dependencies aren't installed.
+Reinstall/upgrade the package so dependencies are present, or temporarily disable non-auth plugins:
+
+```bash
+ralph "Your task" --no-plugins
+```
+
 ## Writing Good Prompts
 
 ### Include Clear Success Criteria

package/cli/ralph.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+
+const scriptPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "ralph.ts");
+const result = spawnSync("bun", [scriptPath, ...process.argv.slice(2)], { stdio: "inherit" });
+
+if (result.error) {
+  console.error("Error: Bun is required to run ralph. Install Bun: https://bun.sh");
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@th0rgal/ralph-wiggum",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Ralph Wiggum technique for OpenCode - iterative AI development loops with self-correcting agents",
   "type": "module",
   "main": ".opencode/plugin/ralph-wiggum.ts",
   "bin": {
-    "ralph": "./ralph.ts"
+    "ralph": "./cli/ralph.js"
   },
   "scripts": {
     "start": "bun ralph.ts",
@@ -13,6 +13,21 @@
     "test": "bun test ./tests/ralph.test.ts",
     "install-local": "bun link"
   },
+  "files": [
+    "cli/",
+    "ralph.ts",
+    ".opencode/command/",
+    ".opencode/plugin/",
+    "README.md",
+    "LICENSE",
+    "install.sh",
+    "install.ps1",
+    "uninstall.sh",
+    "uninstall.ps1"
+  ],
+  "dependencies": {
+    "@opencode-ai/plugin": "1.0.223"
+  },
   "keywords": [
     "opencode",
     "ai",

package/ralph.ts

@@ -7,10 +7,10 @@
  */
 
 import { $ } from "bun";
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
 import { join } from "path";
 
-const VERSION = "1.0.0";
+const VERSION = "1.0.2";
 
 // Parse arguments
 const args = process.argv.slice(2);
@@ -21,6 +21,7 @@ Ralph Wiggum Loop - Iterative AI development with OpenCode
 
 Usage:
   ralph "<prompt>" [options]
+  ralph --prompt-file <path> [options]
 
 Arguments:
   prompt              Task description for the AI to work on
@@ -29,6 +30,9 @@ Options:
   --max-iterations N  Maximum iterations before stopping (default: unlimited)
   --completion-promise TEXT  Phrase that signals completion (default: COMPLETE)
   --model MODEL       Model to use (e.g., anthropic/claude-sonnet)
+  --prompt-file, --file, -f  Read prompt content from a file
+  --no-stream         Buffer OpenCode output and print at the end
+  --verbose-tools     Print every tool line (disable compact tool summary)
   --no-plugins        Disable non-auth OpenCode plugins for this run
   --no-commit         Don't auto-commit after each iteration
   --version, -v       Show version
@@ -38,6 +42,7 @@ Examples:
   ralph "Build a REST API for todos"
   ralph "Fix the auth bug" --max-iterations 10
   ralph "Add tests" --completion-promise "ALL TESTS PASS" --model openai/gpt-5.1
+  ralph --prompt-file ./prompt.md --max-iterations 5
 
 How it works:
   1. Sends your prompt to OpenCode
@@ -66,6 +71,10 @@ let completionPromise = "COMPLETE";
 let model = "";
 let autoCommit = true;
 let disablePlugins = false;
+let promptFile = "";
+let streamOutput = true;
+let verboseTools = false;
+let promptSource = "";
 
 const promptParts: string[] = [];
 
@@ -93,6 +102,19 @@ for (let i = 0; i < args.length; i++) {
       process.exit(1);
     }
     model = val;
+  } else if (arg === "--prompt-file" || arg === "--file" || arg === "-f") {
+    const val = args[++i];
+    if (!val) {
+      console.error("Error: --prompt-file requires a file path");
+      process.exit(1);
+    }
+    promptFile = val;
+  } else if (arg === "--no-stream") {
+    streamOutput = false;
+  } else if (arg === "--stream") {
+    streamOutput = true;
+  } else if (arg === "--verbose-tools") {
+    verboseTools = true;
   } else if (arg === "--no-commit") {
     autoCommit = false;
   } else if (arg === "--no-plugins") {
@@ -106,7 +128,43 @@ for (let i = 0; i < args.length; i++) {
   }
 }
 
-prompt = promptParts.join(" ");
+function readPromptFile(path: string): string {
+  if (!existsSync(path)) {
+    console.error(`Error: Prompt file not found: ${path}`);
+    process.exit(1);
+  }
+  try {
+    const stat = statSync(path);
+    if (!stat.isFile()) {
+      console.error(`Error: Prompt path is not a file: ${path}`);
+      process.exit(1);
+    }
+  } catch {
+    console.error(`Error: Unable to stat prompt file: ${path}`);
+    process.exit(1);
+  }
+  try {
+    const content = readFileSync(path, "utf-8");
+    if (!content.trim()) {
+      console.error(`Error: Prompt file is empty: ${path}`);
+      process.exit(1);
+    }
+    return content;
+  } catch {
+    console.error(`Error: Unable to read prompt file: ${path}`);
+    process.exit(1);
+  }
+}
+
+if (promptFile) {
+  promptSource = promptFile;
+  prompt = readPromptFile(promptFile);
+} else if (promptParts.length === 1 && existsSync(promptParts[0])) {
+  promptSource = promptParts[0];
+  prompt = readPromptFile(promptParts[0]);
+} else {
+  prompt = promptParts.join(" ");
+}
 
 if (!prompt) {
   console.error("Error: No prompt provided");
@@ -184,7 +242,7 @@ function ensureFilteredPluginsConfig(): string {
     ...loadPluginsFromConfig(userConfigPath),
     ...loadPluginsFromConfig(projectConfigPath),
   ];
-  const filtered = Array.from(new Set(plugins)).filter(p => p !== "ralph-wiggum");
+  const filtered = Array.from(new Set(plugins)).filter(p => /auth/i.test(p));
   writeFileSync(
     configPath,
     JSON.stringify(
@@ -246,6 +304,191 @@ function detectPlaceholderPluginError(output: string): boolean {
   return output.includes("ralph-wiggum is not yet ready for use. This is a placeholder package.");
 }
 
+function stripAnsi(input: string): string {
+  return input.replace(/\x1B\[[0-9;]*m/g, "");
+}
+
+function formatDuration(ms: number): string {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+  }
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
+function formatToolSummary(toolCounts: Map<string, number>, maxItems = 6): string {
+  if (!toolCounts.size) return "";
+  const entries = Array.from(toolCounts.entries()).sort((a, b) => b[1] - a[1]);
+  const shown = entries.slice(0, maxItems);
+  const remaining = entries.length - shown.length;
+  const parts = shown.map(([name, count]) => `${name} ${count}`);
+  if (remaining > 0) {
+    parts.push(`+${remaining} more`);
+  }
+  return parts.join(" • ");
+}
+
+function collectToolSummaryFromText(text: string): Map<string, number> {
+  const counts = new Map<string, number>();
+  const lines = text.split(/\r?\n/);
+  for (const line of lines) {
+    const match = stripAnsi(line).match(/^\|\s{2}([A-Za-z0-9_-]+)/);
+    if (match) {
+      const tool = match[1];
+      counts.set(tool, (counts.get(tool) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+
+function printIterationSummary(params: {
+  iteration: number;
+  elapsedMs: number;
+  toolCounts: Map<string, number>;
+  exitCode: number;
+  completionDetected: boolean;
+}): void {
+  const toolSummary = formatToolSummary(params.toolCounts);
+  console.log("\nIteration Summary");
+  console.log("────────────────────────────────────────────────────────────────────");
+  console.log(`Iteration: ${params.iteration}`);
+  console.log(`Elapsed:   ${formatDuration(params.elapsedMs)}`);
+  if (toolSummary) {
+    console.log(`Tools:     ${toolSummary}`);
+  } else {
+    console.log("Tools:     none");
+  }
+  console.log(`Exit code: ${params.exitCode}`);
+  console.log(`Completion promise: ${params.completionDetected ? "detected" : "not detected"}`);
+}
+
+async function streamProcessOutput(
+  proc: ReturnType<typeof Bun.spawn>,
+  options: {
+    compactTools: boolean;
+    toolSummaryIntervalMs: number;
+    heartbeatIntervalMs: number;
+    iterationStart: number;
+  },
+): Promise<{ stdoutText: string; stderrText: string; toolCounts: Map<string, number> }> {
+  const toolCounts = new Map<string, number>();
+  let stdoutText = "";
+  let stderrText = "";
+  let lastPrintedAt = Date.now();
+  let lastActivityAt = Date.now();
+  let lastToolSummaryAt = 0;
+
+  const compactTools = options.compactTools;
+
+  const maybePrintToolSummary = (force = false) => {
+    if (!compactTools || toolCounts.size === 0) return;
+    const now = Date.now();
+    if (!force && now - lastToolSummaryAt < options.toolSummaryIntervalMs) {
+      return;
+    }
+    const summary = formatToolSummary(toolCounts);
+    if (summary) {
+      console.log(`| Tools    ${summary}`);
+      lastPrintedAt = Date.now();
+      lastToolSummaryAt = Date.now();
+    }
+  };
+
+  const handleLine = (line: string, isError: boolean) => {
+    lastActivityAt = Date.now();
+    const match = stripAnsi(line).match(/^\|\s{2}([A-Za-z0-9_-]+)/);
+    if (compactTools && match) {
+      const tool = match[1];
+      toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+      maybePrintToolSummary();
+      return;
+    }
+    if (line.length === 0) {
+      console.log("");
+      lastPrintedAt = Date.now();
+      return;
+    }
+    if (isError) {
+      console.error(line);
+    } else {
+      console.log(line);
+    }
+    lastPrintedAt = Date.now();
+  };
+
+  const streamText = async (
+    stream: ReadableStream<Uint8Array> | null,
+    onText: (chunk: string) => void,
+    isError: boolean,
+  ) => {
+    if (!stream) return;
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      const text = decoder.decode(value, { stream: true });
+      if (text.length > 0) {
+        onText(text);
+        buffer += text;
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          handleLine(line, isError);
+        }
+      }
+    }
+    const flushed = decoder.decode();
+    if (flushed.length > 0) {
+      onText(flushed);
+      buffer += flushed;
+    }
+    if (buffer.length > 0) {
+      handleLine(buffer, isError);
+    }
+  };
+
+  const heartbeatTimer = setInterval(() => {
+    const now = Date.now();
+    if (now - lastPrintedAt >= options.heartbeatIntervalMs) {
+      const elapsed = formatDuration(now - options.iterationStart);
+      const sinceActivity = formatDuration(now - lastActivityAt);
+      console.log(`⏳ working... elapsed ${elapsed} · last activity ${sinceActivity} ago`);
+      lastPrintedAt = now;
+    }
+  }, options.heartbeatIntervalMs);
+
+  try {
+    await Promise.all([
+      streamText(
+        proc.stdout,
+        chunk => {
+          stdoutText += chunk;
+        },
+        false,
+      ),
+      streamText(
+        proc.stderr,
+        chunk => {
+          stderrText += chunk;
+        },
+        true,
+      ),
+    ]);
+  } finally {
+    clearInterval(heartbeatTimer);
+  }
+
+  if (compactTools) {
+    maybePrintToolSummary(true);
+  }
+
+  return { stdoutText, stderrText, toolCounts };
+}
 // Main loop
 async function runRalphLoop(): Promise<void> {
   // Check if a loop is already running
@@ -277,7 +520,13 @@ async function runRalphLoop(): Promise<void> {
 
   saveState(state);
 
-  console.log(`Task: ${prompt.substring(0, 80)}${prompt.length > 80 ? "..." : ""}`);
+  const promptPreview = prompt.replace(/\s+/g, " ").substring(0, 80) + (prompt.length > 80 ? "..." : "");
+  if (promptSource) {
+    console.log(`Task: ${promptSource}`);
+    console.log(`Preview: ${promptPreview}`);
+  } else {
+    console.log(`Task: ${promptPreview}`);
+  }
   console.log(`Completion promise: ${completionPromise}`);
   console.log(`Max iterations: ${maxIterations > 0 ? maxIterations : "unlimited"}`);
   if (model) console.log(`Model: ${model}`);
@@ -329,6 +578,7 @@ async function runRalphLoop(): Promise<void> {
 
     // Build the prompt
     const fullPrompt = buildPrompt(state);
+    const iterationStart = Date.now();
 
     try {
       // Build command arguments
@@ -350,21 +600,65 @@ async function runRalphLoop(): Promise<void> {
         stderr: "pipe",
       });
       const proc = currentProc;
+      const exitCodePromise = proc.exited;
+      let result = "";
+      let stderr = "";
+      let toolCounts = new Map<string, number>();
+
+      if (streamOutput) {
+        const streamed = await streamProcessOutput(proc, {
+          compactTools: !verboseTools,
+          toolSummaryIntervalMs: 3000,
+          heartbeatIntervalMs: 10000,
+          iterationStart,
+        });
+        result = streamed.stdoutText;
+        stderr = streamed.stderrText;
+        toolCounts = streamed.toolCounts;
+      } else {
+        const stdoutPromise = new Response(proc.stdout).text();
+        const stderrPromise = new Response(proc.stderr).text();
+        [result, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+        toolCounts = collectToolSummaryFromText(`${result}\n${stderr}`);
+      }
 
-      const stdoutPromise = new Response(proc.stdout).text();
-      const stderrPromise = new Response(proc.stderr).text();
-      const [result, stderr, exitCode] = await Promise.all([
-        stdoutPromise,
-        stderrPromise,
-        proc.exited,
-      ]);
+      const exitCode = await exitCodePromise;
       currentProc = null; // Clear reference after subprocess completes
 
-      if (stderr) {
-        console.error(stderr);
+      if (!streamOutput) {
+        if (stderr) {
+          console.error(stderr);
+        }
+        console.log(result);
       }
 
-      console.log(result);
+      const combinedOutput = `${result}\n${stderr}`;
+      const completionDetected = checkCompletion(combinedOutput, completionPromise);
+
+      printIterationSummary({
+        iteration: state.iteration,
+        elapsedMs: Date.now() - iterationStart,
+        toolCounts,
+        exitCode,
+        completionDetected,
+      });
+
+      if (detectPlaceholderPluginError(combinedOutput)) {
+        console.error(
+          "\n❌ OpenCode tried to load the npm plugin 'ralph-wiggum', which is a placeholder package.",
+        );
+        console.error(
+          "Remove 'ralph-wiggum' from your opencode.json plugin list, or re-run with --no-plugins.",
+        );
+        clearState();
+        process.exit(1);
+      }
+
+      if (exitCode !== 0) {
+        console.error(`\n❌ OpenCode exited with code ${exitCode}. Stopping the loop.`);
+        clearState();
+        process.exit(exitCode);
+      }
 
       if (detectPlaceholderPluginError(stderr) || detectPlaceholderPluginError(result)) {
         console.error(
@@ -384,7 +678,7 @@ async function runRalphLoop(): Promise<void> {
       }
 
       // Check for completion
-      if (checkCompletion(result, completionPromise)) {
+      if (completionDetected) {
         console.log(`\n╔══════════════════════════════════════════════════════════════════╗`);
         console.log(`║  ✅ Completion promise detected: <promise>${completionPromise}</promise>`);
         console.log(`║  Task completed in ${state.iteration} iteration(s)`);

package/.context/attachments/PR instructions.md

@@ -1,15 +0,0 @@
-The user likes the state of the code.
-
-There are 0 uncommitted changes.
-The current branch is Th0rgal/fix-issue2.
-The target branch is origin/master.
-An upstream branch exists.
-
-The user requested a PR.
-
-Follow these **exact steps** to create a PR:
-
-- Use `git diff origin/master...` to review the PR diff
-- Use `gh pr create --base master` to create a PR onto the target branch. Keep the title under 80 characters and the description under five sentences (unless the user has given you other instructions).
-
-If any of these steps fail, ask the user for help.

package/bun.lock

@@ -1,21 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "opencode-ralph-wiggum",
-      "devDependencies": {
-        "@types/bun": "^1.3.5",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="],
-
-    "@types/node": ["@types/node@25.0.3", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA=="],
-
-    "bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="],
-
-    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
-  }
-}

package/tests/ralph.test.ts

@@ -1,260 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
-import { join } from "path";
-
-const testDir = join(import.meta.dir, "test-workspace");
-const stateFile = join(testDir, ".opencode", "ralph-loop.state.json");
-
-// Helper to set up test workspace
-function setupTestWorkspace() {
-  if (!existsSync(testDir)) {
-    mkdirSync(testDir, { recursive: true });
-  }
-  if (!existsSync(join(testDir, ".opencode"))) {
-    mkdirSync(join(testDir, ".opencode"), { recursive: true });
-  }
-}
-
-// Helper to clean up test workspace
-function cleanupTestWorkspace() {
-  try {
-    if (existsSync(stateFile)) {
-      unlinkSync(stateFile);
-    }
-  } catch {}
-}
-
-describe("Ralph Wiggum State Management", () => {
-  test("should create state file with correct structure", () => {
-    setupTestWorkspace();
-    cleanupTestWorkspace();
-
-    const state = {
-      active: true,
-      iteration: 1,
-      maxIterations: 10,
-      completionPromise: "COMPLETE",
-      prompt: "Test task",
-      startedAt: new Date().toISOString(),
-      model: "",
-    };
-
-    writeFileSync(stateFile, JSON.stringify(state, null, 2));
-
-    expect(existsSync(stateFile)).toBe(true);
-
-    const loaded = JSON.parse(readFileSync(stateFile, "utf-8"));
-    expect(loaded.active).toBe(true);
-    expect(loaded.iteration).toBe(1);
-    expect(loaded.maxIterations).toBe(10);
-    expect(loaded.completionPromise).toBe("COMPLETE");
-    expect(loaded.prompt).toBe("Test task");
-
-    cleanupTestWorkspace();
-  });
-
-  test("should detect completion promise in output", () => {
-    const testCases = [
-      { output: "<promise>COMPLETE</promise>", promise: "COMPLETE", expected: true },
-      { output: "Some text <promise>DONE</promise> more text", promise: "DONE", expected: true },
-      { output: "<promise> COMPLETE </promise>", promise: "COMPLETE", expected: true },
-      { output: "No promise here", promise: "COMPLETE", expected: false },
-      { output: "<promise>WRONG</promise>", promise: "COMPLETE", expected: false },
-      { output: "promise>COMPLETE</promise", promise: "COMPLETE", expected: false },
-      { output: "<promise>ALL TESTS PASS</promise>", promise: "ALL TESTS PASS", expected: true },
-    ];
-
-    for (const { output, promise, expected } of testCases) {
-      const escaped = promise.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const pattern = new RegExp(`<promise>\\s*${escaped}\\s*</promise>`, "i");
-      const result = pattern.test(output);
-      expect(result).toBe(expected);
-    }
-  });
-
-  test("should increment iteration correctly", () => {
-    setupTestWorkspace();
-    cleanupTestWorkspace();
-
-    const state = {
-      active: true,
-      iteration: 1,
-      maxIterations: 0,
-      completionPromise: "COMPLETE",
-      prompt: "Test task",
-      startedAt: new Date().toISOString(),
-      model: "",
-    };
-
-    writeFileSync(stateFile, JSON.stringify(state, null, 2));
-
-    // Simulate iteration increment
-    const loaded = JSON.parse(readFileSync(stateFile, "utf-8"));
-    loaded.iteration++;
-    writeFileSync(stateFile, JSON.stringify(loaded, null, 2));
-
-    const updated = JSON.parse(readFileSync(stateFile, "utf-8"));
-    expect(updated.iteration).toBe(2);
-
-    cleanupTestWorkspace();
-  });
-
-  test("should handle max iterations limit", () => {
-    const maxIterations = 5;
-    let currentIteration = 1;
-
-    while (currentIteration <= maxIterations) {
-      currentIteration++;
-    }
-
-    expect(currentIteration).toBe(6);
-    expect(currentIteration > maxIterations).toBe(true);
-  });
-
-  test("should build prompt with iteration context", () => {
-    const state = {
-      active: true,
-      iteration: 3,
-      maxIterations: 10,
-      completionPromise: "DONE",
-      prompt: "Build a feature",
-      startedAt: new Date().toISOString(),
-      model: "",
-    };
-
-    const prompt = `
-# Ralph Wiggum Loop - Iteration ${state.iteration}
-
-## Your Task
-
-${state.prompt}
-
-## Instructions
-
-When complete, output:
-<promise>${state.completionPromise}</promise>
-
-## Current Iteration: ${state.iteration}${state.maxIterations > 0 ? ` / ${state.maxIterations}` : " (unlimited)"}
-`.trim();
-
-    expect(prompt).toContain("Iteration 3");
-    expect(prompt).toContain("Build a feature");
-    expect(prompt).toContain("<promise>DONE</promise>");
-    expect(prompt).toContain("3 / 10");
-  });
-});
-
-describe("Ralph Wiggum CLI Arguments", () => {
-  test("should parse simple prompt", () => {
-    const args = ["Build a todo app"];
-    const promptParts: string[] = [];
-
-    for (const arg of args) {
-      if (!arg.startsWith("-")) {
-        promptParts.push(arg);
-      }
-    }
-
-    expect(promptParts.join(" ")).toBe("Build a todo app");
-  });
-
-  test("should parse prompt with options", () => {
-    const args = [
-      "Build",
-      "a",
-      "todo",
-      "app",
-      "--max-iterations",
-      "10",
-      "--completion-promise",
-      "DONE",
-    ];
-
-    let maxIterations = 0;
-    let completionPromise = "COMPLETE";
-    const promptParts: string[] = [];
-
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "--max-iterations") {
-        maxIterations = parseInt(args[++i]);
-      } else if (arg === "--completion-promise") {
-        completionPromise = args[++i];
-      } else if (!arg.startsWith("-")) {
-        promptParts.push(arg);
-      }
-    }
-
-    expect(promptParts.join(" ")).toBe("Build a todo app");
-    expect(maxIterations).toBe(10);
-    expect(completionPromise).toBe("DONE");
-  });
-
-  test("should handle empty prompt", () => {
-    const args: string[] = [];
-    const promptParts: string[] = [];
-
-    for (const arg of args) {
-      if (!arg.startsWith("-")) {
-        promptParts.push(arg);
-      }
-    }
-
-    const prompt = promptParts.join(" ");
-    expect(prompt).toBe("");
-  });
-
-  test("should parse model option", () => {
-    const args = ["Test task", "--model", "anthropic/claude-sonnet"];
-
-    let model = "";
-    const promptParts: string[] = [];
-
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "--model") {
-        model = args[++i];
-      } else if (!arg.startsWith("-")) {
-        promptParts.push(arg);
-      }
-    }
-
-    expect(model).toBe("anthropic/claude-sonnet");
-    expect(promptParts.join(" ")).toBe("Test task");
-  });
-});
-
-describe("OpenCode Command Files", () => {
-  const commandDir = join(import.meta.dir, "..", ".opencode", "command");
-
-  test("ralph-loop.md should exist and have correct frontmatter", () => {
-    const filePath = join(commandDir, "ralph-loop.md");
-    expect(existsSync(filePath)).toBe(true);
-
-    const content = readFileSync(filePath, "utf-8");
-    expect(content).toContain("---");
-    expect(content).toContain("description:");
-    expect(content).toContain("$ARGUMENTS");
-    expect(content).toContain("<promise>COMPLETE</promise>");
-  });
-
-  test("cancel-ralph.md should exist", () => {
-    const filePath = join(commandDir, "cancel-ralph.md");
-    expect(existsSync(filePath)).toBe(true);
-
-    const content = readFileSync(filePath, "utf-8");
-    expect(content).toContain("---");
-    expect(content).toContain("Cancel");
-    expect(content).toContain("ralph-loop.state.json");
-  });
-
-  test("help.md should exist and explain Ralph Wiggum", () => {
-    const filePath = join(commandDir, "help.md");
-    expect(existsSync(filePath)).toBe(true);
-
-    const content = readFileSync(filePath, "utf-8");
-    expect(content).toContain("Ralph Wiggum");
-    expect(content).toContain("Geoffrey Huntley");
-    expect(content).toContain("ghuntley.com/ralph");
-  });
-});