revspec 0.5.0 → 0.7.0

package/src/protocol/live-events.ts

@@ -9,7 +9,8 @@ export type LiveEventType =
   | "approve"
   | "delete"
   | "round"
-  | "session-end";
+  | "session-end"
+  | "submit";
 
 export interface LiveEvent {
   type: LiveEventType;
@@ -30,6 +31,7 @@ const VALID_LIVE_EVENT_TYPES: readonly LiveEventType[] = [
   "delete",
   "round",
   "session-end",
+  "submit",
 ];
 
 export function isValidLiveEvent(value: unknown): value is LiveEvent {
@@ -49,7 +51,7 @@ export function isValidLiveEvent(value: unknown): value is LiveEvent {
   if (typeof v.author !== "string") return false;
 
   // threadId required for all except approve, round, and session-end
-  if (v.type !== "approve" && v.type !== "round" && v.type !== "session-end") {
+  if (v.type !== "approve" && v.type !== "round" && v.type !== "session-end" && v.type !== "submit") {
     if (typeof v.threadId !== "string") return false;
   }
 
@@ -186,25 +188,13 @@ export function replayEventsToThreads(events: LiveEvent[]): Thread[] {
 
       case "delete": {
         if (!event.threadId) break;
-        const thread = threadsMap.get(event.threadId);
-        if (!thread) break;
-        // Remove the last reviewer message
-        for (let i = thread.messages.length - 1; i >= 0; i--) {
-          if (thread.messages[i].author === "reviewer") {
-            thread.messages.splice(i, 1);
-            break;
-          }
-        }
-        // Re-derive status from the new last message
-        const lastMsg = thread.messages[thread.messages.length - 1];
-        if (lastMsg) {
-          thread.status = lastMsg.author === "owner" ? "pending" : "open";
-        }
+        threadsMap.delete(event.threadId);
         break;
       }
 
       case "approve":
       case "round":
+      case "submit":
         // Skip these event types
         break;
     }

package/src/state/review-state.ts

@@ -1,5 +1,16 @@
+import { randomBytes } from "crypto";
 import type { Thread, Message } from "../protocol/types";
 
+function nanoid(size = 8): string {
+  const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
+  const bytes = randomBytes(size);
+  let id = "";
+  for (let i = 0; i < size; i++) {
+    id += alphabet[bytes[i] % alphabet.length];
+  }
+  return id;
+}
+
 export class ReviewState {
   specLines: string[];
   threads: Thread[];
@@ -20,12 +31,7 @@ export class ReviewState {
   }
 
   nextThreadId(): string {
-    if (this.threads.length === 0) return "t1";
-    const highest = this.threads.reduce((max, t) => {
-      const n = parseInt(t.id.replace(/^t/, ""), 10);
-      return isNaN(n) ? max : Math.max(max, n);
-    }, 0);
-    return `t${highest + 1}`;
+    return nanoid();
   }
 
   addComment(line: number, text: string): void {
@@ -64,40 +70,47 @@ export class ReviewState {
     }
   }
 
+  resolveAll(): void {
+    for (const thread of this.threads) {
+      if (thread.status !== "resolved" && thread.status !== "outdated") {
+        thread.status = "resolved";
+      }
+    }
+  }
+
+  reset(newSpecLines: string[]): void {
+    this.specLines = newSpecLines;
+    this.threads = [];
+    this.cursorLine = 1;
+    this._unreadThreadIds.clear();
+  }
+
   threadAtLine(line: number): Thread | null {
     return this.threads.find((t) => t.line === line) ?? null;
   }
 
-  nextActiveThread(): number | null {
-    const active = this.threads.filter(
-      (t) => t.status === "open" || t.status === "pending"
-    );
-    if (active.length === 0) return null;
+  nextThread(): number | null {
+    if (this.threads.length === 0) return null;
 
-    // Look for first active thread after cursor (strictly after)
-    const after = active.filter((t) => t.line > this.cursorLine);
+    const after = this.threads.filter((t) => t.line > this.cursorLine);
     if (after.length > 0) {
       return after.reduce((min, t) => (t.line < min.line ? t : min)).line;
     }
 
-    // Wrap: return the lowest-line active thread
-    return active.reduce((min, t) => (t.line < min.line ? t : min)).line;
+    // Wrap: return the lowest-line thread
+    return this.threads.reduce((min, t) => (t.line < min.line ? t : min)).line;
   }
 
-  prevActiveThread(): number | null {
-    const active = this.threads.filter(
-      (t) => t.status === "open" || t.status === "pending"
-    );
-    if (active.length === 0) return null;
+  prevThread(): number | null {
+    if (this.threads.length === 0) return null;
 
-    // Look for last active thread before cursor (strictly before)
-    const before = active.filter((t) => t.line < this.cursorLine);
+    const before = this.threads.filter((t) => t.line < this.cursorLine);
     if (before.length > 0) {
       return before.reduce((max, t) => (t.line > max.line ? t : max)).line;
     }
 
-    // Wrap: return the highest-line active thread
-    return active.reduce((max, t) => (t.line > max.line ? t : max)).line;
+    // Wrap: return the highest-line thread
+    return this.threads.reduce((max, t) => (t.line > max.line ? t : max)).line;
   }
 
   canApprove(): boolean {

package/src/tui/app.ts

@@ -6,10 +6,7 @@ import {
   type CliRenderer,
   type KeyEvent,
 } from "@opentui/core";
-import { readReviewFile } from "../protocol/read";
-import { writeReviewFile } from "../protocol/write";
 import { appendEvent, readEventsFromOffset, replayEventsToThreads } from "../protocol/live-events";
-import { mergeJsonlIntoReview } from "../protocol/live-merge";
 import type { Thread } from "../protocol/types";
 import { ReviewState } from "../state/review-state";
 import { createLiveWatcher, type LiveWatcher } from "./live-watcher";
@@ -24,43 +21,28 @@ import {
   type BottomBarComponents,
 } from "./status-bar";
 import { createCommentInput } from "./comment-input";
-// thread-expand removed — merged into comment-input
 import { createSearch } from "./search";
 import { createThreadList } from "./thread-list";
 import { createConfirm } from "./confirm";
 import { createHelp } from "./help";
+import { createSpinner } from "./spinner";
 import { createKeybindRegistry, type KeyBinding } from "./ui/keybinds";
 
 export async function runTui(
   specFile: string,
-  reviewPath: string,
-  draftPath: string,
   version?: string
 ): Promise<void> {
   // 1. Read spec file into lines
   const specContent = readFileSync(specFile, "utf8");
   const specLines = specContent.split("\n");
 
-  // 2. Load existing review, merge threads
-  const existingReview = readReviewFile(reviewPath);
-
-  let threads: Thread[] = [];
-  if (existingReview) {
-    threads = existingReview.threads.map((t) => ({
-      ...t,
-      messages: [...t.messages],
-    }));
-  }
-
-  // 3. Create ReviewState
-  const state = new ReviewState(specLines, threads);
+  // 2. Create ReviewState
+  const state = new ReviewState(specLines, []);
 
   // 4. Derive JSONL path and set up live protocol
   const dir = dirname(specFile);
   const base = basename(specFile, ".md");
-  const jsonlPath = `${dir}/${base}.review.live.jsonl`;
-  const reviewPathForMerge = `${dir}/${base}.review.json`;
-
+  const jsonlPath = `${dir}/${base}.review.jsonl`;
   // Crash recovery: replay JSONL events if file exists
   if (existsSync(jsonlPath)) {
     const { events } = readEventsFromOffset(jsonlPath, 0);
@@ -141,6 +123,9 @@ export async function runTui(
   // Command mode state
   let commandBuffer: string | null = null;
 
+  // Active spec poll interval (for submit spinner leak prevention)
+  let activeSpecPoll: ReturnType<typeof setInterval> | null = null;
+
   // Overlay state — when an overlay is active, normal keybindings are blocked.
   // The overlay's own key handlers manage its lifecycle.
   type ActiveOverlay = {
@@ -168,29 +153,9 @@ export async function runTui(
     renderer.requestRender();
   }
 
-  // Helper: merge JSONL into review JSON and clean up
-  // Track whether we have unmerged changes since last :w
-  let lastMergedOffset = 0;
-
-  function hasPendingChanges(): boolean {
-    if (!existsSync(jsonlPath)) return false;
-    const { size } = statSync(jsonlPath);
-    return size > lastMergedOffset;
-  }
-
-  function doMerge(): void {
-    const existingReviewForMerge = readReviewFile(reviewPathForMerge);
-    const merged = mergeJsonlIntoReview(jsonlPath, existingReviewForMerge, specFile);
-    writeReviewFile(reviewPathForMerge, merged);
-    if (existsSync(jsonlPath)) {
-      lastMergedOffset = statSync(jsonlPath).size;
-    }
-  }
-
-  function mergeAndExit(resolve: () => void): void {
-    doMerge();
-    // Signal to watch process that session has ended
-    appendEvent(jsonlPath, { type: "session-end", author: "reviewer", ts: Date.now() });
+  // Helper: exit the TUI cleanly
+  function exitTui(resolve: () => void, eventType: "session-end" | "approve"): void {
+    appendEvent(jsonlPath, { type: eventType, author: "reviewer", ts: Date.now() });
     liveWatcher.stop();
     keybinds.destroy();
     renderer.destroy();
@@ -218,42 +183,35 @@ export async function runTui(
   }
 
   // Process command buffer input
-  // Returns: "exit" to exit (caller should destroy+resolve), "merged" if already handled, "stay" to keep running
-  function processCommand(cmd: string, resolve: () => void): "exit" | "merged" | "stay" {
-    if (cmd === "w") {
-      // Merge JSONL -> JSON, stay open
-      doMerge();
-      setBottomBarMessage(bottomBar, " \u2714 Merged to review JSON");
-      renderer.requestRender();
-      setTimeout(() => { refreshPager(); }, 1200);
-      return "stay";
-    }
-    if (cmd === "wq" || cmd === "qw") {
-      // Merge and exit
-      mergeAndExit(resolve);
-      return "merged";
-    }
-    if (cmd === "q") {
-      // Exit only if merged (no pending changes)
-      if (hasPendingChanges()) {
-        setBottomBarMessage(bottomBar, " Unmerged changes. Use :w to save or :q! to discard");
+  function processCommand(cmd: string, resolve: () => void): "exit" | "stay" {
+    if (cmd === "q" || cmd === "wq" || cmd === "qw") {
+      const { open, pending } = state.activeThreadCount();
+      const total = open + pending;
+      if (total > 0) {
+        setBottomBarMessage(bottomBar, ` \u26a0 ${total} unresolved thread(s). Use :q! to force quit`);
         renderer.requestRender();
         setTimeout(() => { refreshPager(); }, 2000);
         return "stay";
       }
-      appendEvent(jsonlPath, { type: "session-end", author: "reviewer", ts: Date.now() });
-      liveWatcher.stop();
-      keybinds.destroy();
+      exitTui(resolve, "session-end");
       return "exit";
     }
     if (cmd === "q!") {
-      // Exit without merging
-      appendEvent(jsonlPath, { type: "session-end", author: "reviewer", ts: Date.now() });
-      liveWatcher.stop();
-      keybinds.destroy();
+      exitTui(resolve, "session-end");
       return "exit";
     }
-    return "stay"; // unknown command, ignore
+    // :{N} — jump to line number
+    const lineNum = parseInt(cmd, 10);
+    if (!isNaN(lineNum) && lineNum > 0) {
+      state.cursorLine = Math.min(lineNum, state.lineCount);
+      ensureCursorVisible();
+      refreshPager();
+      return "stay";
+    }
+    setBottomBarMessage(bottomBar, ` Unknown command: ${cmd}`);
+    renderer.requestRender();
+    setTimeout(() => { refreshPager(); }, 1500);
+    return "stay";
   }
 
   // --- Overlay launchers ---
@@ -354,6 +312,39 @@ export async function runTui(
     showOverlay(overlay);
   }
 
+  // Helper: gate that checks for unresolved threads.
+  // If unresolved, shows confirm popup to resolve all.
+  // Calls onProceed() when all threads are resolved.
+  function unresolvedGate(onProceed: () => void): void {
+    if (state.canApprove()) {
+      onProceed();
+      return;
+    }
+    const { open, pending } = state.activeThreadCount();
+    const total = open + pending;
+    const confirmOverlay = createConfirm({
+      renderer,
+      title: "Unresolved Threads",
+      message: `${total} thread(s) still unresolved. Resolve all and continue?`,
+      onConfirm: () => {
+        dismissOverlay();
+        const unresolved = state.threads.filter(
+          t => t.status !== "resolved" && t.status !== "outdated"
+        );
+        state.resolveAll();
+        for (const t of unresolved) {
+          appendEvent(jsonlPath, { type: "resolve", threadId: t.id, author: "reviewer", ts: Date.now() });
+        }
+        refreshPager();
+        onProceed();
+      },
+      onCancel: () => {
+        dismissOverlay();
+      },
+    });
+    showOverlay(confirmOverlay);
+  }
+
   // Helper: find next search match from current line in given direction, wrapping
   function findNextMatch(
     lines: string[],
@@ -361,11 +352,14 @@ export async function runTui(
     currentLine: number,
     direction: 1 | -1
   ): number | null {
-    const q = query.toLowerCase();
+    // Smartcase: if query has any uppercase, case-sensitive
+    const caseSensitive = query !== query.toLowerCase();
+    const q = caseSensitive ? query : query.toLowerCase();
     const total = lines.length;
     for (let offset = 1; offset <= total; offset++) {
       const i = ((currentLine - 1) + offset * direction + total) % total;
-      if (lines[i].toLowerCase().includes(q)) {
+      const line = caseSensitive ? lines[i] : lines[i].toLowerCase();
+      if (line.includes(q)) {
         return i + 1; // 1-based
       }
     }
@@ -386,20 +380,22 @@ export async function runTui(
     { key: "n", action: "search-next" },
     { key: "N", action: "search-prev" },
     { key: "c", action: "comment" },
-    { key: "l", action: "thread-list" },
+    { key: "t", action: "thread-list" },
     { key: "r", action: "resolve" },
     { key: "R", action: "resolve-all" },
     { key: "dd", action: "delete-draft" },
-    { key: "a", action: "approve" },
+    { key: "S", action: "submit" },
+    { key: "A", action: "approve" },
     { key: "]t", action: "next-thread" },
     { key: "[t", action: "prev-thread" },
     { key: "]r", action: "next-unread" },
     { key: "[r", action: "prev-unread" },
+    { key: "zz", action: "center-cursor" },
     { key: "?", action: "help" },
     { key: "/", action: "search" },
     { key: ":", action: "command-mode" },
   ];
-  const keybinds = createKeybindRegistry(bindings);
+  const keybinds = createKeybindRegistry(bindings, 300);
 
   refreshPager();
   renderer.start();
@@ -412,6 +408,10 @@ export async function runTui(
       // (e.g., TextareaRenderable for typing in comment input).
       if (activeOverlay) {
         if (key.ctrl && key.name === "c") {
+          if (activeSpecPoll) {
+            clearInterval(activeSpecPoll);
+            activeSpecPoll = null;
+          }
           dismissOverlay();
           return;
         }
@@ -426,16 +426,10 @@ export async function runTui(
           commandBuffer = null;
           const result = processCommand(cmd, resolve);
           if (result === "exit") {
-            renderer.destroy();
-            resolve();
+            // exitTui already called destroy+resolve
             return;
           }
-          if (result === "merged") {
-            // mergeAndExit already called destroy+resolve
-            return;
-          }
-          // "stay" — don't refreshPager here, processCommand handles its own bar updates
-          // (e.g., :w shows "saved" briefly before refreshing via setTimeout)
+          // "stay" — processCommand handles its own bar updates
           return;
         }
         if (key.name === "escape") {
@@ -460,9 +454,9 @@ export async function runTui(
         return;
       }
 
-      // Ctrl+C to exit — merge and quit
+      // Ctrl+C to exit
       if (key.ctrl && key.name === "c") {
-        mergeAndExit(resolve);
+        exitTui(resolve, "session-end");
         return;
       }
 
@@ -527,6 +521,14 @@ export async function runTui(
           ensureCursorVisible();
           refreshPager();
           break;
+        case "center-cursor": {
+          const extra = countExtraVisualLines(state.specLines, state.cursorLine - 1);
+          const cursorRow = state.cursorLine - 1 + extra;
+          const halfView = Math.floor(pageSize() / 2);
+          pager.scrollBox.scrollTo(Math.max(0, cursorRow - halfView));
+          refreshPager();
+          break;
+        }
         case "search-next":
           if (searchQuery) {
             const match = findNextMatch(state.specLines, searchQuery, state.cursorLine, 1);
@@ -575,6 +577,10 @@ export async function runTui(
             setBottomBarMessage(bottomBar, msg);
             renderer.requestRender();
             setTimeout(() => { refreshPager(); }, 1500);
+          } else {
+            setBottomBarMessage(bottomBar, " No thread on this line");
+            renderer.requestRender();
+            setTimeout(() => { refreshPager(); }, 1500);
           }
           break;
         }
@@ -593,7 +599,12 @@ export async function runTui(
         }
         case "delete-draft": {
           const thread = state.threadAtLine(state.cursorLine);
-          if (!thread) break;
+          if (!thread) {
+            setBottomBarMessage(bottomBar, " No thread on this line");
+            renderer.requestRender();
+            setTimeout(() => { refreshPager(); }, 1500);
+            break;
+          }
           const deleteOverlay = createConfirm({
             renderer,
             title: "Delete Thread",
@@ -614,48 +625,90 @@ export async function runTui(
           showOverlay(deleteOverlay);
           break;
         }
+        case "submit":
+          unresolvedGate(() => {
+            appendEvent(jsonlPath, { type: "submit", author: "reviewer", ts: Date.now() });
+
+            const spinnerOverlay = createSpinner({
+              renderer,
+              message: "Waiting for agent to update spec...",
+              onCancel: () => {
+                clearInterval(activeSpecPoll!);
+                activeSpecPoll = null;
+                dismissOverlay();
+              },
+              onTimeout: () => {
+                clearInterval(activeSpecPoll!);
+                activeSpecPoll = null;
+                dismissOverlay();
+                setBottomBarMessage(bottomBar, " \u26a0 Agent did not update spec. Press S to retry.");
+                renderer.requestRender();
+                setTimeout(() => { refreshPager(); }, 3000);
+              },
+            });
+            showOverlay(spinnerOverlay);
+
+            activeSpecPoll = setInterval(() => {
+              try {
+                const currentMtime = statSync(specFile).mtimeMs;
+                if (currentMtime !== specMtime) {
+                  clearInterval(activeSpecPoll!);
+                  activeSpecPoll = null;
+                  const newContent = readFileSync(specFile, "utf8");
+                  state.reset(newContent.split("\n"));
+                  specMtime = currentMtime;
+                  specMtimeChanged = false;
+                  liveWatcher.stop();
+                  liveWatcher.start();
+                  dismissOverlay();
+                  searchQuery = null;
+                  ensureCursorVisible();
+                  refreshPager();
+                }
+              } catch {}
+            }, 500);
+          });
+          break;
         case "approve":
-          if (state.canApprove()) {
+          unresolvedGate(() => {
             const confirmOverlay = createConfirm({
               renderer,
               message: "Approve spec and proceed to implementation?",
               onConfirm: () => {
                 dismissOverlay();
-                appendEvent(jsonlPath, { type: "approve", author: "reviewer", ts: Date.now() });
-                mergeAndExit(resolve);
+                exitTui(resolve, "approve");
               },
               onCancel: () => {
                 dismissOverlay();
               },
             });
             showOverlay(confirmOverlay);
-          } else {
-            const { open, pending } = state.activeThreadCount();
-            const total = open + pending;
-            const msg = total === 0
-              ? "No threads to approve"
-              : `${total} thread${total !== 1 ? "s" : ""} still open/pending`;
-            setBottomBarMessage(bottomBar, ` \u26a0  ${msg}`);
-            renderer.requestRender();
-            setTimeout(() => { refreshPager(); }, 2000);
-          }
+          });
           break;
         case "next-thread": {
-          const next = state.nextActiveThread();
+          const next = state.nextThread();
           if (next !== null) {
             state.cursorLine = next;
             ensureCursorVisible();
+            refreshPager();
+          } else {
+            setBottomBarMessage(bottomBar, " No threads");
+            renderer.requestRender();
+            setTimeout(() => { refreshPager(); }, 1500);
           }
-          refreshPager();
           break;
         }
         case "prev-thread": {
-          const prev = state.prevActiveThread();
+          const prev = state.prevThread();
           if (prev !== null) {
             state.cursorLine = prev;
             ensureCursorVisible();
+            refreshPager();
+          } else {
+            setBottomBarMessage(bottomBar, " No threads");
+            renderer.requestRender();
+            setTimeout(() => { refreshPager(); }, 1500);
           }
-          refreshPager();
           break;
         }
         case "next-unread": {
@@ -663,8 +716,12 @@ export async function runTui(
           if (nextLine !== null) {
             state.cursorLine = nextLine;
             ensureCursorVisible();
+            refreshPager();
+          } else {
+            setBottomBarMessage(bottomBar, " No unread replies");
+            renderer.requestRender();
+            setTimeout(() => { refreshPager(); }, 1500);
           }
-          refreshPager();
           break;
         }
         case "prev-unread": {
@@ -672,8 +729,12 @@ export async function runTui(
           if (prevLine !== null) {
             state.cursorLine = prevLine;
             ensureCursorVisible();
+            refreshPager();
+          } else {
+            setBottomBarMessage(bottomBar, " No unread replies");
+            renderer.requestRender();
+            setTimeout(() => { refreshPager(); }, 1500);
           }
-          refreshPager();
           break;
         }
         case "help":

package/src/tui/comment-input.ts

@@ -8,6 +8,7 @@ import {
 import type { Thread, Message } from "../protocol/types";
 import { theme } from "./ui/theme";
 import { createDialog } from "./ui/dialog";
+import { THREAD_NORMAL_HINTS, THREAD_INSERT_HINTS } from "./ui/keymap";
 
 export interface CommentInputOptions {
   renderer: CliRenderer;
@@ -46,20 +47,12 @@ function createThreadView(
     ? `Thread #${thread.id} (line ${line})`
     : `New comment on line ${line}`;
 
-  const normalHints = [
-    { key: "NORMAL", action: "" },
-    { key: "c", action: "reply" },
-    { key: "r", action: "resolve" },
-    { key: "Esc/q", action: "close" },
-  ];
-  const insertHints = [
-    { key: "INSERT", action: "" },
-    { key: "Tab", action: "send" },
-    { key: "Esc", action: "back" },
-  ];
+  const normalHints = THREAD_NORMAL_HINTS;
+  const insertHints = THREAD_INSERT_HINTS;
 
   // --- State ---
   let mode: "normal" | "insert" = "insert";
+  let pendingG: ReturnType<typeof setTimeout> | null = null;
 
   // Build the textarea now (we need it in the key handler closure)
   const textarea = new TextareaRenderable(renderer, {
@@ -151,10 +144,19 @@ function createThreadView(
       case "g":
         if (key.shift) {
           // G = go to bottom
+          if (pendingG) { clearTimeout(pendingG); pendingG = null; }
           scrollBox.scrollTo(scrollBox.scrollHeight);
           renderer.requestRender();
+        } else if (pendingG) {
+          // gg = go to top
+          clearTimeout(pendingG);
+          pendingG = null;
+          scrollBox.scrollTo(0);
+          renderer.requestRender();
+        } else {
+          // First g — wait for second
+          pendingG = setTimeout(() => { pendingG = null; }, 300);
         }
-        // TODO: gg = go to top (needs double-tap tracking)
         return;
     }
   };
@@ -246,9 +248,13 @@ function createThreadView(
     renderer.requestRender();
   }
 
-  // Start in insert mode, scroll conversation to bottom
+  // Start in appropriate mode
   setTimeout(() => {
-    textarea.focus();
+    if (thread.messages.length > 0) {
+      enterNormal(); // Existing thread: let user read conversation first
+    } else {
+      textarea.focus(); // New thread: start typing immediately
+    }
     scrollBox.scrollTo(scrollBox.scrollHeight);
     renderer.requestRender();
     setTimeout(() => {
@@ -273,6 +279,7 @@ function createThreadView(
   return {
     container: dialog.container,
     cleanup() {
+      if (pendingG) clearTimeout(pendingG);
       renderer.keyInput.off("keypress", keyHandler);
       dialog.cleanup();
       textarea.destroy();