revspec 0.6.0 → 0.7.1

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,39 +183,21 @@ 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";
     }
     // :{N} — jump to line number
@@ -261,7 +208,10 @@ export async function runTui(
       refreshPager();
       return "stay";
     }
-    return "stay"; // unknown command, ignore
+    setBottomBarMessage(bottomBar, ` Unknown command: ${cmd}`);
+    renderer.requestRender();
+    setTimeout(() => { refreshPager(); }, 1500);
+    return "stay";
   }
 
   // --- Overlay launchers ---
@@ -362,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[],
@@ -397,11 +380,12 @@ export async function runTui(
     { key: "n", action: "search-next" },
     { key: "N", action: "search-prev" },
     { key: "c", action: "comment" },
-    { key: "T", 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" },
@@ -424,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;
         }
@@ -438,16 +426,10 @@ export async function runTui(
           commandBuffer = null;
           const result = processCommand(cmd, resolve);
           if (result === "exit") {
-            renderer.destroy();
-            resolve();
-            return;
-          }
-          if (result === "merged") {
-            // mergeAndExit already called destroy+resolve
+            // exitTui 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") {
@@ -472,13 +454,9 @@ export async function runTui(
         return;
       }
 
-      // Ctrl+C to exit — quit without merging (same as :q!)
+      // Ctrl+C to exit
       if (key.ctrl && key.name === "c") {
-        appendEvent(jsonlPath, { type: "session-end", author: "reviewer", ts: Date.now() });
-        liveWatcher.stop();
-        keybinds.destroy();
-        renderer.destroy();
-        resolve();
+        exitTui(resolve, "session-end");
         return;
       }
 
@@ -599,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;
         }
@@ -617,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",
@@ -638,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": {
@@ -687,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": {
@@ -696,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,17 +47,8 @@ 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: "q", action: "close" },
-  ];
-  const insertHints = [
-    { key: "INSERT", action: "" },
-    { key: "Tab", action: "send" },
-    { key: "Esc", action: "normal" },
-  ];
+  const normalHints = THREAD_NORMAL_HINTS;
+  const insertHints = THREAD_INSERT_HINTS;
 
   // --- State ---
   let mode: "normal" | "insert" = "insert";
@@ -256,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(() => {

package/src/tui/confirm.ts

@@ -5,6 +5,7 @@ import {
 } from "@opentui/core";
 import { theme } from "./ui/theme";
 import { createDialog } from "./ui/dialog";
+import { CONFIRM_HINTS } from "./ui/keymap";
 
 export interface ConfirmOptions {
   renderer: CliRenderer;
@@ -36,10 +37,7 @@ export function createConfirm(opts: ConfirmOptions): ConfirmOverlay {
     left: "25%",
     borderColor: theme.warning,
     onDismiss: onCancel,
-    hints: [
-      { key: "y", action: "yes" },
-      { key: "n/Esc", action: "no" },
-    ],
+    hints: CONFIRM_HINTS,
   });
 
   const msgText = new TextRenderable(renderer, {
@@ -52,13 +50,13 @@ export function createConfirm(opts: ConfirmOptions): ConfirmOverlay {
   dialog.content.add(msgText);
 
   const extraKeyHandler = (key: KeyEvent) => {
-    if (key.name === "y") {
+    if (key.name === "y" || key.name === "return") {
       key.preventDefault();
       key.stopPropagation();
       onConfirm();
       return;
     }
-    if (key.name === "n") {
+    if (key.name === "q") {
       key.preventDefault();
       key.stopPropagation();
       onCancel();

package/src/tui/help.ts

@@ -6,6 +6,7 @@ import {
 } from "@opentui/core";
 import { theme } from "./ui/theme";
 import { createDialog } from "./ui/dialog";
+import { HELP_HINTS } from "./ui/keymap";
 
 export interface HelpOverlay {
   container: import("@opentui/core").BoxRenderable;
@@ -55,10 +56,7 @@ export function createHelp(opts: {
     left: "20%",
     borderColor: theme.info,
     onDismiss: onClose,
-    hints: [
-      { key: "j/k", action: "navigate" },
-      { key: "q/?/Esc", action: "close" },
-    ],
+    hints: HELP_HINTS,
   });
 
   // Version header
@@ -74,14 +72,14 @@ export function createHelp(opts: {
   addHelpSection(dialog.content, renderer, "Quick Start", [
     "  Navigate to a line and press c to comment.",
     "  The AI replies in real-time via the thread popup.",
-    "  Press r to resolve threads, a to approve the spec.",
-    "  Use :wq to save and quit when done reviewing.",
+    "  Press r to resolve, S to submit for rewrite.",
+    "  Press A to approve when done.",
   ]);
 
   addHelpSection(dialog.content, renderer, "Thread Popup", [
-    "  Opens in INSERT mode — type and press Tab to send.",
-    "  Press Esc for NORMAL mode — scroll with j/k/gg/G,",
-    "  c to reply, r to resolve, q to close.",
+    "  New thread: INSERT mode — type and Tab to send.",
+    "  Existing thread: NORMAL mode — read conversation,",
+    "  c to reply, r to resolve, q/Esc to close.",
   ]);
 
   addHelpSection(dialog.content, renderer, "Navigation", [
@@ -101,17 +99,16 @@ export function createHelp(opts: {
     "  r         Resolve thread (toggle)",
     "  R         Resolve all pending",
     "  dd        Delete thread",
-    "  T         List threads",
-    "  a         Approve spec",
+    "  t         List threads",
+    "  S         Submit for rewrite",
+    "  A         Approve spec",
   ]);
 
   addHelpSection(dialog.content, renderer, "Commands", [
-    "  :w        Merge to review JSON",
-    "  :wq       Merge and quit",
-    "  :q        Quit (blocks if unmerged)",
-    "  :q!       Quit without merging",
+    "  :q/:wq    Quit (warns if unresolved)",
+    "  :q!       Force quit",
     "  :{N}      Jump to line N",
-    "  Ctrl+C    Quit without merging",
+    "  Ctrl+C    Force quit",
   ]);
 
   // Trailing blank line

package/src/tui/spinner.ts

@@ -0,0 +1,81 @@
+import {
+  BoxRenderable,
+  TextRenderable,
+  type CliRenderer,
+  type KeyEvent,
+} from "@opentui/core";
+import { theme } from "./ui/theme";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export interface SpinnerOverlay {
+  container: BoxRenderable;
+  cleanup: () => void;
+}
+
+export function createSpinner(opts: {
+  renderer: CliRenderer;
+  message: string;
+  timeoutMs?: number;
+  onCancel: () => void;
+  onTimeout: () => void;
+}): SpinnerOverlay {
+  const { renderer, message, onCancel, onTimeout, timeoutMs = 120_000 } = opts;
+
+  const container = new BoxRenderable(renderer, {
+    position: "absolute",
+    top: "40%",
+    left: "25%",
+    width: "50%",
+    height: 5,
+    zIndex: 100,
+    backgroundColor: theme.backgroundPanel,
+    border: true,
+    borderStyle: "single",
+    borderColor: theme.blue,
+    title: " Submitting ",
+    flexDirection: "column",
+    paddingLeft: 2,
+    paddingRight: 2,
+    paddingTop: 1,
+    alignItems: "center",
+  });
+
+  const text = new TextRenderable(renderer, {
+    content: `${SPINNER_FRAMES[0]} ${message}`,
+    width: "100%",
+    height: 1,
+    fg: theme.text,
+    wrapMode: "none",
+  });
+  container.add(text);
+
+  let frame = 0;
+  const spinInterval = setInterval(() => {
+    frame = (frame + 1) % SPINNER_FRAMES.length;
+    text.content = `${SPINNER_FRAMES[frame]} ${message}`;
+    renderer.requestRender();
+  }, 80);
+
+  const timeout = setTimeout(() => {
+    onTimeout();
+  }, timeoutMs);
+
+  const keyHandler = (key: KeyEvent) => {
+    if (key.ctrl && key.name === "c") {
+      key.preventDefault();
+      key.stopPropagation();
+      onCancel();
+    }
+  };
+  renderer.keyInput.on("keypress", keyHandler);
+
+  return {
+    container,
+    cleanup() {
+      clearInterval(spinInterval);
+      clearTimeout(timeout);
+      renderer.keyInput.off("keypress", keyHandler);
+    },
+  };
+}

package/src/tui/status-bar.ts

@@ -2,7 +2,8 @@ import { BoxRenderable, TextRenderable, TextNodeRenderable, TextAttributes, type
 import type { ReviewState } from "../state/review-state";
 import { basename } from "path";
 import { theme } from "./ui/theme";
-import { buildHints, type Hint } from "./ui/hint-bar";
+import { buildHints } from "./ui/hint-bar";
+import { PAGER_HINTS } from "./ui/keymap";
 
 export interface TopBarComponents {
   box: BoxRenderable;
@@ -83,14 +84,16 @@ export function buildBottomBar(bar: BottomBarComponents, commandBuffer: string |
     t.add(TextNodeRenderable.fromString(` :${commandBuffer}`, { fg: theme.text }));
     return;
   }
-  const hints: Hint[] = [
-    { key: "j/k", action: "navigate" },
-    { key: "c", action: "comment" },
+  const hints = [
+    PAGER_HINTS.navigate,
+    PAGER_HINTS.comment,
   ];
   if (hasThread) {
-    hints.push({ key: "r", action: "resolve" });
+    hints.push(PAGER_HINTS.resolve);
   }
-  hints.push({ key: "?", action: "help" });
+  hints.push(PAGER_HINTS.submit);
+  hints.push(PAGER_HINTS.approve);
+  hints.push(PAGER_HINTS.help);
   buildHints(t, hints);
 }