revspec 0.6.0 → 0.7.1

package/test/integration/cli-watch.test.ts

@@ -1,216 +0,0 @@
-import { describe, it, expect, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-import { appendEvent, readEventsFromOffset } from "../../src/protocol/live-events";
-
-const CLI = resolve(import.meta.dir, "../../bin/revspec.ts");
-
-interface SpawnResult {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-}
-
-async function runCli(
-  args: string[],
-  env: Record<string, string> = {}
-): Promise<SpawnResult> {
-  const proc = Bun.spawn(["bun", "run", CLI, ...args], {
-    env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1", ...env },
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ]);
-
-  const exitCode = await proc.exited;
-  return { exitCode, stdout, stderr };
-}
-
-function setupTempDir(): string {
-  return mkdtempSync(join(tmpdir(), "revspec-watch-test-"));
-}
-
-function createSpecWithJsonl(
-  dir: string,
-  specContent: string = "# My Spec\n\nLine two\n\nLine four\n"
-): { specPath: string; jsonlPath: string } {
-  const specPath = join(dir, "spec.md");
-  writeFileSync(specPath, specContent);
-
-  const jsonlPath = join(dir, "spec.review.live.jsonl");
-
-  return { specPath, jsonlPath };
-}
-
-describe("revspec watch", () => {
-  let tmpDir: string;
-
-  afterEach(() => {
-    if (tmpDir) {
-      rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("returns new comments with context", async () => {
-    tmpDir = setupTempDir();
-    const { specPath, jsonlPath } = createSpecWithJsonl(tmpDir);
-
-    const threadId = "thread-001";
-    appendEvent(jsonlPath, {
-      type: "comment",
-      threadId,
-      line: 3,
-      author: "reviewer",
-      text: "This needs clarification",
-      ts: Date.now(),
-    });
-
-    const result = await runCli(["watch", specPath]);
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain(threadId);
-    expect(result.stdout).toContain("line 3");
-    expect(result.stdout).toContain("This needs clarification");
-    expect(result.stdout).toContain("revspec reply");
-  });
-
-  it("returns approval message when approve event present", async () => {
-    tmpDir = setupTempDir();
-    const { specPath, jsonlPath } = createSpecWithJsonl(tmpDir);
-
-    appendEvent(jsonlPath, {
-      type: "approve",
-      author: "reviewer",
-      ts: Date.now(),
-    });
-
-    const result = await runCli(["watch", specPath]);
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain("Review approved");
-    expect(result.stdout).toContain("spec.review.json");
-  });
-
-  it("includes thread history for replies", async () => {
-    tmpDir = setupTempDir();
-    const { specPath, jsonlPath } = createSpecWithJsonl(tmpDir);
-
-    const threadId = "thread-002";
-    const ts = Date.now();
-
-    appendEvent(jsonlPath, {
-      type: "comment",
-      threadId,
-      line: 1,
-      author: "reviewer",
-      text: "Initial comment",
-      ts,
-    });
-
-    appendEvent(jsonlPath, {
-      type: "reply",
-      threadId,
-      author: "owner",
-      text: "Thanks, addressing it",
-      ts: ts + 1000,
-    });
-
-    appendEvent(jsonlPath, {
-      type: "reply",
-      threadId,
-      author: "reviewer",
-      text: "Great, looks good now",
-      ts: ts + 2000,
-    });
-
-    // Watch starting at offset 0 should see new comment + replies
-    const result = await runCli(["watch", specPath]);
-
-    expect(result.exitCode).toBe(0);
-    // Should show full thread history in replies section
-    expect(result.stdout).toContain(threadId);
-    expect(result.stdout).toContain("Initial comment");
-    expect(result.stdout).toContain("Thanks, addressing it");
-    expect(result.stdout).toContain("Great, looks good now");
-  });
-
-  it("does not break watch loop for resolve-only events", async () => {
-    tmpDir = setupTempDir();
-    const { specPath, jsonlPath } = createSpecWithJsonl(tmpDir);
-
-    const threadId = "thread-003";
-    const ts = Date.now();
-
-    // Write comment then resolve
-    appendEvent(jsonlPath, {
-      type: "comment",
-      threadId,
-      line: 2,
-      author: "reviewer",
-      text: "Fix this please",
-      ts,
-    });
-
-    // First watch picks up the comment
-    const result1 = await runCli(["watch", specPath]);
-    expect(result1.exitCode).toBe(0);
-    expect(result1.stdout).toContain("Fix this please");
-
-    // Append resolve — watch should return empty (no actionable events)
-    appendEvent(jsonlPath, {
-      type: "resolve",
-      threadId,
-      author: "reviewer",
-      ts: ts + 1000,
-    });
-
-    const result2 = await runCli(["watch", specPath]);
-    // No output — resolve is not actionable
-    expect(result2.stdout.trim()).toBe("");
-  });
-
-  it("exits 1 for missing spec file", async () => {
-    tmpDir = setupTempDir();
-    const missingPath = join(tmpDir, "nonexistent.md");
-
-    const result = await runCli(["watch", missingPath]);
-
-    expect(result.exitCode).toBe(1);
-    expect(result.stderr).toContain("not found");
-  });
-
-  it("exits 3 when another watch is running (lock file with live PID)", async () => {
-    tmpDir = setupTempDir();
-    const { specPath, jsonlPath } = createSpecWithJsonl(tmpDir);
-    const lockPath = join(tmpDir, "spec.review.live.lock");
-    writeFileSync(lockPath, String(process.pid)); // current process is alive
-    appendEvent(jsonlPath, { type: "comment", threadId: "t1", line: 1, author: "reviewer", text: "x", ts: 1 });
-
-    const proc = Bun.spawn(["bun", "run", CLI, "watch", specPath], {
-      stdout: "pipe", stderr: "pipe",
-      env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1" },
-    });
-    await proc.exited;
-    expect(proc.exitCode).toBe(3);
-  });
-
-  it("proceeds when lock file has dead PID", async () => {
-    tmpDir = setupTempDir();
-    const { specPath, jsonlPath } = createSpecWithJsonl(tmpDir);
-    const lockPath = join(tmpDir, "spec.review.live.lock");
-    writeFileSync(lockPath, "999999"); // almost certainly dead
-    appendEvent(jsonlPath, { type: "comment", threadId: "t1", line: 1, author: "reviewer", text: "x", ts: 1 });
-
-    const proc = Bun.spawn(["bun", "run", CLI, "watch", specPath], {
-      stdout: "pipe", stderr: "pipe",
-      env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1" },
-    });
-    await proc.exited;
-    expect(proc.exitCode).toBe(0);
-  });
-});

package/test/integration/cli.test.ts

@@ -1,160 +0,0 @@
-import { describe, it, expect, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-import { appendEvent } from "../../src/protocol/live-events";
-import { writeReviewFile } from "../../src/protocol/write";
-
-const CLI = resolve(import.meta.dir, "../../bin/revspec.ts");
-
-interface SpawnResult {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-}
-
-async function runCli(
-  args: string[],
-  env: Record<string, string> = {}
-): Promise<SpawnResult> {
-  const proc = Bun.spawn(["bun", "run", CLI, ...args], {
-    env: { ...process.env, REVSPEC_SKIP_TUI: "1", ...env },
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ]);
-
-  const exitCode = await proc.exited;
-  return { exitCode, stdout, stderr };
-}
-
-describe("CLI entry point", () => {
-  let tmpDir: string;
-
-  // Create a fresh temp dir before each test
-  function setup(): string {
-    tmpDir = mkdtempSync(join(tmpdir(), "revspec-test-"));
-    return tmpDir;
-  }
-
-  afterEach(() => {
-    if (tmpDir) {
-      rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("exits 1 for missing spec file", async () => {
-    setup();
-    const result = await runCli([join(tmpDir, "nonexistent.md")]);
-    expect(result.exitCode).toBe(1);
-    expect(result.stderr).toContain("not found");
-  });
-
-  it("exits 0 with no output when no review file exists", async () => {
-    const dir = setup();
-    const specFile = join(dir, "spec.md");
-    writeFileSync(specFile, "# My Spec\n");
-
-    const result = await runCli([specFile]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe("");
-    expect(result.stderr.trim()).toBe("");
-  });
-
-  it("outputs APPROVED when JSONL has approve event and review file exists", async () => {
-    const dir = setup();
-    const specFile = join(dir, "spec.md");
-    writeFileSync(specFile, "# My Spec\n");
-
-    // Write a review file (TUI writes this on approve)
-    const reviewPath = join(dir, "spec.review.json");
-    writeReviewFile(reviewPath, { file: specFile, threads: [] });
-
-    // Simulate TUI writing an approve event to JSONL
-    const jsonlPath = join(dir, "spec.review.live.jsonl");
-    appendEvent(jsonlPath, { type: "approve", author: "reviewer", ts: Date.now() });
-
-    const result = await runCli([specFile]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain("APPROVED:");
-    expect(result.stdout).toContain("spec.review.json");
-  });
-
-  it("outputs review path when review file has open threads", async () => {
-    const dir = setup();
-    const specFile = join(dir, "spec.md");
-    writeFileSync(specFile, "# My Spec\n");
-
-    const reviewPath = join(dir, "spec.review.json");
-    writeReviewFile(reviewPath, {
-      file: specFile,
-      threads: [
-        {
-          id: "t1",
-          line: 5,
-          status: "open",
-          messages: [{ author: "reviewer", text: "This needs clarification" }],
-        },
-      ],
-    });
-
-    const result = await runCli([specFile]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain("spec.review.json");
-  });
-
-  it("prints nothing when human adds no comments (no prior review)", async () => {
-    const dir = setup();
-    const specFile = join(dir, "spec.md");
-    writeFileSync(specFile, "# My Spec\n");
-
-    // No JSONL, no review file — TUI is skipped, nothing happened
-    const result = await runCli([specFile]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe("");
-  });
-
-  it("prints nothing when review exists but all threads resolved", async () => {
-    const dir = setup();
-    const specFile = join(dir, "spec.md");
-    writeFileSync(specFile, "# My Spec\n");
-
-    const reviewPath = join(dir, "spec.review.json");
-    writeReviewFile(reviewPath, {
-      file: specFile,
-      threads: [
-        {
-          id: "t1",
-          line: 5,
-          status: "resolved",
-          messages: [
-            { author: "reviewer", text: "Was unclear" },
-            { author: "owner", text: "Fixed" },
-          ],
-        },
-      ],
-    });
-
-    const result = await runCli([specFile]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe("");
-  });
-
-  it("does not output APPROVED if JSONL has approve but no review file", async () => {
-    const dir = setup();
-    const specFile = join(dir, "spec.md");
-    writeFileSync(specFile, "# My Spec\n");
-
-    // JSONL has approve but no review file written
-    const jsonlPath = join(dir, "spec.review.live.jsonl");
-    appendEvent(jsonlPath, { type: "approve", author: "reviewer", ts: Date.now() });
-
-    const result = await runCli([specFile]);
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).not.toContain("APPROVED:");
-  });
-});

package/test/integration/e2e-live.test.ts

@@ -1,171 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test"
-import { mkdtempSync, rmSync, writeFileSync, existsSync } from "fs"
-import { join } from "path"
-import { tmpdir } from "os"
-import { appendEvent, readEventsFromOffset } from "../../src/protocol/live-events"
-import { mergeJsonlIntoReview } from "../../src/protocol/live-merge"
-import { writeReviewFile } from "../../src/protocol/write"
-
-const CLI = join(import.meta.dir, "..", "..", "bin", "revspec.ts")
-
-describe("E2E: live review loop", () => {
-  let dir: string
-  let specPath: string
-  let jsonlPath: string
-  let reviewPath: string
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "revspec-e2e-"))
-    specPath = join(dir, "spec.md")
-    jsonlPath = join(dir, "spec.review.live.jsonl")
-    reviewPath = join(dir, "spec.review.json")
-    writeFileSync(specPath, "# My Spec\n\nLine 3 is important.\n\nLine 5 also matters.\n")
-  })
-
-  afterEach(() => rmSync(dir, { recursive: true }))
-
-  it("simulates full loop: comment → watch → reply → watch → resolve → approve", async () => {
-    // Step 1: Reviewer adds comments (simulating TUI)
-    appendEvent(jsonlPath, { type: "comment", threadId: "t1", line: 3, author: "reviewer", text: "this is unclear", ts: 1000 })
-    appendEvent(jsonlPath, { type: "comment", threadId: "t2", line: 5, author: "reviewer", text: "needs more detail", ts: 1001 })
-
-    // Step 2: AI runs watch, gets comments
-    const watch1 = Bun.spawn(["bun", "run", CLI, "watch", specPath], {
-      stdout: "pipe", stderr: "pipe",
-      env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1" },
-    })
-    const output1 = await new Response(watch1.stdout).text()
-    await watch1.exited
-    expect(watch1.exitCode).toBe(0)
-    expect(output1).toContain("t1")
-    expect(output1).toContain("t2")
-    expect(output1).toContain("this is unclear")
-    expect(output1).toContain("needs more detail")
-
-    // Step 3: AI replies
-    const reply1 = Bun.spawn(["bun", "run", CLI, "reply", specPath, "t1", "I'll restructure this section"], {
-      stdout: "pipe", stderr: "pipe",
-    })
-    await reply1.exited
-    expect(reply1.exitCode).toBe(0)
-
-    const reply2 = Bun.spawn(["bun", "run", CLI, "reply", specPath, "t2", "Adding more context now"], {
-      stdout: "pipe", stderr: "pipe",
-    })
-    await reply2.exited
-    expect(reply2.exitCode).toBe(0)
-
-    // Verify AI replies are in JSONL
-    const { events } = readEventsFromOffset(jsonlPath, 0)
-    expect(events).toHaveLength(4) // 2 comments + 2 replies
-    expect(events[2].author).toBe("owner")
-    expect(events[3].author).toBe("owner")
-
-    // Step 4: Reviewer resolves and approves (simulating TUI)
-    appendEvent(jsonlPath, { type: "resolve", threadId: "t1", author: "reviewer", ts: 2000 })
-    appendEvent(jsonlPath, { type: "resolve", threadId: "t2", author: "reviewer", ts: 2001 })
-    appendEvent(jsonlPath, { type: "approve", author: "reviewer", ts: 2002 })
-
-    // Step 5: AI runs watch, gets approval
-    const watch2 = Bun.spawn(["bun", "run", CLI, "watch", specPath], {
-      stdout: "pipe", stderr: "pipe",
-      env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1" },
-    })
-    const output2 = await new Response(watch2.stdout).text()
-    await watch2.exited
-    expect(watch2.exitCode).toBe(0)
-    expect(output2).toContain("Review approved")
-
-    // Step 6: Merge JSONL → JSON (simulating TUI exit)
-    const review = mergeJsonlIntoReview(jsonlPath, null, specPath)
-    writeReviewFile(reviewPath, review)
-    expect(review.threads).toHaveLength(2)
-    expect(review.threads[0].status).toBe("resolved")
-    expect(review.threads[1].status).toBe("resolved")
-    expect(review.threads[0].messages).toHaveLength(2)
-    expect(review.threads[1].messages).toHaveLength(2)
-    expect(review.threads[0].messages[0].ts).toBe(1000) // timestamps preserved
-  })
-
-  it("handles delete event in the loop", async () => {
-    appendEvent(jsonlPath, { type: "comment", threadId: "t1", line: 3, author: "reviewer", text: "wrong comment", ts: 1000 })
-    appendEvent(jsonlPath, { type: "delete", threadId: "t1", author: "reviewer", ts: 1001 })
-
-    const proc = Bun.spawn(["bun", "run", CLI, "watch", specPath], {
-      stdout: "pipe", stderr: "pipe",
-      env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1" },
-    })
-    const output = await new Response(proc.stdout).text()
-    await proc.exited
-
-    // Watch should show the events
-    expect(proc.exitCode).toBe(0)
-
-    // Merge should exclude empty thread
-    const review = mergeJsonlIntoReview(jsonlPath, null, specPath)
-    expect(review.threads).toHaveLength(0)
-  })
-
-  it("merges with existing review from prior round", async () => {
-    // Prior round left a resolved thread
-    const priorReview = {
-      file: specPath,
-      threads: [{
-        id: "t1", line: 3, status: "resolved" as const,
-        messages: [
-          { author: "reviewer" as const, text: "old comment" },
-          { author: "owner" as const, text: "fixed" },
-        ]
-      }],
-    }
-    writeReviewFile(reviewPath, priorReview)
-
-    // New round
-    appendEvent(jsonlPath, { type: "round", author: "reviewer", round: 2, ts: 3000 })
-    appendEvent(jsonlPath, { type: "comment", threadId: "t2", line: 5, author: "reviewer", text: "new issue", ts: 3001 })
-
-    const review = mergeJsonlIntoReview(jsonlPath, priorReview, specPath)
-    expect(review.threads).toHaveLength(2)
-    expect(review.threads[0].id).toBe("t1")
-    expect(review.threads[1].id).toBe("t2")
-  })
-
-  it("watch output includes spec context lines", async () => {
-    appendEvent(jsonlPath, { type: "comment", threadId: "t1", line: 3, author: "reviewer", text: "unclear", ts: 1000 })
-
-    const proc = Bun.spawn(["bun", "run", CLI, "watch", specPath], {
-      stdout: "pipe", stderr: "pipe",
-      env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1" },
-    })
-    const output = await new Response(proc.stdout).text()
-    await proc.exited
-
-    // Should include context lines around line 3
-    expect(output).toContain("Line 3 is important")
-    expect(output).toContain(">")  // cursor marker on the anchored line
-  })
-
-  it("reply then watch shows thread history", async () => {
-    appendEvent(jsonlPath, { type: "comment", threadId: "t1", line: 3, author: "reviewer", text: "unclear", ts: 1000 })
-
-    // AI replies
-    const reply = Bun.spawn(["bun", "run", CLI, "reply", specPath, "t1", "I'll clarify"], {
-      stdout: "pipe", stderr: "pipe",
-    })
-    await reply.exited
-
-    // Reviewer replies back
-    appendEvent(jsonlPath, { type: "reply", threadId: "t1", author: "reviewer", text: "not quite", ts: 2000 })
-
-    const proc = Bun.spawn(["bun", "run", CLI, "watch", specPath], {
-      stdout: "pipe", stderr: "pipe",
-      env: { ...process.env, REVSPEC_WATCH_NO_BLOCK: "1" },
-    })
-    const output = await new Response(proc.stdout).text()
-    await proc.exited
-
-    expect(output).toContain("Replies")
-    expect(output).toContain("unclear")
-    expect(output).toContain("not quite")
-  })
-})