diffprism 0.44.0 → 0.47.0

package/dist/bin.js

@@ -1,25 +1,21 @@
 #!/usr/bin/env node
 import {
-  createGitHubClient,
-  fetchPullRequest,
-  fetchPullRequestDiff,
   isPrRef,
-  normalizePr,
-  parsePrRef,
-  resolveGitHubToken,
-  submitGitHubReview
-} from "./chunk-6J6PSBL2.js";
+  parsePrRef
+} from "./chunk-24B33UN6.js";
 import {
   demo
-} from "./chunk-LH6H3QSC.js";
+} from "./chunk-TZ5SGWHP.js";
 import {
   ensureServer,
   isServerAlive,
   readServerFile,
   startGlobalServer,
   submitReviewToServer
-} from "./chunk-4IQOTAHD.js";
-import "./chunk-QGWYCEJN.js";
+} from "./chunk-PQWU5NW4.js";
+import {
+  getDiff
+} from "./chunk-QGWYCEJN.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";
 
@@ -27,7 +23,6 @@ import "./chunk-JSBRDJBE.js";
 import { Command } from "commander";
 
 // cli/src/commands/review.ts
-import readline from "readline";
 async function review(ref, flags) {
   let diffRef;
   if (flags.staged) {
@@ -46,72 +41,54 @@ 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 token = resolveGitHubToken();
   const { owner, repo, number } = parsePrRef(pr);
   console.log(`Fetching PR #${number} from ${owner}/${repo}...`);
-  const client = createGitHubClient(token);
-  const [prMetadata, rawDiff] = await Promise.all([
-    fetchPullRequest(client, owner, repo, number),
-    fetchPullRequestDiff(client, owner, repo, number)
-  ]);
-  if (!rawDiff.trim()) {
-    console.log("PR has no changes to review.");
-    return;
-  }
-  const { payload, diffSet } = normalizePr(rawDiff, prMetadata, {
-    title: flags.title,
-    reasoning: flags.reasoning
-  });
-  console.log(
-    `${diffSet.files.length} files, +${diffSet.files.reduce((s, f) => s + f.additions, 0)} -${diffSet.files.reduce((s, f) => s + f.deletions, 0)}`
-  );
   const serverInfo = await ensureServer({ dev: flags.dev });
-  const { result } = await submitReviewToServer(serverInfo, `PR #${number}`, {
-    injectedPayload: payload,
-    projectPath: `github:${owner}/${repo}`,
-    diffRef: `PR #${number}`
-  });
-  console.log(JSON.stringify(result, null, 2));
-  if (result && (flags.postToGithub || result.decision !== "dismissed" && await promptPostToGithub())) {
-    console.log("Posting review to GitHub...");
-    const posted = await submitGitHubReview(client, owner, repo, number, result);
-    if (posted) {
-      console.log(`Review posted: ${prMetadata.url}#pullrequestreview-${posted.reviewId}`);
+  const response = await fetch(
+    `http://localhost:${serverInfo.httpPort}/api/pr/open`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prUrl: pr })
     }
+  );
+  const data = await response.json();
+  if (!response.ok || !data.sessionId) {
+    console.error(`Error: ${data.error ?? "Failed to open PR"}`);
+    process.exit(1);
   }
-  process.exit(0);
-}
-async function promptPostToGithub() {
-  if (!process.stdin.isTTY) {
-    return false;
+  console.log(`${data.pr?.title ?? `PR #${number}`}`);
+  console.log(`${data.fileCount} file${data.fileCount !== 1 ? "s" : ""} changed`);
+  if (data.localRepoPath) {
+    console.log(`Local repo: ${data.localRepoPath}`);
+  } else {
+    console.log("No local clone detected \u2014 file context unavailable");
   }
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    rl.question("Post this review to GitHub? (y/N) ", (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase() === "y");
-    });
-  });
+  console.log(`
+Review open in browser. Use Claude Code to ask questions about this PR.`);
+  console.log(`MCP tools available: get_pr_context, get_file_diff, get_file_context, add_review_comment`);
 }
 
 // cli/src/commands/serve.ts
@@ -124,7 +101,7 @@ async function serve() {
 import fs from "fs";
 import path from "path";
 import os from "os";
-import readline2 from "readline";
+import readline from "readline";
 
 // cli/src/templates/skill.ts
 var skillContent = `---
@@ -134,7 +111,7 @@ description: Open current code changes in DiffPrism's browser-based review UI fo
 
 # DiffPrism Review
 
-You have 9 DiffPrism MCP tools available. Use them proactively \u2014 don't wait for the user to ask.
+You have 14 DiffPrism MCP tools available. Use them proactively \u2014 don't wait for the user to ask.
 
 ## Workflow 1: Self-Review Before Human Review
 
@@ -173,22 +150,32 @@ Handle the review result:
 - If \`postReviewAction\` is \`"commit"\` \u2014 commit the changes.
 - If \`postReviewAction\` is \`"commit_and_pr"\` \u2014 commit and open a PR.
 
-## Workflow 3: PR Review
+## Workflow 3: PR Super Review
+
+When the user opens a GitHub PR for review (via \`diffprism review <PR URL>\` or the DiffPrism UI), you become their AI-powered code reviewer. The diff is visible in the browser; you provide the intelligence.
 
-To review a GitHub pull request:
+### Getting oriented
+1. Call \`mcp__diffprism__get_pr_context\` to understand the PR: title, author, branches, file list, briefing summary, and whether a local repo is connected.
 
-1. Call \`mcp__diffprism__review_pr\` with \`pr: "owner/repo#123"\` or a full GitHub PR URL
-2. Set \`post_to_github: true\` to post the review back to GitHub after the human submits
-3. The tool fetches the PR diff, runs analysis, and opens the review UI
+### Investigating changes
+2. Call \`mcp__diffprism__get_file_diff\` for specific files to see their hunks and triage category (critical/notable/mechanical).
+3. Call \`mcp__diffprism__get_file_context\` to read full files from the local repo \u2014 this gives you surrounding code, not just diff hunks. Use this to understand how changed code fits into the broader file.
+4. Call \`mcp__diffprism__get_user_focus\` to see what file/line the user is currently viewing in the browser. Proactively offer context about what they're looking at.
+
+### Leaving findings
+5. Call \`mcp__diffprism__add_review_comment\` to post findings directly to the browser UI. Comments appear as inline annotations on the diff in real-time. Use this to flag issues, suggest improvements, or answer the user's questions visually.
+6. Call \`mcp__diffprism__get_review_comments\` to see what's already been noted before adding your own.
+
+### Key principle
+The user sees the diff in the browser. You see it through MCP tools. Work together \u2014 they spot visual patterns, you analyze logic and context.
 
 ## Tool Reference
 
 ### Review Lifecycle
 | Tool | Purpose |
 |------|---------|
-| \`open_review\` | Open browser review UI for local changes. Blocks until submitted. |
-| \`review_pr\` | Open browser review UI for a GitHub PR. Blocks until submitted. |
-| \`get_review_result\` | Fetch result from a previous review (advanced \u2014 \`open_review\` already returns it). |
+| \`open_review\` | Open browser review UI for local changes or a GitHub PR. |
+| \`get_review_result\` | Fetch result from a previous review. |
 | \`update_review_context\` | Push updated reasoning/description to a running review session. |
 
 ### Headless Analysis
@@ -197,10 +184,20 @@ To review a GitHub pull request:
 | \`analyze_diff\` | Returns analysis JSON (patterns, complexity, test gaps) without opening a browser. |
 | \`get_diff\` | Returns structured diff JSON (file-level and hunk-level changes). |
 
-### Annotation & Flagging
+### PR Super Review
+| Tool | Purpose |
+|------|---------|
+| \`get_pr_context\` | High-level PR overview: metadata, briefing, file list, local repo status. |
+| \`get_file_diff\` | Diff hunks for a specific file with triage category. |
+| \`get_file_context\` | Full file content from local repo via \`git show\`. |
+| \`get_user_focus\` | What file/line the user is currently viewing in the browser UI. |
+
+### Annotation & Commenting
 | Tool | Purpose |
 |------|---------|
-| \`add_annotation\` | Post a finding/suggestion/question on a specific line in a running review. |
+| \`add_review_comment\` | Post a comment that appears inline in the browser diff. |
+| \`get_review_comments\` | Read all comments and annotations on the session. |
+| \`add_annotation\` | Post a structured finding (finding/suggestion/question/warning). |
 | \`flag_for_attention\` | Mark files for human attention with warning annotations. |
 | \`get_review_state\` | Get current state of a review session including all annotations. |
 
@@ -209,6 +206,7 @@ To review a GitHub pull request:
 - **Self-review is proactive** \u2014 run \`analyze_diff\` after significant changes without being asked.
 - **Human review requires explicit request** \u2014 only open \`open_review\` when the user asks (\`/review\`, "review my changes", or as part of a defined workflow like PR creation).
 - **Annotate generously** \u2014 the more context you provide in annotations, the faster the reviewer can make decisions.
+- **PR review is conversational** \u2014 when a PR is open, use the super review tools to answer questions and post findings without being asked to use specific tools.
 `;
 
 // cli/src/commands/setup.ts
@@ -306,7 +304,7 @@ function setupSkill(gitRoot, global, force) {
   return { action, filePath };
 }
 async function promptUser(question) {
-  const rl = readline2.createInterface({
+  const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -379,7 +377,7 @@ async function setupInteractive(flags) {
 }
 async function runDemo(dev) {
   console.log("");
-  const { demo: demo2 } = await import("./demo-MDPKCAXZ.js");
+  const { demo: demo2 } = await import("./demo-H2NAMKCT.js");
   await demo2({ dev });
 }
 async function setupBatch(flags) {
@@ -712,9 +710,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);
   }
@@ -787,8 +785,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);
   }
 }
@@ -822,7 +820,7 @@ async function fetchStatus(httpPort) {
   return await response.json();
 }
 function printStatus(status, httpPort) {
-  const version = true ? "0.44.0" : "0.0.0-dev";
+  const version = true ? "0.47.0" : "0.0.0-dev";
   console.log(`
 DiffPrism v${version}
 `);
@@ -854,19 +852,211 @@ 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.44.0" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.47.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);