diffprism 0.34.1 → 0.35.0

package/dist/bin.js

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
 import {
   createGitHubClient,
+  ensureServer,
   fetchPullRequest,
   fetchPullRequestDiff,
   isServerAlive,
   normalizePr,
   parsePrRef,
   readServerFile,
-  readWatchFile,
   resolveGitHubToken,
   startGlobalServer,
-  startReview,
-  startWatch,
-  submitGitHubReview
-} from "./chunk-VASCXEMN.js";
+  submitGitHubReview,
+  submitReviewToServer
+} from "./chunk-LUUR6LNP.js";
+import "./chunk-QGWYCEJN.js";
+import "./chunk-DHCVZGHE.js";
+import "./chunk-JSBRDJBE.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
@@ -31,11 +33,11 @@ async function review(ref, flags) {
     diffRef = "working-copy";
   }
   try {
-    const result = await startReview({
-      diffRef,
+    const serverInfo = await ensureServer({ dev: flags.dev });
+    const { result } = await submitReviewToServer(serverInfo, diffRef, {
       title: flags.title,
       cwd: process.cwd(),
-      dev: flags.dev
+      diffRef
     });
     console.log(JSON.stringify(result, null, 2));
     process.exit(0);
@@ -62,46 +64,19 @@ async function reviewPr(pr, flags) {
       console.log("PR has no changes to review.");
       return;
     }
-    const { payload, diffSet, briefing, metadata } = normalizePr(rawDiff, prMetadata, {
+    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)}`
     );
-    let result;
-    const serverInfo = await isServerAlive();
-    if (serverInfo) {
-      const createResponse = await fetch(
-        `http://localhost:${serverInfo.httpPort}/api/reviews`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            payload,
-            projectPath: `github:${owner}/${repo}`,
-            diffRef: `PR #${number}`
-          })
-        }
-      );
-      if (!createResponse.ok) {
-        throw new Error(`Global server returned ${createResponse.status}`);
-      }
-      const { sessionId } = await createResponse.json();
-      console.log(`Review session created: ${sessionId}`);
-      console.log("Waiting for review submission...");
-      result = await pollForResult(serverInfo.httpPort, sessionId);
-    } else {
-      result = await startReview({
-        diffRef: `PR #${number}`,
-        title: metadata.title,
-        description: metadata.description,
-        reasoning: metadata.reasoning,
-        cwd: process.cwd(),
-        dev: flags.dev,
-        injectedPayload: payload
-      });
-    }
+    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 (flags.postToGithub || result.decision !== "dismissed" && await promptPostToGithub()) {
       console.log("Posting review to GitHub...");
@@ -117,24 +92,6 @@ async function reviewPr(pr, flags) {
     process.exit(1);
   }
 }
-async function pollForResult(httpPort, sessionId) {
-  const pollIntervalMs = 2e3;
-  const maxWaitMs = 600 * 1e3;
-  const start2 = Date.now();
-  while (Date.now() - start2 < maxWaitMs) {
-    const response = await fetch(
-      `http://localhost:${httpPort}/api/reviews/${sessionId}/result`
-    );
-    if (response.ok) {
-      const data = await response.json();
-      if (data.result) {
-        return data.result;
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-  }
-  throw new Error("Review timed out waiting for submission.");
-}
 async function promptPostToGithub() {
   if (!process.stdin.isTTY) {
     return false;
@@ -169,130 +126,30 @@ name: review
 description: Open current code changes in DiffPrism's browser-based review UI for human review.
 ---
 
-# DiffPrism Review Skill
-
-When the user invokes \`/review\`, open the current code changes in DiffPrism for browser-based human review.
-
-## Steps
-
-### 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
-- 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
-
-### 2. Load Configuration
-
-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
-{
-  "defaultDiffScope": "staged | unstaged | working-copy",
-  "includeReasoning": true | false
-}
-\`\`\`
-
-**Defaults** (when fields are missing or file doesn't exist):
-- \`defaultDiffScope\`: \`"working-copy"\`
-- \`includeReasoning\`: \`true\`
-
-### 3. Open the Review
-
-Call \`mcp__diffprism__open_review\` with:
-
-- \`diff_ref\`: Use the \`defaultDiffScope\` from config. If the user specified a scope in their message (e.g., "/review staged"), use that instead.
-- \`title\`: A short summary of the changes (generate from git status or the user's message).
-- \`description\`: A brief description of what changed and why.
-- \`reasoning\`: If \`includeReasoning\` is \`true\`, include your reasoning about the implementation decisions.
+# DiffPrism Review
 
-### 4. Handle the Result
+When the user invokes \`/review\`, call \`mcp__diffprism__open_review\` with:
 
-The tool blocks until the user submits their review in the browser. When it returns:
+- \`diff_ref\`: \`"working-copy"\` (or what the user specified, e.g. \`"staged"\`)
+- \`title\`: Brief summary of the changes
+- \`reasoning\`: Your reasoning about the implementation decisions
 
-- **\`approved\`** \u2014 Acknowledge and proceed with whatever task was in progress.
-- **\`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.
+The tool blocks until the human submits their review. Handle the result:
 
-#### Post-Review Actions
+- **\`approved\`** \u2014 Proceed with the task.
+- **\`changes_requested\`** \u2014 Read comments, make fixes, offer to re-review.
+- If \`postReviewAction\` is \`"commit"\` \u2014 commit the changes.
+- If \`postReviewAction\` is \`"commit_and_pr"\` \u2014 commit and open a PR.
 
-The result may include a \`postReviewAction\` field. If present, **execute the action immediately without asking for confirmation** \u2014 the user already chose this action in the review UI:
+## Headless Tools
 
-- **\`"commit"\`** \u2014 Commit the reviewed changes (stage relevant files, create a commit with an appropriate message).
-- **\`"commit_and_pr"\`** \u2014 Commit the changes and open a pull request.
+- \`mcp__diffprism__analyze_diff\` \u2014 Returns analysis JSON (patterns, complexity, test gaps) without opening a browser. Use proactively to self-check before requesting review.
+- \`mcp__diffprism__get_diff\` \u2014 Returns structured diff JSON.
 
-If \`postReviewAction\` is not present or is empty, do nothing extra \u2014 just report the result.
+## Rules
 
-### 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."
-
-## Global Server Mode
-
-When a global DiffPrism server is running (\`diffprism server\`), the MCP tools automatically detect it and route reviews there instead of opening a new browser tab each time. The review appears in the server's multi-session UI at the existing browser tab.
-
-This is transparent \u2014 the same \`open_review\`, \`update_review_context\`, and \`get_review_result\` tools work the same way. No changes to the workflow are needed.
-
-## 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.
-
-**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).
-
-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.).
-
-## Self-Review: Headless Analysis Tools
-
-DiffPrism provides two headless tools that return analysis data as JSON without opening a browser. Use these to check your own work before requesting human review.
-
-### Available Headless Tools
-
-- **\`mcp__diffprism__get_diff\`** \u2014 Returns a structured \`DiffSet\` (files, hunks, additions/deletions) for a given diff ref. Use this to inspect exactly what changed.
-- **\`mcp__diffprism__analyze_diff\`** \u2014 Returns a \`ReviewBriefing\` with summary, file triage, impact detection, complexity scores, test coverage gaps, and pattern flags (security issues, TODOs, console.logs left in, etc.).
-
-Both accept a \`diff_ref\` parameter: \`"staged"\`, \`"unstaged"\`, \`"working-copy"\`, or a git range like \`"HEAD~3..HEAD"\`.
-
-### Self-Review Loop
-
-When you've finished writing code and before requesting human review, use this pattern:
-
-1. **Analyze your changes:** Call \`mcp__diffprism__analyze_diff\` with \`diff_ref: "working-copy"\`
-2. **Check the briefing for issues:**
-   - \`patterns\` \u2014 Look for console.logs, TODOs, security flags, disabled tests
-   - \`testCoverage\` \u2014 Check if changed source files have corresponding test changes
-   - \`complexity\` \u2014 Review high-complexity scores
-   - \`impact.newDependencies\` \u2014 Verify any new deps are intentional
-   - \`impact.breakingChanges\` \u2014 Confirm breaking changes are expected
-3. **Fix any issues found** \u2014 Remove debug statements, add missing tests, address security flags
-4. **Re-analyze** \u2014 Run \`analyze_diff\` again to confirm the issues are resolved
-5. **Open for human review** \u2014 Once clean, use \`/review\` or \`open_review\` for final human sign-off
-
-This loop catches common issues (leftover console.logs, missing tests, security anti-patterns) before the human reviewer sees them, making reviews faster and more focused.
-
-### When to Use Headless Tools
-
-- **After completing a coding task** \u2014 Self-check before requesting review
-- **During implementation** \u2014 Periodically check for patterns and issues as you work
-- **Before committing** \u2014 Quick sanity check on what's about to be committed
-- **Do NOT use these as a replacement for human review** \u2014 They complement, not replace, \`/review\`
-
-## Behavior Rules
-
-- **IMPORTANT: Do NOT open reviews automatically.** Only open a review when the user explicitly invokes \`/review\` or directly asks for a review.
-- Do NOT open reviews before commits, after code changes, or at any other time unless the user requests it.
-- Headless tools (\`get_diff\`, \`analyze_diff\`) can be used proactively during development without explicit user request \u2014 they don't open a browser or interrupt the user.
-- Power users can create \`diffprism.config.json\` manually to customize defaults (diff scope, reasoning).
+- Only open a review when the user explicitly asks (\`/review\` or "review my changes").
+- Headless tools can be used proactively without user request.
 `;
 
 // cli/src/commands/setup.ts
@@ -808,7 +665,7 @@ async function start(ref, flags) {
   });
   const hasChanges = outcome.created.length > 0 || outcome.updated.length > 0;
   if (hasChanges) {
-    console.log("\u2713 DiffPrism configured for Claude Code.");
+    console.log("DiffPrism configured for Claude Code.");
   }
   let diffRef;
   if (flags.staged) {
@@ -820,30 +677,23 @@ async function start(ref, flags) {
   } 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.");
+    const serverInfo = await ensureServer({ dev: flags.dev });
+    console.log(
+      `DiffPrism server at http://localhost:${serverInfo.httpPort}`
+    );
     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(() => {
+    const { result } = await submitReviewToServer(serverInfo, diffRef, {
+      title: flags.title,
+      cwd: process.cwd(),
+      diffRef
     });
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(0);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`Error: ${message}`);
@@ -863,24 +713,19 @@ async function watch(ref, flags) {
   } else {
     diffRef = "working-copy";
   }
-  const pollInterval = flags.interval ? parseInt(flags.interval, 10) : 1e3;
   try {
-    const handle = await startWatch({
-      diffRef,
+    const serverInfo = await ensureServer({ dev: flags.dev });
+    console.log(
+      `DiffPrism server at http://localhost:${serverInfo.httpPort}`
+    );
+    console.log("Submitting review session...");
+    const { result } = await submitReviewToServer(serverInfo, 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(() => {
+      diffRef
     });
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(0);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`Error: ${message}`);
@@ -891,15 +736,15 @@ async function watch(ref, flags) {
 // cli/src/commands/notify-stop.ts
 async function notifyStop() {
   try {
-    const watchInfo = readWatchFile();
-    if (!watchInfo) {
+    const serverInfo = await isServerAlive();
+    if (!serverInfo) {
       process.exit(0);
       return;
     }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 2e3);
     try {
-      await fetch(`http://localhost:${watchInfo.wsPort}/api/refresh`, {
+      await fetch(`http://localhost:${serverInfo.httpPort}/api/refresh`, {
         method: "POST",
         signal: controller.signal
       });
@@ -912,18 +757,33 @@ async function notifyStop() {
 }
 
 // cli/src/commands/server.ts
+import { spawn } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
 async function server(flags) {
-  const existing = await isServerAlive();
-  if (existing) {
-    console.log(`DiffPrism server is already running on port ${existing.httpPort} (PID ${existing.pid})`);
-    console.log(`Use 'diffprism server stop' to stop it first.`);
-    process.exit(1);
+  if (flags.background) {
+    await spawnDaemon(flags);
     return;
   }
+  const isDaemon = !!flags._daemon;
+  if (!isDaemon) {
+    const existing = await isServerAlive();
+    if (existing) {
+      console.log(`DiffPrism server is already running on port ${existing.httpPort} (PID ${existing.pid})`);
+      console.log(`Use 'diffprism server stop' to stop it first.`);
+      process.exit(1);
+      return;
+    }
+  }
   if (!isGlobalSetupDone()) {
-    console.log("Running global setup...\n");
-    await setup({ global: true, quiet: false });
-    console.log("");
+    if (!isDaemon) {
+      console.log("Running global setup...\n");
+    }
+    await setup({ global: true, quiet: isDaemon });
+    if (!isDaemon) {
+      console.log("");
+    }
   }
   const httpPort = flags.port ? parseInt(flags.port, 10) : void 0;
   const wsPort = flags.wsPort ? parseInt(flags.wsPort, 10) : void 0;
@@ -931,10 +791,14 @@ async function server(flags) {
     const handle = await startGlobalServer({
       httpPort,
       wsPort,
-      dev: flags.dev
+      dev: flags.dev,
+      silent: isDaemon,
+      openBrowser: !isDaemon
     });
     const shutdown = async () => {
-      console.log("\nStopping server...");
+      if (!isDaemon) {
+        console.log("\nStopping server...");
+      }
       await handle.stop();
       process.exit(0);
     };
@@ -944,10 +808,48 @@ async function server(flags) {
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error starting server: ${message}`);
+    if (!isDaemon) {
+      console.error(`Error starting server: ${message}`);
+    }
     process.exit(1);
   }
 }
+async function spawnDaemon(flags) {
+  const existing = await isServerAlive();
+  if (existing) {
+    console.log(`DiffPrism server is already running on port ${existing.httpPort} (PID ${existing.pid})`);
+    return;
+  }
+  const args = process.argv.slice(1).filter((a) => a !== "--background");
+  args.push("--_daemon");
+  const logDir = path3.join(os3.homedir(), ".diffprism");
+  if (!fs3.existsSync(logDir)) {
+    fs3.mkdirSync(logDir, { recursive: true });
+  }
+  const logPath = path3.join(logDir, "server.log");
+  const logFd = fs3.openSync(logPath, "a");
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.unref();
+  fs3.closeSync(logFd);
+  console.log("Starting DiffPrism server in background...");
+  const startTime = Date.now();
+  const timeoutMs = 15e3;
+  while (Date.now() - startTime < timeoutMs) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const info = await isServerAlive();
+    if (info) {
+      console.log(`DiffPrism server started (PID ${info.pid}, port ${info.httpPort})`);
+      console.log(`Logs: ${logPath}`);
+      return;
+    }
+  }
+  console.error("Timed out waiting for server to start. Check logs at:", logPath);
+  process.exit(1);
+}
 async function serverStatus() {
   const info = await isServerAlive();
   if (!info) {
@@ -1001,7 +903,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.34.1" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.35.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("review-pr <pr>").description("Review a GitHub pull request in DiffPrism").option("-t, --title <title>", "Override review title").option("--reasoning <text>", "Agent reasoning about the PR").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(reviewPr);
 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);
@@ -1014,7 +916,7 @@ program.command("setup").description("Configure DiffPrism for Claude Code integr
 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);
+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").option("--background", "Start server as a background daemon").option("--_daemon", "Internal: run as spawned daemon (do not use directly)").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);
 program.parse();