diffprism 0.13.7 → 0.14.0

package/dist/bin.js

@@ -3,7 +3,7 @@ import {
   readWatchFile,
   startReview,
   startWatch
-} from "./chunk-QB2PKDLU.js";
+} from "./chunk-TVXIMP3G.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
@@ -18,7 +18,7 @@ async function review(ref, flags) {
   } else if (ref) {
     diffRef = ref;
   } else {
-    diffRef = "all";
+    diffRef = "working-copy";
   }
   try {
     const result = await startReview({
@@ -66,57 +66,29 @@ Before opening a new review, check if \`diffprism watch\` is already running. Lo
 
 - **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
+- Then **immediately** call \`mcp__diffprism__get_review_result\` with \`wait: true\` to block until the developer submits their review
+- Tell the user: "DiffPrism watch is running \u2014 pushed reasoning to the live review. Waiting for your feedback..."
+- When the result comes back, handle it per step 5 below
+- Skip steps 2-4
 
-### 1b. Check for Pending Review Feedback
+### 2. Load Configuration
 
-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:
+Look for \`diffprism.config.json\` at the project root. If it exists, read it for preferences. If it doesn't exist, use defaults silently \u2014 do not prompt or create the file.
 
 \`\`\`json
 {
   "reviewTrigger": "ask | before_commit | always",
-  "defaultDiffScope": "staged | unstaged | all",
+  "defaultDiffScope": "staged | unstaged | working-copy",
   "includeReasoning": true | false
 }
 \`\`\`
 
 **Defaults** (when fields are missing or file doesn't exist):
 - \`reviewTrigger\`: \`"ask"\`
-- \`defaultDiffScope\`: \`"all"\`
+- \`defaultDiffScope\`: \`"working-copy"\`
 - \`includeReasoning\`: \`true\`
 
-### 3. First-Run Onboarding
-
-If \`diffprism.config.json\` does **not** exist, ask the user these questions before proceeding:
-
-1. **"When should I open DiffPrism reviews?"**
-   - \`"ask"\` \u2014 Only when you explicitly ask (default)
-   - \`"before_commit"\` \u2014 Automatically before every commit
-   - \`"always"\` \u2014 After every code change
-
-2. **"What should the default diff scope be?"**
-   - \`"all"\` \u2014 All changes, staged and unstaged (default)
-   - \`"staged"\` \u2014 Only staged changes
-   - \`"unstaged"\` \u2014 Only unstaged changes
-
-3. **"Should I include my reasoning about the changes in reviews?"**
-   - Yes (default)
-   - No
-
-After collecting answers, create \`diffprism.config.json\` at the project root with the user's choices. Then proceed to open the review.
-
-### 4. Open the Review
+### 3. Open the Review
 
 Call \`mcp__diffprism__open_review\` with:
 
@@ -125,7 +97,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.
 
-### 5. Handle the Result
+### 4. Handle the Result
 
 The tool blocks until the user submits their review in the browser. When it returns:
 
@@ -133,21 +105,24 @@ 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.
 
-### 6. Error Handling
+### 5. 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."
+- Tell the user: "The DiffPrism MCP server isn't configured. Run \`npx diffprism start\` to set it up, then restart Claude Code."
 
-## Watch Mode: Polling for Review Feedback
+## Watch Mode: Waiting for Review Feedback
 
-When \`diffprism watch\` is active (detected via \`.diffprism/watch.json\`), the developer can submit reviews at any time in the browser. Since there is no push notification, **you must poll for feedback** to close the loop.
+When \`diffprism watch\` is active (detected via \`.diffprism/watch.json\`), the developer can submit reviews at any time in the browser.
 
-**After pushing context to a watch session**, call \`mcp__diffprism__get_review_result\` to check for pending feedback:
-- **Between tasks** \u2014 Before starting a new piece of work, check for feedback.
-- **After making changes** \u2014 After addressing requested changes, push updated reasoning via \`update_review_context\`, then check again shortly after.
-- **When the user mentions review feedback** \u2014 If the user says they submitted a review or left comments, check immediately.
+**After pushing context to a watch session**, call \`mcp__diffprism__get_review_result\` with \`wait: true\` to block until the developer submits their review. This polls the result file every 2 seconds and returns as soon as feedback is available (up to 5 minutes by default).
 
-Do not poll in a tight loop. Check at natural breakpoints in your workflow (e.g., after finishing a subtask, before committing, before moving to the next file).
+Use this pattern:
+1. Push context via \`update_review_context\`
+2. Call \`get_review_result\` with \`wait: true\` \u2014 this blocks until the developer submits
+3. Handle the result (approved, changes_requested, etc.)
+4. If changes were requested, make fixes, push updated context, and call \`get_review_result\` with \`wait: true\` again
+
+You can also check for feedback without blocking by calling \`get_review_result\` without \`wait\` at natural breakpoints (between tasks, before committing, etc.).
 
 ## Behavior Rules
 
@@ -156,7 +131,7 @@ Do not poll in a tight loop. Check at natural breakpoints in your workflow (e.g.
   - \`"ask"\` \u2014 Never auto-review; only review when the user asks.
   - \`"before_commit"\` \u2014 Open a review before creating any git commit.
   - \`"always"\` \u2014 Open a review after any code change.
-- To re-run onboarding, the user can delete \`diffprism.config.json\` and invoke \`/review\` again.
+- Power users can create \`diffprism.config.json\` manually to customize defaults.
 `;
 
 // cli/src/commands/setup.ts
@@ -247,6 +222,34 @@ function setupSkill(gitRoot, global, force) {
   fs.writeFileSync(filePath, skillContent);
   return { action, filePath };
 }
+function cleanDiffprismHooks(gitRoot) {
+  const filePath = path.join(gitRoot, ".claude", "settings.json");
+  const existing = readJsonFile(filePath);
+  const hooks = existing.hooks;
+  if (!hooks) return { removed: 0 };
+  const stopHooks = hooks.Stop;
+  if (!Array.isArray(stopHooks) || stopHooks.length === 0) {
+    return { removed: 0 };
+  }
+  const filtered = stopHooks.filter((entry) => {
+    const innerHooks = entry.hooks;
+    if (!Array.isArray(innerHooks)) return true;
+    return !innerHooks.some((h) => {
+      const cmd = h.command;
+      return typeof cmd === "string" && cmd.includes("diffprism") && cmd.includes("notify-stop");
+    });
+  });
+  const removed = stopHooks.length - filtered.length;
+  if (removed > 0) {
+    if (filtered.length > 0) {
+      hooks.Stop = filtered;
+    } else {
+      delete hooks.Stop;
+    }
+    writeJsonFile(filePath, { ...existing, hooks });
+  }
+  return { removed };
+}
 function setupStopHook(gitRoot, force) {
   const filePath = path.join(gitRoot, ".claude", "settings.json");
   const existing = readJsonFile(filePath);
@@ -324,11 +327,14 @@ async function setup(flags) {
       "Error: Not in a git repository. Run this command from inside a git project."
     );
     process.exit(1);
-    return;
+    return { created: [], updated: [], skipped: [] };
   }
   const force = flags.force ?? false;
   const global = flags.global ?? false;
-  console.log("Setting up DiffPrism for Claude Code...\n");
+  const quiet = flags.quiet ?? false;
+  if (!quiet) {
+    console.log("Setting up DiffPrism for Claude Code...\n");
+  }
   const result = { created: [], updated: [], skipped: [] };
   const gitignore = await setupGitignore(gitRoot);
   result[gitignore.action].push(gitignore.filePath);
@@ -336,37 +342,92 @@ 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 cleaned = cleanDiffprismHooks(gitRoot);
+  if (cleaned.removed > 0 && !quiet) {
+    console.log(`  Cleaned ${cleaned.removed} stale hook(s)`);
+  }
   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) {
-    console.log("Created:");
-    for (const f of result.created) {
-      console.log(`  + ${path.relative(gitRoot, f)}`);
+  if (!quiet) {
+    if (result.created.length > 0) {
+      console.log("Created:");
+      for (const f of result.created) {
+        console.log(`  + ${path.relative(gitRoot, f)}`);
+      }
     }
-  }
-  if (result.updated.length > 0) {
-    console.log("Updated:");
-    for (const f of result.updated) {
-      console.log(`  ~ ${path.relative(gitRoot, f)}`);
+    if (result.updated.length > 0) {
+      console.log("Updated:");
+      for (const f of result.updated) {
+        console.log(`  ~ ${path.relative(gitRoot, f)}`);
+      }
     }
+    if (result.skipped.length > 0) {
+      console.log("Skipped (already configured):");
+      for (const f of result.skipped) {
+        console.log(`  - ${path.relative(gitRoot, f)}`);
+      }
+    }
+    console.log("\n\u2713 DiffPrism configured for Claude Code.\n");
+    console.log("Next steps:");
+    console.log("  1. Restart Claude Code to pick up the MCP configuration");
+    console.log("  2. Use /review in Claude Code to review your changes\n");
+    console.log("Tip: Run `diffprism start` to combine setup + live watch mode.");
+  }
+  return result;
+}
+
+// cli/src/commands/start.ts
+async function start(ref, flags) {
+  const outcome = await setup({
+    global: flags.global,
+    force: flags.force,
+    quiet: true
+  });
+  const hasChanges = outcome.created.length > 0 || outcome.updated.length > 0;
+  if (hasChanges) {
+    console.log("\u2713 DiffPrism configured for Claude Code.");
   }
-  if (result.skipped.length > 0) {
-    console.log("Skipped (already configured):");
-    for (const f of result.skipped) {
-      console.log(`  - ${path.relative(gitRoot, f)}`);
+  let diffRef;
+  if (flags.staged) {
+    diffRef = "staged";
+  } else if (flags.unstaged) {
+    diffRef = "unstaged";
+  } else if (ref) {
+    diffRef = ref;
+  } else {
+    diffRef = "working-copy";
+  }
+  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
+    });
+    console.log("Use /review in Claude Code to send changes for review.");
+    if (hasChanges) {
+      console.log(
+        "If this is your first time, restart Claude Code first to load the MCP server."
+      );
     }
+    const shutdown = async () => {
+      console.log("\nStopping DiffPrism...");
+      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);
   }
-  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
@@ -379,7 +440,7 @@ async function watch(ref, flags) {
   } else if (ref) {
     diffRef = ref;
   } else {
-    diffRef = "all";
+    diffRef = "working-copy";
   }
   const pollInterval = flags.interval ? parseInt(flags.interval, 10) : 1e3;
   try {
@@ -431,10 +492,13 @@ async function notifyStop() {
 
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.13.7" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.14.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("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);
 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.command("setup").description("Configure DiffPrism for Claude Code integration").option("--global", "Install skill globally (~/.claude/skills/)").option("--force", "Overwrite existing configuration files").action((flags) => {
+  setup(flags);
+});
 program.parse();

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

@@ -303,6 +303,9 @@ function parseDiff(rawDiff, baseRef, headRef) {
 
 // packages/git/src/index.ts
 function getDiff(ref, options) {
+  if (ref === "working-copy") {
+    return getWorkingCopyDiff(options);
+  }
   const rawDiff = getGitDiff(ref, options);
   let baseRef;
   let headRef;
@@ -323,6 +326,29 @@ function getDiff(ref, options) {
   const diffSet = parseDiff(rawDiff, baseRef, headRef);
   return { diffSet, rawDiff };
 }
+function getWorkingCopyDiff(options) {
+  const stagedRaw = getGitDiff("staged", options);
+  const unstagedRaw = getGitDiff("unstaged", options);
+  const stagedDiffSet = parseDiff(stagedRaw, "HEAD", "staged");
+  const unstagedDiffSet = parseDiff(unstagedRaw, "staged", "working tree");
+  const stagedFiles = stagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "staged"
+  }));
+  const unstagedFiles = unstagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "unstaged"
+  }));
+  const rawDiff = [stagedRaw, unstagedRaw].filter(Boolean).join("");
+  return {
+    diffSet: {
+      baseRef: "HEAD",
+      headRef: "working tree",
+      files: [...stagedFiles, ...unstagedFiles]
+    },
+    rawDiff
+  };
+}
 
 // packages/analysis/src/deterministic.ts
 function categorizeFiles(files) {
@@ -1173,25 +1199,29 @@ function createWatchBridge(port, callbacks) {
 function hashDiff(rawDiff) {
   return createHash("sha256").update(rawDiff).digest("hex");
 }
+function fileKey(file) {
+  return file.stage ? `${file.stage}:${file.path}` : file.path;
+}
 function detectChangedFiles(oldDiffSet, newDiffSet) {
   if (!oldDiffSet) {
-    return newDiffSet.files.map((f) => f.path);
+    return newDiffSet.files.map(fileKey);
   }
   const oldFiles = new Map(
-    oldDiffSet.files.map((f) => [f.path, f])
+    oldDiffSet.files.map((f) => [fileKey(f), f])
   );
   const changed = [];
   for (const newFile of newDiffSet.files) {
-    const oldFile = oldFiles.get(newFile.path);
+    const key = fileKey(newFile);
+    const oldFile = oldFiles.get(key);
     if (!oldFile) {
-      changed.push(newFile.path);
+      changed.push(key);
     } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
-      changed.push(newFile.path);
+      changed.push(key);
     }
   }
   for (const oldFile of oldDiffSet.files) {
-    if (!newDiffSet.files.some((f) => f.path === oldFile.path)) {
-      changed.push(oldFile.path);
+    if (!newDiffSet.files.some((f) => fileKey(f) === fileKey(oldFile))) {
+      changed.push(fileKey(oldFile));
     }
   }
   return changed;

package/dist/mcp-server.js

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

package/package.json

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