diffprism 0.13.8 → 0.15.0

package/dist/{chunk-QB2PKDLU.js → chunk-NGHUHDAM.js}

@@ -303,6 +303,9 @@ function parseDiff(rawDiff, baseRef, headRef) {
 
 // packages/git/src/index.ts
 function getDiff(ref, options) {
+  if (ref === "working-copy") {
+    return getWorkingCopyDiff(options);
+  }
   const rawDiff = getGitDiff(ref, options);
   let baseRef;
   let headRef;
@@ -323,6 +326,29 @@ function getDiff(ref, options) {
   const diffSet = parseDiff(rawDiff, baseRef, headRef);
   return { diffSet, rawDiff };
 }
+function getWorkingCopyDiff(options) {
+  const stagedRaw = getGitDiff("staged", options);
+  const unstagedRaw = getGitDiff("unstaged", options);
+  const stagedDiffSet = parseDiff(stagedRaw, "HEAD", "staged");
+  const unstagedDiffSet = parseDiff(unstagedRaw, "staged", "working tree");
+  const stagedFiles = stagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "staged"
+  }));
+  const unstagedFiles = unstagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "unstaged"
+  }));
+  const rawDiff = [stagedRaw, unstagedRaw].filter(Boolean).join("");
+  return {
+    diffSet: {
+      baseRef: "HEAD",
+      headRef: "working tree",
+      files: [...stagedFiles, ...unstagedFiles]
+    },
+    rawDiff
+  };
+}
 
 // packages/analysis/src/deterministic.ts
 function categorizeFiles(files) {
@@ -511,15 +537,15 @@ var CONFIG_PATTERNS = [
   /vite\.config/,
   /vitest\.config/
 ];
-function isTestFile(path5) {
-  return TEST_PATTERNS.some((re) => re.test(path5));
+function isTestFile(path6) {
+  return TEST_PATTERNS.some((re) => re.test(path6));
 }
-function isNonCodeFile(path5) {
-  const ext = path5.slice(path5.lastIndexOf("."));
+function isNonCodeFile(path6) {
+  const ext = path6.slice(path6.lastIndexOf("."));
   return NON_CODE_EXTENSIONS.has(ext);
 }
-function isConfigFile(path5) {
-  return CONFIG_PATTERNS.some((re) => re.test(path5));
+function isConfigFile(path6) {
+  return CONFIG_PATTERNS.some((re) => re.test(path6));
 }
 function detectTestCoverageGaps(files) {
   const filePaths = new Set(files.map((f) => f.path));
@@ -694,14 +720,14 @@ function analyze(diffSet) {
 // packages/core/src/ws-bridge.ts
 import { WebSocketServer, WebSocket } from "ws";
 function createWsBridge(port) {
-  const wss = new WebSocketServer({ port });
+  const wss2 = new WebSocketServer({ port });
   let client = null;
   let resultResolve = null;
   let resultReject = null;
   let pendingInit = null;
   let initPayload = null;
   let closeTimer = null;
-  wss.on("connection", (ws) => {
+  wss2.on("connection", (ws) => {
     if (closeTimer) {
       clearTimeout(closeTimer);
       closeTimer = null;
@@ -761,10 +787,10 @@ function createWsBridge(port) {
       });
     },
     close() {
-      for (const ws of wss.clients) {
+      for (const ws of wss2.clients) {
         ws.close();
       }
-      wss.close();
+      wss2.close();
     }
   };
 }
@@ -1091,13 +1117,13 @@ function createWatchBridge(port, callbacks) {
     res.writeHead(404);
     res.end("Not found");
   });
-  const wss = new WebSocketServer2({ server: httpServer });
+  const wss2 = new WebSocketServer2({ server: httpServer });
   function sendToClient(msg) {
     if (client && client.readyState === WebSocket2.OPEN) {
       client.send(JSON.stringify(msg));
     }
   }
-  wss.on("connection", (ws) => {
+  wss2.on("connection", (ws) => {
     if (closeTimer) {
       clearTimeout(closeTimer);
       closeTimer = null;
@@ -1156,10 +1182,10 @@ function createWatchBridge(port, callbacks) {
           if (closeTimer) {
             clearTimeout(closeTimer);
           }
-          for (const ws of wss.clients) {
+          for (const ws of wss2.clients) {
             ws.close();
           }
-          wss.close();
+          wss2.close();
           await new Promise((resolve2) => {
             httpServer.close(() => resolve2());
           });
@@ -1173,25 +1199,29 @@ function createWatchBridge(port, callbacks) {
 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((f) => f.path);
+    return newDiffSet.files.map(fileKey);
   }
   const oldFiles = new Map(
-    oldDiffSet.files.map((f) => [f.path, f])
+    oldDiffSet.files.map((f) => [fileKey(f), f])
   );
   const changed = [];
   for (const newFile of newDiffSet.files) {
-    const oldFile = oldFiles.get(newFile.path);
+    const key = fileKey(newFile);
+    const oldFile = oldFiles.get(key);
     if (!oldFile) {
-      changed.push(newFile.path);
+      changed.push(key);
     } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
-      changed.push(newFile.path);
+      changed.push(key);
     }
   }
   for (const oldFile of oldDiffSet.files) {
-    if (!newDiffSet.files.some((f) => f.path === oldFile.path)) {
-      changed.push(oldFile.path);
+    if (!newDiffSet.files.some((f) => fileKey(f) === fileKey(oldFile))) {
+      changed.push(fileKey(oldFile));
     }
   }
   return changed;
@@ -1339,10 +1369,412 @@ Review submitted: ${result.decision}`);
   return { stop, updateContext };
 }
 
+// packages/core/src/global-server.ts
+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";
+
+// packages/core/src/server-file.ts
+import fs3 from "fs";
+import path5 from "path";
+import os from "os";
+function serverDir() {
+  return path5.join(os.homedir(), ".diffprism");
+}
+function serverFilePath() {
+  return path5.join(serverDir(), "server.json");
+}
+function isPidAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeServerFile(info) {
+  const dir = serverDir();
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
+}
+function readServerFile() {
+  const filePath = serverFilePath();
+  if (!fs3.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const info = JSON.parse(raw);
+    if (!isPidAlive2(info.pid)) {
+      fs3.unlinkSync(filePath);
+      return null;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+function removeServerFile() {
+  try {
+    const filePath = serverFilePath();
+    if (fs3.existsSync(filePath)) {
+      fs3.unlinkSync(filePath);
+    }
+  } catch {
+  }
+}
+async function isServerAlive() {
+  const info = readServerFile();
+  if (!info) {
+    return null;
+  }
+  try {
+    const response = await fetch(`http://localhost:${info.httpPort}/api/status`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (response.ok) {
+      return info;
+    }
+    return null;
+  } catch {
+    removeServerFile();
+    return null;
+  }
+}
+
+// packages/core/src/global-server.ts
+var sessions2 = /* @__PURE__ */ new Map();
+var clientSessions = /* @__PURE__ */ new Map();
+function toSummary(session) {
+  const { payload } = session;
+  const fileCount = payload.diffSet.files.length;
+  let additions = 0;
+  let deletions = 0;
+  for (const file of payload.diffSet.files) {
+    additions += file.additions;
+    deletions += file.deletions;
+  }
+  return {
+    id: session.id,
+    projectPath: session.projectPath,
+    branch: payload.metadata.currentBranch,
+    title: payload.metadata.title,
+    fileCount,
+    additions,
+    deletions,
+    status: session.status,
+    createdAt: session.createdAt
+  };
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+function jsonResponse(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function matchRoute(method, url, expectedMethod, pattern) {
+  if (method !== expectedMethod) return null;
+  const patternParts = pattern.split("/");
+  const urlParts = url.split("/");
+  if (patternParts.length !== urlParts.length) return null;
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    if (patternParts[i].startsWith(":")) {
+      params[patternParts[i].slice(1)] = urlParts[i];
+    } else if (patternParts[i] !== urlParts[i]) {
+      return null;
+    }
+  }
+  return params;
+}
+var wss = null;
+function broadcastToAll(msg) {
+  if (!wss) return;
+  const data = JSON.stringify(msg);
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket3.OPEN) {
+      client.send(data);
+    }
+  }
+}
+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) {
+      client.send(data);
+    }
+  }
+}
+async function handleApiRequest(req, res) {
+  const method = req.method ?? "GET";
+  const url = (req.url ?? "/").split("?")[0];
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  if (method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return true;
+  }
+  if (!url.startsWith("/api/")) {
+    return false;
+  }
+  if (method === "GET" && url === "/api/status") {
+    jsonResponse(res, 200, {
+      running: true,
+      pid: process.pid,
+      sessions: sessions2.size,
+      uptime: process.uptime()
+    });
+    return true;
+  }
+  if (method === "POST" && url === "/api/reviews") {
+    try {
+      const body = await readBody(req);
+      const { payload, projectPath } = JSON.parse(body);
+      const sessionId = `session-${randomUUID().slice(0, 8)}`;
+      payload.reviewId = sessionId;
+      const session = {
+        id: sessionId,
+        payload,
+        projectPath,
+        status: "pending",
+        createdAt: Date.now(),
+        result: null
+      };
+      sessions2.set(sessionId, session);
+      broadcastToAll({
+        type: "session:added",
+        payload: toSummary(session)
+      });
+      jsonResponse(res, 201, { sessionId });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  if (method === "GET" && url === "/api/reviews") {
+    const summaries = Array.from(sessions2.values()).map(toSummary);
+    jsonResponse(res, 200, { sessions: summaries });
+    return true;
+  }
+  const getReviewParams = matchRoute(method, url, "GET", "/api/reviews/:id");
+  if (getReviewParams) {
+    const session = sessions2.get(getReviewParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, toSummary(session));
+    return true;
+  }
+  const postResultParams = matchRoute(method, url, "POST", "/api/reviews/:id/result");
+  if (postResultParams) {
+    const session = sessions2.get(postResultParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const result = JSON.parse(body);
+      session.result = result;
+      session.status = "submitted";
+      jsonResponse(res, 200, { ok: true });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const getResultParams = matchRoute(method, url, "GET", "/api/reviews/:id/result");
+  if (getResultParams) {
+    const session = sessions2.get(getResultParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    if (session.result) {
+      jsonResponse(res, 200, { result: session.result, status: "submitted" });
+    } else {
+      jsonResponse(res, 200, { result: null, status: session.status });
+    }
+    return true;
+  }
+  const postContextParams = matchRoute(method, url, "POST", "/api/reviews/:id/context");
+  if (postContextParams) {
+    const session = sessions2.get(postContextParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const contextPayload = JSON.parse(body);
+      if (contextPayload.reasoning !== void 0) {
+        session.payload.metadata.reasoning = contextPayload.reasoning;
+      }
+      if (contextPayload.title !== void 0) {
+        session.payload.metadata.title = contextPayload.title;
+      }
+      if (contextPayload.description !== void 0) {
+        session.payload.metadata.description = contextPayload.description;
+      }
+      sendToSessionClients(session.id, {
+        type: "context:update",
+        payload: contextPayload
+      });
+      jsonResponse(res, 200, { ok: true });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
+  if (deleteParams) {
+    if (sessions2.delete(deleteParams.id)) {
+      jsonResponse(res, 200, { ok: true });
+    } else {
+      jsonResponse(res, 404, { error: "Session not found" });
+    }
+    return true;
+  }
+  jsonResponse(res, 404, { error: "Not found" });
+  return true;
+}
+async function startGlobalServer(options = {}) {
+  const {
+    httpPort: preferredHttpPort = 24680,
+    wsPort: preferredWsPort = 24681,
+    silent = false,
+    dev = false
+  } = options;
+  const [httpPort, wsPort] = await Promise.all([
+    getPort3({ port: preferredHttpPort }),
+    getPort3({ port: preferredWsPort })
+  ]);
+  let uiPort;
+  let uiHttpServer = null;
+  let viteServer = null;
+  if (dev) {
+    uiPort = await getPort3();
+    const uiRoot = resolveUiRoot();
+    viteServer = await startViteDevServer(uiRoot, uiPort, silent);
+  } else {
+    uiPort = await getPort3();
+    const uiDist = resolveUiDist();
+    uiHttpServer = await createStaticServer(uiDist, uiPort);
+  }
+  const httpServer = http3.createServer(async (req, res) => {
+    const handled = await handleApiRequest(req, res);
+    if (!handled) {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  wss = new WebSocketServer3({ port: wsPort });
+  wss.on("connection", (ws, req) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
+    const sessionId = url.searchParams.get("sessionId");
+    if (sessionId) {
+      clientSessions.set(ws, sessionId);
+      const session = sessions2.get(sessionId);
+      if (session) {
+        session.status = "in_review";
+        const msg = {
+          type: "review:init",
+          payload: session.payload
+        };
+        ws.send(JSON.stringify(msg));
+      }
+    }
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "review:submit") {
+          const sid = clientSessions.get(ws);
+          if (sid) {
+            const session = sessions2.get(sid);
+            if (session) {
+              session.result = msg.payload;
+              session.status = "submitted";
+            }
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      clientSessions.delete(ws);
+    });
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(httpPort, () => resolve());
+  });
+  const serverInfo = {
+    httpPort,
+    wsPort,
+    pid: process.pid,
+    startedAt: Date.now()
+  };
+  writeServerFile(serverInfo);
+  if (!silent) {
+    console.log(`
+DiffPrism Global Server`);
+    console.log(`  API:  http://localhost:${httpPort}`);
+    console.log(`  WS:   ws://localhost:${wsPort}`);
+    console.log(`  UI:   http://localhost:${uiPort}`);
+    console.log(`  PID:  ${process.pid}`);
+    console.log(`
+Waiting for reviews...
+`);
+  }
+  const uiUrl = `http://localhost:${uiPort}?wsPort=${wsPort}&serverMode=true`;
+  await open3(uiUrl);
+  async function stop() {
+    if (wss) {
+      for (const client of wss.clients) {
+        client.close();
+      }
+      wss.close();
+      wss = null;
+    }
+    clientSessions.clear();
+    sessions2.clear();
+    await new Promise((resolve) => {
+      httpServer.close(() => resolve());
+    });
+    if (viteServer) {
+      await viteServer.close();
+    }
+    if (uiHttpServer) {
+      uiHttpServer.close();
+    }
+    removeServerFile();
+  }
+  return { httpPort, wsPort, stop };
+}
+
 export {
   startReview,
   readWatchFile,
   readReviewResult,
   consumeReviewResult,
-  startWatch
+  startWatch,
+  readServerFile,
+  isServerAlive,
+  startGlobalServer
 };

package/dist/mcp-server.js

@@ -3,7 +3,7 @@ import {
   readReviewResult,
   readWatchFile,
   startReview
-} from "./chunk-QB2PKDLU.js";
+} from "./chunk-NGHUHDAM.js";
 
 // packages/mcp-server/src/index.ts
 import fs from "fs";
@@ -14,14 +14,14 @@ import { z } from "zod";
 async function startMcpServer() {
   const server = new McpServer({
     name: "diffprism",
-    version: true ? "0.13.8" : "0.0.0-dev"
+    version: true ? "0.15.0" : "0.0.0-dev"
   });
   server.tool(
     "open_review",
     "Open a browser-based code review for local git changes. Blocks until the engineer submits their review decision.",
     {
       diff_ref: z.string().describe(
-        'Git diff reference: "staged", "unstaged", or a ref range like "HEAD~3..HEAD"'
+        'Git diff reference: "staged", "unstaged", "working-copy" (staged+unstaged grouped), or a ref range like "HEAD~3..HEAD"'
       ),
       title: z.string().optional().describe("Title for the review"),
       description: z.string().optional().describe("Description of the changes"),
@@ -124,10 +124,41 @@ async function startMcpServer() {
   );
   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 () => {
+    "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. Use wait=true to block until a result is available (recommended after pushing context to a watch session).",
+    {
+      wait: z.boolean().optional().describe("If true, poll until a review result is available (blocks up to timeout)"),
+      timeout: z.number().optional().describe("Max wait time in seconds when wait=true (default: 300, max: 600)")
+    },
+    async ({ wait, timeout }) => {
       try {
+        if (wait) {
+          const maxWaitMs = Math.min(timeout ?? 300, 600) * 1e3;
+          const pollIntervalMs = 2e3;
+          const start = Date.now();
+          while (Date.now() - start < maxWaitMs) {
+            const data2 = readReviewResult();
+            if (data2) {
+              consumeReviewResult();
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(data2.result, null, 2)
+                  }
+                ]
+              };
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No review result received within timeout."
+              }
+            ]
+          };
+        }
         const data = readReviewResult();
         if (!data) {
           return {

package/package.json

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