revspec 0.1.0

package/src/tui/status-bar.ts

@@ -0,0 +1,76 @@
+import { TextRenderable, type CliRenderer } from "@opentui/core";
+import type { ReviewState } from "../state/review-state";
+import { basename } from "path";
+import { theme } from "./theme";
+
+export interface TopBarComponents {
+  bar: TextRenderable;
+}
+
+export interface BottomBarComponents {
+  bar: TextRenderable;
+}
+
+/**
+ * Build the top bar text: filename + thread summary.
+ */
+export function buildTopBarText(
+  specFile: string,
+  state: ReviewState
+): string {
+  const name = basename(specFile);
+  const { open, pending } = state.activeThreadCount();
+  const parts: string[] = [];
+  if (open > 0) parts.push(`${open} open`);
+  if (pending > 0) parts.push(`${pending} pending`);
+  const threadSummary =
+    parts.length > 0 ? `Threads: ${parts.join(", ")}` : "No active threads";
+  return ` ${name}  |  ${threadSummary}  |  L${state.cursorLine}/${state.lineCount}`;
+}
+
+/**
+ * Build the bottom bar text: keybinding hints.
+ * Contextually shows command buffer when in command mode.
+ * Prepends mode indicator when provided.
+ */
+export function buildBottomBarText(commandBuffer: string | null, mode?: "markdown" | "line"): string {
+  const modeLabel = mode === "markdown" ? "[md]" : mode === "line" ? "[line]" : "";
+  if (commandBuffer !== null) {
+    return ` ${modeLabel} :${commandBuffer}`;
+  }
+  return ` ${modeLabel}  j/k:move  c:comment  r:resolve  /:search  ?:help`;
+}
+
+/**
+ * Create the top status bar.
+ */
+export function createTopBar(renderer: CliRenderer): TopBarComponents {
+  const bar = new TextRenderable(renderer, {
+    content: "",
+    width: "100%",
+    height: 1,
+    bg: theme.surface0,
+    fg: theme.text,
+    wrapMode: "none",
+    truncate: true,
+  });
+
+  return { bar };
+}
+
+/**
+ * Create the bottom status bar.
+ */
+export function createBottomBar(renderer: CliRenderer): BottomBarComponents {
+  const bar = new TextRenderable(renderer, {
+    content: "",
+    width: "100%",
+    height: 1,
+    bg: theme.surface0,
+    fg: theme.text,
+    wrapMode: "none",
+    truncate: true,
+  });
+
+  return { bar };
+}

package/src/tui/theme.ts

@@ -0,0 +1,34 @@
+export const theme = {
+  // Base surfaces
+  base:     "#1e1e2e",
+  surface0: "#313244",
+  surface1: "#45475a",
+
+  // Text hierarchy
+  text:     "#cdd6f4",
+  subtext:  "#a6adc8",
+  overlay:  "#6c7086",
+
+  // Semantic accents
+  blue:     "#89b4fa",
+  green:    "#a6e3a1",
+  red:      "#f38ba8",
+  yellow:   "#f9e2af",
+  mauve:    "#cba6f7",
+
+  // Derived roles
+  borderComment:  "#89b4fa",
+  borderThread:   "#f9e2af",   // yellow for informational view
+  borderList:     "#cba6f7",
+  borderConfirm:  "#f38ba8",
+  borderSearch:   "#89b4fa",
+  hintFg:         "#6c7086",
+  hintBg:         "#313244",
+} as const;
+
+export const STATUS_ICONS: Record<string, string> = {
+  open: "*",
+  pending: "~",
+  resolved: "\u2714",
+  outdated: "\u26A0",
+};

package/src/tui/thread-list.ts

@@ -0,0 +1,145 @@
+import {
+  BoxRenderable,
+  TextRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  type CliRenderer,
+  type KeyEvent,
+} from "@opentui/core";
+import type { Thread } from "../protocol/types";
+import { theme, STATUS_ICONS } from "./theme";
+
+export interface ThreadListOptions {
+  renderer: CliRenderer;
+  threads: Thread[];
+  onSelect: (lineNumber: number) => void;
+  onCancel: () => void;
+}
+
+export interface ThreadListOverlay {
+  container: BoxRenderable;
+  cleanup: () => void;
+}
+
+const MAX_PREVIEW_LENGTH = 50;
+
+function previewText(thread: Thread): string {
+  if (thread.messages.length === 0) return "(empty)";
+  const last = thread.messages[thread.messages.length - 1];
+  const text = last.text.replace(/\n/g, " ");
+  if (text.length <= MAX_PREVIEW_LENGTH) return text;
+  return text.slice(0, MAX_PREVIEW_LENGTH - 1) + "\u2026";
+}
+
+/**
+ * Create a thread list overlay showing open/pending threads.
+ * Select + Enter: jump to that thread's line.
+ * Escape: cancel.
+ */
+export function createThreadList(opts: ThreadListOptions): ThreadListOverlay {
+  const { renderer, threads, onSelect, onCancel } = opts;
+
+  // Filter to active threads (open/pending)
+  const activeThreads = threads.filter(
+    (t) => t.status === "open" || t.status === "pending"
+  );
+
+  // Overlay container
+  const container = new BoxRenderable(renderer, {
+    position: "absolute",
+    top: "15%",
+    left: "15%",
+    width: "70%",
+    height: "60%",
+    zIndex: 100,
+    backgroundColor: theme.base,
+    border: true,
+    borderStyle: "single",
+    borderColor: theme.borderList,
+    title: ` Threads (${activeThreads.length} active) `,
+    flexDirection: "column",
+    padding: 1,
+  });
+
+  if (activeThreads.length === 0) {
+    const emptyMsg = new TextRenderable(renderer, {
+      content: "No active threads. Press [Esc] to close.",
+      width: "100%",
+      height: 1,
+      fg: theme.overlay,
+      wrapMode: "none",
+    });
+    container.add(emptyMsg);
+  } else {
+    // Build select options from threads
+    const selectOptions = activeThreads.map((t) => {
+      const icon = STATUS_ICONS[t.status];
+      return {
+        name: `${icon} #${t.id} line ${t.line}: ${previewText(t)}`,
+        description: `${t.status} - ${t.messages.length} message(s)`,
+        value: t.line,
+      };
+    });
+
+    const select = new SelectRenderable(renderer, {
+      width: "100%",
+      flexGrow: 1,
+      options: selectOptions,
+      selectedIndex: 0,
+      backgroundColor: theme.base,
+      textColor: theme.text,
+      focusedBackgroundColor: theme.base,
+      focusedTextColor: theme.text,
+      selectedBackgroundColor: theme.surface1,
+      selectedTextColor: "#f5c2e7",
+      descriptionColor: theme.overlay,
+      selectedDescriptionColor: theme.subtext,
+      showDescription: true,
+      wrapSelection: true,
+    });
+
+    container.add(select);
+
+    // Focus the select so it handles j/k navigation
+    renderer.focusRenderable(select);
+
+    // Listen for item selection (Enter key)
+    select.on(SelectRenderableEvents.ITEM_SELECTED, () => {
+      const selected = select.getSelectedOption();
+      if (selected && selected.value != null) {
+        onSelect(selected.value as number);
+      }
+    });
+  }
+
+  // Hint bar
+  const hint = new TextRenderable(renderer, {
+    content: " [j/k] navigate  [Enter] jump  [Esc] close",
+    width: "100%",
+    height: 1,
+    fg: theme.hintFg,
+    bg: theme.hintBg,
+    wrapMode: "none",
+    truncate: true,
+  });
+
+  container.add(hint);
+
+  // Key handler for Esc
+  const keyHandler = (key: KeyEvent) => {
+    if (key.name === "escape") {
+      key.preventDefault();
+      key.stopPropagation();
+      onCancel();
+      return;
+    }
+  };
+
+  renderer.keyInput.on("keypress", keyHandler);
+
+  function cleanup(): void {
+    renderer.keyInput.off("keypress", keyHandler);
+  }
+
+  return { container, cleanup };
+}

package/test/cli.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { tmpdir } from "os";
+
+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 draft has approved flag", async () => {
+    const dir = setup();
+    const specFile = join(dir, "spec.md");
+    writeFileSync(specFile, "# My Spec\n");
+
+    const draftPath = join(dir, "spec.review.draft.json");
+    writeFileSync(draftPath, JSON.stringify({ approved: true }));
+
+    const result = await runCli([specFile]);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("APPROVED:");
+    expect(result.stdout).toContain("spec.review.json");
+
+    // Draft should be deleted
+    const approvedDraftExists = await Bun.file(draftPath)
+      .exists()
+      .catch(() => false);
+    expect(approvedDraftExists).toBe(false);
+  });
+
+  it("merges draft into review file", async () => {
+    const dir = setup();
+    const specFile = join(dir, "spec.md");
+    writeFileSync(specFile, "# My Spec\n");
+
+    const draft = {
+      threads: [
+        {
+          id: "t1",
+          line: 5,
+          status: "open",
+          messages: [{ author: "human", text: "This needs clarification" }],
+        },
+      ],
+    };
+    const draftPath = join(dir, "spec.review.draft.json");
+    writeFileSync(draftPath, JSON.stringify(draft));
+
+    const result = await runCli([specFile]);
+    expect(result.exitCode).toBe(0);
+
+    const reviewPath = join(dir, "spec.review.json");
+    const reviewFile = await Bun.file(reviewPath).json();
+    expect(reviewFile.threads).toHaveLength(1);
+    expect(reviewFile.threads[0].id).toBe("t1");
+
+    // Draft should be deleted
+    const draftExists = await Bun.file(draftPath)
+      .exists()
+      .catch(() => false);
+    expect(draftExists).toBe(false);
+
+    // Should output review path (has open thread)
+    expect(result.stdout).toContain("spec.review.json");
+  });
+
+  it("warns and deletes corrupted draft file", async () => {
+    const dir = setup();
+    const specFile = join(dir, "spec.md");
+    writeFileSync(specFile, "# My Spec\n");
+
+    const draftPath = join(dir, "spec.review.draft.json");
+    writeFileSync(draftPath, "this is not valid JSON {{{{");
+
+    const result = await runCli([specFile]);
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toContain("corrupted");
+
+    // Draft should be deleted
+    const draftExists = await Bun.file(draftPath)
+      .exists()
+      .catch(() => false);
+    expect(draftExists).toBe(false);
+  });
+
+  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 draft, no review file — TUI is skipped, nothing happened
+    const result = await runCli([specFile]);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.trim()).toBe("");
+  });
+});

package/test/opentui-smoke.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "bun:test";
+describe("OpenTUI API availability", () => {
+  it("core imports exist", async () => {
+    const core = await import("@opentui/core");
+    expect(core.createCliRenderer).toBeDefined();
+    expect(core.TextRenderable).toBeDefined();
+    expect(core.BoxRenderable).toBeDefined();
+    expect(core.ScrollBoxRenderable).toBeDefined();
+    expect(core.InputRenderable).toBeDefined();
+    expect(core.SelectRenderable).toBeDefined();
+  });
+});

package/test/protocol/merge.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from "bun:test";
+import { mergeDraftIntoReview } from "../../src/protocol/merge";
+import type { ReviewFile, DraftFile, Thread } from "../../src/protocol/types";
+
+const baseReview: ReviewFile = {
+  file: "spec.md",
+  threads: [],
+};
+
+function makeThread(id: string, messages: string[] = ["hello"]): Thread {
+  return {
+    id,
+    line: 1,
+    status: "open",
+    messages: messages.map((text) => ({ author: "human", text })),
+  };
+}
+
+describe("mergeDraftIntoReview", () => {
+  it("adds new threads from draft to an empty review", () => {
+    const draft: DraftFile = {
+      threads: [makeThread("t1"), makeThread("t2")],
+    };
+    const result = mergeDraftIntoReview({ ...baseReview }, draft);
+    expect(result.threads).toHaveLength(2);
+    expect(result.threads.map((t) => t.id)).toEqual(["t1", "t2"]);
+  });
+
+  it("appends only new messages to an existing thread (draft has full history)", () => {
+    const existingThread: Thread = makeThread("t1", ["first message"]);
+    const review: ReviewFile = { file: "spec.md", threads: [existingThread] };
+
+    // Draft contains full history (existing + new)
+    const draftThread: Thread = {
+      ...existingThread,
+      messages: [
+        { author: "human", text: "first message" },
+        { author: "ai", text: "second message" },
+      ],
+    };
+    const draft: DraftFile = { threads: [draftThread] };
+
+    const result = mergeDraftIntoReview(review, draft);
+    expect(result.threads).toHaveLength(1);
+    expect(result.threads[0].messages).toHaveLength(2);
+    expect(result.threads[0].messages[1].text).toBe("second message");
+  });
+
+  it("handles a mix of new and existing threads", () => {
+    const existing: Thread = makeThread("t1", ["msg1"]);
+    const review: ReviewFile = { file: "spec.md", threads: [existing] };
+
+    const draftExisting: Thread = {
+      ...existing,
+      messages: [
+        { author: "human", text: "msg1" },
+        { author: "ai", text: "reply" },
+      ],
+    };
+    const draftNew: Thread = makeThread("t2", ["new thread"]);
+    const draft: DraftFile = { threads: [draftExisting, draftNew] };
+
+    const result = mergeDraftIntoReview(review, draft);
+    expect(result.threads).toHaveLength(2);
+    expect(result.threads[0].messages).toHaveLength(2);
+    expect(result.threads[1].id).toBe("t2");
+  });
+
+  it("updates thread status from draft", () => {
+    const existing: Thread = { ...makeThread("t1"), status: "open" };
+    const review: ReviewFile = { file: "spec.md", threads: [existing] };
+
+    const draftThread: Thread = {
+      ...existing,
+      status: "resolved",
+      messages: existing.messages,
+    };
+    const draft: DraftFile = { threads: [draftThread] };
+
+    const result = mergeDraftIntoReview(review, draft);
+    expect(result.threads[0].status).toBe("resolved");
+  });
+
+  it("returns review unchanged when draft has no threads", () => {
+    const thread: Thread = makeThread("t1");
+    const review: ReviewFile = { file: "spec.md", threads: [thread] };
+    const draft: DraftFile = { approved: true };
+
+    const result = mergeDraftIntoReview(review, draft);
+    expect(result.threads).toHaveLength(1);
+    expect(result.threads[0].id).toBe("t1");
+  });
+
+  it("creates a new ReviewFile with specFile when review is null", () => {
+    const draft: DraftFile = { threads: [makeThread("t1")] };
+    const result = mergeDraftIntoReview(null, draft, "new-spec.md");
+    expect(result.file).toBe("new-spec.md");
+    expect(result.threads).toHaveLength(1);
+  });
+});

package/test/protocol/read.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { readReviewFile, readDraftFile } from "../../src/protocol/read";
+import type { ReviewFile, DraftFile } from "../../src/protocol/types";
+
+function tmpDir() {
+  return mkdtempSync("/tmp/revspec-test-");
+}
+
+describe("readReviewFile", () => {
+  it("returns null for a missing file", () => {
+    expect(readReviewFile("/nonexistent/path/review.json")).toBeNull();
+  });
+
+  it("returns parsed ReviewFile for a valid file", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "review.json");
+    const data: ReviewFile = {
+      file: "spec.md",
+      threads: [
+        {
+          id: "t1",
+          line: 10,
+          status: "open",
+          messages: [{ author: "human", text: "Looks good?" }],
+        },
+      ],
+    };
+    writeFileSync(filePath, JSON.stringify(data));
+    const result = readReviewFile(filePath);
+    expect(result).toEqual(data);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns null for invalid JSON", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "review.json");
+    writeFileSync(filePath, "not valid json {{");
+    expect(readReviewFile(filePath)).toBeNull();
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns null when JSON doesn't match ReviewFile schema", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "review.json");
+    writeFileSync(filePath, JSON.stringify({ threads: [] })); // missing 'file'
+    expect(readReviewFile(filePath)).toBeNull();
+    rmSync(dir, { recursive: true });
+  });
+});
+
+describe("readDraftFile", () => {
+  it("returns null for a missing file", () => {
+    expect(readDraftFile("/nonexistent/path/draft.json")).toBeNull();
+  });
+
+  it("returns parsed DraftFile for an approval draft", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "draft.json");
+    const data: DraftFile = { approved: true };
+    writeFileSync(filePath, JSON.stringify(data));
+    expect(readDraftFile(filePath)).toEqual(data);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns parsed DraftFile for a threads draft", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "draft.json");
+    const data: DraftFile = {
+      threads: [
+        {
+          id: "t2",
+          line: 5,
+          status: "pending",
+          messages: [{ author: "ai", text: "Response here" }],
+        },
+      ],
+    };
+    writeFileSync(filePath, JSON.stringify(data));
+    expect(readDraftFile(filePath)).toEqual(data);
+    rmSync(dir, { recursive: true });
+  });
+
+  it("returns null for corrupted JSON", () => {
+    const dir = tmpDir();
+    const filePath = join(dir, "draft.json");
+    writeFileSync(filePath, "{bad json");
+    expect(readDraftFile(filePath)).toBeNull();
+    rmSync(dir, { recursive: true });
+  });
+});