revspec 0.6.0 → 0.7.1

package/src/cli/watch.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, renameSync } from "fs";
 import { watch as fsWatch } from "fs";
 import { resolve, dirname, basename, join } from "path";
 import {
@@ -8,6 +8,13 @@ import {
 import type { Thread } from "../protocol/types";
 import { replayEventsToThreads } from "../protocol/live-events";
 
+/** Atomic write: write to .tmp then rename (POSIX rename is atomic) */
+function atomicWriteFileSync(filePath: string, content: string): void {
+  const tmpPath = filePath + ".tmp";
+  writeFileSync(tmpPath, content, "utf8");
+  renameSync(tmpPath, filePath);
+}
+
 export async function runWatch(specFile: string): Promise<void> {
   // Resolve and validate spec path
   const specPath = resolve(specFile);
@@ -19,10 +26,9 @@ export async function runWatch(specFile: string): Promise<void> {
   // Derive paths
   const dir = dirname(specPath);
   const base = basename(specPath, ".md");
-  const jsonlPath = join(dir, `${base}.review.live.jsonl`);
-  const offsetPath = join(dir, `${base}.review.live.offset`);
-  const lockPath = join(dir, `${base}.review.live.lock`);
-  const reviewPath = join(dir, `${base}.review.json`);
+  const jsonlPath = join(dir, `${base}.review.jsonl`);
+  const offsetPath = join(dir, `${base}.review.offset`);
+  const lockPath = join(dir, `${base}.review.lock`);
 
   // Handle lock file
   if (existsSync(lockPath)) {
@@ -46,14 +52,21 @@ export async function runWatch(specFile: string): Promise<void> {
   // Create/overwrite lock with current PID
   writeFileSync(lockPath, String(process.pid), "utf8");
 
-  // Read offset from offset file (or 0)
+  // Read offset and last processed submit timestamp from offset file
   let offset = 0;
+  let lastSubmitTs = 0;
   if (existsSync(offsetPath)) {
-    const raw = readFileSync(offsetPath, "utf8").trim();
-    const parsed = parseInt(raw, 10);
+    const lines = readFileSync(offsetPath, "utf8").trim().split("\n");
+    const parsed = parseInt(lines[0], 10);
     if (!isNaN(parsed)) {
       offset = parsed;
     }
+    if (lines.length > 1) {
+      const parsedTs = parseInt(lines[1], 10);
+      if (!isNaN(parsedTs)) {
+        lastSubmitTs = parsedTs;
+      }
+    }
   }
 
   // Read spec lines for context
@@ -66,14 +79,14 @@ export async function runWatch(specFile: string): Promise<void> {
     const result = processNewEvents(
       jsonlPath,
       offsetPath,
-      lockPath,
-      reviewPath,
       specPath,
       specLines,
-      offset
+      offset,
+      lastSubmitTs,
+      true // always check recovery in non-blocking (one-shot)
     );
     if (result.approved) {
-      console.log(`Review approved.\nReview file: ${reviewPath}`);
+      console.log("Review approved.");
       cleanupFiles(lockPath, offsetPath);
     } else if (result.output) {
       process.stdout.write(result.output);
@@ -83,23 +96,25 @@ export async function runWatch(specFile: string): Promise<void> {
 
   // Blocking mode: watch for JSONL changes
   let processing = false;
+  let firstPoll = true; // only run crash recovery on first poll
 
-  const handleChange = async () => {
+  const handleChange = () => {
     if (processing) return;
     processing = true;
     try {
       const result = processNewEvents(
         jsonlPath,
         offsetPath,
-        lockPath,
-        reviewPath,
         specPath,
         specLines,
-        offset
+        offset,
+        lastSubmitTs,
+        firstPoll
       );
+      firstPoll = false;
 
       if (result.approved) {
-        console.log(`Review approved.\nReview file: ${reviewPath}`);
+        console.log("Review approved.");
         cleanupFiles(lockPath, offsetPath);
         process.exit(0);
       }
@@ -110,8 +125,15 @@ export async function runWatch(specFile: string): Promise<void> {
         process.exit(0);
       }
 
-      // Update offset for next call
+      // Update state for next poll iteration
       offset = result.newOffset;
+      if (existsSync(offsetPath)) {
+        const lines = readFileSync(offsetPath, "utf8").trim().split("\n");
+        if (lines.length > 1) {
+          const parsedTs = parseInt(lines[1], 10);
+          if (!isNaN(parsedTs)) lastSubmitTs = parsedTs;
+        }
+      }
     } finally {
       processing = false;
     }
@@ -135,7 +157,7 @@ export async function runWatch(specFile: string): Promise<void> {
 
   // Also watch the directory for the JSONL file to appear
   const dirWatcher = fsWatch(dir, (eventType, filename) => {
-    if (filename && filename.endsWith(".live.jsonl")) {
+    if (filename && filename.endsWith(".jsonl")) {
       setupWatcher();
     }
   });
@@ -168,11 +190,11 @@ interface ProcessResult {
 function processNewEvents(
   jsonlPath: string,
   offsetPath: string,
-  lockPath: string,
-  reviewPath: string,
   specPath: string,
   specLines: string[],
-  offset: number
+  offset: number,
+  lastSubmitTs: number,
+  checkRecovery: boolean
 ): ProcessResult {
   if (!existsSync(jsonlPath)) {
     return { approved: false, output: "", newOffset: offset };
@@ -180,12 +202,41 @@ function processNewEvents(
 
   const { events, newOffset } = readEventsFromOffset(jsonlPath, offset);
 
+  // Recovery: detect pending unprocessed submit (only on first poll to avoid
+  // re-reading the entire JSONL every 500ms in blocking mode)
+  if (events.length === 0 && checkRecovery) {
+    const { events: allEvents } = readEventsFromOffset(jsonlPath, 0);
+    const lastSubmitIdx = allEvents.findLastIndex(e => e.type === "submit");
+    if (lastSubmitIdx >= 0) {
+      const lastSubmitEvent = allEvents[lastSubmitIdx];
+      // If we already output this submit, skip (not a crash)
+      if (lastSubmitEvent.ts === lastSubmitTs) {
+        return { approved: false, output: "", newOffset: offset };
+      }
+      const afterSubmit = allEvents.slice(lastSubmitIdx + 1);
+      const hasNewActivity = afterSubmit.some(e =>
+        e.type === "comment" || e.type === "reply" ||
+        e.type === "approve" || e.type === "session-end"
+      );
+      if (!hasNewActivity) {
+        const roundStart = findCurrentRoundStartIndex(allEvents);
+        const currentRoundThreads = replayEventsToThreads(allEvents.slice(roundStart));
+        const resolved = currentRoundThreads.filter(t => t.status === "resolved");
+        const output = formatSubmitOutput(resolved, specPath);
+        // Record this submit's ts so we don't re-output it
+        atomicWriteFileSync(offsetPath, `${offset}\n${lastSubmitEvent.ts}`);
+        return { approved: false, output, newOffset: offset };
+      }
+    }
+    return { approved: false, output: "", newOffset: offset };
+  }
+
   if (events.length === 0) {
     return { approved: false, output: "", newOffset: offset };
   }
 
   // Save new offset
-  writeFileSync(offsetPath, String(newOffset), "utf8");
+  atomicWriteFileSync(offsetPath, String(newOffset));
 
   // Check for approve event
   const hasApprove = events.some((e) => e.type === "approve");
@@ -193,6 +244,19 @@ function processNewEvents(
     return { approved: true, output: "", newOffset };
   }
 
+  // Check for submit event — priority over session-end
+  const submitEvent = events.findLast((e) => e.type === "submit");
+  if (submitEvent) {
+    const { events: allEvents } = readEventsFromOffset(jsonlPath, 0);
+    const roundStart = findCurrentRoundStartIndex(allEvents);
+    const currentRoundThreads = replayEventsToThreads(allEvents.slice(roundStart));
+    const resolved = currentRoundThreads.filter(t => t.status === "resolved");
+    const output = formatSubmitOutput(resolved, specPath);
+    // Record submit ts for crash recovery dedup
+    atomicWriteFileSync(offsetPath, `${newOffset}\n${submitEvent.ts}`);
+    return { approved: false, output, newOffset };
+  }
+
   // Check for session-end — TUI exited, break the loop
   const hasSessionEnd = events.some((e) => e.type === "session-end");
   if (hasSessionEnd) {
@@ -233,8 +297,6 @@ function formatWatchOutput(
   // Group events by type
   const newCommentThreadIds: string[] = [];
   const replyThreadIds: string[] = [];
-  const resolvedThreadIds: string[] = [];
-  const deletedThreadIds: string[] = [];
 
   const seen = new Set<string>();
 
@@ -249,14 +311,6 @@ function formatWatchOutput(
       if (!replyThreadIds.includes(tid)) {
         replyThreadIds.push(tid);
       }
-    } else if (event.type === "resolve") {
-      if (!resolvedThreadIds.includes(tid)) {
-        resolvedThreadIds.push(tid);
-      }
-    } else if (event.type === "delete") {
-      if (!deletedThreadIds.includes(tid)) {
-        deletedThreadIds.push(tid);
-      }
     }
   }
 
@@ -315,31 +369,6 @@ function formatWatchOutput(
     }
   }
 
-  // Resolved threads
-  if (resolvedThreadIds.length > 0) {
-    lines.push("=== Resolved ===");
-    for (const tid of resolvedThreadIds) {
-      const thread = threadsById.get(tid);
-      if (!thread) continue;
-      lines.push(`Thread: ${tid} (line ${thread.line}) — resolved`);
-      lines.push("");
-    }
-  }
-
-  // Deleted threads
-  if (deletedThreadIds.length > 0) {
-    lines.push("=== Deleted ===");
-    for (const tid of deletedThreadIds) {
-      const thread = threadsById.get(tid);
-      if (thread) {
-        lines.push(`Thread: ${tid} (line ${thread.line}) — deleted`);
-      } else {
-        lines.push(`Thread: ${tid} — deleted`);
-      }
-      lines.push("");
-    }
-  }
-
   // Add footer instruction
   const hasActionable = newCommentThreadIds.length > 0 || replyThreadIds.length > 0;
   if (hasActionable) {
@@ -368,6 +397,41 @@ function getContext(
   return result;
 }
 
+function findCurrentRoundStartIndex(events: LiveEvent[]): number {
+  let count = 0;
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].type === "submit") {
+      count++;
+      if (count === 2) return i + 1;
+    }
+  }
+  return 0;
+}
+
+function formatSubmitOutput(
+  resolvedThreads: Thread[],
+  specPath: string
+): string {
+  const lines: string[] = [];
+  lines.push("=== Submit: Rewrite Requested ===");
+  lines.push("");
+  if (resolvedThreads.length > 0) {
+    lines.push("Resolved threads:");
+    for (const t of resolvedThreads) {
+      const reviewerMsgs = t.messages.filter(m => m.author === "reviewer");
+      const ownerMsgs = t.messages.filter(m => m.author === "owner");
+      lines.push(`  ${t.id} (line ${t.line}): "${reviewerMsgs.map(m => m.text).join("; ")}"`);
+      if (ownerMsgs.length > 0) {
+        lines.push(`    → AI: "${ownerMsgs.map(m => m.text).join("; ")}"`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(`Rewrite the spec incorporating the above, then run: revspec watch ${basename(specPath)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+
 function cleanupFiles(lockPath: string, offsetPath: string): void {
   if (existsSync(lockPath)) unlinkSync(lockPath);
   if (existsSync(offsetPath)) unlinkSync(offsetPath);

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 {