revspec 0.1.0

package/test/protocol/types.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "bun:test";
+import {
+  isValidStatus,
+  isValidThread,
+  isValidReviewFile,
+} from "../../src/protocol/types";
+
+describe("isValidStatus", () => {
+  it("accepts open", () => expect(isValidStatus("open")).toBe(true));
+  it("accepts pending", () => expect(isValidStatus("pending")).toBe(true));
+  it("accepts resolved", () => expect(isValidStatus("resolved")).toBe(true));
+  it("accepts outdated", () => expect(isValidStatus("outdated")).toBe(true));
+  it("rejects addressed", () => expect(isValidStatus("addressed")).toBe(false));
+  it("rejects empty string", () => expect(isValidStatus("")).toBe(false));
+  it("rejects OPEN (uppercase)", () => expect(isValidStatus("OPEN")).toBe(false));
+});
+
+describe("isValidThread", () => {
+  it("accepts a minimal valid thread", () => {
+    expect(
+      isValidThread({
+        id: "t1",
+        line: 5,
+        status: "open",
+        messages: [{ author: "human", text: "hello" }],
+      })
+    ).toBe(true);
+  });
+
+  it("rejects thread missing line", () => {
+    expect(
+      isValidThread({
+        id: "t1",
+        status: "open",
+        messages: [],
+      })
+    ).toBe(false);
+  });
+
+  it("rejects thread missing messages", () => {
+    expect(
+      isValidThread({
+        id: "t1",
+        line: 3,
+        status: "open",
+      })
+    ).toBe(false);
+  });
+
+  it("rejects thread with invalid status", () => {
+    expect(
+      isValidThread({
+        id: "t1",
+        line: 3,
+        status: "addressed",
+        messages: [],
+      })
+    ).toBe(false);
+  });
+});
+
+describe("isValidReviewFile", () => {
+  it("accepts a valid review file", () => {
+    expect(
+      isValidReviewFile({
+        file: "spec.md",
+        threads: [
+          {
+            id: "t1",
+            line: 1,
+            status: "open",
+            messages: [{ author: "human", text: "comment" }],
+          },
+        ],
+      })
+    ).toBe(true);
+  });
+
+  it("accepts a review file with empty threads array", () => {
+    expect(
+      isValidReviewFile({
+        file: "spec.md",
+        threads: [],
+      })
+    ).toBe(true);
+  });
+
+  it("rejects a review file missing the file field", () => {
+    expect(
+      isValidReviewFile({
+        threads: [],
+      })
+    ).toBe(false);
+  });
+});

package/test/protocol/write.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync, readFileSync } from "fs";
+import { join } from "path";
+import { writeReviewFile, writeDraftFile } from "../../src/protocol/write";
+import type { ReviewFile, DraftFile } from "../../src/protocol/types";
+
+function tmpDir() {
+  return mkdtempSync("/tmp/revspec-test-");
+}
+
+describe("writeReviewFile", () => {
+  it("writes valid JSON that can be parsed back to ReviewFile", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "review.json");
+    const data: ReviewFile = {
+      file: "spec.md",
+      threads: [
+        {
+          id: "t1",
+          line: 3,
+          status: "open",
+          messages: [{ author: "human", text: "Is this right?" }],
+        },
+      ],
+    };
+    writeReviewFile(filePath, data);
+    const raw = readFileSync(filePath, "utf8");
+    expect(JSON.parse(raw)).toEqual(data);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("writes pretty-printed JSON (contains newlines)", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "review.json");
+    const data: ReviewFile = { file: "spec.md", threads: [] };
+    writeReviewFile(filePath, data);
+    const raw = readFileSync(filePath, "utf8");
+    expect(raw).toContain("\n");
+    rmSync(dir, { recursive: true });
+  });
+});
+
+describe("writeDraftFile", () => {
+  it("writes an approval draft", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "draft.json");
+    const data: DraftFile = { approved: true };
+    writeDraftFile(filePath, data);
+    const raw = readFileSync(filePath, "utf8");
+    expect(JSON.parse(raw)).toEqual(data);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("writes a threads draft", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "draft.json");
+    const data: DraftFile = {
+      threads: [
+        {
+          id: "t2",
+          line: 7,
+          status: "resolved",
+          messages: [{ author: "ai", text: "Fixed." }],
+        },
+      ],
+    };
+    writeDraftFile(filePath, data);
+    const raw = readFileSync(filePath, "utf8");
+    expect(JSON.parse(raw)).toEqual(data);
+    rmSync(dir, { recursive: true });
+  });
+});

package/test/state/review-state.test.ts

@@ -0,0 +1,326 @@
+import { describe, expect, it, beforeEach } from "bun:test";
+import { ReviewState } from "../../src/state/review-state";
+import type { Thread } from "../../src/protocol/types";
+
+const SPEC = ["line one", "line two", "line three", "line four", "line five"];
+
+function makeThread(
+  id: string,
+  line: number,
+  status: Thread["status"],
+  messages: Thread["messages"] = [{ author: "human", text: "comment" }]
+): Thread {
+  return { id, line, status, messages };
+}
+
+describe("ReviewState", () => {
+  describe("initializes with spec lines and no threads", () => {
+    it("sets lineCount from specLines", () => {
+      const state = new ReviewState(SPEC, []);
+      expect(state.lineCount).toBe(5);
+    });
+
+    it("starts cursor at line 1", () => {
+      const state = new ReviewState(SPEC, []);
+      expect(state.cursorLine).toBe(1);
+    });
+
+    it("starts with empty threads array", () => {
+      const state = new ReviewState(SPEC, []);
+      expect(state.threads).toHaveLength(0);
+    });
+  });
+
+  describe("addComment", () => {
+    it("adds a new thread with status open", () => {
+      const state = new ReviewState(SPEC, []);
+      state.addComment(3, "needs clarification");
+      expect(state.threads).toHaveLength(1);
+      expect(state.threads[0].line).toBe(3);
+      expect(state.threads[0].status).toBe("open");
+      expect(state.threads[0].messages).toHaveLength(1);
+      expect(state.threads[0].messages[0]).toEqual({
+        author: "human",
+        text: "needs clarification",
+      });
+    });
+
+    it("assigns auto-incremented id", () => {
+      const state = new ReviewState(SPEC, [makeThread("t3", 1, "open")]);
+      state.addComment(2, "another comment");
+      expect(state.threads[1].id).toBe("t4");
+    });
+  });
+
+  describe("replyToThread", () => {
+    it("appends human message to existing thread", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 2, "pending")]);
+      state.replyToThread("t1", "my reply");
+      expect(state.threads[0].messages).toHaveLength(2);
+      expect(state.threads[0].messages[1]).toEqual({
+        author: "human",
+        text: "my reply",
+      });
+    });
+
+    it("flips status to open", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 2, "pending")]);
+      state.replyToThread("t1", "my reply");
+      expect(state.threads[0].status).toBe("open");
+    });
+
+    it("does nothing for unknown threadId", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 2, "pending")]);
+      state.replyToThread("t99", "ghost reply");
+      expect(state.threads[0].messages).toHaveLength(1);
+    });
+  });
+
+  describe("resolveThread", () => {
+    it("sets thread status to resolved", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 1, "open")]);
+      state.resolveThread("t1");
+      expect(state.threads[0].status).toBe("resolved");
+    });
+
+    it("toggles resolved thread back to open", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 1, "resolved")]);
+      state.resolveThread("t1");
+      expect(state.threads[0].status).toBe("open");
+    });
+
+    it("does nothing for unknown threadId", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 1, "open")]);
+      state.resolveThread("t99");
+      expect(state.threads[0].status).toBe("open");
+    });
+  });
+
+  describe("resolveAllPending", () => {
+    it("resolves all pending threads", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "pending"),
+        makeThread("t2", 2, "pending"),
+        makeThread("t3", 3, "open"),
+      ]);
+      state.resolveAllPending();
+      expect(state.threads[0].status).toBe("resolved");
+      expect(state.threads[1].status).toBe("resolved");
+    });
+
+    it("leaves open threads unchanged", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "pending"),
+        makeThread("t2", 2, "open"),
+      ]);
+      state.resolveAllPending();
+      expect(state.threads[1].status).toBe("open");
+    });
+  });
+
+  describe("threadAtLine", () => {
+    it("returns thread when found", () => {
+      const thread = makeThread("t1", 3, "open");
+      const state = new ReviewState(SPEC, [thread]);
+      expect(state.threadAtLine(3)).toEqual(thread);
+    });
+
+    it("returns null when not found", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 3, "open")]);
+      expect(state.threadAtLine(5)).toBeNull();
+    });
+  });
+
+  describe("nextActiveThread", () => {
+    it("returns next open/pending thread line after cursor", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 2, "open"),
+        makeThread("t2", 4, "pending"),
+      ]);
+      state.cursorLine = 3;
+      expect(state.nextActiveThread()).toBe(4);
+    });
+
+    it("wraps around to first active thread when none after cursor", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "open"),
+        makeThread("t2", 3, "pending"),
+      ]);
+      state.cursorLine = 4;
+      expect(state.nextActiveThread()).toBe(1);
+    });
+
+    it("skips resolved threads", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 2, "resolved"),
+        makeThread("t2", 4, "open"),
+      ]);
+      state.cursorLine = 1;
+      expect(state.nextActiveThread()).toBe(4);
+    });
+
+    it("returns null when no active threads", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 2, "resolved"),
+        makeThread("t2", 4, "outdated"),
+      ]);
+      expect(state.nextActiveThread()).toBeNull();
+    });
+  });
+
+  describe("prevActiveThread", () => {
+    it("returns previous open/pending thread line before cursor", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "open"),
+        makeThread("t2", 3, "pending"),
+      ]);
+      state.cursorLine = 4;
+      expect(state.prevActiveThread()).toBe(3);
+    });
+
+    it("wraps around to last active thread when none before cursor", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 2, "open"),
+        makeThread("t2", 4, "pending"),
+      ]);
+      state.cursorLine = 1;
+      expect(state.prevActiveThread()).toBe(4);
+    });
+
+    it("skips resolved threads", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "open"),
+        makeThread("t2", 3, "resolved"),
+      ]);
+      state.cursorLine = 5;
+      expect(state.prevActiveThread()).toBe(1);
+    });
+
+    it("returns null when no active threads", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 2, "resolved")]);
+      expect(state.prevActiveThread()).toBeNull();
+    });
+  });
+
+  describe("canApprove", () => {
+    it("returns true when all threads are resolved", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "resolved"),
+        makeThread("t2", 2, "resolved"),
+      ]);
+      expect(state.canApprove()).toBe(true);
+    });
+
+    it("returns true when threads are resolved or outdated", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "resolved"),
+        makeThread("t2", 2, "outdated"),
+      ]);
+      expect(state.canApprove()).toBe(true);
+    });
+
+    it("returns false when any thread is open", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "resolved"),
+        makeThread("t2", 2, "open"),
+      ]);
+      expect(state.canApprove()).toBe(false);
+    });
+
+    it("returns false when any thread is pending", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "resolved"),
+        makeThread("t2", 2, "pending"),
+      ]);
+      expect(state.canApprove()).toBe(false);
+    });
+
+    it("returns false when there are no threads", () => {
+      const state = new ReviewState(SPEC, []);
+      expect(state.canApprove()).toBe(false);
+    });
+  });
+
+  describe("nextThreadId", () => {
+    it("returns t1 when no threads exist", () => {
+      const state = new ReviewState(SPEC, []);
+      expect(state.nextThreadId()).toBe("t1");
+    });
+
+    it("increments from the highest existing id", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t3", 1, "open"),
+        makeThread("t1", 2, "open"),
+        makeThread("t7", 3, "open"),
+      ]);
+      expect(state.nextThreadId()).toBe("t8");
+    });
+  });
+
+  describe("deleteLastDraftMessage", () => {
+    it("removes the last human message from the thread", () => {
+      const state = new ReviewState(SPEC, [
+        {
+          id: "t1",
+          line: 1,
+          status: "open",
+          messages: [
+            { author: "ai", text: "AI response" },
+            { author: "human", text: "my draft" },
+          ],
+        },
+      ]);
+      state.deleteLastDraftMessage("t1");
+      expect(state.threads[0].messages).toHaveLength(1);
+      expect(state.threads[0].messages[0].author).toBe("ai");
+    });
+
+    it("removes the thread entirely when it becomes empty", () => {
+      const state = new ReviewState(SPEC, [
+        {
+          id: "t1",
+          line: 1,
+          status: "open",
+          messages: [{ author: "human", text: "only message" }],
+        },
+      ]);
+      state.deleteLastDraftMessage("t1");
+      expect(state.threads).toHaveLength(0);
+    });
+
+    it("does nothing for unknown threadId", () => {
+      const state = new ReviewState(SPEC, [makeThread("t1", 1, "open")]);
+      state.deleteLastDraftMessage("t99");
+      expect(state.threads).toHaveLength(1);
+      expect(state.threads[0].messages).toHaveLength(1);
+    });
+  });
+
+  describe("toDraft", () => {
+    it("serializes current threads", () => {
+      const threads = [makeThread("t1", 2, "open")];
+      const state = new ReviewState(SPEC, threads);
+      expect(state.toDraft()).toEqual({ threads });
+    });
+  });
+
+  describe("activeThreadCount", () => {
+    it("counts open and pending threads separately", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "open"),
+        makeThread("t2", 2, "pending"),
+        makeThread("t3", 3, "open"),
+        makeThread("t4", 4, "resolved"),
+      ]);
+      expect(state.activeThreadCount()).toEqual({ open: 2, pending: 1 });
+    });
+
+    it("returns zeros when no active threads", () => {
+      const state = new ReviewState(SPEC, [
+        makeThread("t1", 1, "resolved"),
+        makeThread("t2", 2, "outdated"),
+      ]);
+      expect(state.activeThreadCount()).toEqual({ open: 0, pending: 0 });
+    });
+  });
+});

package/test/tui/pager.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from "bun:test";
+import { buildPagerContent } from "../../src/tui/pager";
+import { ReviewState } from "../../src/state/review-state";
+import type { Thread } from "../../src/protocol/types";
+
+const SPEC = ["# Title", "Some text", "More text", "Final line"];
+
+function makeThread(
+  id: string,
+  line: number,
+  status: Thread["status"],
+  messages: Thread["messages"] = [{ author: "human", text: "comment" }]
+): Thread {
+  return { id, line, status, messages };
+}
+
+describe("buildPagerContent", () => {
+  it("renders lines with line numbers", () => {
+    const state = new ReviewState(SPEC, []);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    expect(lines).toHaveLength(4);
+    // Line 1 is the cursor line, gets ">" prefix
+    expect(lines[0]).toContain("   1");
+    expect(lines[0]).toContain("# Title");
+    // Other lines get " " prefix
+    expect(lines[1]).toContain("   2");
+    expect(lines[1]).toContain("Some text");
+    expect(lines[2]).toContain("   3");
+    expect(lines[3]).toContain("   4");
+  });
+
+  it("marks cursor line with > prefix", () => {
+    const state = new ReviewState(SPEC, []);
+    state.cursorLine = 3;
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    // Line 3 (index 2) should have ">" prefix
+    expect(lines[2]).toMatch(/^>/);
+    // Other lines should have " " prefix
+    expect(lines[0]).toMatch(/^ /);
+    expect(lines[1]).toMatch(/^ /);
+    expect(lines[3]).toMatch(/^ /);
+  });
+
+  it("shows status indicator for open threads", () => {
+    const state = new ReviewState(SPEC, [makeThread("t1", 2, "open")]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    // Line 2 should contain the open icon (*)
+    expect(lines[1]).toContain("*");
+  });
+
+  it("shows status indicator for pending threads", () => {
+    const state = new ReviewState(SPEC, [makeThread("t1", 2, "pending")]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    expect(lines[1]).toContain("~");
+  });
+
+  it("shows status indicator for resolved threads", () => {
+    const state = new ReviewState(SPEC, [makeThread("t1", 2, "resolved")]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    expect(lines[1]).toContain("\u2714");
+  });
+
+  it("shows status indicator for outdated threads", () => {
+    const state = new ReviewState(SPEC, [makeThread("t1", 2, "outdated")]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    expect(lines[1]).toContain("\u26A0");
+  });
+
+  it("shows different icons for different statuses", () => {
+    const state = new ReviewState(SPEC, [
+      makeThread("t1", 1, "open"),
+      makeThread("t2", 2, "pending"),
+      makeThread("t3", 3, "resolved"),
+      makeThread("t4", 4, "outdated"),
+    ]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    expect(lines[0]).toContain("*");
+    expect(lines[1]).toContain("~");
+    expect(lines[2]).toContain("\u2714");
+    expect(lines[3]).toContain("\u26A0");
+  });
+
+  it("shows thread hint with latest message text", () => {
+    const state = new ReviewState(SPEC, [
+      makeThread("t1", 2, "open", [
+        { author: "ai", text: "AI said something" },
+        { author: "human", text: "My response" },
+      ]),
+    ]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    expect(lines[1]).toContain("My response");
+  });
+
+  it("truncates long comment text to 40 chars", () => {
+    const longText =
+      "This is a very long comment that should be truncated because it exceeds the maximum hint length";
+    const state = new ReviewState(SPEC, [
+      makeThread("t1", 2, "open", [{ author: "human", text: longText }]),
+    ]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    // Should be truncated to 39 chars + ellipsis
+    expect(lines[1]).toContain("\u2026");
+    // The full text should NOT appear
+    expect(lines[1]).not.toContain(longText);
+  });
+
+  it("does not show status indicator for lines without threads", () => {
+    const state = new ReviewState(SPEC, [makeThread("t1", 2, "open")]);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    // Line 1 (no thread) should not contain any status icons
+    expect(lines[0]).not.toContain("\u{1F4AC}");
+    expect(lines[0]).not.toContain("\u{1F535}");
+    expect(lines[0]).not.toContain("\u2714");
+    expect(lines[0]).not.toContain("\u26A0");
+  });
+
+  it("pads line numbers to 4 characters", () => {
+    const state = new ReviewState(SPEC, []);
+    const content = buildPagerContent(state);
+    const lines = content.split("\n");
+
+    // Line numbers are wrapped in ANSI gray codes, so check the raw number is present
+    expect(lines[0]).toContain("   1");
+    expect(lines[0]).toContain("# Title");
+  });
+
+  it("handles empty spec", () => {
+    const state = new ReviewState([], []);
+    const content = buildPagerContent(state);
+    expect(content).toBe("");
+  });
+
+  it("highlights search matches with >> << markers", () => {
+    const state = new ReviewState(SPEC, []);
+    const content = buildPagerContent(state, "text");
+    const lines = content.split("\n");
+
+    // Lines 2 and 3 contain "text" — should be highlighted
+    expect(lines[1]).toContain("Some >>text<<");
+    expect(lines[2]).toContain("More >>text<<");
+    // Lines 1 and 4 do not contain "text"
+    expect(lines[0]).not.toContain(">>");
+    expect(lines[3]).not.toContain(">>");
+  });
+
+  it("highlights search matches case-insensitively", () => {
+    const state = new ReviewState(["Hello World", "hello again"], []);
+    const content = buildPagerContent(state, "hello");
+    const lines = content.split("\n");
+
+    expect(lines[0]).toContain(">>Hello<<");
+    expect(lines[1]).toContain(">>hello<<");
+  });
+
+  it("does not highlight when searchQuery is null", () => {
+    const state = new ReviewState(SPEC, []);
+    const content = buildPagerContent(state, null);
+    const lines = content.split("\n");
+
+    expect(lines[1]).toContain("Some text");
+    expect(lines[1]).not.toContain(">>");
+  });
+});
+

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*.ts", "bin/**/*.ts", "test/**/*.ts"]
+}