diffprism 0.35.0 → 0.37.0

package/dist/chunk-ITPHDFOS.js

@@ -0,0 +1,1283 @@
+import {
+  getCurrentBranch,
+  getDiff,
+  listBranches,
+  listCommits
+} from "./chunk-QGWYCEJN.js";
+import {
+  analyze
+} from "./chunk-DHCVZGHE.js";
+
+// packages/core/src/server-file.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function serverDir() {
+  return path.join(os.homedir(), ".diffprism");
+}
+function serverFilePath() {
+  return path.join(serverDir(), "server.json");
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeServerFile(info) {
+  const dir = serverDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
+}
+function readServerFile() {
+  const filePath = serverFilePath();
+  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 removeServerFile() {
+  try {
+    const filePath = serverFilePath();
+    if (fs.existsSync(filePath)) {
+      fs.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/server-client.ts
+import { spawn } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+import { fileURLToPath } from "url";
+async function ensureServer(options = {}) {
+  const existing = await isServerAlive();
+  if (existing) {
+    return existing;
+  }
+  const spawnArgs = options.spawnCommand ?? buildDefaultSpawnCommand(options);
+  const logDir = path2.join(os2.homedir(), ".diffprism");
+  if (!fs2.existsSync(logDir)) {
+    fs2.mkdirSync(logDir, { recursive: true });
+  }
+  const logPath = path2.join(logDir, "server.log");
+  const logFd = fs2.openSync(logPath, "a");
+  const [cmd, ...args] = spawnArgs;
+  const child = spawn(cmd, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.unref();
+  fs2.closeSync(logFd);
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const info = await isServerAlive();
+    if (info) {
+      return info;
+    }
+  }
+  throw new Error(
+    `DiffPrism server failed to start within ${timeoutMs / 1e3}s. Check logs at ${logPath}`
+  );
+}
+function buildDefaultSpawnCommand(options) {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = path2.dirname(thisFile);
+  const workspaceRoot = path2.resolve(thisDir, "..", "..", "..");
+  const devBin = path2.join(workspaceRoot, "cli", "bin", "diffprism.mjs");
+  let binPath = "diffprism";
+  if (fs2.existsSync(devBin)) {
+    binPath = devBin;
+  } else {
+    let searchDir = thisDir;
+    while (searchDir !== path2.dirname(searchDir)) {
+      const candidate = path2.join(
+        searchDir,
+        "node_modules",
+        ".bin",
+        "diffprism"
+      );
+      if (fs2.existsSync(candidate)) {
+        binPath = candidate;
+        break;
+      }
+      searchDir = path2.dirname(searchDir);
+    }
+  }
+  const args = [process.execPath, binPath, "server", "--_daemon"];
+  if (options.dev) {
+    args.push("--dev");
+  }
+  return args;
+}
+async function submitReviewToServer(serverInfo, diffRef, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const projectPath = options.projectPath ?? cwd;
+  let payload;
+  if (options.injectedPayload) {
+    payload = options.injectedPayload;
+  } else {
+    const { getDiff: getDiff2, getCurrentBranch: getCurrentBranch2, detectWorktree } = await import("./src-AMCPIYDZ.js");
+    const { analyze: analyze2 } = await import("./src-JMPTSU3P.js");
+    const { diffSet, rawDiff } = getDiff2(diffRef, { cwd });
+    if (diffSet.files.length === 0) {
+      return {
+        result: {
+          decision: "approved",
+          comments: [],
+          summary: "No changes to review."
+        },
+        sessionId: ""
+      };
+    }
+    const briefing = analyze2(diffSet);
+    const currentBranch = getCurrentBranch2({ cwd });
+    const worktreeInfo = detectWorktree({ cwd });
+    payload = {
+      reviewId: "",
+      // Server assigns the real ID
+      diffSet,
+      rawDiff,
+      briefing,
+      metadata: {
+        title: options.title,
+        description: options.description,
+        reasoning: options.reasoning,
+        currentBranch,
+        worktree: worktreeInfo.isWorktree ? {
+          isWorktree: true,
+          worktreePath: worktreeInfo.worktreePath,
+          mainWorktreePath: worktreeInfo.mainWorktreePath
+        } : void 0
+      }
+    };
+  }
+  const createResponse = await fetch(
+    `http://localhost:${serverInfo.httpPort}/api/reviews`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        payload,
+        projectPath,
+        diffRef: options.diffRef ?? diffRef
+      })
+    }
+  );
+  if (!createResponse.ok) {
+    throw new Error(
+      `Global server returned ${createResponse.status} on create`
+    );
+  }
+  const { sessionId } = await createResponse.json();
+  if (options.annotations?.length) {
+    for (const ann of options.annotations) {
+      await fetch(
+        `http://localhost:${serverInfo.httpPort}/api/reviews/${sessionId}/annotations`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            file: ann.file,
+            line: ann.line,
+            body: ann.body,
+            type: ann.type,
+            confidence: ann.confidence ?? 1,
+            category: ann.category ?? "other",
+            source: {
+              agent: ann.source_agent ?? "unknown",
+              tool: "open_review"
+            }
+          })
+        }
+      );
+    }
+  }
+  const pollIntervalMs = 2e3;
+  const maxWaitMs = options.timeoutMs ?? 6e5;
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    const resultResponse = await fetch(
+      `http://localhost:${serverInfo.httpPort}/api/reviews/${sessionId}/result`
+    );
+    if (resultResponse.ok) {
+      const data = await resultResponse.json();
+      if (data.result) {
+        return { result: data.result, sessionId };
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error("Review timed out waiting for submission.");
+}
+
+// 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()
+        };
+        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);
+    },
+    stop() {
+      running = false;
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+    },
+    setDiffRef(newRef) {
+      diffRef = newRef;
+      lastDiffHash = null;
+      lastDiffSet = null;
+    },
+    refresh() {
+      refreshRequested = true;
+    }
+  };
+}
+
+// packages/core/src/global-server.ts
+import http2 from "http";
+import { randomUUID as randomUUID2 } from "crypto";
+import getPort from "get-port";
+import open from "open";
+import { WebSocketServer, WebSocket } from "ws";
+
+// packages/core/src/ui-server.ts
+import http from "http";
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function resolveUiDist() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = path3.dirname(thisFile);
+  const publishedUiDist = path3.resolve(thisDir, "..", "ui-dist");
+  if (fs3.existsSync(path3.join(publishedUiDist, "index.html"))) {
+    return publishedUiDist;
+  }
+  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
+  const devUiDist = path3.join(workspaceRoot, "packages", "ui", "dist");
+  if (fs3.existsSync(path3.join(devUiDist, "index.html"))) {
+    return devUiDist;
+  }
+  throw new Error(
+    "Could not find built UI. Run 'pnpm -F @diffprism/ui build' first."
+  );
+}
+function resolveUiRoot() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = path3.dirname(thisFile);
+  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
+  const uiRoot = path3.join(workspaceRoot, "packages", "ui");
+  if (fs3.existsSync(path3.join(uiRoot, "index.html"))) {
+    return uiRoot;
+  }
+  throw new Error(
+    "Could not find UI source directory. Dev mode requires the diffprism workspace."
+  );
+}
+async function startViteDevServer(uiRoot, port, silent) {
+  const { createServer } = await import("vite");
+  const vite = await createServer({
+    root: uiRoot,
+    server: { port, strictPort: true, open: false },
+    logLevel: silent ? "silent" : "warn"
+  });
+  await vite.listen();
+  return vite;
+}
+function createStaticServer(distPath, port) {
+  const server = http.createServer((req, res) => {
+    const urlPath = req.url?.split("?")[0] ?? "/";
+    let filePath = path3.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+    if (!fs3.existsSync(filePath)) {
+      filePath = path3.join(distPath, "index.html");
+    }
+    const ext = path3.extname(filePath);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    try {
+      const content = fs3.readFileSync(filePath);
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content);
+    } catch {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(port, () => resolve(server));
+  });
+}
+
+// packages/core/src/review-history.ts
+import fs4 from "fs";
+import path4 from "path";
+import { randomUUID } from "crypto";
+function generateEntryId() {
+  return randomUUID();
+}
+function getHistoryPath(projectDir) {
+  return path4.join(projectDir, ".diffprism", "history", "reviews.json");
+}
+function readHistory(projectDir) {
+  const filePath = getHistoryPath(projectDir);
+  if (!fs4.existsSync(filePath)) {
+    return { version: 1, entries: [] };
+  }
+  try {
+    const raw = fs4.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return { version: 1, entries: [] };
+  }
+}
+function appendHistory(projectDir, entry) {
+  const filePath = getHistoryPath(projectDir);
+  const dir = path4.dirname(filePath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  const history = readHistory(projectDir);
+  history.entries.push(entry);
+  history.entries.sort((a, b) => a.timestamp - b.timestamp);
+  fs4.writeFileSync(filePath, JSON.stringify(history, null, 2) + "\n");
+}
+function getRecentHistory(projectDir, limit = 50) {
+  const history = readHistory(projectDir);
+  return history.entries.slice(-limit);
+}
+
+// packages/core/src/global-server.ts
+var SUBMITTED_TTL_MS = 5 * 60 * 1e3;
+var ABANDONED_TTL_MS = 60 * 60 * 1e3;
+var CLEANUP_INTERVAL_MS = 60 * 1e3;
+var sessions = /* @__PURE__ */ new Map();
+var clientSessions = /* @__PURE__ */ new Map();
+var sessionWatchers = /* @__PURE__ */ new Map();
+var serverPollInterval = 2e3;
+var reopenBrowserIfNeeded = null;
+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,
+    decision: session.result?.decision,
+    createdAt: session.createdAt,
+    hasNewChanges: session.hasNewChanges
+  };
+}
+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 === WebSocket.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 === WebSocket.OPEN) {
+      client.send(data);
+    }
+  }
+}
+function broadcastSessionUpdate(session) {
+  broadcastToAll({
+    type: "session:updated",
+    payload: toSummary(session)
+  });
+}
+function broadcastSessionRemoved(sessionId) {
+  for (const [client, sid] of clientSessions.entries()) {
+    if (sid === sessionId) {
+      clientSessions.delete(client);
+    }
+  }
+  broadcastToAll({
+    type: "session:removed",
+    payload: { sessionId }
+  });
+}
+function hasViewersForSession(sessionId) {
+  for (const [client, sid] of clientSessions.entries()) {
+    if (sid === sessionId && client.readyState === WebSocket.OPEN) {
+      return true;
+    }
+  }
+  return false;
+}
+function startSessionWatcher(sessionId) {
+  if (sessionWatchers.has(sessionId)) return;
+  const session = sessions.get(sessionId);
+  if (!session?.diffRef) return;
+  const poller = createDiffPoller({
+    diffRef: session.diffRef,
+    cwd: session.projectPath,
+    pollInterval: serverPollInterval,
+    onDiffChanged: (updatePayload) => {
+      const s = sessions.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();
+      }
+    }
+  });
+  poller.start();
+  sessionWatchers.set(sessionId, poller);
+}
+function stopSessionWatcher(sessionId) {
+  const poller = sessionWatchers.get(sessionId);
+  if (poller) {
+    poller.stop();
+    sessionWatchers.delete(sessionId);
+  }
+}
+function startAllWatchers() {
+  for (const [id, session] of sessions.entries()) {
+    if (session.diffRef && !sessionWatchers.has(id)) {
+      startSessionWatcher(id);
+    }
+  }
+}
+function stopAllWatchers() {
+  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 === WebSocket.OPEN) return true;
+  }
+  return false;
+}
+function broadcastSessionList() {
+  const summaries = Array.from(sessions.values()).map(toSummary);
+  broadcastToAll({ type: "session:list", payload: summaries });
+}
+function recordReviewHistory(session, result) {
+  if (session.projectPath.startsWith("github:")) return;
+  try {
+    const { payload } = session;
+    const entry = {
+      id: generateEntryId(),
+      timestamp: Date.now(),
+      diffRef: session.diffRef ?? "unknown",
+      decision: result.decision,
+      filesReviewed: payload.diffSet.files.length,
+      additions: payload.diffSet.files.reduce((sum, f) => sum + f.additions, 0),
+      deletions: payload.diffSet.files.reduce((sum, f) => sum + f.deletions, 0),
+      commentCount: result.comments.length,
+      branch: payload.metadata.currentBranch,
+      title: payload.metadata.title,
+      summary: result.summary ?? payload.briefing.summary
+    };
+    appendHistory(session.projectPath, entry);
+  } catch {
+  }
+}
+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, DELETE, 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: sessions.size,
+      uptime: process.uptime()
+    });
+    return true;
+  }
+  if (method === "POST" && url === "/api/reviews") {
+    try {
+      const body = await readBody(req);
+      const { payload, projectPath, diffRef } = JSON.parse(body);
+      let existingSession;
+      for (const session of sessions.values()) {
+        if (session.projectPath === projectPath) {
+          existingSession = session;
+          break;
+        }
+      }
+      if (existingSession) {
+        const sessionId = existingSession.id;
+        payload.reviewId = sessionId;
+        if (diffRef) {
+          payload.watchMode = true;
+        }
+        stopSessionWatcher(sessionId);
+        existingSession.payload = payload;
+        existingSession.status = "pending";
+        existingSession.result = null;
+        existingSession.createdAt = Date.now();
+        existingSession.diffRef = diffRef;
+        existingSession.lastDiffHash = diffRef ? hashDiff(payload.rawDiff) : void 0;
+        existingSession.lastDiffSet = diffRef ? payload.diffSet : void 0;
+        existingSession.hasNewChanges = false;
+        existingSession.annotations = [];
+        if (diffRef) {
+          startSessionWatcher(sessionId);
+        }
+        if (hasViewersForSession(sessionId)) {
+          sendToSessionClients(sessionId, {
+            type: "review:init",
+            payload
+          });
+        }
+        broadcastSessionUpdate(existingSession);
+        reopenBrowserIfNeeded?.();
+        jsonResponse(res, 200, { sessionId });
+      } else {
+        const sessionId = `session-${randomUUID2().slice(0, 8)}`;
+        payload.reviewId = sessionId;
+        if (diffRef) {
+          payload.watchMode = true;
+        }
+        const session = {
+          id: sessionId,
+          payload,
+          projectPath,
+          status: "pending",
+          createdAt: Date.now(),
+          result: null,
+          diffRef,
+          lastDiffHash: diffRef ? hashDiff(payload.rawDiff) : void 0,
+          lastDiffSet: diffRef ? payload.diffSet : void 0,
+          hasNewChanges: false,
+          annotations: []
+        };
+        sessions.set(sessionId, session);
+        if (diffRef) {
+          startSessionWatcher(sessionId);
+        }
+        broadcastToAll({
+          type: "session:added",
+          payload: toSummary(session)
+        });
+        reopenBrowserIfNeeded?.();
+        jsonResponse(res, 201, { sessionId });
+      }
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  if (method === "GET" && url === "/api/reviews") {
+    const summaries = Array.from(sessions.values()).map(toSummary);
+    jsonResponse(res, 200, { sessions: summaries });
+    return true;
+  }
+  const getReviewParams = matchRoute(method, url, "GET", "/api/reviews/:id");
+  if (getReviewParams) {
+    const session = sessions.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 = sessions.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";
+      recordReviewHistory(session, result);
+      if (result.decision === "dismissed") {
+        broadcastSessionRemoved(postResultParams.id);
+      } else {
+        broadcastSessionUpdate(session);
+      }
+      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 = sessions.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 = sessions.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 postAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations");
+  if (postAnnotationParams) {
+    const session = sessions.get(postAnnotationParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const { file, line, body: annotationBody, type, confidence, category, source } = JSON.parse(body);
+      const annotation = {
+        id: randomUUID2(),
+        sessionId: session.id,
+        file,
+        line,
+        body: annotationBody,
+        type,
+        confidence: confidence ?? 1,
+        category: category ?? "other",
+        source,
+        createdAt: Date.now()
+      };
+      session.annotations.push(annotation);
+      sendToSessionClients(session.id, {
+        type: "annotation:added",
+        payload: annotation
+      });
+      jsonResponse(res, 200, { annotationId: annotation.id });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const getAnnotationsParams = matchRoute(method, url, "GET", "/api/reviews/:id/annotations");
+  if (getAnnotationsParams) {
+    const session = sessions.get(getAnnotationsParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, { annotations: session.annotations });
+    return true;
+  }
+  const dismissAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations/:annotationId/dismiss");
+  if (dismissAnnotationParams) {
+    const session = sessions.get(dismissAnnotationParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    const annotation = session.annotations.find((a) => a.id === dismissAnnotationParams.annotationId);
+    if (!annotation) {
+      jsonResponse(res, 404, { error: "Annotation not found" });
+      return true;
+    }
+    annotation.dismissed = true;
+    sendToSessionClients(dismissAnnotationParams.id, {
+      type: "annotation:dismissed",
+      payload: { annotationId: dismissAnnotationParams.annotationId }
+    });
+    jsonResponse(res, 200, { ok: true });
+    return true;
+  }
+  const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
+  if (deleteParams) {
+    stopSessionWatcher(deleteParams.id);
+    if (sessions.delete(deleteParams.id)) {
+      broadcastSessionRemoved(deleteParams.id);
+      jsonResponse(res, 200, { ok: true });
+    } else {
+      jsonResponse(res, 404, { error: "Session not found" });
+    }
+    return true;
+  }
+  const getRefsParams = matchRoute(method, url, "GET", "/api/reviews/:id/refs");
+  if (getRefsParams) {
+    const session = sessions.get(getRefsParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    if (session.projectPath.startsWith("github:")) {
+      jsonResponse(res, 400, { error: "Ref listing not available for GitHub PRs" });
+      return true;
+    }
+    try {
+      const branches = listBranches({ cwd: session.projectPath });
+      const commits = listCommits({ cwd: session.projectPath });
+      const currentBranch = getCurrentBranch({ cwd: session.projectPath });
+      jsonResponse(res, 200, { branches, commits, currentBranch });
+    } catch {
+      jsonResponse(res, 500, { error: "Failed to list git refs" });
+    }
+    return true;
+  }
+  const postCompareParams = matchRoute(method, url, "POST", "/api/reviews/:id/compare");
+  if (postCompareParams) {
+    const session = sessions.get(postCompareParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    if (session.projectPath.startsWith("github:")) {
+      jsonResponse(res, 400, { error: "Ref comparison not available for GitHub PRs" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const { ref } = JSON.parse(body);
+      if (!ref) {
+        jsonResponse(res, 400, { error: "Missing ref in request body" });
+        return true;
+      }
+      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(ref, {
+        cwd: session.projectPath
+      });
+      const newBriefing = analyze(newDiffSet);
+      const changedFiles = detectChangedFiles(session.lastDiffSet ?? null, newDiffSet);
+      session.payload = {
+        ...session.payload,
+        diffSet: newDiffSet,
+        rawDiff: newRawDiff,
+        briefing: newBriefing
+      };
+      session.lastDiffHash = hashDiff(newRawDiff);
+      session.lastDiffSet = newDiffSet;
+      stopSessionWatcher(session.id);
+      session.diffRef = ref;
+      if (hasConnectedClients()) {
+        startSessionWatcher(session.id);
+      }
+      sendToSessionClients(session.id, {
+        type: "diff:update",
+        payload: {
+          diffSet: newDiffSet,
+          rawDiff: newRawDiff,
+          briefing: newBriefing,
+          changedFiles,
+          timestamp: Date.now()
+        }
+      });
+      jsonResponse(res, 200, { ok: true, fileCount: newDiffSet.files.length });
+    } catch {
+      jsonResponse(res, 400, { error: "Failed to compute diff for the given ref" });
+    }
+    return true;
+  }
+  const getSessionHistoryParams = matchRoute(method, url, "GET", "/api/reviews/:id/history");
+  if (getSessionHistoryParams) {
+    const session = sessions.get(getSessionHistoryParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    if (session.projectPath.startsWith("github:")) {
+      jsonResponse(res, 200, { history: [] });
+      return true;
+    }
+    const history = getRecentHistory(session.projectPath);
+    jsonResponse(res, 200, { history });
+    return true;
+  }
+  if (method === "GET" && req.url) {
+    const parsedUrl = new URL(req.url, "http://localhost");
+    if (parsedUrl.pathname === "/api/history") {
+      const projectPath = parsedUrl.searchParams.get("project");
+      if (!projectPath) {
+        jsonResponse(res, 400, { error: "Missing required query parameter: project" });
+        return true;
+      }
+      if (projectPath.startsWith("github:")) {
+        jsonResponse(res, 200, { history: [] });
+        return true;
+      }
+      const history = getRecentHistory(projectPath);
+      jsonResponse(res, 200, { history });
+      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,
+    pollInterval = 2e3,
+    openBrowser = true
+  } = options;
+  serverPollInterval = pollInterval;
+  const [httpPort, wsPort] = await Promise.all([
+    getPort({ port: preferredHttpPort }),
+    getPort({ port: preferredWsPort })
+  ]);
+  let uiPort;
+  let uiHttpServer = null;
+  let viteServer = null;
+  if (dev) {
+    uiPort = await getPort();
+    const uiRoot = resolveUiRoot();
+    viteServer = await startViteDevServer(uiRoot, uiPort, silent);
+  } else {
+    uiPort = await getPort();
+    const uiDist = resolveUiDist();
+    uiHttpServer = await createStaticServer(uiDist, uiPort);
+  }
+  const httpServer = http2.createServer(async (req, res) => {
+    const handled = await handleApiRequest(req, res);
+    if (!handled) {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  wss = new WebSocketServer({ port: wsPort });
+  wss.on("connection", (ws, req) => {
+    startAllWatchers();
+    const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
+    const sessionId = url.searchParams.get("sessionId");
+    if (sessionId) {
+      clientSessions.set(ws, sessionId);
+      const session = sessions.get(sessionId);
+      if (session) {
+        session.status = "in_review";
+        session.hasNewChanges = false;
+        broadcastSessionUpdate(session);
+        const msg = {
+          type: "review:init",
+          payload: session.payload
+        };
+        ws.send(JSON.stringify(msg));
+        for (const annotation of session.annotations) {
+          ws.send(JSON.stringify({
+            type: "annotation:added",
+            payload: annotation
+          }));
+        }
+      }
+    } else {
+      const summaries = Array.from(sessions.values()).map(toSummary);
+      const msg = {
+        type: "session:list",
+        payload: summaries
+      };
+      ws.send(JSON.stringify(msg));
+      if (summaries.length === 1) {
+        const session = sessions.get(summaries[0].id);
+        if (session) {
+          clientSessions.set(ws, session.id);
+          session.status = "in_review";
+          session.hasNewChanges = false;
+          broadcastSessionUpdate(session);
+          ws.send(JSON.stringify({
+            type: "review:init",
+            payload: session.payload
+          }));
+          for (const annotation of session.annotations) {
+            ws.send(JSON.stringify({
+              type: "annotation:added",
+              payload: annotation
+            }));
+          }
+        }
+      }
+    }
+    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 = sessions.get(sid);
+            if (session) {
+              session.result = msg.payload;
+              session.status = "submitted";
+              recordReviewHistory(session, msg.payload);
+              if (msg.payload.decision === "dismissed") {
+                broadcastSessionRemoved(sid);
+              } else {
+                broadcastSessionUpdate(session);
+              }
+            }
+          }
+        } else if (msg.type === "session:select") {
+          const session = sessions.get(msg.payload.sessionId);
+          if (session) {
+            clientSessions.set(ws, session.id);
+            session.status = "in_review";
+            session.hasNewChanges = false;
+            startSessionWatcher(session.id);
+            broadcastSessionUpdate(session);
+            ws.send(JSON.stringify({
+              type: "review:init",
+              payload: session.payload
+            }));
+            for (const annotation of session.annotations) {
+              ws.send(JSON.stringify({
+                type: "annotation:added",
+                payload: annotation
+              }));
+            }
+          }
+        } else if (msg.type === "session:close") {
+          const closedId = msg.payload.sessionId;
+          stopSessionWatcher(closedId);
+          const closedSession = sessions.get(closedId);
+          if (closedSession && !closedSession.result) {
+            closedSession.result = { decision: "dismissed", comments: [] };
+            closedSession.status = "submitted";
+          }
+          broadcastSessionRemoved(closedId);
+        } else if (msg.type === "diff:change_ref") {
+          const sid = clientSessions.get(ws);
+          if (sid) {
+            const session = sessions.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 {
+      }
+    });
+    ws.on("close", () => {
+      clientSessions.delete(ws);
+    });
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(httpPort, () => resolve());
+  });
+  function cleanupExpiredSessions() {
+    const now = Date.now();
+    for (const [id, session] of sessions.entries()) {
+      const age = now - session.createdAt;
+      const expired = session.status === "submitted" && age > SUBMITTED_TTL_MS || session.status === "pending" && age > ABANDONED_TTL_MS;
+      if (expired) {
+        stopSessionWatcher(id);
+        sessions.delete(id);
+        broadcastSessionRemoved(id);
+      }
+    }
+  }
+  const cleanupTimer = setInterval(cleanupExpiredSessions, CLEANUP_INTERVAL_MS);
+  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}&httpPort=${httpPort}&serverMode=true`;
+  if (openBrowser) {
+    await open(uiUrl);
+  }
+  reopenBrowserIfNeeded = () => {
+    if (!hasConnectedClients()) {
+      open(uiUrl);
+    }
+  };
+  async function stop() {
+    clearInterval(cleanupTimer);
+    stopAllWatchers();
+    if (wss) {
+      for (const client of wss.clients) {
+        client.close();
+      }
+      wss.close();
+      wss = null;
+    }
+    clientSessions.clear();
+    sessions.clear();
+    reopenBrowserIfNeeded = null;
+    await new Promise((resolve) => {
+      httpServer.close(() => resolve());
+    });
+    if (viteServer) {
+      await viteServer.close();
+    }
+    if (uiHttpServer) {
+      uiHttpServer.close();
+    }
+    removeServerFile();
+  }
+  return { httpPort, wsPort, stop };
+}
+
+export {
+  readServerFile,
+  isServerAlive,
+  startGlobalServer,
+  ensureServer,
+  submitReviewToServer
+};