diffprism 0.27.0 → 0.28.0

package/dist/{chunk-BNCXGE4V.js → chunk-VPIL4KYB.js}

@@ -764,20 +764,222 @@ function analyze(diffSet) {
   };
 }
 
+// packages/core/src/watch-file.ts
+import fs from "fs";
+import path3 from "path";
+import { execSync as execSync2 } from "child_process";
+function findGitRoot(cwd) {
+  const root = execSync2("git rev-parse --show-toplevel", {
+    cwd: cwd ?? process.cwd(),
+    encoding: "utf-8"
+  }).trim();
+  return root;
+}
+function watchFilePath(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  return path3.join(gitRoot, ".diffprism", "watch.json");
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeWatchFile(cwd, info) {
+  const filePath = watchFilePath(cwd);
+  const dir = path3.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(info, null, 2) + "\n");
+}
+function readWatchFile(cwd) {
+  const filePath = watchFilePath(cwd);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const info = JSON.parse(raw);
+    if (!isPidAlive(info.pid)) {
+      fs.unlinkSync(filePath);
+      return null;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+function removeWatchFile(cwd) {
+  try {
+    const filePath = watchFilePath(cwd);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  } catch {
+  }
+}
+function reviewResultPath(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  return path3.join(gitRoot, ".diffprism", "last-review.json");
+}
+function writeReviewResult(cwd, result) {
+  const filePath = reviewResultPath(cwd);
+  const dir = path3.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const data = {
+    result,
+    timestamp: Date.now(),
+    consumed: false
+  };
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function readReviewResult(cwd) {
+  try {
+    const filePath = reviewResultPath(cwd);
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.consumed) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function consumeReviewResult(cwd) {
+  try {
+    const filePath = reviewResultPath(cwd);
+    if (!fs.existsSync(filePath)) {
+      return;
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    data.consumed = true;
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  } catch {
+  }
+}
+
 // packages/core/src/pipeline.ts
 import getPort from "get-port";
 import open from "open";
 
-// packages/core/src/ws-bridge.ts
+// packages/core/src/watch-bridge.ts
+import http from "http";
 import { WebSocketServer, WebSocket } from "ws";
-function createWsBridge(port) {
-  const wss2 = new WebSocketServer({ port });
+function createWatchBridge(port, callbacks) {
   let client = null;
-  let resultResolve = null;
-  let resultReject = null;
-  let pendingInit = null;
   let initPayload = null;
+  let pendingInit = null;
   let closeTimer = null;
+  let submitCallback = null;
+  let resultReject = null;
+  const httpServer = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method === "GET" && req.url === "/api/status") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ running: true, pid: process.pid }));
+      return;
+    }
+    if (req.method === "POST" && req.url === "/api/context") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", () => {
+        try {
+          const payload = JSON.parse(body);
+          callbacks.onContextUpdate(payload);
+          sendToClient({ type: "context:update", payload });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid JSON" }));
+        }
+      });
+      return;
+    }
+    if (req.method === "POST" && req.url === "/api/refresh") {
+      callbacks.onRefreshRequest();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+      return;
+    }
+    const pathname = (req.url ?? "").split("?")[0];
+    if (req.method === "GET" && (pathname === "/api/refs" || /^\/api\/reviews\/[^/]+\/refs$/.test(pathname))) {
+      if (callbacks.onRefsRequest) {
+        const refsPayload = await callbacks.onRefsRequest();
+        if (refsPayload) {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(refsPayload));
+        } else {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Failed to list git refs" }));
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+      return;
+    }
+    if (req.method === "POST" && (pathname === "/api/compare" || /^\/api\/reviews\/[^/]+\/compare$/.test(pathname))) {
+      if (callbacks.onCompareRequest) {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", async () => {
+          try {
+            const { ref } = JSON.parse(body);
+            if (!ref) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Missing ref" }));
+              return;
+            }
+            const success = await callbacks.onCompareRequest(ref);
+            if (success) {
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ ok: true }));
+            } else {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Failed to compute diff" }));
+            }
+          } catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Invalid JSON" }));
+          }
+        });
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  });
+  const wss2 = new WebSocketServer({ server: httpServer });
+  function sendToClient(msg) {
+    if (client && client.readyState === WebSocket.OPEN) {
+      client.send(JSON.stringify(msg));
+    }
+  }
   wss2.on("connection", (ws) => {
     if (closeTimer) {
       clearTimeout(closeTimer);
@@ -786,20 +988,16 @@ function createWsBridge(port) {
     client = ws;
     const payload = pendingInit ?? initPayload;
     if (payload) {
-      const msg = {
-        type: "review:init",
-        payload
-      };
-      ws.send(JSON.stringify(msg));
+      sendToClient({ type: "review:init", payload });
       pendingInit = null;
     }
     ws.on("message", (data) => {
       try {
         const msg = JSON.parse(data.toString());
-        if (msg.type === "review:submit" && resultResolve) {
-          resultResolve(msg.payload);
-          resultResolve = null;
-          resultReject = null;
+        if (msg.type === "review:submit" && submitCallback) {
+          submitCallback(msg.payload);
+        } else if (msg.type === "diff:change_ref" && callbacks.onDiffRefChange) {
+          callbacks.onDiffRefChange(msg.payload.diffRef);
         }
       } catch {
       }
@@ -808,40 +1006,168 @@ function createWsBridge(port) {
       client = null;
       if (resultReject) {
         closeTimer = setTimeout(() => {
+          closeTimer = null;
           if (resultReject) {
             resultReject(new Error("Browser closed before review was submitted"));
-            resultResolve = null;
             resultReject = null;
+            submitCallback = null;
           }
         }, 2e3);
+      } else {
+        closeTimer = setTimeout(() => {
+          closeTimer = null;
+        }, 2e3);
       }
     });
   });
-  return {
-    port,
-    sendInit(payload) {
-      initPayload = payload;
-      if (client && client.readyState === WebSocket.OPEN) {
-        const msg = {
-          type: "review:init",
-          payload
+  return new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(port, () => {
+      resolve({
+        port,
+        sendInit(payload) {
+          initPayload = payload;
+          if (client && client.readyState === WebSocket.OPEN) {
+            sendToClient({ type: "review:init", payload });
+          } else {
+            pendingInit = payload;
+          }
+        },
+        storeInitPayload(payload) {
+          initPayload = payload;
+        },
+        sendDiffUpdate(payload) {
+          sendToClient({ type: "diff:update", payload });
+        },
+        sendContextUpdate(payload) {
+          sendToClient({ type: "context:update", payload });
+        },
+        sendDiffError(payload) {
+          sendToClient({ type: "diff:error", payload });
+        },
+        onSubmit(callback) {
+          submitCallback = callback;
+        },
+        waitForResult() {
+          return new Promise((resolve2, reject2) => {
+            submitCallback = resolve2;
+            resultReject = reject2;
+          });
+        },
+        triggerRefresh() {
+          callbacks.onRefreshRequest();
+        },
+        async close() {
+          if (closeTimer) {
+            clearTimeout(closeTimer);
+          }
+          for (const ws of wss2.clients) {
+            ws.close();
+          }
+          wss2.close();
+          await new Promise((resolve2) => {
+            httpServer.close(() => resolve2());
+          });
+        }
+      });
+    });
+  });
+}
+
+// packages/core/src/diff-utils.ts
+import { createHash } from "crypto";
+function hashDiff(rawDiff) {
+  return createHash("sha256").update(rawDiff).digest("hex");
+}
+function fileKey(file) {
+  return file.stage ? `${file.stage}:${file.path}` : file.path;
+}
+function detectChangedFiles(oldDiffSet, newDiffSet) {
+  if (!oldDiffSet) {
+    return newDiffSet.files.map(fileKey);
+  }
+  const oldFiles = new Map(
+    oldDiffSet.files.map((f) => [fileKey(f), f])
+  );
+  const changed = [];
+  for (const newFile of newDiffSet.files) {
+    const key = fileKey(newFile);
+    const oldFile = oldFiles.get(key);
+    if (!oldFile) {
+      changed.push(key);
+    } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
+      changed.push(key);
+    }
+  }
+  for (const oldFile of oldDiffSet.files) {
+    if (!newDiffSet.files.some((f) => fileKey(f) === fileKey(oldFile))) {
+      changed.push(fileKey(oldFile));
+    }
+  }
+  return changed;
+}
+
+// packages/core/src/diff-poller.ts
+function createDiffPoller(options) {
+  let { diffRef } = options;
+  const { cwd, pollInterval, onDiffChanged, onError, silent } = options;
+  let lastDiffHash = null;
+  let lastDiffSet = null;
+  let refreshRequested = false;
+  let interval = null;
+  let running = false;
+  function poll() {
+    if (!running) return;
+    try {
+      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(diffRef, { cwd });
+      const newHash = hashDiff(newRawDiff);
+      if (newHash !== lastDiffHash || refreshRequested) {
+        refreshRequested = false;
+        const newBriefing = analyze(newDiffSet);
+        const changedFiles = detectChangedFiles(lastDiffSet, newDiffSet);
+        lastDiffHash = newHash;
+        lastDiffSet = newDiffSet;
+        const updatePayload = {
+          diffSet: newDiffSet,
+          rawDiff: newRawDiff,
+          briefing: newBriefing,
+          changedFiles,
+          timestamp: Date.now()
         };
-        client.send(JSON.stringify(msg));
-      } else {
-        pendingInit = payload;
+        onDiffChanged(updatePayload);
       }
+    } catch (err) {
+      if (onError && err instanceof Error) {
+        onError(err);
+      }
+    }
+  }
+  return {
+    start() {
+      if (running) return;
+      running = true;
+      try {
+        const { diffSet: initialDiffSet, rawDiff: initialRawDiff } = getDiff(diffRef, { cwd });
+        lastDiffHash = hashDiff(initialRawDiff);
+        lastDiffSet = initialDiffSet;
+      } catch {
+      }
+      interval = setInterval(poll, pollInterval);
     },
-    waitForResult() {
-      return new Promise((resolve, reject) => {
-        resultResolve = resolve;
-        resultReject = reject;
-      });
-    },
-    close() {
-      for (const ws of wss2.clients) {
-        ws.close();
+    stop() {
+      running = false;
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
       }
-      wss2.close();
+    },
+    setDiffRef(newRef) {
+      diffRef = newRef;
+      lastDiffHash = null;
+      lastDiffSet = null;
+    },
+    refresh() {
+      refreshRequested = true;
     }
   };
 }
@@ -868,9 +1194,9 @@ function updateSession(id, update) {
 }
 
 // packages/core/src/ui-server.ts
-import http from "http";
-import fs from "fs";
-import path3 from "path";
+import http2 from "http";
+import fs2 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 var MIME_TYPES = {
   ".html": "text/html",
@@ -885,14 +1211,14 @@ var MIME_TYPES = {
 };
 function resolveUiDist() {
   const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path3.dirname(thisFile);
-  const publishedUiDist = path3.resolve(thisDir, "..", "ui-dist");
-  if (fs.existsSync(path3.join(publishedUiDist, "index.html"))) {
+  const thisDir = path4.dirname(thisFile);
+  const publishedUiDist = path4.resolve(thisDir, "..", "ui-dist");
+  if (fs2.existsSync(path4.join(publishedUiDist, "index.html"))) {
     return publishedUiDist;
   }
-  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
-  const devUiDist = path3.join(workspaceRoot, "packages", "ui", "dist");
-  if (fs.existsSync(path3.join(devUiDist, "index.html"))) {
+  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
+  const devUiDist = path4.join(workspaceRoot, "packages", "ui", "dist");
+  if (fs2.existsSync(path4.join(devUiDist, "index.html"))) {
     return devUiDist;
   }
   throw new Error(
@@ -901,10 +1227,10 @@ function resolveUiDist() {
 }
 function resolveUiRoot() {
   const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path3.dirname(thisFile);
-  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
-  const uiRoot = path3.join(workspaceRoot, "packages", "ui");
-  if (fs.existsSync(path3.join(uiRoot, "index.html"))) {
+  const thisDir = path4.dirname(thisFile);
+  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
+  const uiRoot = path4.join(workspaceRoot, "packages", "ui");
+  if (fs2.existsSync(path4.join(uiRoot, "index.html"))) {
     return uiRoot;
   }
   throw new Error(
@@ -922,16 +1248,16 @@ async function startViteDevServer(uiRoot, port, silent) {
   return vite;
 }
 function createStaticServer(distPath, port) {
-  const server = http.createServer((req, res) => {
+  const server = http2.createServer((req, res) => {
     const urlPath = req.url?.split("?")[0] ?? "/";
-    let filePath = path3.join(distPath, urlPath === "/" ? "index.html" : urlPath);
-    if (!fs.existsSync(filePath)) {
-      filePath = path3.join(distPath, "index.html");
+    let filePath = path4.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+    if (!fs2.existsSync(filePath)) {
+      filePath = path4.join(distPath, "index.html");
     }
-    const ext = path3.extname(filePath);
+    const ext = path4.extname(filePath);
     const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
     try {
-      const content = fs.readFileSync(filePath);
+      const content = fs2.readFileSync(filePath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch {
@@ -963,11 +1289,75 @@ async function startReview(options) {
   const briefing = analyze(diffSet);
   const session = createSession(options);
   updateSession(session.id, { status: "in_progress" });
-  const [wsPort, httpPort] = await Promise.all([
+  const metadata = {
+    title,
+    description,
+    reasoning,
+    currentBranch
+  };
+  let poller = null;
+  const [bridgePort, httpPort] = await Promise.all([
     getPort(),
     getPort()
   ]);
-  const bridge = createWsBridge(wsPort);
+  function handleDiffRefChange(newRef) {
+    const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, { cwd });
+    const newBriefing = analyze(newDiffSet);
+    bridge.sendDiffUpdate({
+      diffSet: newDiffSet,
+      rawDiff: newRawDiff,
+      briefing: newBriefing,
+      changedFiles: newDiffSet.files.map((f) => f.path),
+      timestamp: Date.now()
+    });
+    bridge.storeInitPayload({
+      reviewId: session.id,
+      diffSet: newDiffSet,
+      rawDiff: newRawDiff,
+      briefing: newBriefing,
+      metadata,
+      watchMode: true
+    });
+    poller?.setDiffRef(newRef);
+  }
+  const bridge = await createWatchBridge(bridgePort, {
+    onRefreshRequest: () => {
+      poller?.refresh();
+    },
+    onContextUpdate: (payload) => {
+      if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
+      if (payload.title !== void 0) metadata.title = payload.title;
+      if (payload.description !== void 0) metadata.description = payload.description;
+    },
+    onDiffRefChange: (newRef) => {
+      try {
+        handleDiffRefChange(newRef);
+      } catch (err) {
+        bridge.sendDiffError({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
+    onRefsRequest: async () => {
+      try {
+        const resolvedCwd = cwd ?? process.cwd();
+        const branches = listBranches({ cwd: resolvedCwd });
+        const commits = listCommits({ cwd: resolvedCwd });
+        const branch = getCurrentBranch({ cwd: resolvedCwd });
+        return { branches, commits, currentBranch: branch };
+      } catch {
+        return null;
+      }
+    },
+    onCompareRequest: async (ref) => {
+      try {
+        handleDiffRefChange(ref);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  });
   let httpServer = null;
   let viteServer = null;
   try {
@@ -978,7 +1368,15 @@ async function startReview(options) {
       const uiDist = resolveUiDist();
       httpServer = await createStaticServer(uiDist, httpPort);
     }
-    const url = `http://localhost:${httpPort}?wsPort=${wsPort}&reviewId=${session.id}`;
+    writeWatchFile(cwd, {
+      wsPort: bridgePort,
+      uiPort: httpPort,
+      pid: process.pid,
+      cwd: cwd ?? process.cwd(),
+      diffRef,
+      startedAt: Date.now()
+    });
+    const url = `http://localhost:${httpPort}?wsPort=${bridgePort}&httpPort=${bridgePort}&reviewId=${session.id}`;
     if (!silent) {
       console.log(`
 DiffPrism Review: ${title ?? briefing.summary}`);
@@ -991,124 +1389,46 @@ DiffPrism Review: ${title ?? briefing.summary}`);
       diffSet,
       rawDiff,
       briefing,
-      metadata: { title, description, reasoning, currentBranch }
+      metadata,
+      watchMode: true
     };
     bridge.sendInit(initPayload);
+    poller = createDiffPoller({
+      diffRef,
+      cwd: cwd ?? process.cwd(),
+      pollInterval: 1e3,
+      onDiffChanged: (updatePayload) => {
+        bridge.storeInitPayload({
+          reviewId: session.id,
+          diffSet: updatePayload.diffSet,
+          rawDiff: updatePayload.rawDiff,
+          briefing: updatePayload.briefing,
+          metadata,
+          watchMode: true
+        });
+        bridge.sendDiffUpdate(updatePayload);
+        if (!silent && updatePayload.changedFiles.length > 0) {
+          console.log(
+            `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${updatePayload.changedFiles.length} file(s) changed`
+          );
+        }
+      }
+    });
+    poller.start();
     const result = await bridge.waitForResult();
+    poller.stop();
     updateSession(session.id, { status: "completed", result });
     return result;
   } finally {
-    bridge.close();
+    poller?.stop();
+    await bridge.close();
+    removeWatchFile(cwd);
     if (viteServer) {
-      await viteServer.close();
-    }
-    if (httpServer) {
-      httpServer.close();
-    }
-  }
-}
-
-// packages/core/src/watch-file.ts
-import fs2 from "fs";
-import path4 from "path";
-import { execSync as execSync2 } from "child_process";
-function findGitRoot(cwd) {
-  const root = execSync2("git rev-parse --show-toplevel", {
-    cwd: cwd ?? process.cwd(),
-    encoding: "utf-8"
-  }).trim();
-  return root;
-}
-function watchFilePath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path4.join(gitRoot, ".diffprism", "watch.json");
-}
-function isPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function writeWatchFile(cwd, info) {
-  const filePath = watchFilePath(cwd);
-  const dir = path4.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  fs2.writeFileSync(filePath, JSON.stringify(info, null, 2) + "\n");
-}
-function readWatchFile(cwd) {
-  const filePath = watchFilePath(cwd);
-  if (!fs2.existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const info = JSON.parse(raw);
-    if (!isPidAlive(info.pid)) {
-      fs2.unlinkSync(filePath);
-      return null;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function removeWatchFile(cwd) {
-  try {
-    const filePath = watchFilePath(cwd);
-    if (fs2.existsSync(filePath)) {
-      fs2.unlinkSync(filePath);
-    }
-  } catch {
-  }
-}
-function reviewResultPath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path4.join(gitRoot, ".diffprism", "last-review.json");
-}
-function writeReviewResult(cwd, result) {
-  const filePath = reviewResultPath(cwd);
-  const dir = path4.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  const data = {
-    result,
-    timestamp: Date.now(),
-    consumed: false
-  };
-  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-}
-function readReviewResult(cwd) {
-  try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs2.existsSync(filePath)) {
-      return null;
-    }
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    if (data.consumed) {
-      return null;
+      await viteServer.close();
     }
-    return data;
-  } catch {
-    return null;
-  }
-}
-function consumeReviewResult(cwd) {
-  try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs2.existsSync(filePath)) {
-      return;
+    if (httpServer) {
+      httpServer.close();
     }
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    data.consumed = true;
-    fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-  } catch {
   }
 }
 
@@ -1185,170 +1505,6 @@ async function isServerAlive() {
 // packages/core/src/watch.ts
 import getPort2 from "get-port";
 import open2 from "open";
-
-// packages/core/src/watch-bridge.ts
-import http2 from "http";
-import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket2 } from "ws";
-function createWatchBridge(port, callbacks) {
-  let client = null;
-  let initPayload = null;
-  let pendingInit = null;
-  let closeTimer = null;
-  let submitCallback = null;
-  const httpServer = http2.createServer((req, res) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    if (req.method === "GET" && req.url === "/api/status") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ running: true, pid: process.pid }));
-      return;
-    }
-    if (req.method === "POST" && req.url === "/api/context") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk.toString();
-      });
-      req.on("end", () => {
-        try {
-          const payload = JSON.parse(body);
-          callbacks.onContextUpdate(payload);
-          sendToClient({ type: "context:update", payload });
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: true }));
-        } catch {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Invalid JSON" }));
-        }
-      });
-      return;
-    }
-    if (req.method === "POST" && req.url === "/api/refresh") {
-      callbacks.onRefreshRequest();
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true }));
-      return;
-    }
-    res.writeHead(404);
-    res.end("Not found");
-  });
-  const wss2 = new WebSocketServer2({ server: httpServer });
-  function sendToClient(msg) {
-    if (client && client.readyState === WebSocket2.OPEN) {
-      client.send(JSON.stringify(msg));
-    }
-  }
-  wss2.on("connection", (ws) => {
-    if (closeTimer) {
-      clearTimeout(closeTimer);
-      closeTimer = null;
-    }
-    client = ws;
-    const payload = pendingInit ?? initPayload;
-    if (payload) {
-      sendToClient({ type: "review:init", payload });
-      pendingInit = null;
-    }
-    ws.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "review:submit" && submitCallback) {
-          submitCallback(msg.payload);
-        }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      client = null;
-      closeTimer = setTimeout(() => {
-        closeTimer = null;
-      }, 2e3);
-    });
-  });
-  return new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, () => {
-      resolve({
-        port,
-        sendInit(payload) {
-          initPayload = payload;
-          if (client && client.readyState === WebSocket2.OPEN) {
-            sendToClient({ type: "review:init", payload });
-          } else {
-            pendingInit = payload;
-          }
-        },
-        storeInitPayload(payload) {
-          initPayload = payload;
-        },
-        sendDiffUpdate(payload) {
-          sendToClient({ type: "diff:update", payload });
-        },
-        sendContextUpdate(payload) {
-          sendToClient({ type: "context:update", payload });
-        },
-        onSubmit(callback) {
-          submitCallback = callback;
-        },
-        triggerRefresh() {
-          callbacks.onRefreshRequest();
-        },
-        async close() {
-          if (closeTimer) {
-            clearTimeout(closeTimer);
-          }
-          for (const ws of wss2.clients) {
-            ws.close();
-          }
-          wss2.close();
-          await new Promise((resolve2) => {
-            httpServer.close(() => resolve2());
-          });
-        }
-      });
-    });
-  });
-}
-
-// packages/core/src/diff-utils.ts
-import { createHash } from "crypto";
-function hashDiff(rawDiff) {
-  return createHash("sha256").update(rawDiff).digest("hex");
-}
-function fileKey(file) {
-  return file.stage ? `${file.stage}:${file.path}` : file.path;
-}
-function detectChangedFiles(oldDiffSet, newDiffSet) {
-  if (!oldDiffSet) {
-    return newDiffSet.files.map(fileKey);
-  }
-  const oldFiles = new Map(
-    oldDiffSet.files.map((f) => [fileKey(f), f])
-  );
-  const changed = [];
-  for (const newFile of newDiffSet.files) {
-    const key = fileKey(newFile);
-    const oldFile = oldFiles.get(key);
-    if (!oldFile) {
-      changed.push(key);
-    } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
-      changed.push(key);
-    }
-  }
-  for (const oldFile of oldDiffSet.files) {
-    if (!newDiffSet.files.some((f) => fileKey(f) === fileKey(oldFile))) {
-      changed.push(fileKey(oldFile));
-    }
-  }
-  return changed;
-}
-
-// packages/core/src/watch.ts
 async function startWatch(options) {
   const {
     diffRef,
@@ -1363,8 +1519,6 @@ async function startWatch(options) {
   const { diffSet: initialDiffSet, rawDiff: initialRawDiff } = getDiff(diffRef, { cwd });
   const currentBranch = getCurrentBranch({ cwd });
   const initialBriefing = analyze(initialDiffSet);
-  let lastDiffHash = hashDiff(initialRawDiff);
-  let lastDiffSet = initialDiffSet;
   const metadata = {
     title,
     description,
@@ -1375,15 +1529,63 @@ async function startWatch(options) {
     getPort2(),
     getPort2()
   ]);
-  let refreshRequested = false;
+  const reviewId = "watch-session";
+  function handleDiffRefChange(newRef) {
+    const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, { cwd });
+    const newBriefing = analyze(newDiffSet);
+    bridge.sendDiffUpdate({
+      diffSet: newDiffSet,
+      rawDiff: newRawDiff,
+      briefing: newBriefing,
+      changedFiles: newDiffSet.files.map((f) => f.path),
+      timestamp: Date.now()
+    });
+    bridge.storeInitPayload({
+      reviewId,
+      diffSet: newDiffSet,
+      rawDiff: newRawDiff,
+      briefing: newBriefing,
+      metadata,
+      watchMode: true
+    });
+    poller.setDiffRef(newRef);
+  }
   const bridge = await createWatchBridge(bridgePort, {
     onRefreshRequest: () => {
-      refreshRequested = true;
+      poller.refresh();
     },
     onContextUpdate: (payload) => {
       if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
       if (payload.title !== void 0) metadata.title = payload.title;
       if (payload.description !== void 0) metadata.description = payload.description;
+    },
+    onDiffRefChange: (newRef) => {
+      try {
+        handleDiffRefChange(newRef);
+      } catch (err) {
+        bridge.sendDiffError({
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
+    onRefsRequest: async () => {
+      try {
+        const resolvedCwd = cwd ?? process.cwd();
+        const branches = listBranches({ cwd: resolvedCwd });
+        const commits = listCommits({ cwd: resolvedCwd });
+        const branch = getCurrentBranch({ cwd: resolvedCwd });
+        return { branches, commits, currentBranch: branch };
+      } catch {
+        return null;
+      }
+    },
+    onCompareRequest: async (ref) => {
+      try {
+        handleDiffRefChange(ref);
+        return true;
+      } catch {
+        return false;
+      }
     }
   });
   let httpServer = null;
@@ -1403,8 +1605,7 @@ async function startWatch(options) {
     diffRef,
     startedAt: Date.now()
   });
-  const reviewId = "watch-session";
-  const url = `http://localhost:${uiPort}?wsPort=${bridgePort}&reviewId=${reviewId}`;
+  const url = `http://localhost:${uiPort}?wsPort=${bridgePort}&httpPort=${bridgePort}&reviewId=${reviewId}`;
   if (!silent) {
     console.log(`
 DiffPrism Watch: ${title ?? `watching ${diffRef}`}`);
@@ -1434,46 +1635,30 @@ Review submitted: ${result.decision}`);
     }
     writeReviewResult(cwd, result);
   });
-  let pollRunning = true;
-  const pollLoop = setInterval(() => {
-    if (!pollRunning) return;
-    try {
-      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(diffRef, { cwd });
-      const newHash = hashDiff(newRawDiff);
-      if (newHash !== lastDiffHash || refreshRequested) {
-        refreshRequested = false;
-        const newBriefing = analyze(newDiffSet);
-        const changedFiles = detectChangedFiles(lastDiffSet, newDiffSet);
-        lastDiffHash = newHash;
-        lastDiffSet = newDiffSet;
-        bridge.storeInitPayload({
-          reviewId,
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing,
-          metadata,
-          watchMode: true
-        });
-        const updatePayload = {
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing,
-          changedFiles,
-          timestamp: Date.now()
-        };
-        bridge.sendDiffUpdate(updatePayload);
-        if (!silent && changedFiles.length > 0) {
-          console.log(
-            `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${changedFiles.length} file(s) changed`
-          );
-        }
+  const poller = createDiffPoller({
+    diffRef,
+    cwd: cwd ?? process.cwd(),
+    pollInterval,
+    onDiffChanged: (updatePayload) => {
+      bridge.storeInitPayload({
+        reviewId,
+        diffSet: updatePayload.diffSet,
+        rawDiff: updatePayload.rawDiff,
+        briefing: updatePayload.briefing,
+        metadata,
+        watchMode: true
+      });
+      bridge.sendDiffUpdate(updatePayload);
+      if (!silent && updatePayload.changedFiles.length > 0) {
+        console.log(
+          `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${updatePayload.changedFiles.length} file(s) changed`
+        );
       }
-    } catch {
     }
-  }, pollInterval);
+  });
+  poller.start();
   async function stop() {
-    pollRunning = false;
-    clearInterval(pollLoop);
+    poller.stop();
     await bridge.close();
     if (viteServer) {
       await viteServer.close();
@@ -1497,7 +1682,7 @@ import http3 from "http";
 import { randomUUID } from "crypto";
 import getPort3 from "get-port";
 import open3 from "open";
-import { WebSocketServer as WebSocketServer3, WebSocket as WebSocket3 } from "ws";
+import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket2 } from "ws";
 var SUBMITTED_TTL_MS = 5 * 60 * 1e3;
 var ABANDONED_TTL_MS = 60 * 60 * 1e3;
 var CLEANUP_INTERVAL_MS = 60 * 1e3;
@@ -1563,7 +1748,7 @@ function broadcastToAll(msg) {
   if (!wss) return;
   const data = JSON.stringify(msg);
   for (const client of wss.clients) {
-    if (client.readyState === WebSocket3.OPEN) {
+    if (client.readyState === WebSocket2.OPEN) {
       client.send(data);
     }
   }
@@ -1572,7 +1757,7 @@ function sendToSessionClients(sessionId, msg) {
   if (!wss) return;
   const data = JSON.stringify(msg);
   for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId && client.readyState === WebSocket3.OPEN) {
+    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
       client.send(data);
     }
   }
@@ -1596,7 +1781,7 @@ function broadcastSessionRemoved(sessionId) {
 }
 function hasViewersForSession(sessionId) {
   for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId && client.readyState === WebSocket3.OPEN) {
+    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
       return true;
     }
   }
@@ -1606,54 +1791,40 @@ function startSessionWatcher(sessionId) {
   if (sessionWatchers.has(sessionId)) return;
   const session = sessions2.get(sessionId);
   if (!session?.diffRef) return;
-  const interval = setInterval(() => {
-    const s = sessions2.get(sessionId);
-    if (!s?.diffRef) {
-      stopSessionWatcher(sessionId);
-      return;
-    }
-    try {
-      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(s.diffRef, {
-        cwd: s.projectPath
-      });
-      const newHash = hashDiff(newRawDiff);
-      if (newHash !== s.lastDiffHash) {
-        const newBriefing = analyze(newDiffSet);
-        const changedFiles = detectChangedFiles(s.lastDiffSet ?? null, newDiffSet);
-        s.payload = {
-          ...s.payload,
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing
-        };
-        s.lastDiffHash = newHash;
-        s.lastDiffSet = newDiffSet;
-        if (hasViewersForSession(sessionId)) {
-          sendToSessionClients(sessionId, {
-            type: "diff:update",
-            payload: {
-              diffSet: newDiffSet,
-              rawDiff: newRawDiff,
-              briefing: newBriefing,
-              changedFiles,
-              timestamp: Date.now()
-            }
-          });
-          s.hasNewChanges = false;
-        } else {
-          s.hasNewChanges = true;
-          broadcastSessionList();
-        }
+  const poller = createDiffPoller({
+    diffRef: session.diffRef,
+    cwd: session.projectPath,
+    pollInterval: serverPollInterval,
+    onDiffChanged: (updatePayload) => {
+      const s = sessions2.get(sessionId);
+      if (!s) return;
+      s.payload = {
+        ...s.payload,
+        diffSet: updatePayload.diffSet,
+        rawDiff: updatePayload.rawDiff,
+        briefing: updatePayload.briefing
+      };
+      s.lastDiffHash = hashDiff(updatePayload.rawDiff);
+      s.lastDiffSet = updatePayload.diffSet;
+      if (hasViewersForSession(sessionId)) {
+        sendToSessionClients(sessionId, {
+          type: "diff:update",
+          payload: updatePayload
+        });
+        s.hasNewChanges = false;
+      } else {
+        s.hasNewChanges = true;
+        broadcastSessionList();
       }
-    } catch {
     }
-  }, serverPollInterval);
-  sessionWatchers.set(sessionId, interval);
+  });
+  poller.start();
+  sessionWatchers.set(sessionId, poller);
 }
 function stopSessionWatcher(sessionId) {
-  const interval = sessionWatchers.get(sessionId);
-  if (interval) {
-    clearInterval(interval);
+  const poller = sessionWatchers.get(sessionId);
+  if (poller) {
+    poller.stop();
     sessionWatchers.delete(sessionId);
   }
 }
@@ -1665,15 +1836,15 @@ function startAllWatchers() {
   }
 }
 function stopAllWatchers() {
-  for (const [id, interval] of sessionWatchers.entries()) {
-    clearInterval(interval);
+  for (const [, poller] of sessionWatchers.entries()) {
+    poller.stop();
   }
   sessionWatchers.clear();
 }
 function hasConnectedClients() {
   if (!wss) return false;
   for (const client of wss.clients) {
-    if (client.readyState === WebSocket3.OPEN) return true;
+    if (client.readyState === WebSocket2.OPEN) return true;
   }
   return false;
 }
@@ -1968,7 +2139,7 @@ async function startGlobalServer(options = {}) {
       res.end("Not found");
     }
   });
-  wss = new WebSocketServer3({ port: wsPort });
+  wss = new WebSocketServer2({ port: wsPort });
   wss.on("connection", (ws, req) => {
     startAllWatchers();
     const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
@@ -2046,6 +2217,49 @@ async function startGlobalServer(options = {}) {
             closedSession.status = "submitted";
           }
           broadcastSessionRemoved(closedId);
+        } else if (msg.type === "diff:change_ref") {
+          const sid = clientSessions.get(ws);
+          if (sid) {
+            const session = sessions2.get(sid);
+            if (session) {
+              const newRef = msg.payload.diffRef;
+              try {
+                const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, {
+                  cwd: session.projectPath
+                });
+                const newBriefing = analyze(newDiffSet);
+                session.payload = {
+                  ...session.payload,
+                  diffSet: newDiffSet,
+                  rawDiff: newRawDiff,
+                  briefing: newBriefing
+                };
+                session.diffRef = newRef;
+                session.lastDiffHash = hashDiff(newRawDiff);
+                session.lastDiffSet = newDiffSet;
+                stopSessionWatcher(sid);
+                startSessionWatcher(sid);
+                sendToSessionClients(sid, {
+                  type: "diff:update",
+                  payload: {
+                    diffSet: newDiffSet,
+                    rawDiff: newRawDiff,
+                    briefing: newBriefing,
+                    changedFiles: newDiffSet.files.map((f) => f.path),
+                    timestamp: Date.now()
+                  }
+                });
+              } catch (err) {
+                const errorMsg = {
+                  type: "diff:error",
+                  payload: {
+                    error: err instanceof Error ? err.message : String(err)
+                  }
+                };
+                ws.send(JSON.stringify(errorMsg));
+              }
+            }
+          }
         }
       } catch {
       }
@@ -2130,10 +2344,10 @@ export {
   getCurrentBranch,
   getDiff,
   analyze,
-  startReview,
   readWatchFile,
   readReviewResult,
   consumeReviewResult,
+  startReview,
   startWatch,
   readServerFile,
   isServerAlive,