revspec 0.8.4 → 0.8.6

package/bin/revspec.ts

@@ -2,6 +2,7 @@
 import { existsSync } from "fs";
 import { resolve, basename, extname, dirname, join } from "path";
 import { runTui } from "../src/tui/app";
+import pkg from "../package.json";
 
 const args = process.argv.slice(2);
 const subcommand = args[0];
@@ -36,7 +37,6 @@ if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
 }
 
 if (args.includes("--version") || args.includes("-v")) {
-  const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
   console.log(`revspec ${pkg.version}`);
   process.exit(0);
 }
@@ -55,7 +55,6 @@ if (!existsSync(specPath)) {
 }
 
 // 2. Launch TUI
-const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
 await runTui(specPath, pkg.version);
 
 process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "revspec",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "Terminal-based spec review tool with real-time AI conversation",
   "type": "module",
   "license": "MIT",

package/src/cli/watch.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync, renameSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, renameSync, statSync } from "fs";
 import { watch as fsWatch } from "fs";
 import { resolve, dirname, basename, join } from "path";
 import {
@@ -69,6 +69,17 @@ export async function runWatch(specFile: string): Promise<void> {
     }
   }
 
+  // Reset offset if JSONL was deleted/recreated/truncated (file smaller than offset)
+  if (existsSync(jsonlPath)) {
+    if (offset > statSync(jsonlPath).size) {
+      offset = 0;
+      lastSubmitTs = 0;
+    }
+  } else {
+    offset = 0;
+    lastSubmitTs = 0;
+  }
+
   // Read spec lines for context
   const specLines = readFileSync(specPath, "utf8").split("\n");
 

package/src/tui/app.ts

@@ -128,8 +128,17 @@ export async function runTui(
     buildTopBar(topBar, specFile, state, state.unreadCount(), specMtimeChanged);
     // Don't overwrite transient messages (welcome hint, warnings) during navigation
     if (!messageTimer) {
-      const hasThread = !!state.threadAtLine(state.cursorLine);
-      buildBottomBar(bottomBar, commandBuffer, hasThread);
+      const curThread = state.threadAtLine(state.cursorLine);
+      if (curThread && curThread.messages.length > 0 && commandBuffer === null) {
+        // Show thread preview in bottom bar
+        const first = curThread.messages[0].text.replace(/\n/g, " ");
+        const replies = curThread.messages.length - 1;
+        const preview = first.length > 60 ? first.slice(0, 59) + "\u2026" : first;
+        const replyStr = replies > 0 ? ` (${replies} repl${replies === 1 ? "y" : "ies"})` : "";
+        setBottomBarMessage(bottomBar, `${preview}${replyStr} [${curThread.status}]`);
+      } else {
+        buildBottomBar(bottomBar, commandBuffer, !!curThread);
+      }
     }
     renderer.requestRender();
   }
@@ -351,8 +360,11 @@ export async function runTui(
         searchQuery = query;
         savePrevPosition();
         state.cursorLine = lineNumber;
-        dismissOverlay();
         ensureCursorVisible();
+        dismissOverlay(); // calls refreshPager with cursor + scroll already set
+      },
+      onPreview: (query: string | null) => {
+        searchQuery = query;
         refreshPager();
       },
       onCancel: () => {

package/src/tui/pager.ts

@@ -7,7 +7,7 @@ import {
   type CliRenderer,
 } from "@opentui/core";
 import { theme } from "./ui/theme";
-import { parseMarkdownLine, addSegments, collectTable, renderTableBorder, renderTableSeparator, renderTableRow, parseTableCells, type TableBlock } from "./ui/markdown";
+import { parseMarkdownLine, addSegments, collectTable, renderTableBorder, renderTableSeparator, renderTableRow, parseTableCells, type TableBlock, type StyledSegment } from "./ui/markdown";
 
 // --- Plain text builder (for tests) ---
 
@@ -30,14 +30,7 @@ export function buildPagerContent(state: ReviewState, searchQuery?: string | nul
     }
     let indicator = " ";
     if (thread) {
-      const isUnread = unreadThreadIds && unreadThreadIds.has(thread.id);
-      if (isUnread) {
-        indicator = "\u2588";
-      } else if (thread.status === "resolved") {
-        indicator = "=";
-      } else {
-        indicator = "\u258c";
-      }
+      indicator = "\u2588"; // █ full block for all statuses
     }
     const numStr = String(lineNum);
     const padded = " ".repeat(numWidth - numStr.length) + numStr;
@@ -54,7 +47,53 @@ export function buildPagerContent(state: ReviewState, searchQuery?: string | nul
  * Line numbers and thread hints are dimmed.
  */
 /**
- * Word-wrap a string at the given width, breaking at word boundaries.
+ * Wrap pre-parsed markdown segments at the given width.
+ * Breaks at segment boundaries when possible, word boundaries within segments otherwise.
+ * Returns an array of segment arrays (one per visual line).
+ */
+function wrapSegments(segments: StyledSegment[], width: number): StyledSegment[][] {
+  if (width <= 0) return [segments];
+  // Check total length
+  let totalLen = 0;
+  for (const s of segments) totalLen += s.text.length;
+  if (totalLen <= width) return [segments];
+
+  const lines: StyledSegment[][] = [];
+  let curLine: StyledSegment[] = [];
+  let curWidth = 0;
+
+  for (const seg of segments) {
+    if (curWidth + seg.text.length <= width) {
+      curLine.push(seg);
+      curWidth += seg.text.length;
+      continue;
+    }
+    // Segment doesn't fit — break it at word boundaries
+    let remaining = seg.text;
+    while (remaining.length > 0) {
+      const avail = width - curWidth;
+      if (remaining.length <= avail) {
+        curLine.push({ ...seg, text: remaining });
+        curWidth += remaining.length;
+        break;
+      }
+      if (avail > 0) {
+        let breakAt = remaining.lastIndexOf(" ", avail);
+        if (breakAt <= 0) breakAt = avail; // hard break
+        curLine.push({ ...seg, text: remaining.slice(0, breakAt) });
+        remaining = remaining.slice(breakAt).replace(/^ /, "");
+      }
+      lines.push(curLine);
+      curLine = [];
+      curWidth = 0;
+    }
+  }
+  if (curLine.length > 0) lines.push(curLine);
+  return lines;
+}
+
+/**
+ * Word-wrap a raw string (for countExtraVisualLines estimation).
  */
 function wordWrap(text: string, width: number): string[] {
   if (width <= 0 || text.length <= width) return [text];
@@ -62,9 +101,9 @@ function wordWrap(text: string, width: number): string[] {
   let remaining = text;
   while (remaining.length > width) {
     let breakAt = remaining.lastIndexOf(" ", width);
-    if (breakAt <= 0) breakAt = width; // no space found — hard break
+    if (breakAt <= 0) breakAt = width;
     lines.push(remaining.slice(0, breakAt));
-    remaining = remaining.slice(breakAt).replace(/^ /, ""); // trim leading space on continuation
+    remaining = remaining.slice(breakAt).replace(/^ /, "");
   }
   if (remaining.length > 0) lines.push(remaining);
   return lines;
@@ -82,11 +121,17 @@ export function buildPagerNodes(lineNode: TextRenderable, state: ReviewState, se
   const contentWidth = wrapWidth && wrapWidth > gutterWidth ? wrapWidth - gutterWidth : 0;
 
   // Pre-scan for table blocks so we can calculate column widths
+  // Skip lines inside fenced code blocks — pipes in code are not tables
   const tableBlocks = new Map<number, TableBlock>();
+  let preScanCodeBlock = false;
   for (let i = 0; i < state.specLines.length; i++) {
+    if (state.specLines[i].trimStart().startsWith("```")) {
+      preScanCodeBlock = !preScanCodeBlock;
+      continue;
+    }
+    if (preScanCodeBlock) continue;
     if (state.specLines[i].trimStart().startsWith("|") && !tableBlocks.has(i)) {
       const block = collectTable(state.specLines, i);
-      // Mark all lines in this block
       for (let j = 0; j < block.lines.length; j++) {
         tableBlocks.set(i + j, block);
       }
@@ -104,20 +149,18 @@ export function buildPagerNodes(lineNode: TextRenderable, state: ReviewState, se
     const prefix = isCursor ? ">" : " ";
     const specText = state.specLines[i];
 
-    // Thread indicator — gutter bar on the left
+    // Thread indicator — gutter bar on the left (all █, color-coded)
     let indicator = " ";
     let indicatorColor: string = theme.textDim;
     if (thread) {
+      indicator = "\u2588"; // █ full block
       const isUnread = unreadThreadIds && unreadThreadIds.has(thread.id);
       if (isUnread) {
-        indicator = "\u2588"; // █ full block — unread reply
         indicatorColor = theme.yellow;
       } else if (thread.status === "resolved") {
-        indicator = "="; // resolved
         indicatorColor = theme.green;
       } else {
-        indicator = "\u258c"; // ▌ half block — has thread
-        indicatorColor = theme.blue;
+        indicatorColor = theme.text; // open — white
       }
     }
 
@@ -199,21 +242,21 @@ export function buildPagerNodes(lineNode: TextRenderable, state: ReviewState, se
           lineNode.add(TextNodeRenderable.fromString(part, { fg: theme.text, bg: isCursor ? theme.backgroundElement : undefined }));
         }
       }
-    } else if (contentWidth > 0 && specText.length > contentWidth) {
-      // Wrap long lines — first chunk gets markdown, continuations get blank gutter + markdown
-      const chunks = wordWrap(specText, contentWidth);
-      const segments = parseMarkdownLine(chunks[0]);
-      addSegments(lineNode, segments, theme.text, isCursor ? theme.backgroundElement : undefined);
-      for (let c = 1; c < chunks.length; c++) {
-        lineNode.add(TextNodeRenderable.fromString("\n", {}));
-        lineNode.add(TextNodeRenderable.fromString(gutterBlank, { fg: theme.textDim }));
-        const contSegments = parseMarkdownLine(chunks[c]);
-        addSegments(lineNode, contSegments, theme.text, isCursor ? theme.backgroundElement : undefined);
-      }
     } else {
-      // Parse and render inline markdown
+      // Parse inline markdown, then wrap if needed
       const segments = parseMarkdownLine(specText);
-      addSegments(lineNode, segments, theme.text, isCursor ? theme.backgroundElement : undefined);
+      const bg = isCursor ? theme.backgroundElement : undefined;
+      if (contentWidth > 0 && specText.length > contentWidth) {
+        const wrapped = wrapSegments(segments, contentWidth);
+        addSegments(lineNode, wrapped[0], theme.text, bg);
+        for (let c = 1; c < wrapped.length; c++) {
+          lineNode.add(TextNodeRenderable.fromString("\n", {}));
+          lineNode.add(TextNodeRenderable.fromString(gutterBlank, { fg: theme.textDim }));
+          addSegments(lineNode, wrapped[c], theme.text, bg);
+        }
+      } else {
+        addSegments(lineNode, segments, theme.text, bg);
+      }
     }
 
     // Newline between lines (except last)
@@ -236,8 +279,14 @@ export function countExtraVisualLines(specLines: string[], cursorIndex: number,
 
   let extra = 0;
   let i = 0;
+  let inCode = false;
   while (i < specLines.length) {
-    if (specLines[i].trimStart().startsWith("|")) {
+    if (specLines[i].trimStart().startsWith("```")) {
+      inCode = !inCode;
+      i++;
+      continue;
+    }
+    if (!inCode && specLines[i].trimStart().startsWith("|")) {
       const tableStart = i;
       while (i < specLines.length && specLines[i].trimStart().startsWith("|")) {
         i++;
@@ -250,8 +299,8 @@ export function countExtraVisualLines(specLines: string[], cursorIndex: number,
       if (cursorIndex >= tableEnd) extra++;
       continue;
     }
-    // Word wrap: count extra continuation lines
-    if (contentWidth > 0 && i < cursorIndex && specLines[i].length > contentWidth) {
+    // Word wrap: count extra continuation lines (not in code blocks — those render unwrapped)
+    if (!inCode && contentWidth > 0 && i < cursorIndex && specLines[i].length > contentWidth) {
       extra += wordWrap(specLines[i], contentWidth).length - 1;
     }
     i++;

package/src/tui/search.ts

@@ -1,6 +1,7 @@
 import {
   BoxRenderable,
   InputRenderable,
+  InputRenderableEvents,
   TextRenderable,
   type CliRenderer,
   type KeyEvent,
@@ -12,6 +13,7 @@ export interface SearchOptions {
   specLines: string[];
   cursorLine: number;
   onResult: (lineNumber: number, query: string) => void;
+  onPreview?: (query: string | null) => void;
   onCancel: () => void;
 }
 
@@ -72,6 +74,14 @@ export function createSearch(opts: SearchOptions): SearchOverlay {
     renderer.requestRender();
   }, 0);
 
+  // Incremental search — preview highlights after 3+ characters
+  if (opts.onPreview) {
+    input.on(InputRenderableEvents.INPUT, () => {
+      const raw = input.value.trim();
+      opts.onPreview!(raw.length >= 3 ? raw : null);
+    });
+  }
+
   // Key handler
   const keyHandler = (key: KeyEvent) => {
     if (key.name === "escape") {

package/src/tui/ui/theme.ts

@@ -2,7 +2,7 @@ export const theme = {
   // Surfaces
   base: undefined,
   backgroundPanel: "#313244",
-  backgroundElement: undefined,
+  backgroundElement: "#313244",
 
   // Text hierarchy
   text: "#cdd6f4",
@@ -28,10 +28,10 @@ export const theme = {
 } as const;
 
 export const STATUS_ICONS: Record<string, string> = {
-  open: "\u258c",     // ▌ half block
-  pending: "\u2588",  // █ full block
-  resolved: "=",
-  outdated: "-",
+  open: "\u2588",     // █ full block — white
+  pending: "\u2588",  // █ full block — yellow (unread)
+  resolved: "\u2588", // █ full block — green
+  outdated: "\u2588", // █ full block — dim
 };
 
 export const SPLIT_BORDER = {