@towles/tool 0.0.53 → 0.0.55

package/src/commands/ralph/run.test.ts

@@ -1,607 +0,0 @@
-/**
- * Unit tests for ralph-loop script
- */
-import { describe, it, expect, afterEach } from "vitest";
-import { existsSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import type { RalphPlan, IterationHistory } from "../../lib/ralph/index.js";
-import {
-  createInitialState,
-  saveState,
-  loadState,
-  addPlanToState,
-  formatPlansAsMarkdown,
-  formatPlanAsMarkdown,
-  formatPlanAsJson,
-  buildIterationPrompt,
-  extractOutputSummary,
-  detectCompletionMarker,
-  appendHistory,
-  DEFAULT_MAX_ITERATIONS,
-  DEFAULT_STATE_FILE,
-  DEFAULT_HISTORY_FILE,
-  DEFAULT_COMPLETION_MARKER,
-  DEFAULT_TASK_DONE_MARKER,
-  CLAUDE_DEFAULT_ARGS,
-} from "../../lib/ralph/index.js";
-
-describe("ralph-loop", () => {
-  const testStateFile = join(tmpdir(), `ralph-test-${Date.now()}.json`);
-  const testHistoryFile = join(tmpdir(), `ralph-history-${Date.now()}.log`);
-
-  afterEach(() => {
-    // Cleanup test files
-    if (existsSync(testStateFile)) {
-      unlinkSync(testStateFile);
-    }
-    if (existsSync(testHistoryFile)) {
-      unlinkSync(testHistoryFile);
-    }
-  });
-
-  describe("constants", () => {
-    it("should have correct default values", () => {
-      expect(DEFAULT_MAX_ITERATIONS).toBe(10);
-      expect(DEFAULT_STATE_FILE).toBe("./.claude/.ralph/ralph-state.local.json");
-      expect(DEFAULT_HISTORY_FILE).toBe("./.claude/.ralph/ralph-history.local.log");
-      expect(DEFAULT_COMPLETION_MARKER).toBe("RALPH_DONE");
-      expect(DEFAULT_TASK_DONE_MARKER).toBe("TASK_DONE");
-      expect(CLAUDE_DEFAULT_ARGS).toEqual([
-        "--print",
-        "--verbose",
-        "--output-format",
-        "stream-json",
-        "--permission-mode",
-        "bypassPermissions",
-      ]);
-    });
-  });
-
-  describe("createInitialState", () => {
-    it("should create state with correct structure", () => {
-      const state = createInitialState();
-
-      expect(state.version).toBe(1);
-      expect(state.status).toBe("running");
-      expect(state.plans).toEqual([]);
-      expect(state.startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-    });
-  });
-
-  describe("saveState and loadState", () => {
-    it("should save and load state correctly", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/test-plan.md");
-
-      saveState(state, testStateFile);
-      const loaded = loadState(testStateFile);
-
-      expect(loaded).not.toBeNull();
-      expect(loaded?.plans).toHaveLength(1);
-      expect(loaded?.plans[0].planFilePath).toBe("/tmp/test-plan.md");
-    });
-
-    it("should return null for non-existent file", () => {
-      const loaded = loadState("/nonexistent/path/file.json");
-      expect(loaded).toBeNull();
-    });
-
-    it("should return null for invalid JSON", () => {
-      writeFileSync(testStateFile, "invalid json {{{");
-      const loaded = loadState(testStateFile);
-      expect(loaded).toBeNull();
-    });
-  });
-
-  describe("buildIterationPrompt", () => {
-    const testPlan: RalphPlan = {
-      id: 1,
-      planFilePath: "/tmp/first-plan.md",
-      status: "ready",
-      addedAt: new Date().toISOString(),
-    };
-
-    it("should include completion marker", () => {
-      const prompt = buildIterationPrompt({
-        completionMarker: "RALPH_DONE",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-      });
-      expect(prompt).toContain("RALPH_DONE");
-    });
-
-    it("should include plan file path for reading", () => {
-      const prompt = buildIterationPrompt({
-        completionMarker: "RALPH_DONE",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-      });
-      expect(prompt).toContain("/tmp/first-plan.md");
-      expect(prompt).toContain("Read Plan:");
-    });
-
-    it("should include instruction to update plan file", () => {
-      const prompt = buildIterationPrompt({
-        completionMarker: "RALPH_DONE",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-      });
-      expect(prompt).toContain("Update the plan");
-      expect(prompt).toContain("/tmp/first-plan.md");
-    });
-
-    it("should include custom completion marker", () => {
-      const prompt = buildIterationPrompt({
-        completionMarker: "CUSTOM_MARKER",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-      });
-      expect(prompt).toContain("CUSTOM_MARKER");
-    });
-
-    it("should include TASK_DONE for tasks remaining", () => {
-      const prompt = buildIterationPrompt({
-        completionMarker: "RALPH_DONE",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-      });
-      expect(prompt).toContain("TASK_DONE");
-      expect(prompt).toContain("tasks remain");
-    });
-
-    it("should include RALPH_DONE for plan complete", () => {
-      const prompt = buildIterationPrompt({
-        completionMarker: "RALPH_DONE",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-      });
-      expect(prompt).toContain("RALPH_DONE");
-      expect(prompt).toContain("plan is complete");
-    });
-
-    it("should skip commit step when skipCommit is true", () => {
-      const promptWithCommit = buildIterationPrompt({
-        completionMarker: "RALPH_DONE",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-        skipCommit: false,
-      });
-      const promptWithoutCommit = buildIterationPrompt({
-        completionMarker: "RALPH_DONE",
-        taskDoneMarker: "TASK_DONE",
-        plan: testPlan,
-        skipCommit: true,
-      });
-      expect(promptWithCommit).toContain("git commit");
-      expect(promptWithoutCommit).not.toContain("git commit");
-    });
-  });
-
-  describe("extractOutputSummary", () => {
-    it("should return last 5 lines joined", () => {
-      const output = "line 1\nline 2\nline 3\nline 4\nline 5\nline 6\nline 7";
-      const summary = extractOutputSummary(output);
-
-      expect(summary).toContain("line 3");
-      expect(summary).toContain("line 7");
-      expect(summary).not.toContain("line 1");
-      expect(summary).not.toContain("line 2");
-    });
-
-    it("should filter empty lines", () => {
-      const output = "line 1\n\n\nline 2\n\nline 3";
-      const summary = extractOutputSummary(output);
-
-      expect(summary).toBe("line 1 line 2 line 3");
-    });
-
-    it("should truncate long output", () => {
-      const longLine = "x".repeat(300);
-      const summary = extractOutputSummary(longLine, 200);
-
-      expect(summary.length).toBe(203); // 200 + '...'
-      expect(summary.endsWith("...")).toBe(true);
-    });
-
-    it('should return "(no output)" for empty string', () => {
-      expect(extractOutputSummary("")).toBe("(no output)");
-      expect(extractOutputSummary("   \n  \n   ")).toBe("(no output)");
-    });
-
-    it("should use custom maxLength", () => {
-      const output = "a".repeat(100);
-      const summary = extractOutputSummary(output, 50);
-
-      expect(summary.length).toBe(53); // 50 + '...'
-    });
-  });
-
-  describe("detectCompletionMarker", () => {
-    it("should detect marker in output", () => {
-      expect(detectCompletionMarker("Task complete RALPH_DONE", "RALPH_DONE")).toBe(true);
-    });
-
-    it("should return false when marker not present", () => {
-      expect(detectCompletionMarker("Task still in progress", "RALPH_DONE")).toBe(false);
-    });
-
-    it("should detect marker anywhere in output", () => {
-      expect(detectCompletionMarker("start RALPH_DONE end", "RALPH_DONE")).toBe(true);
-      expect(detectCompletionMarker("RALPH_DONE", "RALPH_DONE")).toBe(true);
-      expect(detectCompletionMarker("prefix\nRALPH_DONE\nsuffix", "RALPH_DONE")).toBe(true);
-    });
-
-    it("should work with custom markers", () => {
-      expect(detectCompletionMarker("CUSTOM_DONE", "CUSTOM_DONE")).toBe(true);
-      expect(detectCompletionMarker("<done/>", "<done/>")).toBe(true);
-    });
-
-    it("should be case-sensitive", () => {
-      expect(detectCompletionMarker("ralph_done", "RALPH_DONE")).toBe(false);
-    });
-
-    it("should detect TASK_DONE marker", () => {
-      expect(detectCompletionMarker("finished <promise>TASK_DONE</promise>", "TASK_DONE")).toBe(
-        true,
-      );
-    });
-
-    it("should distinguish TASK_DONE from RALPH_DONE", () => {
-      const output = "<promise>TASK_DONE</promise>";
-      expect(detectCompletionMarker(output, "TASK_DONE")).toBe(true);
-      expect(detectCompletionMarker(output, "RALPH_DONE")).toBe(false);
-    });
-  });
-
-  describe("state transitions", () => {
-    it("should update status correctly", () => {
-      const state = createInitialState();
-
-      expect(state.status).toBe("running");
-
-      state.status = "completed";
-      expect(state.status).toBe("completed");
-
-      state.status = "max_iterations_reached";
-      expect(state.status).toBe("max_iterations_reached");
-
-      state.status = "error";
-      expect(state.status).toBe("error");
-    });
-  });
-
-  describe("appendHistory", () => {
-    it("should append history as JSON line", () => {
-      const history: IterationHistory = {
-        iteration: 1,
-        startedAt: "2026-01-08T10:00:00Z",
-        completedAt: "2026-01-08T10:01:00Z",
-        durationMs: 60000,
-        durationHuman: "1m 0s",
-        outputSummary: "test output",
-        markerFound: false,
-      };
-
-      appendHistory(history, testHistoryFile);
-
-      const content = require("node:fs").readFileSync(testHistoryFile, "utf-8");
-      const lines = content.trim().split("\n");
-      expect(lines).toHaveLength(1);
-
-      const parsed = JSON.parse(lines[0]);
-      expect(parsed.iteration).toBe(1);
-      expect(parsed.outputSummary).toBe("test output");
-    });
-
-    it("should append multiple entries", () => {
-      const history1: IterationHistory = {
-        iteration: 1,
-        startedAt: "2026-01-08T10:00:00Z",
-        completedAt: "2026-01-08T10:01:00Z",
-        durationMs: 60000,
-        durationHuman: "1m 0s",
-        outputSummary: "first",
-        markerFound: false,
-      };
-      const history2: IterationHistory = {
-        iteration: 2,
-        startedAt: "2026-01-08T10:02:00Z",
-        completedAt: "2026-01-08T10:03:00Z",
-        durationMs: 60000,
-        durationHuman: "1m 0s",
-        outputSummary: "second",
-        markerFound: true,
-      };
-
-      appendHistory(history1, testHistoryFile);
-      appendHistory(history2, testHistoryFile);
-
-      const content = require("node:fs").readFileSync(testHistoryFile, "utf-8");
-      const lines = content.trim().split("\n");
-      expect(lines).toHaveLength(2);
-
-      const parsed1 = JSON.parse(lines[0]);
-      const parsed2 = JSON.parse(lines[1]);
-      expect(parsed1.outputSummary).toBe("first");
-      expect(parsed2.outputSummary).toBe("second");
-      expect(parsed2.markerFound).toBe(true);
-    });
-
-    it("should include taskMarkerFound field", () => {
-      const history: IterationHistory = {
-        iteration: 1,
-        startedAt: "2026-01-19T10:00:00Z",
-        completedAt: "2026-01-19T10:01:00Z",
-        durationMs: 60000,
-        durationHuman: "1m 0s",
-        outputSummary: "test output",
-        markerFound: false,
-        taskMarkerFound: true,
-      };
-
-      appendHistory(history, testHistoryFile);
-
-      const content = require("node:fs").readFileSync(testHistoryFile, "utf-8");
-      const parsed = JSON.parse(content.trim());
-      expect(parsed.taskMarkerFound).toBe(true);
-      expect(parsed.markerFound).toBe(false);
-    });
-  });
-
-  describe("addPlanToState", () => {
-    it("should add plan with correct structure", () => {
-      const state = createInitialState();
-      const plan = addPlanToState(state, "/tmp/implement-feature.md");
-
-      expect(plan.id).toBe(1);
-      expect(plan.planFilePath).toBe("/tmp/implement-feature.md");
-      expect(plan.status).toBe("ready");
-      expect(plan.addedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-      expect(plan.completedAt).toBeUndefined();
-    });
-
-    it("should increment plan IDs", () => {
-      const state = createInitialState();
-
-      const plan1 = addPlanToState(state, "/tmp/plan-1.md");
-      const plan2 = addPlanToState(state, "/tmp/plan-2.md");
-      const plan3 = addPlanToState(state, "/tmp/plan-3.md");
-
-      expect(plan1.id).toBe(1);
-      expect(plan2.id).toBe(2);
-      expect(plan3.id).toBe(3);
-      expect(state.plans).toHaveLength(3);
-    });
-
-    it("should handle non-sequential IDs", () => {
-      const state = createInitialState();
-
-      // Simulate deleted plan by adding with gap
-      state.plans.push({
-        id: 5,
-        planFilePath: "/tmp/existing-plan.md",
-        status: "done",
-        addedAt: new Date().toISOString(),
-      });
-
-      const newPlan = addPlanToState(state, "/tmp/new-plan.md");
-      expect(newPlan.id).toBe(6);
-    });
-  });
-
-  describe("formatPlansAsMarkdown", () => {
-    it("should return placeholder for empty plans", () => {
-      const formatted = formatPlansAsMarkdown([]);
-      expect(formatted).toContain("# Plans");
-      expect(formatted).toContain("No plans.");
-    });
-
-    it("should include summary counts", () => {
-      const plans: RalphPlan[] = [
-        { id: 1, planFilePath: "/tmp/plan-1.md", status: "done", addedAt: "" },
-        { id: 2, planFilePath: "/tmp/plan-2.md", status: "ready", addedAt: "" },
-      ];
-
-      const formatted = formatPlansAsMarkdown(plans);
-
-      expect(formatted).toContain("**Total:** 2");
-      expect(formatted).toContain("**Done:** 1");
-      expect(formatted).toContain("**Ready:** 1");
-    });
-
-    it("should format done plans with checked boxes", () => {
-      const plans: RalphPlan[] = [
-        { id: 1, planFilePath: "/tmp/completed-plan.md", status: "done", addedAt: "" },
-      ];
-
-      const formatted = formatPlansAsMarkdown(plans);
-
-      expect(formatted).toContain("## Done");
-      expect(formatted).toContain("- [x] **#1** /tmp/completed-plan.md");
-      expect(formatted).toContain("`✓ done`");
-    });
-
-    it("should format ready plans with unchecked boxes", () => {
-      const plans: RalphPlan[] = [
-        { id: 2, planFilePath: "/tmp/ready-plan.md", status: "ready", addedAt: "" },
-      ];
-
-      const formatted = formatPlansAsMarkdown(plans);
-
-      expect(formatted).toContain("## Ready");
-      expect(formatted).toContain("- [ ] **#2** /tmp/ready-plan.md");
-      expect(formatted).toContain("`○ ready`");
-    });
-
-    it("should group plans by status section", () => {
-      const plans: RalphPlan[] = [
-        { id: 1, planFilePath: "/tmp/done-plan.md", status: "done", addedAt: "" },
-        { id: 2, planFilePath: "/tmp/ready-plan.md", status: "ready", addedAt: "" },
-      ];
-
-      const formatted = formatPlansAsMarkdown(plans);
-
-      expect(formatted).toContain("## Ready");
-      expect(formatted).toContain("## Done");
-    });
-  });
-
-  describe("formatPlanAsMarkdown", () => {
-    it("should include plan header and summary", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/plan-1.md");
-
-      const formatted = formatPlanAsMarkdown(state.plans, state);
-
-      expect(formatted).toContain("# Ralph Plan");
-      expect(formatted).toContain("## Summary");
-      expect(formatted).toContain("**Status:** running");
-      expect(formatted).toContain("**Total:** 1");
-    });
-
-    it("should include plans section", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/implement-feature.md");
-
-      const formatted = formatPlanAsMarkdown(state.plans, state);
-
-      expect(formatted).toContain("## Plans");
-      expect(formatted).toContain("**#1** /tmp/implement-feature.md");
-    });
-
-    it("should include mermaid graph section", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/plan-1.md");
-      addPlanToState(state, "/tmp/plan-2.md");
-
-      const formatted = formatPlanAsMarkdown(state.plans, state);
-
-      expect(formatted).toContain("## Progress Graph");
-      expect(formatted).toContain("```mermaid");
-      expect(formatted).toContain("graph LR");
-      expect(formatted).toContain("classDef done fill:#22c55e");
-      expect(formatted).toContain("classDef ready fill:#94a3b8");
-    });
-
-    it("should format done plans correctly in mermaid", () => {
-      const state = createInitialState();
-      const plan = addPlanToState(state, "/tmp/done-plan.md");
-      plan.status = "done";
-
-      const formatted = formatPlanAsMarkdown(state.plans, state);
-
-      expect(formatted).toContain('P1["#1: done-plan.md"]:::done');
-    });
-
-    it("should truncate long filenames in mermaid", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/this-is-a-very-long-plan-filename-that-should-be-truncated.md");
-
-      const formatted = formatPlanAsMarkdown(state.plans, state);
-
-      // Mermaid section should have truncated filename
-      expect(formatted).toContain('P1["#1: this-is-a-very-long-plan-fi..."]');
-      // But the Plans section should have full path
-      expect(formatted).toContain(
-        "**#1** /tmp/this-is-a-very-long-plan-filename-that-should-be-truncated.md",
-      );
-    });
-  });
-
-  describe("formatPlanAsJson", () => {
-    it("should return valid JSON", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/plan-1.md");
-
-      const json = formatPlanAsJson(state.plans, state);
-      const parsed = JSON.parse(json);
-
-      expect(parsed.status).toBe("running");
-      expect(parsed.plans).toHaveLength(1);
-    });
-
-    it("should include summary counts", () => {
-      const state = createInitialState();
-      const plan1 = addPlanToState(state, "/tmp/done-plan.md");
-      plan1.status = "done";
-      addPlanToState(state, "/tmp/ready-plan.md");
-
-      const json = formatPlanAsJson(state.plans, state);
-      const parsed = JSON.parse(json);
-
-      expect(parsed.summary.total).toBe(2);
-      expect(parsed.summary.done).toBe(1);
-      expect(parsed.summary.ready).toBe(1);
-    });
-
-    it("should include all plan fields", () => {
-      const state = createInitialState();
-      const plan = addPlanToState(state, "/tmp/test-plan.md");
-      plan.status = "done";
-      plan.completedAt = "2026-01-10T12:00:00Z";
-
-      const json = formatPlanAsJson(state.plans, state);
-      const parsed = JSON.parse(json);
-
-      expect(parsed.plans[0].id).toBe(1);
-      expect(parsed.plans[0].planFilePath).toBe("/tmp/test-plan.md");
-      expect(parsed.plans[0].status).toBe("done");
-      expect(parsed.plans[0].addedAt).toBeDefined();
-      expect(parsed.plans[0].completedAt).toBe("2026-01-10T12:00:00Z");
-    });
-  });
-
-  describe("markDone functionality", () => {
-    it("should mark plan as done and add completedAt", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/plan-1.md");
-      addPlanToState(state, "/tmp/plan-2.md");
-
-      // Simulate marking plan 1 as done
-      const plan = state.plans.find((t) => t.id === 1);
-      expect(plan).toBeDefined();
-      expect(plan?.status).toBe("ready");
-
-      plan!.status = "done";
-      plan!.completedAt = new Date().toISOString();
-
-      expect(plan?.status).toBe("done");
-      expect(plan?.completedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-    });
-
-    it("should find plan by ID", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/plan-1.md");
-      addPlanToState(state, "/tmp/plan-2.md");
-      addPlanToState(state, "/tmp/plan-3.md");
-
-      const plan = state.plans.find((p) => p.id === 2);
-      expect(plan).toBeDefined();
-      expect(plan?.planFilePath).toBe("/tmp/plan-2.md");
-    });
-
-    it("should return undefined for non-existent plan ID", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/plan-1.md");
-
-      const plan = state.plans.find((t) => t.id === 99);
-      expect(plan).toBeUndefined();
-    });
-
-    it("should persist marked-done plan to file", () => {
-      const state = createInitialState();
-      addPlanToState(state, "/tmp/plan-1.md");
-
-      const plan = state.plans.find((t) => t.id === 1)!;
-      plan.status = "done";
-      plan.completedAt = new Date().toISOString();
-
-      saveState(state, testStateFile);
-      const loaded = loadState(testStateFile);
-
-      expect(loaded?.plans[0].status).toBe("done");
-      expect(loaded?.plans[0].completedAt).toBeDefined();
-    });
-  });
-});