diffprism 0.12.2 → 0.13.0

package/dist/{chunk-LOX6GE37.js → chunk-TYUDIWD6.js}

@@ -1,10 +1,6 @@
 // packages/core/src/pipeline.ts
-import http from "http";
-import fs from "fs";
-import path3 from "path";
 import getPort from "get-port";
 import open from "open";
-import { fileURLToPath } from "url";
 
 // packages/git/src/local.ts
 import { execSync } from "child_process";
@@ -515,15 +511,15 @@ var CONFIG_PATTERNS = [
   /vite\.config/,
   /vitest\.config/
 ];
-function isTestFile(path4) {
-  return TEST_PATTERNS.some((re) => re.test(path4));
+function isTestFile(path5) {
+  return TEST_PATTERNS.some((re) => re.test(path5));
 }
-function isNonCodeFile(path4) {
-  const ext = path4.slice(path4.lastIndexOf("."));
+function isNonCodeFile(path5) {
+  const ext = path5.slice(path5.lastIndexOf("."));
   return NON_CODE_EXTENSIONS.has(ext);
 }
-function isConfigFile(path4) {
-  return CONFIG_PATTERNS.some((re) => re.test(path4));
+function isConfigFile(path5) {
+  return CONFIG_PATTERNS.some((re) => re.test(path5));
 }
 function detectTestCoverageGaps(files) {
   const filePaths = new Set(files.map((f) => f.path));
@@ -794,7 +790,11 @@ function updateSession(id, update) {
   }
 }
 
-// packages/core/src/pipeline.ts
+// packages/core/src/ui-server.ts
+import http from "http";
+import fs from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -867,6 +867,8 @@ function createStaticServer(distPath, port) {
     server.listen(port, () => resolve(server));
   });
 }
+
+// packages/core/src/pipeline.ts
 async function startReview(options) {
   const { diffRef, title, description, reasoning, cwd, silent, dev } = options;
   const { diffSet, rawDiff } = getDiff(diffRef, { cwd });
@@ -929,6 +931,415 @@ DiffPrism Review: ${title ?? briefing.summary}`);
   }
 }
 
+// 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;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function consumeReviewResult(cwd) {
+  try {
+    const filePath = reviewResultPath(cwd);
+    if (!fs2.existsSync(filePath)) {
+      return;
+    }
+    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 {
+  }
+}
+
+// packages/core/src/watch.ts
+import { createHash } from "crypto";
+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 wss = new WebSocketServer2({ server: httpServer });
+  function sendToClient(msg) {
+    if (client && client.readyState === WebSocket2.OPEN) {
+      client.send(JSON.stringify(msg));
+    }
+  }
+  wss.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;
+          }
+        },
+        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 wss.clients) {
+            ws.close();
+          }
+          wss.close();
+          await new Promise((resolve2) => {
+            httpServer.close(() => resolve2());
+          });
+        }
+      });
+    });
+  });
+}
+
+// packages/core/src/watch.ts
+function hashDiff(rawDiff) {
+  return createHash("sha256").update(rawDiff).digest("hex");
+}
+function detectChangedFiles(oldDiffSet, newDiffSet) {
+  if (!oldDiffSet) {
+    return newDiffSet.files.map((f) => f.path);
+  }
+  const oldFiles = new Map(
+    oldDiffSet.files.map((f) => [f.path, f])
+  );
+  const changed = [];
+  for (const newFile of newDiffSet.files) {
+    const oldFile = oldFiles.get(newFile.path);
+    if (!oldFile) {
+      changed.push(newFile.path);
+    } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
+      changed.push(newFile.path);
+    }
+  }
+  for (const oldFile of oldDiffSet.files) {
+    if (!newDiffSet.files.some((f) => f.path === oldFile.path)) {
+      changed.push(oldFile.path);
+    }
+  }
+  return changed;
+}
+async function startWatch(options) {
+  const {
+    diffRef,
+    title,
+    description,
+    reasoning,
+    cwd,
+    silent,
+    dev,
+    pollInterval = 1e3
+  } = 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,
+    reasoning,
+    currentBranch
+  };
+  const [bridgePort, uiPort] = await Promise.all([
+    getPort2(),
+    getPort2()
+  ]);
+  let refreshRequested = false;
+  const bridge = await createWatchBridge(bridgePort, {
+    onRefreshRequest: () => {
+      refreshRequested = true;
+    },
+    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;
+    }
+  });
+  let httpServer = null;
+  let viteServer = null;
+  if (dev) {
+    const uiRoot = resolveUiRoot();
+    viteServer = await startViteDevServer(uiRoot, uiPort, !!silent);
+  } else {
+    const uiDist = resolveUiDist();
+    httpServer = await createStaticServer(uiDist, uiPort);
+  }
+  writeWatchFile(cwd, {
+    wsPort: bridgePort,
+    uiPort,
+    pid: process.pid,
+    cwd: cwd ?? process.cwd(),
+    diffRef,
+    startedAt: Date.now()
+  });
+  const reviewId = "watch-session";
+  const url = `http://localhost:${uiPort}?wsPort=${bridgePort}&reviewId=${reviewId}`;
+  if (!silent) {
+    console.log(`
+DiffPrism Watch: ${title ?? `watching ${diffRef}`}`);
+    console.log(`Browser: ${url}`);
+    console.log(`API: http://localhost:${bridgePort}`);
+    console.log(`Polling every ${pollInterval}ms
+`);
+  }
+  await open2(url);
+  const initPayload = {
+    reviewId,
+    diffSet: initialDiffSet,
+    rawDiff: initialRawDiff,
+    briefing: initialBriefing,
+    metadata,
+    watchMode: true
+  };
+  bridge.sendInit(initPayload);
+  bridge.onSubmit((result) => {
+    if (!silent) {
+      console.log(`
+Review submitted: ${result.decision}`);
+      if (result.comments.length > 0) {
+        console.log(`  ${result.comments.length} comment(s)`);
+      }
+      console.log("Continuing to watch...\n");
+    }
+    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.sendInit({
+          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`
+          );
+        }
+      }
+    } catch {
+    }
+  }, pollInterval);
+  async function stop() {
+    pollRunning = false;
+    clearInterval(pollLoop);
+    await bridge.close();
+    if (viteServer) {
+      await viteServer.close();
+    }
+    if (httpServer) {
+      httpServer.close();
+    }
+    removeWatchFile(cwd);
+  }
+  function updateContext(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;
+    bridge.sendContextUpdate(payload);
+  }
+  return { stop, updateContext };
+}
+
 export {
-  startReview
+  startReview,
+  readWatchFile,
+  readReviewResult,
+  consumeReviewResult,
+  startWatch
 };

package/dist/mcp-server.js

@@ -1,6 +1,9 @@
 import {
+  consumeReviewResult,
+  readReviewResult,
+  readWatchFile,
   startReview
-} from "./chunk-LOX6GE37.js";
+} from "./chunk-TYUDIWD6.js";
 
 // packages/mcp-server/src/index.ts
 import fs from "fs";
@@ -11,7 +14,7 @@ import { z } from "zod";
 async function startMcpServer() {
   const server = new McpServer({
     name: "diffprism",
-    version: true ? "0.12.2" : "0.0.0-dev"
+    version: true ? "0.13.0" : "0.0.0-dev"
   });
   server.tool(
     "open_review",
@@ -61,6 +64,104 @@ async function startMcpServer() {
       }
     }
   );
+  server.tool(
+    "update_review_context",
+    "Push reasoning/context to a running DiffPrism watch session. Non-blocking \u2014 returns immediately. Use this when `diffprism watch` is running to update the review UI with agent reasoning without opening a new review.",
+    {
+      reasoning: z.string().optional().describe("Agent reasoning about the current changes"),
+      title: z.string().optional().describe("Updated title for the review"),
+      description: z.string().optional().describe("Updated description of the changes")
+    },
+    async ({ reasoning, title, description }) => {
+      try {
+        const watchInfo = readWatchFile();
+        if (!watchInfo) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No DiffPrism watch session is running. Start one with `diffprism watch`."
+              }
+            ]
+          };
+        }
+        const payload = {};
+        if (reasoning !== void 0) payload.reasoning = reasoning;
+        if (title !== void 0) payload.title = title;
+        if (description !== void 0) payload.description = description;
+        const response = await fetch(
+          `http://localhost:${watchInfo.wsPort}/api/context`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload)
+          }
+        );
+        if (!response.ok) {
+          throw new Error(`Watch server returned ${response.status}`);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Context updated in DiffPrism watch session."
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error updating watch context: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_review_result",
+    "Fetch the most recent review result from a DiffPrism watch session. Returns the reviewer's decision and comments if a review has been submitted, or a message indicating no pending result. The result is marked as consumed after retrieval so it won't be returned again.",
+    {},
+    async () => {
+      try {
+        const data = readReviewResult();
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No pending review result."
+              }
+            ]
+          };
+        }
+        consumeReviewResult();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(data.result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error reading review result: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffprism",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "type": "module",
   "description": "Local-first code review tool for agent-generated code changes",
   "bin": {