diffprism 0.34.1 → 0.36.0

package/dist/bin.js

@@ -3,17 +3,24 @@ import {
   createGitHubClient,
   fetchPullRequest,
   fetchPullRequestDiff,
-  isServerAlive,
   normalizePr,
   parsePrRef,
-  readServerFile,
-  readWatchFile,
   resolveGitHubToken,
-  startGlobalServer,
-  startReview,
-  startWatch,
   submitGitHubReview
-} from "./chunk-VASCXEMN.js";
+} from "./chunk-OR6PCPZX.js";
+import {
+  demo
+} from "./chunk-UYZ3A2PB.js";
+import {
+  ensureServer,
+  isServerAlive,
+  readServerFile,
+  startGlobalServer,
+  submitReviewToServer
+} from "./chunk-ITPHDFOS.js";
+import "./chunk-QGWYCEJN.js";
+import "./chunk-DHCVZGHE.js";
+import "./chunk-JSBRDJBE.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
@@ -31,11 +38,12 @@ async function review(ref, flags) {
     diffRef = "working-copy";
   }
   try {
-    const result = await startReview({
-      diffRef,
+    const serverInfo = await ensureServer({ dev: flags.dev });
+    console.log("Opening review in browser...");
+    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 +70,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 +98,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 +132,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.
-
-### 4. Handle the Result
+# DiffPrism Review
 
-The tool blocks until the user submits their review in the browser. When it returns:
+When the user invokes \`/review\`, call \`mcp__diffprism__open_review\` with:
 
-- **\`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.
+- \`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
 
-#### Post-Review Actions
+The tool blocks until the human submits their review. Handle the result:
 
-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:
+- **\`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.
 
-- **\`"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.
+## Headless Tools
 
-If \`postReviewAction\` is not present or is empty, do nothing extra \u2014 just report the result.
+- \`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.
 
-### 5. Error Handling
+## Rules
 
-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
@@ -494,7 +357,84 @@ async function setupGitignore(gitRoot) {
   fs.writeFileSync(filePath, GITIGNORE_ENTRIES.map((e) => e + "\n").join(""));
   return { action: "created", filePath };
 }
+async function promptChoice(question, options) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  for (let i = 0; i < options.length; i++) {
+    console.log(`  ${i + 1}. ${options[i]}`);
+  }
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      const num = parseInt(answer.trim(), 10);
+      if (num >= 1 && num <= options.length) {
+        resolve(num - 1);
+      } else {
+        resolve(0);
+      }
+    });
+  });
+}
 async function setup(flags) {
+  const force = flags.force ?? false;
+  const global = flags.global ?? false;
+  const quiet = flags.quiet ?? false;
+  const isInteractive = !global && !force && !quiet && process.stdin.isTTY;
+  if (isInteractive) {
+    return setupInteractive(flags);
+  }
+  return setupBatch(flags);
+}
+async function setupInteractive(flags) {
+  const dev = flags.dev;
+  const gitRoot = findGitRoot(process.cwd());
+  console.log("\n  Welcome to DiffPrism");
+  console.log("  Browser-based code review for agent-generated changes.\n");
+  const modeChoice = await promptChoice("\nHow will you use DiffPrism? ", [
+    "With Claude Code (recommended)",
+    "From the CLI only"
+  ]);
+  if (modeChoice === 0) {
+    if (!gitRoot) {
+      console.log("\n  Not in a git repository \u2014 configuring globally.\n");
+      const outcome2 = await setupBatch({ global: true, quiet: true });
+      console.log("  Setting up for Claude Code...");
+      console.log("  \u2713 Installed /review skill");
+      console.log("  \u2713 Added tool permissions");
+      console.log("\n  Restart Claude Code, then type /review to start a review.\n");
+      await offerDemo(dev);
+      return outcome2;
+    }
+    console.log("\n  Setting up for Claude Code...");
+    const outcome = await setupBatch({ quiet: true });
+    if (outcome.created.length > 0 || outcome.updated.length > 0) {
+      console.log("  \u2713 Registered MCP server (.mcp.json)");
+      console.log("  \u2713 Added tool permissions (.claude/settings.json)");
+      console.log("  \u2713 Installed /review skill");
+      console.log("  \u2713 Added .diffprism to .gitignore");
+    } else {
+      console.log("  \u2713 Already configured");
+    }
+    console.log("\n  Restart Claude Code, then type /review to start a review.\n");
+    await offerDemo(dev);
+    return outcome;
+  }
+  console.log("\n  DiffPrism is ready to use.");
+  console.log("  Run `diffprism review` in any git repo to review changes.\n");
+  await offerDemo(dev);
+  return { created: [], updated: [], skipped: [] };
+}
+async function offerDemo(dev) {
+  const wantsDemo = await promptUser("Try a demo review now? (Y/n) ");
+  if (wantsDemo) {
+    console.log("");
+    const { demo: demo2 } = await import("./demo-JH5YOKTZ.js");
+    await demo2({ dev });
+  }
+}
+async function setupBatch(flags) {
   const force = flags.force ?? false;
   const global = flags.global ?? false;
   const quiet = flags.quiet ?? false;
@@ -808,7 +748,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 +760,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 +796,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 +819,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 +840,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 +874,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 +891,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,20 +986,21 @@ 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.36.0" : "0.0.0-dev");
+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").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);
 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", "Configure globally (skill + permissions, no git repo required)").option("--force", "Overwrite existing configuration files").action((flags) => {
+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").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);
+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();