diffprism 0.19.1 → 0.20.1

package/dist/bin.js

@@ -6,7 +6,7 @@ import {
   startGlobalServer,
   startReview,
   startWatch
-} from "./chunk-4VXA6GCO.js";
+} from "./chunk-L2D5SDUV.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
@@ -144,6 +144,12 @@ You can also check for feedback without blocking by calling \`get_review_result\
 `;
 
 // cli/src/commands/setup.ts
+var GITIGNORE_ENTRIES = [
+  ".diffprism",
+  ".mcp.json",
+  ".claude/settings.json",
+  ".claude/skills/review/"
+];
 function findGitRoot(from) {
   let dir = path.resolve(from);
   while (true) {
@@ -306,27 +312,28 @@ async function promptUser(question) {
 }
 async function setupGitignore(gitRoot) {
   const filePath = path.join(gitRoot, ".gitignore");
-  const entry = ".diffprism";
   if (fs.existsSync(filePath)) {
     const content = fs.readFileSync(filePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
-    if (lines.includes(entry)) {
+    const missing = GITIGNORE_ENTRIES.filter((e) => !lines.includes(e));
+    if (missing.length === 0) {
       return { action: "skipped", filePath };
     }
-    const newContent = content.endsWith("\n") ? content + entry + "\n" : content + "\n" + entry + "\n";
+    const suffix = missing.map((e) => e + "\n").join("");
+    const newContent = content.endsWith("\n") ? content + suffix : content + "\n" + suffix;
     fs.writeFileSync(filePath, newContent);
     return { action: "updated", filePath };
   }
   const confirmed = await promptUser(
-    "No .gitignore found. Create one with .diffprism entry? (Y/n) "
+    "No .gitignore found. Create one with DiffPrism entries? (Y/n) "
   );
   if (!confirmed) {
     console.log(
-      "  Warning: .diffprism directory will appear in git status and may trigger watch-mode loops."
+      "  Warning: DiffPrism files will appear in git status and may be accidentally committed."
     );
     return { action: "skipped", filePath };
   }
-  fs.writeFileSync(filePath, entry + "\n");
+  fs.writeFileSync(filePath, GITIGNORE_ENTRIES.map((e) => e + "\n").join(""));
   return { action: "created", filePath };
 }
 async function setup(flags) {
@@ -427,6 +434,202 @@ function isGlobalSetupDone() {
   return toolNames.every((t) => allow.includes(t));
 }
 
+// cli/src/commands/teardown.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+function teardownMcpJson(gitRoot) {
+  const filePath = path2.join(gitRoot, ".mcp.json");
+  if (!fs2.existsSync(filePath)) {
+    return { action: "skipped", filePath };
+  }
+  const existing = readJsonFile(filePath);
+  const servers = existing.mcpServers ?? {};
+  if (!servers.diffprism) {
+    return { action: "skipped", filePath };
+  }
+  delete servers.diffprism;
+  if (Object.keys(servers).length === 0) {
+    const { mcpServers: _, ...rest } = existing;
+    if (Object.keys(rest).length === 0) {
+      fs2.unlinkSync(filePath);
+    } else {
+      writeJsonFile(filePath, rest);
+    }
+  } else {
+    writeJsonFile(filePath, { ...existing, mcpServers: servers });
+  }
+  return { action: "removed", filePath };
+}
+function teardownClaudePermissions(baseDir) {
+  const filePath = path2.join(baseDir, ".claude", "settings.json");
+  if (!fs2.existsSync(filePath)) {
+    return { action: "skipped", filePath };
+  }
+  const existing = readJsonFile(filePath);
+  const permissions = existing.permissions ?? {};
+  const allow = permissions.allow ?? [];
+  const toolNames = [
+    "mcp__diffprism__open_review",
+    "mcp__diffprism__update_review_context",
+    "mcp__diffprism__get_review_result"
+  ];
+  const filtered = allow.filter((t) => !toolNames.includes(t));
+  if (filtered.length === allow.length) {
+    return { action: "skipped", filePath };
+  }
+  if (filtered.length > 0) {
+    permissions.allow = filtered;
+  } else {
+    delete permissions.allow;
+  }
+  if (Object.keys(permissions).length === 0) {
+    delete existing.permissions;
+  } else {
+    existing.permissions = permissions;
+  }
+  writeJsonFile(filePath, existing);
+  return { action: "removed", filePath };
+}
+function teardownHooks(gitRoot) {
+  const filePath = path2.join(gitRoot, ".claude", "settings.json");
+  const result = cleanDiffprismHooks(gitRoot);
+  if (result.removed > 0) {
+    const existing = readJsonFile(filePath);
+    const hooks = existing.hooks;
+    if (hooks && Object.keys(hooks).length === 0) {
+      delete existing.hooks;
+      writeJsonFile(filePath, existing);
+    }
+    return { action: "removed", filePath: filePath + " (hooks)" };
+  }
+  return { action: "skipped", filePath: filePath + " (hooks)" };
+}
+function cleanupSettingsFile(baseDir) {
+  const filePath = path2.join(baseDir, ".claude", "settings.json");
+  if (!fs2.existsSync(filePath)) return;
+  const existing = readJsonFile(filePath);
+  if (Object.keys(existing).length === 0) {
+    fs2.unlinkSync(filePath);
+    tryRmdir(path2.join(baseDir, ".claude"));
+  }
+}
+function tryRmdir(dirPath) {
+  try {
+    const entries = fs2.readdirSync(dirPath);
+    if (entries.length === 0) {
+      fs2.rmdirSync(dirPath);
+    }
+  } catch {
+  }
+}
+function teardownSkill(baseDir, global) {
+  const skillDir = global ? path2.join(os2.homedir(), ".claude", "skills", "review") : path2.join(baseDir, ".claude", "skills", "review");
+  const filePath = path2.join(skillDir, "SKILL.md");
+  if (!fs2.existsSync(filePath)) {
+    return { action: "skipped", filePath };
+  }
+  fs2.unlinkSync(filePath);
+  tryRmdir(skillDir);
+  tryRmdir(path2.dirname(skillDir));
+  return { action: "removed", filePath };
+}
+function teardownGitignore(gitRoot) {
+  const filePath = path2.join(gitRoot, ".gitignore");
+  if (!fs2.existsSync(filePath)) {
+    return { action: "skipped", filePath };
+  }
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const entrySet = new Set(GITIGNORE_ENTRIES);
+  const filtered = lines.filter((l) => !entrySet.has(l.trim()));
+  if (filtered.length === lines.length) {
+    return { action: "skipped", filePath };
+  }
+  const newContent = filtered.join("\n");
+  if (newContent.trim() === "") {
+    fs2.unlinkSync(filePath);
+  } else {
+    fs2.writeFileSync(filePath, newContent);
+  }
+  return { action: "removed", filePath };
+}
+function teardownDiffprismDir(gitRoot) {
+  const dirPath = path2.join(gitRoot, ".diffprism");
+  if (!fs2.existsSync(dirPath)) {
+    return { action: "skipped", filePath: dirPath };
+  }
+  fs2.rmSync(dirPath, { recursive: true });
+  return { action: "removed", filePath: dirPath };
+}
+async function teardown(flags) {
+  const global = flags.global ?? false;
+  const quiet = flags.quiet ?? false;
+  const home = os2.homedir();
+  const result = { removed: [], skipped: [] };
+  if (global) {
+    if (!quiet) {
+      console.log("Tearing down DiffPrism global configuration...\n");
+    }
+    const skill2 = teardownSkill("", true);
+    result[skill2.action].push(skill2.filePath);
+    const perms2 = teardownClaudePermissions(home);
+    result[perms2.action].push(perms2.filePath);
+    cleanupSettingsFile(home);
+    if (!quiet) {
+      printTeardownSummary(result, home);
+      console.log("\n\u2713 DiffPrism global configuration removed.");
+    }
+    return result;
+  }
+  const gitRoot = findGitRoot(process.cwd());
+  if (!gitRoot) {
+    console.error(
+      "Error: Not in a git repository. Run this command from inside a git project."
+    );
+    console.error(
+      "Tip: Use `diffprism teardown --global` to remove global DiffPrism configuration."
+    );
+    process.exit(1);
+    return { removed: [], skipped: [] };
+  }
+  if (!quiet) {
+    console.log("Tearing down DiffPrism configuration...\n");
+  }
+  const mcp = teardownMcpJson(gitRoot);
+  result[mcp.action].push(mcp.filePath);
+  const perms = teardownClaudePermissions(gitRoot);
+  result[perms.action].push(perms.filePath);
+  const hooks = teardownHooks(gitRoot);
+  result[hooks.action].push(hooks.filePath);
+  cleanupSettingsFile(gitRoot);
+  const skill = teardownSkill(gitRoot, false);
+  result[skill.action].push(skill.filePath);
+  const gitignore = teardownGitignore(gitRoot);
+  result[gitignore.action].push(gitignore.filePath);
+  const diffprismDir = teardownDiffprismDir(gitRoot);
+  result[diffprismDir.action].push(diffprismDir.filePath);
+  if (!quiet) {
+    printTeardownSummary(result, gitRoot);
+    console.log("\n\u2713 DiffPrism configuration removed.");
+  }
+  return result;
+}
+function printTeardownSummary(result, baseDir) {
+  if (result.removed.length > 0) {
+    console.log("Removed:");
+    for (const f of result.removed) {
+      console.log(`  - ${path2.relative(baseDir, f) || f}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    console.log("Skipped (not found):");
+    for (const f of result.skipped) {
+      console.log(`  . ${path2.relative(baseDir, f) || f}`);
+    }
+  }
+}
+
 // cli/src/commands/start.ts
 async function start(ref, flags) {
   const outcome = await setup({
@@ -629,7 +832,7 @@ async function serverStop() {
 
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.19.1" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.20.1" : "0.0.0-dev");
 program.command("review [ref]").description("Open a browser-based diff review").option("--staged", "Review staged changes").option("--unstaged", "Review unstaged changes").option("-t, --title <title>", "Review title").option("--dev", "Use Vite dev server with HMR instead of static files").action(review);
 program.command("start [ref]").description("Set up DiffPrism and start watching for changes").option("--staged", "Watch staged changes").option("--unstaged", "Watch unstaged changes").option("-t, --title <title>", "Review title").option("--interval <ms>", "Poll interval in milliseconds (default: 1000)").option("--dev", "Use Vite dev server with HMR instead of static files").option("--global", "Install skill globally (~/.claude/skills/)").option("--force", "Overwrite existing configuration files").action(start);
 program.command("watch [ref]").description("Start a persistent diff watcher with live-updating browser UI").option("--staged", "Watch staged changes").option("--unstaged", "Watch unstaged changes").option("-t, --title <title>", "Review title").option("--interval <ms>", "Poll interval in milliseconds (default: 1000)").option("--dev", "Use Vite dev server with HMR instead of static files").action(watch);
@@ -638,6 +841,9 @@ program.command("serve").description("Start the MCP server for Claude Code integ
 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").action((flags) => {
   setup(flags);
 });
+program.command("teardown").description("Remove DiffPrism configuration from the current project").option("--global", "Remove global configuration (skill + permissions at ~/.claude/)").option("-q, --quiet", "Suppress output").action((flags) => {
+  teardown(flags);
+});
 var serverCmd = program.command("server").description("Start the global DiffPrism server for multi-session reviews").option("-p, --port <port>", "HTTP API port (default: 24680)").option("--ws-port <port>", "WebSocket port (default: 24681)").option("--dev", "Use Vite dev server with HMR instead of static files").action(server);
 serverCmd.command("status").description("Check if the global server is running and list active sessions").action(serverStatus);
 serverCmd.command("stop").description("Stop the running global server").action(serverStop);

package/dist/{chunk-4VXA6GCO.js → chunk-L2D5SDUV.js}

@@ -1132,7 +1132,6 @@ async function isServerAlive() {
 }
 
 // packages/core/src/watch.ts
-import { createHash } from "crypto";
 import getPort2 from "get-port";
 import open2 from "open";
 
@@ -1265,7 +1264,8 @@ function createWatchBridge(port, callbacks) {
   });
 }
 
-// packages/core/src/watch.ts
+// packages/core/src/diff-utils.ts
+import { createHash } from "crypto";
 function hashDiff(rawDiff) {
   return createHash("sha256").update(rawDiff).digest("hex");
 }
@@ -1296,6 +1296,8 @@ function detectChangedFiles(oldDiffSet, newDiffSet) {
   }
   return changed;
 }
+
+// packages/core/src/watch.ts
 async function startWatch(options) {
   const {
     diffRef,
@@ -1447,6 +1449,8 @@ import open3 from "open";
 import { WebSocketServer as WebSocketServer3, WebSocket as WebSocket3 } from "ws";
 var sessions2 = /* @__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;
@@ -1466,7 +1470,8 @@ function toSummary(session) {
     additions,
     deletions,
     status: session.status,
-    createdAt: session.createdAt
+    createdAt: session.createdAt,
+    hasNewChanges: session.hasNewChanges
   };
 }
 function readBody(req) {
@@ -1517,6 +1522,93 @@ function sendToSessionClients(sessionId, msg) {
     }
   }
 }
+function hasViewersForSession(sessionId) {
+  for (const [client, sid] of clientSessions.entries()) {
+    if (sid === sessionId && client.readyState === WebSocket3.OPEN) {
+      return true;
+    }
+  }
+  return false;
+}
+function startSessionWatcher(sessionId) {
+  if (sessionWatchers.has(sessionId)) return;
+  const session = sessions2.get(sessionId);
+  if (!session?.diffRef) return;
+  const interval = setInterval(() => {
+    const s = sessions2.get(sessionId);
+    if (!s?.diffRef) {
+      stopSessionWatcher(sessionId);
+      return;
+    }
+    try {
+      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(s.diffRef, {
+        cwd: s.projectPath
+      });
+      const newHash = hashDiff(newRawDiff);
+      if (newHash !== s.lastDiffHash) {
+        const newBriefing = analyze(newDiffSet);
+        const changedFiles = detectChangedFiles(s.lastDiffSet ?? null, newDiffSet);
+        s.payload = {
+          ...s.payload,
+          diffSet: newDiffSet,
+          rawDiff: newRawDiff,
+          briefing: newBriefing
+        };
+        s.lastDiffHash = newHash;
+        s.lastDiffSet = newDiffSet;
+        if (hasViewersForSession(sessionId)) {
+          sendToSessionClients(sessionId, {
+            type: "diff:update",
+            payload: {
+              diffSet: newDiffSet,
+              rawDiff: newRawDiff,
+              briefing: newBriefing,
+              changedFiles,
+              timestamp: Date.now()
+            }
+          });
+          s.hasNewChanges = false;
+        } else {
+          s.hasNewChanges = true;
+          broadcastSessionList();
+        }
+      }
+    } catch {
+    }
+  }, serverPollInterval);
+  sessionWatchers.set(sessionId, interval);
+}
+function stopSessionWatcher(sessionId) {
+  const interval = sessionWatchers.get(sessionId);
+  if (interval) {
+    clearInterval(interval);
+    sessionWatchers.delete(sessionId);
+  }
+}
+function startAllWatchers() {
+  for (const [id, session] of sessions2.entries()) {
+    if (session.diffRef && !sessionWatchers.has(id)) {
+      startSessionWatcher(id);
+    }
+  }
+}
+function stopAllWatchers() {
+  for (const [id, interval] of sessionWatchers.entries()) {
+    clearInterval(interval);
+  }
+  sessionWatchers.clear();
+}
+function hasConnectedClients() {
+  if (!wss) return false;
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket3.OPEN) return true;
+  }
+  return false;
+}
+function broadcastSessionList() {
+  const summaries = Array.from(sessions2.values()).map(toSummary);
+  broadcastToAll({ type: "session:list", payload: summaries });
+}
 async function handleApiRequest(req, res) {
   const method = req.method ?? "GET";
   const url = (req.url ?? "/").split("?")[0];
@@ -1543,18 +1635,28 @@ async function handleApiRequest(req, res) {
   if (method === "POST" && url === "/api/reviews") {
     try {
       const body = await readBody(req);
-      const { payload, projectPath } = JSON.parse(body);
+      const { payload, projectPath, diffRef } = JSON.parse(body);
       const sessionId = `session-${randomUUID().slice(0, 8)}`;
       payload.reviewId = sessionId;
+      if (diffRef) {
+        payload.watchMode = true;
+      }
       const session = {
         id: sessionId,
         payload,
         projectPath,
         status: "pending",
         createdAt: Date.now(),
-        result: null
+        result: null,
+        diffRef,
+        lastDiffHash: diffRef ? hashDiff(payload.rawDiff) : void 0,
+        lastDiffSet: diffRef ? payload.diffSet : void 0,
+        hasNewChanges: false
       };
       sessions2.set(sessionId, session);
+      if (diffRef && hasConnectedClients()) {
+        startSessionWatcher(sessionId);
+      }
       broadcastToAll({
         type: "session:added",
         payload: toSummary(session)
@@ -1644,6 +1746,7 @@ async function handleApiRequest(req, res) {
   }
   const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
   if (deleteParams) {
+    stopSessionWatcher(deleteParams.id);
     if (sessions2.delete(deleteParams.id)) {
       jsonResponse(res, 200, { ok: true });
     } else {
@@ -1659,8 +1762,10 @@ async function startGlobalServer(options = {}) {
     httpPort: preferredHttpPort = 24680,
     wsPort: preferredWsPort = 24681,
     silent = false,
-    dev = false
+    dev = false,
+    pollInterval = 2e3
   } = options;
+  serverPollInterval = pollInterval;
   const [httpPort, wsPort] = await Promise.all([
     getPort3({ port: preferredHttpPort }),
     getPort3({ port: preferredWsPort })
@@ -1686,6 +1791,7 @@ async function startGlobalServer(options = {}) {
   });
   wss = new WebSocketServer3({ 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) {
@@ -1693,6 +1799,7 @@ async function startGlobalServer(options = {}) {
       const session = sessions2.get(sessionId);
       if (session) {
         session.status = "in_review";
+        session.hasNewChanges = false;
         const msg = {
           type: "review:init",
           payload: session.payload
@@ -1711,6 +1818,7 @@ async function startGlobalServer(options = {}) {
         if (session) {
           clientSessions.set(ws, session.id);
           session.status = "in_review";
+          session.hasNewChanges = false;
           ws.send(JSON.stringify({
             type: "review:init",
             payload: session.payload
@@ -1735,17 +1843,32 @@ async function startGlobalServer(options = {}) {
           if (session) {
             clientSessions.set(ws, session.id);
             session.status = "in_review";
+            session.hasNewChanges = false;
+            startSessionWatcher(session.id);
             ws.send(JSON.stringify({
               type: "review:init",
               payload: session.payload
             }));
           }
+        } else if (msg.type === "session:close") {
+          const closedId = msg.payload.sessionId;
+          stopSessionWatcher(closedId);
+          sessions2.delete(closedId);
+          for (const [client, sid] of clientSessions.entries()) {
+            if (sid === closedId) {
+              clientSessions.delete(client);
+            }
+          }
+          broadcastSessionList();
         }
       } catch {
       }
     });
     ws.on("close", () => {
       clientSessions.delete(ws);
+      if (!hasConnectedClients()) {
+        stopAllWatchers();
+      }
     });
   });
   await new Promise((resolve, reject) => {
@@ -1772,19 +1895,13 @@ Waiting for reviews...
   }
   const uiUrl = `http://localhost:${uiPort}?wsPort=${wsPort}&serverMode=true`;
   await open3(uiUrl);
-  function hasConnectedClients() {
-    if (!wss) return false;
-    for (const client of wss.clients) {
-      if (client.readyState === WebSocket3.OPEN) return true;
-    }
-    return false;
-  }
   reopenBrowserIfNeeded = () => {
     if (!hasConnectedClients()) {
       open3(uiUrl);
     }
   };
   async function stop() {
+    stopAllWatchers();
     if (wss) {
       for (const client of wss.clients) {
         client.close();

package/dist/mcp-server.js

@@ -7,7 +7,7 @@ import {
   readReviewResult,
   readWatchFile,
   startReview
-} from "./chunk-4VXA6GCO.js";
+} from "./chunk-L2D5SDUV.js";
 
 // packages/mcp-server/src/index.ts
 import fs from "fs";
@@ -47,7 +47,7 @@ async function reviewViaGlobalServer(serverInfo, diffRef, options) {
     {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ payload, projectPath: cwd })
+      body: JSON.stringify({ payload, projectPath: cwd, diffRef })
     }
   );
   if (!createResponse.ok) {
@@ -76,7 +76,7 @@ async function reviewViaGlobalServer(serverInfo, diffRef, options) {
 async function startMcpServer() {
   const server = new McpServer({
     name: "diffprism",
-    version: true ? "0.19.1" : "0.0.0-dev"
+    version: true ? "0.20.1" : "0.0.0-dev"
   });
   server.tool(
     "open_review",

package/package.json

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