diffprism 0.12.2 → 0.13.0

package/README.md

@@ -60,9 +60,36 @@ diffprism review --staged --title "Add auth middleware"
 
 A browser window opens with the diff viewer. Review the changes and click **Approve**, **Request Changes**, or **Approve with Comments**.
 
+### Watch Mode (live-updating)
+
+Keep a persistent browser tab that auto-refreshes as files change — ideal for reviewing while an agent is working:
+
+```bash
+# Watch staged changes, auto-refresh on every change
+diffprism watch --staged
+
+# Watch all changes with custom poll interval
+diffprism watch --interval 2000
+
+# Watch unstaged changes
+diffprism watch --unstaged
+```
+
+When `diffprism watch` is running:
+- The browser tab stays open and updates diffs + analysis within 1-2s of file changes
+- Submit a review and it stays open, waiting for the next change
+- File review statuses are preserved for unchanged files
+- Claude Code's `/review` skill automatically detects the watch session and pushes reasoning without blocking
+
+Stop the watcher with `Ctrl+C`.
+
 ## MCP Tool Reference
 
-The MCP server exposes one tool: **`open_review`**
+The MCP server exposes two tools:
+
+### `open_review`
+
+Opens a browser-based code review. Blocks until the engineer submits their decision.
 
 | Parameter     | Required | Description                                                       |
 |---------------|----------|-------------------------------------------------------------------|
@@ -71,6 +98,16 @@ The MCP server exposes one tool: **`open_review`**
 | `description` | No       | Description of the changes                                        |
 | `reasoning`   | No       | Agent reasoning about why the changes were made (shown in the reasoning panel) |
 
+### `update_review_context`
+
+Pushes reasoning/context to a running `diffprism watch` session. Non-blocking — returns immediately.
+
+| Parameter     | Required | Description                                    |
+|---------------|----------|------------------------------------------------|
+| `reasoning`   | No       | Agent reasoning about the current changes      |
+| `title`       | No       | Updated title for the review                   |
+| `description` | No       | Updated description of the changes             |
+
 **Returns:** A `ReviewResult` JSON object:
 
 ```json

package/dist/bin.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import {
-  startReview
-} from "./chunk-LOX6GE37.js";
+  readWatchFile,
+  startReview,
+  startWatch
+} from "./chunk-TYUDIWD6.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
@@ -57,7 +59,26 @@ When the user invokes \`/review\`, open the current code changes in DiffPrism fo
 
 ## Steps
 
-### 1. Check for Configuration
+### 1. Check for Watch Mode
+
+Before opening a new review, check if \`diffprism watch\` is already running. Look for \`.diffprism/watch.json\` at the git root. If it exists and the process is alive:
+
+- **Do NOT call \`open_review\`** (the browser is already open with live-updating diffs)
+- Instead, call \`mcp__diffprism__update_review_context\` to push your reasoning to the existing watch session
+- Tell the user: "DiffPrism watch is running \u2014 pushed reasoning to the live review."
+- Skip the remaining steps
+
+### 1b. Check for Pending Review Feedback
+
+If watch mode is running, call \`mcp__diffprism__get_review_result\` to check for pending review feedback from the developer. If a result is returned:
+
+- **\`approved\`** \u2014 Acknowledge approval and continue with your current task.
+- **\`approved_with_comments\`** \u2014 Note the comments, address any actionable feedback.
+- **\`changes_requested\`** \u2014 Read the comments carefully, make the requested changes, then push updated reasoning via \`mcp__diffprism__update_review_context\`.
+
+If no pending result, continue normally.
+
+### 2. Check for Configuration
 
 Look for \`diffprism.config.json\` at the project root. If it exists, read it for preferences:
 
@@ -74,7 +95,7 @@ Look for \`diffprism.config.json\` at the project root. If it exists, read it fo
 - \`defaultDiffScope\`: \`"all"\`
 - \`includeReasoning\`: \`true\`
 
-### 2. First-Run Onboarding
+### 3. First-Run Onboarding
 
 If \`diffprism.config.json\` does **not** exist, ask the user these questions before proceeding:
 
@@ -94,7 +115,7 @@ If \`diffprism.config.json\` does **not** exist, ask the user these questions be
 
 After collecting answers, create \`diffprism.config.json\` at the project root with the user's choices. Then proceed to open the review.
 
-### 3. Open the Review
+### 4. Open the Review
 
 Call \`mcp__diffprism__open_review\` with:
 
@@ -103,7 +124,7 @@ Call \`mcp__diffprism__open_review\` with:
 - \`description\`: A brief description of what changed and why.
 - \`reasoning\`: If \`includeReasoning\` is \`true\`, include your reasoning about the implementation decisions.
 
-### 4. Handle the Result
+### 5. Handle the Result
 
 The tool blocks until the user submits their review in the browser. When it returns:
 
@@ -111,7 +132,7 @@ The tool blocks until the user submits their review in the browser. When it retu
 - **\`approved_with_comments\`** \u2014 Note the comments, address any actionable feedback.
 - **\`changes_requested\`** \u2014 Read the comments carefully, make the requested changes, and offer to open another review.
 
-### 5. Error Handling
+### 6. Error Handling
 
 If the \`mcp__diffprism__open_review\` tool is not available:
 - Tell the user: "The DiffPrism MCP server isn't configured. Run \`npx diffprism setup\` to set it up, then restart Claude Code."
@@ -173,12 +194,19 @@ function setupClaudeSettings(gitRoot, force) {
   const existing = readJsonFile(filePath);
   const permissions = existing.permissions ?? {};
   const allow = permissions.allow ?? [];
-  const toolName = "mcp__diffprism__open_review";
-  if (allow.includes(toolName) && !force) {
+  const toolNames = [
+    "mcp__diffprism__open_review",
+    "mcp__diffprism__update_review_context",
+    "mcp__diffprism__get_review_result"
+  ];
+  const allPresent = toolNames.every((t) => allow.includes(t));
+  if (allPresent && !force) {
     return { action: "skipped", filePath };
   }
-  if (!allow.includes(toolName)) {
-    allow.push(toolName);
+  for (const toolName of toolNames) {
+    if (!allow.includes(toolName)) {
+      allow.push(toolName);
+    }
   }
   permissions.allow = allow;
   const action = fs.existsSync(filePath) ? "updated" : "created";
@@ -207,6 +235,39 @@ function setupSkill(gitRoot, global, force) {
   fs.writeFileSync(filePath, skillContent);
   return { action, filePath };
 }
+function setupStopHook(gitRoot, force) {
+  const filePath = path.join(gitRoot, ".claude", "settings.json");
+  const existing = readJsonFile(filePath);
+  const hooks = existing.hooks ?? {};
+  const stopHooks = hooks.Stop;
+  const hookCommand = "npx diffprism notify-stop";
+  if (stopHooks && !force) {
+    const hasHook = stopHooks.some((entry) => {
+      const innerHooks = entry.hooks;
+      return innerHooks?.some((h) => h.command === hookCommand);
+    });
+    if (hasHook) {
+      return { action: "skipped", filePath };
+    }
+  }
+  const hookEntry = {
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: hookCommand
+      }
+    ]
+  };
+  if (stopHooks && !force) {
+    stopHooks.push(hookEntry);
+  } else {
+    hooks.Stop = [hookEntry];
+  }
+  const action = fs.existsSync(filePath) ? "updated" : "created";
+  writeJsonFile(filePath, { ...existing, hooks });
+  return { action, filePath: filePath + " (Stop hook)" };
+}
 async function setup(flags) {
   const gitRoot = findGitRoot(process.cwd());
   if (!gitRoot) {
@@ -224,6 +285,8 @@ async function setup(flags) {
   result[mcp.action === "skipped" ? "skipped" : mcp.action === "created" ? "created" : "updated"].push(mcp.filePath);
   const settings = setupClaudeSettings(gitRoot, force);
   result[settings.action === "skipped" ? "skipped" : settings.action === "created" ? "created" : "updated"].push(settings.filePath);
+  const hook = setupStopHook(gitRoot, force);
+  result[hook.action === "skipped" ? "skipped" : hook.action === "created" ? "created" : "updated"].push(hook.filePath);
   const skill = setupSkill(gitRoot, global, force);
   result[skill.action === "skipped" ? "skipped" : skill.action === "created" ? "created" : "updated"].push(skill.filePath);
   if (result.created.length > 0) {
@@ -247,15 +310,80 @@ async function setup(flags) {
   console.log(
     "\nYou can now use /review in Claude Code to open a DiffPrism review."
   );
+  console.log(
+    "Or run `diffprism watch --staged` for live-updating reviews."
+  );
   console.log(
     "If Claude Code is running, restart it to pick up the new configuration."
   );
 }
 
+// cli/src/commands/watch.ts
+async function watch(ref, flags) {
+  let diffRef;
+  if (flags.staged) {
+    diffRef = "staged";
+  } else if (flags.unstaged) {
+    diffRef = "unstaged";
+  } else if (ref) {
+    diffRef = ref;
+  } else {
+    diffRef = "all";
+  }
+  const pollInterval = flags.interval ? parseInt(flags.interval, 10) : 1e3;
+  try {
+    const handle = await startWatch({
+      diffRef,
+      title: flags.title,
+      cwd: process.cwd(),
+      dev: flags.dev,
+      pollInterval
+    });
+    const shutdown = async () => {
+      console.log("\nStopping watch...");
+      await handle.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+
+// cli/src/commands/notify-stop.ts
+async function notifyStop() {
+  try {
+    const watchInfo = readWatchFile();
+    if (!watchInfo) {
+      process.exit(0);
+      return;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2e3);
+    try {
+      await fetch(`http://localhost:${watchInfo.wsPort}/api/refresh`, {
+        method: "POST",
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch {
+  }
+  process.exit(0);
+}
+
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.12.2" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.13.0" : "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("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);
+program.command("notify-stop").description("Signal the watch server to refresh (used by Claude Code hooks)").action(notifyStop);
 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", "Install skill globally (~/.claude/skills/)").option("--force", "Overwrite existing configuration files").action(setup);
 program.parse();