diffprism 0.13.8 → 0.15.0

package/dist/bin.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import {
+  isServerAlive,
+  readServerFile,
   readWatchFile,
+  startGlobalServer,
   startReview,
   startWatch
-} from "./chunk-QB2PKDLU.js";
+} from "./chunk-NGHUHDAM.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
@@ -18,7 +21,7 @@ async function review(ref, flags) {
   } else if (ref) {
     diffRef = ref;
   } else {
-    diffRef = "all";
+    diffRef = "working-copy";
   }
   try {
     const result = await startReview({
@@ -66,57 +69,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 +100,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 +108,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: Waiting for Review Feedback
 
-## Watch Mode: Polling for Review Feedback
+When \`diffprism watch\` is active (detected via \`.diffprism/watch.json\`), the developer can submit reviews at any time in the browser.
 
-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.
+**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).
 
-**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.
+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
 
-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).
+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 +134,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
@@ -352,11 +330,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);
@@ -365,40 +346,91 @@ async function setup(flags) {
   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) {
+  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.");
   }
-  if (result.skipped.length > 0) {
-    console.log("Skipped (already configured):");
-    for (const f of result.skipped) {
-      console.log(`  - ${path.relative(gitRoot, f)}`);
+  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.");
+  }
+  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
@@ -411,7 +443,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 {
@@ -461,12 +493,101 @@ async function notifyStop() {
   process.exit(0);
 }
 
+// cli/src/commands/server.ts
+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);
+    return;
+  }
+  const httpPort = flags.port ? parseInt(flags.port, 10) : void 0;
+  const wsPort = flags.wsPort ? parseInt(flags.wsPort, 10) : void 0;
+  try {
+    const handle = await startGlobalServer({
+      httpPort,
+      wsPort,
+      dev: flags.dev
+    });
+    const shutdown = async () => {
+      console.log("\nStopping server...");
+      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 starting server: ${message}`);
+    process.exit(1);
+  }
+}
+async function serverStatus() {
+  const info = await isServerAlive();
+  if (!info) {
+    console.log("No DiffPrism server is running.");
+    process.exit(1);
+    return;
+  }
+  try {
+    const response = await fetch(`http://localhost:${info.httpPort}/api/status`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    const status = await response.json();
+    console.log(`DiffPrism Server`);
+    console.log(`  API:      http://localhost:${info.httpPort}`);
+    console.log(`  WS:       ws://localhost:${info.wsPort}`);
+    console.log(`  PID:      ${status.pid}`);
+    console.log(`  Sessions: ${status.sessions}`);
+    console.log(`  Uptime:   ${Math.floor(status.uptime)}s`);
+    if (status.sessions > 0) {
+      const sessionsResponse = await fetch(
+        `http://localhost:${info.httpPort}/api/reviews`,
+        { signal: AbortSignal.timeout(2e3) }
+      );
+      const { sessions } = await sessionsResponse.json();
+      console.log(`
+  Active Sessions:`);
+      for (const s of sessions) {
+        const label = s.title ?? s.branch ?? s.projectPath;
+        console.log(`    ${s.id} \u2014 ${label} (${s.status}, ${s.fileCount} files, +${s.additions}/-${s.deletions})`);
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error checking server status: ${message}`);
+    process.exit(1);
+  }
+}
+async function serverStop() {
+  const info = readServerFile();
+  if (!info) {
+    console.log("No DiffPrism server is running.");
+    return;
+  }
+  try {
+    process.kill(info.pid, "SIGTERM");
+    console.log(`Sent stop signal to DiffPrism server (PID ${info.pid}).`);
+  } catch {
+    console.log(`Server process (PID ${info.pid}) is no longer running. Cleaning up.`);
+  }
+}
+
 // 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.8" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.15.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);
+});
+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);
+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();