diffprism 0.43.0 → 0.45.0

package/README.md

@@ -1,67 +1,130 @@
 # DiffPrism
 
-Your AI writes code — you need to review it before it ships. But terminal diffs
-are hard to read, and there's no way to leave structured feedback that the agent
-actually acts on.
-
-DiffPrism opens a code review UI in your browser with syntax-highlighted diffs,
-inline commenting, and structured decisions (approve / request changes) that
-Claude reads and responds to.
+Review GitHub PRs with AI superpowers. Paste a PR URL, see the diff in your browser, and use Claude Code or Cursor to interrogate every line, file, and change. Your AI gets full codebase context from your local clone — not just the diff hunks.
 
 ## How It Works
 
-1. Type `/review` in Claude Code — your browser opens with the diff
-2. Review the changes, leave inline comments, approve or request changes
-3. Claude reads your decision and acts on it (commits, opens a PR, or fixes what you flagged)
+1. **Open a PR** — `diffprism review https://github.com/owner/repo/pull/123`
+2. **See the diff** — Browser opens with syntax-highlighted diffs, file browser, and analysis briefing
+3. **Ask your AI** — In Claude Code or Cursor, ask questions about the changes. Your AI calls MCP tools to get context and posts findings inline on the diff.
+
+```
+$ cd ~/dev/my-project
+$ diffprism review https://github.com/owner/repo/pull/123
+  Fetching PR #123 from owner/repo...
+  Add retry logic to API client
+  4 files changed
+  Local repo: /Users/you/dev/my-project
+
+  Review open in browser. Use Claude Code to ask questions about this PR.
+```
+
+Then in Claude Code:
+
+```
+> What does this PR change?
+  → calls get_pr_context → high-level overview
+
+> Is the retry logic in client.ts correct?
+  → calls get_file_diff + get_file_context → full file from your local clone
+
+> Flag line 47 as a concern
+  → calls add_review_comment → annotation appears on the diff in your browser
+```
 
-## Setup for Claude Code
+## Setup
 
 ```bash
-npx diffprism setup
+npm install -g diffprism
+diffprism setup          # Register MCP server with Claude Code
 ```
 
-Configures everything and opens a demo review so you can see it in action. Restart Claude Code afterward to load the MCP server.
+Run the server from within your local clone so the AI gets full file context:
 
-## Use from the CLI
+```bash
+cd ~/dev/my-project
+diffprism server         # Or let it auto-start on first review
+```
 
-No setup needed — just run:
+## PR Review
 
 ```bash
-diffprism review                    # Review all changes (staged + unstaged)
-diffprism review --staged           # Staged changes only
-diffprism review HEAD~3             # Last 3 commits
-diffprism review main..feature      # Branch diff
+diffprism review https://github.com/owner/repo/pull/123   # Full GitHub URL
+diffprism review owner/repo#123                            # Shorthand format
 ```
 
-## Multi-Agent Reviews
+The server auto-detects your local clone by matching `git remote -v` against the PR's repo. Your AI can then read full files via `git show` — not just diff hunks.
+
+## MCP Tools
+
+DiffPrism exposes 14 MCP tools to your AI:
+
+### PR 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` |
+| `add_review_comment` | Post a comment that appears inline on the diff in real-time |
+| `get_review_comments` | Read all comments and annotations on the session |
+| `get_user_focus` | What file/line the user is currently viewing in the browser |
+
+### Review Lifecycle
+| Tool | Purpose |
+|------|---------|
+| `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 session |
+
+### Analysis
+| Tool | Purpose |
+|------|---------|
+| `analyze_diff` | Returns analysis JSON (patterns, complexity, test gaps) |
+| `get_diff` | Returns structured diff JSON (file-level and hunk-level changes) |
 
-Running multiple Claude Code sessions (e.g., in git worktrees)? All reviews appear in one browser tab.
+### Annotation
+| Tool | Purpose |
+|------|---------|
+| `add_annotation` | Post a structured finding on a specific line |
+| `flag_for_attention` | Mark files for human attention |
+| `get_review_state` | Get current state of a session including all annotations |
 
-The server starts automatically on first use — no manual setup needed. Each review shows up as a session with status badges, branch info, and change stats. Click to switch between reviews. Desktop notifications alert you when new reviews arrive.
+## Local Agent Review
+
+DiffPrism also works for reviewing local agent-generated changes:
 
 ```bash
-diffprism server status             # Check if server is running
-diffprism server stop               # Stop the background server
+diffprism review                    # Review all changes (staged + unstaged)
+diffprism review --staged           # Staged changes only
+diffprism review HEAD~3             # Last 3 commits
+diffprism review main..feature      # Branch diff
 ```
 
+Running multiple Claude Code sessions? All reviews appear in one browser dashboard with status badges, branch info, and desktop notifications.
+
 ## Features
 
-- **Syntax-highlighted diffs** — unified or split (side-by-side) view
-- **Inline commenting** — click any line to add `must_fix`, `suggestion`, `question`, or `nitpick` comments
-- **Review briefing** — complexity scores, test coverage gaps, pattern flags, dependency tracking
-- **Agent reasoning panel** — see why the AI made each change
-- **Quick actions** — Approve & Commit or Approve, Commit & PR from the review UI
-- **Multi-session dashboard** — review multiple agents from one browser tab
-- **Desktop notifications** — get alerted when a new review arrives
-- **GitHub PR review** — review any GitHub PR in DiffPrism's UI
-- **Keyboard shortcuts** — `j`/`k` files, `n`/`p` hunks, `c` comment, `s` status, `?` help
-- **Dark/light mode** — toggle with persistence
+- **AI-powered PR review** — Your AI gets full codebase context via 14 MCP tools
+- **Live annotations** — AI findings appear inline on the diff in real-time
+- **Local repo context** — Full file content from your clone, not just diff hunks
+- **No vendor lock-in** — Works with Claude Code, Cursor, or any MCP client
+- **Syntax-highlighted diffs** — Unified or split view with refractor
+- **Multi-session dashboard** — Review multiple agents from one browser tab
+- **Review briefing** — Complexity scores, test coverage gaps, pattern flags
+- **Auto-detect local repo** — Matches `git remote -v` against the PR's repo
+- **Keyboard shortcuts** — `j`/`k` files, `n`/`p` hunks, `s` status, `?` help
+- **Dark/light mode** — Toggle with persistence
 
-## Uninstall
+## CLI Reference
 
 ```bash
-npx diffprism teardown              # Remove from current project
-npx diffprism teardown --global     # Remove global config
+diffprism review <ref>              # Open a review (PR URL, git ref, or flags)
+diffprism setup                     # Configure Claude Code integration
+diffprism setup --global            # Global setup (no git repo needed)
+diffprism server                    # Start the background server
+diffprism server status             # Check server status
+diffprism server stop               # Stop the server
+diffprism teardown                  # Remove configuration
 ```
 
 ## Development
@@ -82,7 +145,7 @@ packages/core       — Server, types, server-client utilities
 packages/git        — Git diff extraction + parser
 packages/analysis   — Deterministic review briefing
 packages/ui         — React 19 + Vite 6 + Tailwind + Zustand
-packages/mcp-server — MCP tool server (9 tools)
+packages/mcp-server — MCP tool server (14 tools)
 packages/github     — GitHub PR fetching + review submission
 cli/                — Commander CLI
 ```

package/dist/bin.js

@@ -1,24 +1,18 @@
 #!/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-WDOB26I4.js";
+} from "./chunk-RVI74JF5.js";
 import {
   ensureServer,
   isServerAlive,
   readServerFile,
   startGlobalServer,
   submitReviewToServer
-} from "./chunk-VR2C6WTQ.js";
+} from "./chunk-RICVPPTE.js";
 import "./chunk-QGWYCEJN.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";
@@ -27,7 +21,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) {
@@ -63,55 +56,32 @@ async function reviewLocalFlow(diffRef, flags) {
   process.exit(0);
 }
 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 +94,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 +104,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 +143,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
 
-To review a GitHub pull request:
+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.
 
-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
+### 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.
+
+### 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 +177,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 |
 |------|---------|
-| \`add_annotation\` | Post a finding/suggestion/question on a specific line in a running review. |
+| \`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_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 +199,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 +297,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 +370,7 @@ async function setupInteractive(flags) {
 }
 async function runDemo(dev) {
   console.log("");
-  const { demo: demo2 } = await import("./demo-EMHF7QFK.js");
+  const { demo: demo2 } = await import("./demo-WVNNI6CE.js");
   await demo2({ dev });
 }
 async function setupBatch(flags) {
@@ -822,7 +813,7 @@ async function fetchStatus(httpPort) {
   return await response.json();
 }
 function printStatus(status, httpPort) {
-  const version = true ? "0.43.0" : "0.0.0-dev";
+  const version = true ? "0.45.0" : "0.0.0-dev";
   console.log(`
 DiffPrism v${version}
 `);
@@ -862,7 +853,7 @@ async function defaultAction() {
 
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.43.0" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.45.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);

package/dist/{chunk-VR2C6WTQ.js → chunk-RICVPPTE.js}

@@ -668,6 +668,16 @@ function recordReviewHistory(session, result) {
   } catch {
   }
 }
+function isInsideGitRepo(dirPath) {
+  let current = dirPath;
+  while (current !== "/") {
+    if (fs5.existsSync(`${current}/.git`)) return true;
+    const parent = current.replace(/\/[^/]+$/, "") || "/";
+    if (parent === current) break;
+    current = parent;
+  }
+  return fs5.existsSync(`${current}/.git`);
+}
 async function handleApiRequest(req, res) {
   const method = req.method ?? "GET";
   const url = (req.url ?? "/").split("?")[0];
@@ -841,6 +851,96 @@ async function handleApiRequest(req, res) {
     }
     return true;
   }
+  if (method === "POST" && url === "/api/pr/open") {
+    try {
+      const body = await readBody(req);
+      const { prUrl } = JSON.parse(body);
+      if (!prUrl) {
+        jsonResponse(res, 400, { error: "Missing prUrl" });
+        return true;
+      }
+      const {
+        isPrRef,
+        parsePrRef,
+        resolveGitHubToken,
+        createGitHubClient,
+        fetchPullRequest,
+        fetchPullRequestDiff,
+        normalizePr
+      } = await import("./src-KF5HRJPX.js");
+      if (!isPrRef(prUrl)) {
+        jsonResponse(res, 400, {
+          error: "Invalid PR URL. Expected https://github.com/owner/repo/pull/123 or owner/repo#123"
+        });
+        return true;
+      }
+      let token;
+      try {
+        token = resolveGitHubToken();
+      } catch (err) {
+        jsonResponse(res, 401, {
+          error: err instanceof Error ? err.message : "GitHub token not found"
+        });
+        return true;
+      }
+      const { owner, repo, number: prNumber } = parsePrRef(prUrl);
+      const client = createGitHubClient(token);
+      const [prMetadata, rawDiff] = await Promise.all([
+        fetchPullRequest(client, owner, repo, prNumber),
+        fetchPullRequestDiff(client, owner, repo, prNumber)
+      ]);
+      const normalized = normalizePr(rawDiff, prMetadata);
+      let localRepoPath = null;
+      try {
+        const { execSync } = await import("child_process");
+        const remoteOutput = execSync("git remote -v", {
+          cwd: process.cwd(),
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const repoPattern = new RegExp(`github\\.com[:/]${owner}/${repo}(\\.git)?\\s`, "i");
+        if (repoPattern.test(remoteOutput)) {
+          localRepoPath = process.cwd();
+        }
+      } catch {
+      }
+      const sessionId = `session-${randomUUID2().slice(0, 8)}`;
+      normalized.payload.reviewId = sessionId;
+      const session = {
+        id: sessionId,
+        payload: normalized.payload,
+        projectPath: localRepoPath ?? `github:${owner}/${repo}#${prNumber}`,
+        source: "manual",
+        status: "pending",
+        createdAt: Date.now(),
+        result: null,
+        hasNewChanges: false,
+        annotations: []
+      };
+      sessions.set(sessionId, session);
+      broadcastToAll({
+        type: "session:added",
+        payload: toSummary(session)
+      });
+      jsonResponse(res, 201, {
+        sessionId,
+        fileCount: normalized.diffSet.files.length,
+        localRepoPath,
+        pr: {
+          title: prMetadata.title,
+          author: prMetadata.author,
+          url: prMetadata.url,
+          baseBranch: prMetadata.baseBranch,
+          headBranch: prMetadata.headBranch
+        }
+      });
+    } catch (err) {
+      jsonResponse(res, 500, {
+        error: err instanceof Error ? err.message : "Failed to fetch PR"
+      });
+    }
+    return true;
+  }
   if (method === "GET" && req.url) {
     const parsedUrl = new URL(req.url, "http://localhost");
     if (parsedUrl.pathname === "/api/fs/list") {
@@ -869,7 +969,7 @@ async function handleApiRequest(req, res) {
           if (a.isGitRepo !== b.isGitRepo) return a.isGitRepo ? -1 : 1;
           return a.name.localeCompare(b.name);
         });
-        const isGitRepo = fs5.existsSync(`${dirPath}/.git`);
+        const isGitRepo = isInsideGitRepo(dirPath);
         const parentPath = dirPath === "/" ? null : dirPath.replace(/\/[^/]+$/, "") || "/";
         jsonResponse(res, 200, { path: dirPath, parentPath, isGitRepo, dirs });
       } catch {
@@ -893,6 +993,20 @@ async function handleApiRequest(req, res) {
     jsonResponse(res, 200, toSummary(session));
     return true;
   }
+  const getPayloadParams = matchRoute(method, url, "GET", "/api/reviews/:id/payload");
+  if (getPayloadParams) {
+    const session = sessions.get(getPayloadParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, {
+      payload: session.payload,
+      projectPath: session.projectPath,
+      annotations: session.annotations
+    });
+    return true;
+  }
   const postResultParams = matchRoute(method, url, "POST", "/api/reviews/:id/result");
   if (postResultParams) {
     const session = sessions.get(postResultParams.id);
@@ -1023,6 +1137,38 @@ async function handleApiRequest(req, res) {
     jsonResponse(res, 200, { ok: true });
     return true;
   }
+  const postFocusParams = matchRoute(method, url, "POST", "/api/reviews/:id/focus");
+  if (postFocusParams) {
+    const session = sessions.get(postFocusParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const { file, lineStart, lineEnd } = JSON.parse(body);
+      session.userFocus = {
+        file,
+        lineStart,
+        lineEnd,
+        updatedAt: Date.now()
+      };
+      jsonResponse(res, 200, { ok: true });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const getFocusParams = matchRoute(method, url, "GET", "/api/reviews/:id/focus");
+  if (getFocusParams) {
+    const session = sessions.get(getFocusParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, { focus: session.userFocus ?? null });
+    return true;
+  }
   const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
   if (deleteParams) {
     stopSessionWatcher(deleteParams.id);

package/dist/{chunk-WDOB26I4.js → chunk-RVI74JF5.js}

@@ -1,7 +1,7 @@
 import {
   ensureServer,
   submitReviewToServer
-} from "./chunk-VR2C6WTQ.js";
+} from "./chunk-RICVPPTE.js";
 import {
   parseDiff
 } from "./chunk-QGWYCEJN.js";

package/dist/{demo-EMHF7QFK.js → demo-WVNNI6CE.js}

@@ -1,7 +1,7 @@
 import {
   demo
-} from "./chunk-WDOB26I4.js";
-import "./chunk-VR2C6WTQ.js";
+} from "./chunk-RVI74JF5.js";
+import "./chunk-RICVPPTE.js";
 import "./chunk-QGWYCEJN.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";