diffprism 0.45.0 → 0.48.0

package/README.md

@@ -102,6 +102,41 @@ diffprism review main..feature      # Branch diff
 
 Running multiple Claude Code sessions? All reviews appear in one browser dashboard with status badges, branch info, and desktop notifications.
 
+## Commit Gate
+
+Review is only reliable if something other than memory triggers it. `diffprism hook`
+wires the review into your pre-commit hook, so a substantial change opens a review
+before it can land.
+
+```bash
+diffprism hook install              # Add the gate to this repo's pre-commit hook
+diffprism hook uninstall            # Remove it
+```
+
+By default a staged diff of **120+ changed lines** opens a review; anything smaller
+commits untouched. A gate that stops every commit is one you learn to skip with
+`--no-verify`, and a skipped gate is worse than none. Tune it per repo:
+
+```bash
+git config diffprism.gate-lines 200
+```
+
+Approve and the commit proceeds. Request changes and the commit is blocked — with
+your comments printed in the output, so the agent that ran `git commit` can read
+what you asked for and fix it without another round trip:
+
+```
+140 staged lines (gate at 120) — opening DiffPrism review...
+
+  feature.ts:12  [must_fix]  these should be a single exported record
+  feature.ts:88  [question]  is this range meant to be inclusive?
+
+Commit blocked: the review requested changes.
+```
+
+Install adds one line between markers, so uninstall removes exactly that and leaves
+the rest of your hook alone. Repos using `core.hooksPath` are handled.
+
 ## Features
 
 - **AI-powered PR review** — Your AI gets full codebase context via 14 MCP tools
@@ -124,6 +159,8 @@ diffprism setup --global            # Global setup (no git repo needed)
 diffprism server                    # Start the background server
 diffprism server status             # Check server status
 diffprism server stop               # Stop the server
+diffprism hook install              # Gate commits on a review
+diffprism hook uninstall            # Remove the gate
 diffprism teardown                  # Remove configuration
 ```
 

package/dist/bin.js

@@ -5,15 +5,19 @@ import {
 } from "./chunk-24B33UN6.js";
 import {
   demo
-} from "./chunk-RVI74JF5.js";
+} from "./chunk-SWSRPUXO.js";
 import {
+  describeVersion,
   ensureServer,
+  getBuildInfo,
   isServerAlive,
   readServerFile,
   startGlobalServer,
   submitReviewToServer
-} from "./chunk-RICVPPTE.js";
-import "./chunk-QGWYCEJN.js";
+} from "./chunk-AJGESVAM.js";
+import {
+  getDiff
+} from "./chunk-QGWYCEJN.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";
 
@@ -39,21 +43,26 @@ async function review(ref, flags) {
       await reviewLocalFlow(diffRef, flags);
     }
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error: ${message}`);
+    const message2 = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message2}`);
     process.exit(1);
   }
 }
 async function reviewLocalFlow(diffRef, flags) {
   const serverInfo = await ensureServer({ dev: flags.dev });
-  console.log("Opening review in browser...");
+  console.error("Opening review in browser...");
   const { result } = await submitReviewToServer(serverInfo, diffRef, {
     title: flags.title,
     cwd: process.cwd(),
     diffRef
   });
   console.log(JSON.stringify(result, null, 2));
-  process.exit(0);
+  if (!result) {
+    console.error("No review result was returned.");
+    process.exit(1);
+  }
+  const approved = result.decision === "approved" || result.decision === "approved_with_comments";
+  process.exit(approved ? 0 : 1);
 }
 async function reviewPrFlow(pr, flags) {
   const { owner, repo, number } = parsePrRef(pr);
@@ -370,7 +379,7 @@ async function setupInteractive(flags) {
 }
 async function runDemo(dev) {
   console.log("");
-  const { demo: demo2 } = await import("./demo-WVNNI6CE.js");
+  const { demo: demo2 } = await import("./demo-7GBBKPPB.js");
   await demo2({ dev });
 }
 async function setupBatch(flags) {
@@ -703,9 +712,9 @@ async function server(flags) {
     await new Promise(() => {
     });
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+    const message2 = err instanceof Error ? err.message : String(err);
     if (!isDaemon) {
-      console.error(`Error starting server: ${message}`);
+      console.error(`Error starting server: ${message2}`);
     }
     process.exit(1);
   }
@@ -764,6 +773,10 @@ async function serverStatus() {
     console.log(`  PID:      ${status.pid}`);
     console.log(`  Sessions: ${status.sessions}`);
     console.log(`  Uptime:   ${Math.floor(status.uptime)}s`);
+    const build = getBuildInfo();
+    if (build.dev) {
+      console.log(`  Build:    dev \u2014 ${build.root}`);
+    }
     if (status.sessions > 0) {
       const sessionsResponse = await fetch(
         `http://localhost:${info.httpPort}/api/reviews`,
@@ -778,8 +791,8 @@ async function serverStatus() {
       }
     }
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error checking server status: ${message}`);
+    const message2 = err instanceof Error ? err.message : String(err);
+    console.error(`Error checking server status: ${message2}`);
     process.exit(1);
   }
 }
@@ -813,7 +826,7 @@ async function fetchStatus(httpPort) {
   return await response.json();
 }
 function printStatus(status, httpPort) {
-  const version = true ? "0.45.0" : "0.0.0-dev";
+  const version = true ? "0.48.0" : "0.0.0-dev";
   console.log(`
 DiffPrism v${version}
 `);
@@ -845,19 +858,215 @@ async function defaultAction() {
       await open(status.uiUrl);
     }
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error fetching server status: ${message}`);
+    const message2 = err instanceof Error ? err.message : String(err);
+    console.error(`Error fetching server status: ${message2}`);
     process.exit(1);
   }
 }
 
+// cli/src/commands/hook.ts
+import { execFileSync } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+var DEFAULT_MIN_LINES = 120;
+var MARKER_START = "# >>> diffprism >>>";
+var MARKER_END = "# <<< diffprism <<<";
+var HOOK_LINE = "diffprism hook pre-commit || exit 1";
+async function preCommitHook(flags = {}) {
+  const cwd = process.cwd();
+  const minLines = resolveMinLines(flags, cwd);
+  let changedLines;
+  try {
+    const { diffSet } = getDiff("staged", { cwd });
+    changedLines = diffSet.files.reduce(
+      (total, file) => total + file.additions + file.deletions,
+      0
+    );
+  } catch (err) {
+    fail(`Could not read the staged diff: ${message(err)}`);
+    return;
+  }
+  if (changedLines === 0) {
+    process.exit(0);
+  }
+  if (changedLines < minLines) {
+    process.exit(0);
+  }
+  console.error(
+    `${changedLines} staged lines (gate at ${minLines}) \u2014 opening DiffPrism review...`
+  );
+  let review2 = null;
+  try {
+    const serverInfo = await ensureServer({ dev: flags.dev });
+    const { result } = await submitReviewToServer(serverInfo, "staged", {
+      cwd,
+      diffRef: "staged",
+      title: "Pre-commit review"
+    });
+    review2 = result;
+  } catch (err) {
+    fail(`DiffPrism could not run the review: ${message(err)}`);
+    return;
+  }
+  const decision = review2?.decision;
+  if (decision === "approved" || decision === "approved_with_comments") {
+    console.error(`Review: ${decision} \u2014 proceeding.`);
+    process.exit(0);
+  }
+  if (decision === "changes_requested") {
+    printComments(review2?.comments ?? []);
+    fail("Commit blocked: the review requested changes.");
+    return;
+  }
+  if (decision === "dismissed") {
+    fail("Commit blocked: the review was dismissed without a decision.");
+    return;
+  }
+  fail(
+    `Commit blocked: no review decision was returned (got ${String(decision)}).`
+  );
+}
+function printComments(comments) {
+  if (comments.length === 0) {
+    return;
+  }
+  console.error("");
+  for (const c of comments) {
+    console.error(`  ${c.file}:${c.line}  [${c.type}]  ${c.body}`);
+  }
+  console.error("");
+}
+function installHook() {
+  const hookPath = resolveHookPath(process.cwd());
+  const existing = fs4.existsSync(hookPath) ? fs4.readFileSync(hookPath, "utf8") : "";
+  if (existing.includes(MARKER_START)) {
+    console.log(`Already installed in ${hookPath}`);
+    return;
+  }
+  const block = `${MARKER_START}
+${HOOK_LINE}
+${MARKER_END}
+`;
+  const base = existing === "" ? "#!/bin/sh\n" : ensureTrailingNewline(existing);
+  const created = existing === "";
+  fs4.mkdirSync(path4.dirname(hookPath), { recursive: true });
+  fs4.writeFileSync(hookPath, `${base}
+${block}`);
+  fs4.chmodSync(hookPath, 493);
+  console.log(`${created ? "Created" : "Updated"} ${hookPath}`);
+  console.log(
+    `Staged changes of ${DEFAULT_MIN_LINES}+ lines now open a review before the commit lands.`
+  );
+  console.log("Tune with:  git config diffprism.gate-lines <n>");
+  console.log("Remove with: diffprism hook uninstall");
+}
+function uninstallHook() {
+  const hookPath = resolveHookPath(process.cwd());
+  if (!fs4.existsSync(hookPath)) {
+    console.log("Nothing to remove \u2014 no hook file.");
+    return;
+  }
+  const existing = fs4.readFileSync(hookPath, "utf8");
+  if (!existing.includes(MARKER_START)) {
+    console.log(`Nothing to remove \u2014 no diffprism block in ${hookPath}`);
+    return;
+  }
+  const cleaned = removeMarkedBlock(existing);
+  if (/^\s*(#![^\n]*)?\s*$/.test(cleaned)) {
+    fs4.rmSync(hookPath);
+    console.log(`Removed ${hookPath} (it contained nothing else).`);
+    return;
+  }
+  fs4.writeFileSync(hookPath, cleaned);
+  console.log(`Removed the diffprism block from ${hookPath}`);
+}
+function removeMarkedBlock(contents) {
+  const lines = contents.split("\n");
+  const out = [];
+  let inside = false;
+  for (const line of lines) {
+    if (line.trim() === MARKER_START) {
+      inside = true;
+      continue;
+    }
+    if (line.trim() === MARKER_END) {
+      inside = false;
+      continue;
+    }
+    if (!inside) {
+      out.push(line);
+    }
+  }
+  return ensureTrailingNewline(out.join("\n").replace(/\n{3,}/g, "\n\n"));
+}
+function resolveMinLines(flags, cwd) {
+  const fromFlag = flags.minLines ? Number.parseInt(flags.minLines, 10) : NaN;
+  if (Number.isFinite(fromFlag) && fromFlag > 0) {
+    return fromFlag;
+  }
+  const configured = Number.parseInt(
+    git(["config", "--get", "diffprism.gate-lines"], cwd) ?? "",
+    10
+  );
+  if (Number.isFinite(configured) && configured > 0) {
+    return configured;
+  }
+  return DEFAULT_MIN_LINES;
+}
+function resolveHookPath(cwd) {
+  const configured = git(["config", "--get", "core.hooksPath"], cwd);
+  if (configured) {
+    return path4.resolve(cwd, configured, "pre-commit");
+  }
+  const hooksDir = git(["rev-parse", "--git-path", "hooks"], cwd) ?? ".git/hooks";
+  return path4.resolve(cwd, hooksDir, "pre-commit");
+}
+function git(args, cwd) {
+  try {
+    const out = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = out.trim();
+    return trimmed === "" ? null : trimmed;
+  } catch {
+    return null;
+  }
+}
+function ensureTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function fail(text) {
+  console.error(text);
+  process.exit(1);
+}
+
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.45.0" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(
+  describeVersion(
+    true ? "0.48.0" : "0.0.0-dev"
+  )
+);
 program.action(defaultAction);
 program.command("demo").description("Open a sample review to see DiffPrism in action").option("--dev", "Use Vite dev server").action(demo);
 program.command("review [ref]").description("Open a browser-based diff review (local git ref or GitHub PR ref like owner/repo#123)").option("--staged", "Review staged changes").option("--unstaged", "Review unstaged changes").option("-t, --title <title>", "Review title").option("--reasoning <text>", "Agent reasoning about the changes").option("--dev", "Use Vite dev server with HMR instead of static files").option("--post-to-github", "Automatically post review back to GitHub without prompting").action(review);
 program.command("review-pr <pr>", { hidden: true }).action((pr, flags) => review(pr, flags));
+var hookCmd = program.command("hook").description("Git hook integration \u2014 gate commits on a human review");
+hookCmd.command("pre-commit").description("Run the review gate for the staged changes (called from a git hook)").option("--min-lines <n>", "Staged lines required to trigger a review (default: 120)").option("--dev", "Use Vite dev server").action((flags) => {
+  void preCommitHook(flags);
+});
+hookCmd.command("install").description("Add the diffprism gate to this repo's pre-commit hook").action(() => {
+  installHook();
+});
+hookCmd.command("uninstall").description("Remove the diffprism gate from this repo's pre-commit hook").action(() => {
+  uninstallHook();
+});
 program.command("serve").description("Start the MCP server for Claude Code integration").action(serve);
 program.command("setup").description("Configure DiffPrism for Claude Code integration").option("--global", "Configure globally (skill + permissions, no git repo required)").option("--force", "Overwrite existing configuration files").option("--dev", "Use Vite dev server").option("--no-demo", "Skip the demo review after setup").action((flags) => {
   setup(flags);

package/dist/{chunk-RICVPPTE.js → chunk-AJGESVAM.js}

@@ -122,30 +122,45 @@ function buildDefaultSpawnCommand(options) {
   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"
+    return withDevFlag([process.execPath, devBin, "server", "--_daemon"], options);
+  }
+  let searchDir = thisDir;
+  while (searchDir !== path2.dirname(searchDir)) {
+    const ownBin = readOwnBinPath(searchDir);
+    if (ownBin) {
+      return withDevFlag(
+        [process.execPath, ownBin, "server", "--_daemon"],
+        options
       );
-      if (fs2.existsSync(candidate)) {
-        binPath = candidate;
-        break;
-      }
-      searchDir = path2.dirname(searchDir);
     }
+    const shim = path2.join(searchDir, "node_modules", ".bin", "diffprism");
+    if (fs2.existsSync(shim)) {
+      return withDevFlag([shim, "server", "--_daemon"], options);
+    }
+    searchDir = path2.dirname(searchDir);
   }
-  const args = [process.execPath, binPath, "server", "--_daemon"];
-  if (options.dev) {
-    args.push("--dev");
+  return withDevFlag(["diffprism", "server", "--_daemon"], options);
+}
+function withDevFlag(args, options) {
+  return options.dev ? [...args, "--dev"] : args;
+}
+function readOwnBinPath(dir) {
+  const manifestPath = path2.join(dir, "package.json");
+  if (!fs2.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+    const entry = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.diffprism;
+    if (!entry) {
+      return null;
+    }
+    const resolved = path2.resolve(dir, entry);
+    return fs2.existsSync(resolved) ? resolved : null;
+  } catch {
+    return null;
   }
-  return args;
 }
 async function submitReviewToServer(serverInfo, diffRef, options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -251,6 +266,27 @@ async function submitReviewToServer(serverInfo, diffRef, options = {}) {
   throw new Error("Review timed out waiting for submission.");
 }
 
+// packages/core/src/build-info.ts
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getBuildInfo() {
+  let dir = path3.dirname(fileURLToPath2(import.meta.url));
+  while (dir !== path3.dirname(dir)) {
+    if (fs3.existsSync(path3.join(dir, "package.json"))) {
+      if (fs3.existsSync(path3.join(dir, ".git"))) {
+        return { dev: true, root: dir };
+      }
+    }
+    dir = path3.dirname(dir);
+  }
+  return { dev: false, root: null };
+}
+function describeVersion(version) {
+  const info = getBuildInfo();
+  return info.dev ? `${version} (dev build \u2014 ${info.root})` : version;
+}
+
 // packages/core/src/diff-utils.ts
 import { createHash } from "crypto";
 function hashDiff(rawDiff) {
@@ -355,13 +391,13 @@ import { randomUUID as randomUUID2 } from "crypto";
 import getPort from "get-port";
 import open from "open";
 import { WebSocketServer, WebSocket } from "ws";
-import fs5 from "fs";
+import fs6 from "fs";
 
 // packages/core/src/ui-server.ts
 import http from "http";
-import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -374,15 +410,15 @@ var MIME_TYPES = {
   ".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"))) {
+  const thisFile = fileURLToPath3(import.meta.url);
+  const thisDir = path4.dirname(thisFile);
+  const publishedUiDist = path4.resolve(thisDir, "..", "ui-dist");
+  if (fs4.existsSync(path4.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"))) {
+  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
+  const devUiDist = path4.join(workspaceRoot, "packages", "ui", "dist");
+  if (fs4.existsSync(path4.join(devUiDist, "index.html"))) {
     return devUiDist;
   }
   throw new Error(
@@ -390,11 +426,11 @@ function resolveUiDist() {
   );
 }
 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"))) {
+  const thisFile = fileURLToPath3(import.meta.url);
+  const thisDir = path4.dirname(thisFile);
+  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
+  const uiRoot = path4.join(workspaceRoot, "packages", "ui");
+  if (fs4.existsSync(path4.join(uiRoot, "index.html"))) {
     return uiRoot;
   }
   throw new Error(
@@ -414,14 +450,14 @@ async function startViteDevServer(uiRoot, port, silent) {
 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");
+    let filePath = path4.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+    if (!fs4.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 = fs3.readFileSync(filePath);
+      const content = fs4.readFileSync(filePath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch {
@@ -436,22 +472,22 @@ function createStaticServer(distPath, port) {
 }
 
 // packages/core/src/review-history.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { randomUUID } from "crypto";
 function generateEntryId() {
   return randomUUID();
 }
 function getHistoryPath(projectDir) {
-  return path4.join(projectDir, ".diffprism", "history", "reviews.json");
+  return path5.join(projectDir, ".diffprism", "history", "reviews.json");
 }
 function readHistory(projectDir) {
   const filePath = getHistoryPath(projectDir);
-  if (!fs4.existsSync(filePath)) {
+  if (!fs5.existsSync(filePath)) {
     return { version: 1, entries: [] };
   }
   try {
-    const raw = fs4.readFileSync(filePath, "utf-8");
+    const raw = fs5.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -460,14 +496,14 @@ function readHistory(projectDir) {
 }
 function appendHistory(projectDir, entry) {
   const filePath = getHistoryPath(projectDir);
-  const dir = path4.dirname(filePath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const dir = path5.dirname(filePath);
+  if (!fs5.existsSync(dir)) {
+    fs5.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");
+  fs5.writeFileSync(filePath, JSON.stringify(history, null, 2) + "\n");
 }
 function getRecentHistory(projectDir, limit = 50) {
   const history = readHistory(projectDir);
@@ -671,12 +707,12 @@ function recordReviewHistory(session, result) {
 function isInsideGitRepo(dirPath) {
   let current = dirPath;
   while (current !== "/") {
-    if (fs5.existsSync(`${current}/.git`)) return true;
+    if (fs6.existsSync(`${current}/.git`)) return true;
     const parent = current.replace(/\/[^/]+$/, "") || "/";
     if (parent === current) break;
     current = parent;
   }
-  return fs5.existsSync(`${current}/.git`);
+  return fs6.existsSync(`${current}/.git`);
 }
 async function handleApiRequest(req, res) {
   const method = req.method ?? "GET";
@@ -787,7 +823,7 @@ async function handleApiRequest(req, res) {
         return true;
       }
       try {
-        const stat = fs5.statSync(projectPath);
+        const stat = fs6.statSync(projectPath);
         if (!stat.isDirectory()) {
           jsonResponse(res, 400, { error: "Path is not a directory" });
           return true;
@@ -946,7 +982,7 @@ async function handleApiRequest(req, res) {
     if (parsedUrl.pathname === "/api/fs/list") {
       const dirPath = parsedUrl.searchParams.get("path") || process.cwd();
       try {
-        const stat = fs5.statSync(dirPath);
+        const stat = fs6.statSync(dirPath);
         if (!stat.isDirectory()) {
           jsonResponse(res, 400, { error: "Not a directory" });
           return true;
@@ -956,13 +992,13 @@ async function handleApiRequest(req, res) {
         return true;
       }
       try {
-        const entries = fs5.readdirSync(dirPath, { withFileTypes: true });
+        const entries = fs6.readdirSync(dirPath, { withFileTypes: true });
         const dirs = [];
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
           if (entry.name.startsWith(".")) continue;
           const fullPath = `${dirPath}/${entry.name}`;
-          const isGitRepo2 = fs5.existsSync(`${fullPath}/.git`);
+          const isGitRepo2 = fs6.existsSync(`${fullPath}/.git`);
           dirs.push({ name: entry.name, path: fullPath, isGitRepo: isGitRepo2 });
         }
         dirs.sort((a, b) => {
@@ -1550,5 +1586,7 @@ export {
   isServerAlive,
   startGlobalServer,
   ensureServer,
-  submitReviewToServer
+  submitReviewToServer,
+  getBuildInfo,
+  describeVersion
 };

package/dist/{chunk-RVI74JF5.js → chunk-SWSRPUXO.js}

@@ -1,7 +1,7 @@
 import {
   ensureServer,
   submitReviewToServer
-} from "./chunk-RICVPPTE.js";
+} from "./chunk-AJGESVAM.js";
 import {
   parseDiff
 } from "./chunk-QGWYCEJN.js";

package/dist/{demo-WVNNI6CE.js → demo-7GBBKPPB.js}

@@ -1,7 +1,7 @@
 import {
   demo
-} from "./chunk-RVI74JF5.js";
-import "./chunk-RICVPPTE.js";
+} from "./chunk-SWSRPUXO.js";
+import "./chunk-AJGESVAM.js";
 import "./chunk-QGWYCEJN.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";

package/dist/mcp-server.js

@@ -6,7 +6,7 @@ import {
   ensureServer,
   isServerAlive,
   submitReviewToServer
-} from "./chunk-RICVPPTE.js";
+} from "./chunk-AJGESVAM.js";
 import {
   getDiff
 } from "./chunk-QGWYCEJN.js";
@@ -144,7 +144,7 @@ async function handlePrReview(pr, options) {
 async function startMcpServer() {
   const server = new McpServer({
     name: "diffprism",
-    version: true ? "0.45.0" : "0.0.0-dev"
+    version: true ? "0.48.0" : "0.0.0-dev"
   });
   server.tool(
     "open_review",

package/package.json

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