local-diff-reviewer 0.1.0

package/dist/cli/start.js

@@ -0,0 +1,949 @@
+#!/usr/bin/env node
+
+// src/cli/start.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname2, join as join4, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/server/storage.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { homedir, platform } from "node:os";
+import { basename, dirname, join } from "node:path";
+
+// src/shared/thread-utils.ts
+function sameAnchor(left, right) {
+  if (left.type !== right.type || left.filePath !== right.filePath) return false;
+  if (left.type === "file" && right.type === "file") return true;
+  if (left.type === "diff-line" && right.type === "diff-line") {
+    return left.side === right.side && left.lineNumber === right.lineNumber;
+  }
+  if (left.type === "markdown-line" && right.type === "markdown-line") {
+    return left.lineNumber === right.lineNumber;
+  }
+  return false;
+}
+function anchorKey(anchor) {
+  if (anchor.type === "file") return `file:${anchor.filePath}`;
+  if (anchor.type === "diff-line") return `diff:${anchor.filePath}:${anchor.side}:${anchor.lineNumber}`;
+  return `markdown:${anchor.filePath}:${anchor.lineNumber}`;
+}
+function getThreadStatus(thread) {
+  if (thread.status === "resolved") return "resolved";
+  return getOpenThreadStatus(thread);
+}
+function getOpenThreadStatus(thread) {
+  return thread.comments.some((comment) => comment.author === "agent") ? "replied" : "submit";
+}
+function getMergedThreadStatus(threads) {
+  if (threads.length > 0 && threads.every((thread) => getThreadStatus(thread) === "resolved")) return "resolved";
+  return threads.some((thread) => getOpenThreadStatus(thread) === "replied") ? "replied" : "submit";
+}
+
+// src/server/storage.ts
+async function readComments(repoRoot) {
+  const path = commentsPath(repoRoot);
+  try {
+    return normalizeStore(JSON.parse(await readFile(path, "utf8")));
+  } catch {
+    return readLegacyComments(repoRoot);
+  }
+}
+async function writeComments(repoRoot, store) {
+  const path = commentsPath(repoRoot);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(store, null, 2)}
+`, "utf8");
+}
+function commentsPath(repoRoot) {
+  const repoName = basename(repoRoot) || "repo";
+  const repoHash = createHash("sha256").update(repoRoot).digest("hex").slice(0, 12);
+  return join(commentLogsDir(), `${repoName}-${repoHash}.comments.json`);
+}
+function commentLogsDir() {
+  if (platform() === "win32") {
+    return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "diff-review", "logs");
+  }
+  return join(homedir(), ".local", "diff-review", "logs");
+}
+async function readLegacyComments(repoRoot) {
+  try {
+    return normalizeStore(JSON.parse(await readFile(join(repoRoot, ".diff-review", "comments.json"), "utf8")));
+  } catch {
+    return { threads: [] };
+  }
+}
+function normalizeStore(store) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const thread of store.threads) {
+    const key = anchorKey(thread.anchor);
+    groups.set(key, [...groups.get(key) ?? [], thread]);
+  }
+  return {
+    threads: Array.from(groups.values()).map((threads) => {
+      const [firstThread, ...restThreads] = threads;
+      const merged = {
+        ...firstThread,
+        comments: threads.flatMap((thread) => thread.comments),
+        status: getMergedThreadStatus(threads),
+        updatedAt: latestTimestamp(threads.map((thread) => thread.updatedAt))
+      };
+      if (restThreads.length === 0) return merged;
+      return {
+        ...merged,
+        createdAt: earliestTimestamp(threads.map((thread) => thread.createdAt))
+      };
+    })
+  };
+}
+function latestTimestamp(values) {
+  return values.reduce((latest, value) => value > latest ? value : latest, values[0] ?? (/* @__PURE__ */ new Date()).toISOString());
+}
+function earliestTimestamp(values) {
+  return values.reduce((earliest, value) => value < earliest ? value : earliest, values[0] ?? (/* @__PURE__ */ new Date()).toISOString());
+}
+
+// src/core/comment-import.ts
+async function importAgentComments(repoRoot, diffFiles, rawComments) {
+  const result = { imported: 0, skipped: [] };
+  if (rawComments.length === 0) return result;
+  const store = await readComments(repoRoot);
+  for (let index = 0; index < rawComments.length; index += 1) {
+    const label = `--comment #${index + 1}`;
+    const parsed = parseImportComment(rawComments[index], label, result);
+    if (!parsed) continue;
+    if (parsed.type === "reply") {
+      if (appendAgentReply(store.threads, parsed, result, label)) {
+        result.imported += 1;
+      }
+      continue;
+    }
+    const thread = buildAgentThread(parsed, diffFiles, result, label);
+    if (!thread) continue;
+    const existingThread = store.threads.find((item) => sameAnchor(item.anchor, thread.anchor));
+    if (hasDuplicateAgentComment(store.threads, thread)) {
+      result.skipped.push(`${label}: duplicate agent comment skipped`);
+      continue;
+    }
+    if (existingThread) {
+      existingThread.comments.push(thread.comments[0]);
+      existingThread.status = getOpenThreadStatus(existingThread);
+      existingThread.updatedAt = thread.updatedAt;
+    } else {
+      store.threads.push(thread);
+    }
+    result.imported += 1;
+  }
+  if (result.imported > 0) {
+    await writeComments(repoRoot, store);
+  }
+  return result;
+}
+function parseImportComment(raw, label, result) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    result.skipped.push(`${label}: invalid JSON (${error instanceof Error ? error.message : String(error)})`);
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    result.skipped.push(`${label}: comment must be a JSON object`);
+    return void 0;
+  }
+  if (value.type === "reply") {
+    const threadId = stringField(value, "threadId");
+    const body = stringField(value, "body")?.trim();
+    if (!threadId || !body) {
+      result.skipped.push(`${label}: reply comments require non-empty threadId and body`);
+      return void 0;
+    }
+    return { type: "reply", threadId, body };
+  }
+  if (value.type === "thread") {
+    const filePath = stringField(value, "filePath");
+    const body = stringField(value, "body")?.trim();
+    if (!filePath || !body) {
+      result.skipped.push(`${label}: thread comments require non-empty filePath and body`);
+      return void 0;
+    }
+    return { type: "thread", filePath, body, position: parsePosition(value.position) };
+  }
+  result.skipped.push(`${label}: unsupported comment type`);
+  return void 0;
+}
+function appendAgentReply(threads, comment, result, label) {
+  const thread = threads.find((item) => item.id === comment.threadId);
+  if (!thread) {
+    result.skipped.push(`${label}: thread ${comment.threadId} was not found`);
+    return false;
+  }
+  if (thread.comments.some((item) => item.author === "agent" && item.body.trim() === comment.body)) {
+    result.skipped.push(`${label}: duplicate agent reply skipped`);
+    return false;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  thread.comments.push({
+    id: crypto.randomUUID(),
+    body: comment.body,
+    author: "agent",
+    createdAt: now,
+    updatedAt: now
+  });
+  if (thread.status !== "resolved") {
+    thread.status = "replied";
+  }
+  thread.updatedAt = now;
+  return true;
+}
+function buildAgentThread(comment, diffFiles, result, label) {
+  const file = diffFiles.find((item) => item.path === comment.filePath || item.oldPath === comment.filePath || item.newPath === comment.filePath);
+  if (!file) {
+    result.skipped.push(`${label}: ${comment.filePath} is not present in the current diff`);
+    return void 0;
+  }
+  const anchor = buildAnchor(file, comment, result, label);
+  if (!anchor) return void 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: crypto.randomUUID(),
+    filePath: anchor.filePath,
+    anchor,
+    status: "replied",
+    comments: [
+      {
+        id: crypto.randomUUID(),
+        body: comment.body,
+        author: "agent",
+        createdAt: now,
+        updatedAt: now
+      }
+    ],
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function buildAnchor(file, comment, result, label) {
+  if (!comment.position) {
+    return { type: "file", filePath: file.path };
+  }
+  const position = comment.position;
+  if (isMarkdownPosition(position)) {
+    const line2 = getStartLine(position.line);
+    if (!Number.isInteger(line2) || line2 < 1) {
+      result.skipped.push(`${label}: markdown position requires a positive line number`);
+      return void 0;
+    }
+    if (!file.isMarkdown) {
+      result.skipped.push(`${label}: markdown position can only be used for Markdown files`);
+      return void 0;
+    }
+    return { type: "markdown-line", filePath: file.path, lineNumber: line2, blockId: `line-${line2}` };
+  }
+  const side = position.side ?? "new";
+  const line = getStartLine(position.line);
+  if (!Number.isInteger(line) || line < 1) {
+    result.skipped.push(`${label}: diff position requires a positive line number`);
+    return void 0;
+  }
+  if (!diffLineExists(file, side, line)) {
+    result.skipped.push(`${label}: ${file.path}:${line} (${side}) is not present in the current diff`);
+    return void 0;
+  }
+  return { type: "diff-line", filePath: file.path, side, lineNumber: line };
+}
+function hasDuplicateAgentComment(threads, nextThread) {
+  const nextComment = nextThread.comments[0]?.body.trim();
+  return threads.some((thread) => {
+    return thread.comments.some((comment) => comment.author === "agent" && comment.body.trim() === nextComment) && thread.filePath === nextThread.filePath && sameAnchor(thread.anchor, nextThread.anchor);
+  });
+}
+function diffLineExists(file, side, lineNumber) {
+  return file.hunks.some(
+    (hunk) => hunk.lines.some((line) => side === "old" ? line.oldLineNumber === lineNumber : line.newLineNumber === lineNumber)
+  );
+}
+function isMarkdownPosition(position) {
+  return "type" in position && position.type === "markdown";
+}
+function parsePosition(value) {
+  if (!isRecord(value)) return void 0;
+  if (value.type === "markdown") {
+    return { type: "markdown", line: parseLine(value.line) };
+  }
+  const side = value.side === "old" || value.side === "new" ? value.side : void 0;
+  return { side, line: parseLine(value.line) };
+}
+function parseLine(value) {
+  if (typeof value === "number") return value;
+  if (isRecord(value) && typeof value.start === "number") {
+    return typeof value.end === "number" ? { start: value.start, end: value.end } : { start: value.start };
+  }
+  return Number.NaN;
+}
+function getStartLine(line) {
+  if (typeof line === "number") return line;
+  return line?.start ?? Number.NaN;
+}
+function stringField(value, key) {
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/diff-parser.ts
+var hunkHeaderPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+function parseUnifiedDiff(input) {
+  const lines = input.replace(/\r\n/g, "\n").split("\n");
+  const files = [];
+  let currentFile;
+  let currentHunk;
+  let oldLine = 0;
+  let newLine = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.startsWith("diff --git ")) {
+      const paths = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+      currentFile = {
+        oldPath: paths?.[1] ?? "",
+        newPath: paths?.[2] ?? "",
+        path: paths?.[2] ?? "",
+        status: "modified",
+        additions: 0,
+        deletions: 0,
+        isMarkdown: isMarkdownPath(paths?.[2] ?? ""),
+        hunks: []
+      };
+      files.push(currentFile);
+      currentHunk = void 0;
+      continue;
+    }
+    if (!currentFile) continue;
+    if (line.startsWith("rename from ")) {
+      currentFile.oldPath = line.slice("rename from ".length);
+      currentFile.status = "renamed";
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      currentFile.newPath = line.slice("rename to ".length);
+      currentFile.path = currentFile.newPath;
+      currentFile.isMarkdown = isMarkdownPath(currentFile.path);
+      continue;
+    }
+    if (line.startsWith("new file mode")) {
+      currentFile.status = "added";
+      continue;
+    }
+    if (line.startsWith("deleted file mode")) {
+      currentFile.status = "deleted";
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      currentFile.oldPath = normalizeDiffPath(line.slice(4));
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      currentFile.newPath = normalizeDiffPath(line.slice(4));
+      currentFile.path = currentFile.newPath !== "/dev/null" ? currentFile.newPath : currentFile.oldPath;
+      currentFile.isMarkdown = isMarkdownPath(currentFile.path);
+      continue;
+    }
+    const hunkMatch = line.match(hunkHeaderPattern);
+    if (hunkMatch) {
+      oldLine = Number(hunkMatch[1]);
+      newLine = Number(hunkMatch[3]);
+      currentHunk = {
+        header: line,
+        oldStart: oldLine,
+        oldLines: Number(hunkMatch[2] ?? 1),
+        newStart: newLine,
+        newLines: Number(hunkMatch[4] ?? 1),
+        lines: []
+      };
+      currentFile.hunks.push(currentHunk);
+      continue;
+    }
+    if (!currentHunk) continue;
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      currentHunk.lines.push({ type: "add", content: line.slice(1), newLineNumber: newLine });
+      currentFile.additions += 1;
+      newLine += 1;
+      continue;
+    }
+    if (line.startsWith("-") && !line.startsWith("---")) {
+      currentHunk.lines.push({ type: "remove", content: line.slice(1), oldLineNumber: oldLine });
+      currentFile.deletions += 1;
+      oldLine += 1;
+      continue;
+    }
+    if (line.startsWith(" ")) {
+      currentHunk.lines.push({
+        type: "context",
+        content: line.slice(1),
+        oldLineNumber: oldLine,
+        newLineNumber: newLine
+      });
+      oldLine += 1;
+      newLine += 1;
+      continue;
+    }
+    if (line === "\") {
+      continue;
+    }
+    const synthetic = { type: "context", content: line, oldLineNumber: oldLine, newLineNumber: newLine };
+    currentHunk.lines.push(synthetic);
+  }
+  return files.filter((file) => file.path);
+}
+function normalizeDiffPath(path) {
+  if (path === "/dev/null") return path;
+  return path.replace(/^[ab]\//, "");
+}
+function isMarkdownPath(path) {
+  return /\.(md|mdx)$/i.test(path);
+}
+
+// src/core/git.ts
+import { createHash as createHash2 } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join2, normalize, relative } from "node:path";
+var execFileAsync = promisify(execFile);
+async function getRepoRoot(cwd) {
+  const { stdout } = await execGit(["rev-parse", "--show-toplevel"], cwd);
+  return stdout.trim();
+}
+async function getDiff(mode, repoRoot) {
+  if (mode.kind === "staged") {
+    return execGitStdout(["diff", "--cached", "--no-ext-diff", "--no-color"], repoRoot);
+  }
+  if (mode.kind === "revision") {
+    return execGitStdout(["diff", "--no-ext-diff", "--no-color", mode.base, mode.target], repoRoot);
+  }
+  const trackedDiff = await execGitStdout(["diff", "--no-ext-diff", "--no-color"], repoRoot);
+  const untrackedDiff = await getUntrackedDiff(repoRoot);
+  return [trackedDiff, untrackedDiff].filter(Boolean).join("\n");
+}
+async function readFileForPreview(file, mode, repoRoot) {
+  const targetPath = file.status === "deleted" ? file.oldPath : file.path;
+  if (!isSafeRepoPath(repoRoot, targetPath)) {
+    throw new Error(`Unsafe file path: ${targetPath}`);
+  }
+  if (mode.kind === "staged") {
+    if (file.status === "deleted") {
+      return { content: await gitShow(`HEAD:${targetPath}`, repoRoot), deleted: true };
+    }
+    return { content: await gitShow(`:${targetPath}`, repoRoot), deleted: false };
+  }
+  if (mode.kind === "revision") {
+    const ref = file.status === "deleted" ? mode.base : mode.target;
+    return { content: await gitShow(`${ref}:${targetPath}`, repoRoot), deleted: file.status === "deleted" };
+  }
+  if (file.status === "deleted") {
+    return { content: await gitShow(`HEAD:${targetPath}`, repoRoot), deleted: true };
+  }
+  return { content: await readFile2(join2(repoRoot, targetPath), "utf8"), deleted: false };
+}
+function parseReviewMode(args) {
+  const filtered = args.filter(Boolean);
+  if (filtered.length === 0 || filtered[0] === "working") return { kind: "working" };
+  if (filtered[0] === "staged") return { kind: "staged" };
+  if (filtered.length === 2) return { kind: "revision", base: filtered[0], target: filtered[1] };
+  throw new Error("Usage: local-diff-reviewer [working|staged|<base> <target>]");
+}
+function diffHash(diff) {
+  return createHash2("sha256").update(diff).digest("hex").slice(0, 16);
+}
+function isSafeRepoPath(repoRoot, path) {
+  const normalized = normalize(join2(repoRoot, path));
+  const rel = relative(repoRoot, normalized);
+  return rel !== "" && !rel.startsWith("..") && !rel.startsWith("/");
+}
+async function gitShow(revPath, repoRoot) {
+  return execGitStdout(["show", revPath], repoRoot);
+}
+async function execGitStdout(args, cwd) {
+  const { stdout } = await execGit(args, cwd);
+  return stdout;
+}
+async function execGit(args, cwd) {
+  const { stdout, stderr } = await execFileAsync("git", args, {
+    cwd,
+    maxBuffer: 1024 * 1024 * 80
+  });
+  return { stdout, stderr };
+}
+async function getUntrackedDiff(repoRoot) {
+  const stdout = await execGitStdout(["ls-files", "--others", "--exclude-standard"], repoRoot);
+  const paths = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+  const diffs = await Promise.all(
+    paths.map(async (path) => {
+      if (!isSafeRepoPath(repoRoot, path)) return "";
+      const content = await readFile2(join2(repoRoot, path));
+      if (content.includes(0)) return binaryAddedDiff(path);
+      return textAddedDiff(path, content.toString("utf8"));
+    })
+  );
+  return diffs.filter(Boolean).join("\n");
+}
+function textAddedDiff(path, content) {
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  const hasTrailingNewline = lines.at(-1) === "";
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const additions = bodyLines.map((line) => `+${line}`).join("\n");
+  const noNewline = hasTrailingNewline ? "" : "\n\";
+  return [
+    `diff --git a/${path} b/${path}`,
+    "new file mode 100644",
+    "index 0000000..0000000",
+    "--- /dev/null",
+    `+++ b/${path}`,
+    `@@ -0,0 +1,${bodyLines.length} @@`,
+    additions + noNewline
+  ].join("\n");
+}
+function binaryAddedDiff(path) {
+  return [`diff --git a/${path} b/${path}`, "new file mode 100644", "index 0000000..0000000", `Binary files /dev/null and b/${path} differ`].join("\n");
+}
+
+// src/server/index.ts
+import express from "express";
+import { existsSync } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/core/markdown-source-map.ts
+import GithubSlugger from "github-slugger";
+function buildMarkdownBlocks(content) {
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  const blocks = [];
+  const slugger = new GithubSlugger();
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index];
+    const lineNumber = index + 1;
+    if (!line.trim()) {
+      index += 1;
+      continue;
+    }
+    if (/^```/.test(line.trim())) {
+      const start2 = lineNumber;
+      const collected2 = [line];
+      index += 1;
+      while (index < lines.length && !/^```/.test(lines[index].trim())) {
+        collected2.push(lines[index]);
+        index += 1;
+      }
+      if (index < lines.length) {
+        collected2.push(lines[index]);
+        index += 1;
+      }
+      blocks.push(makeBlock("code", start2, index, collected2.join("\n"), slugger));
+      continue;
+    }
+    if (/^#{1,6}\s+/.test(line)) {
+      blocks.push(makeBlock("heading", lineNumber, lineNumber, line, slugger));
+      index += 1;
+      continue;
+    }
+    if (/^\s*>/.test(line)) {
+      const start2 = lineNumber;
+      const collected2 = [];
+      while (index < lines.length && /^\s*>/.test(lines[index])) {
+        collected2.push(lines[index]);
+        index += 1;
+      }
+      blocks.push(makeBlock("blockquote", start2, index, collected2.join("\n"), slugger));
+      continue;
+    }
+    if (/^\s*([-*+]|\d+\.)\s+/.test(line)) {
+      const start2 = lineNumber;
+      const collected2 = [];
+      while (index < lines.length && (lines[index].trim() === "" || /^\s*([-*+]|\d+\.)\s+/.test(lines[index]))) {
+        collected2.push(lines[index]);
+        index += 1;
+      }
+      blocks.push(makeBlock("list", start2, index, collected2.join("\n"), slugger));
+      continue;
+    }
+    if (line.includes("|") && index + 1 < lines.length && /^\s*\|?[\s:-]+\|/.test(lines[index + 1])) {
+      const start2 = lineNumber;
+      const collected2 = [];
+      while (index < lines.length && lines[index].includes("|")) {
+        collected2.push(lines[index]);
+        index += 1;
+      }
+      blocks.push(makeBlock("table", start2, index, collected2.join("\n"), slugger));
+      continue;
+    }
+    const start = lineNumber;
+    const collected = [];
+    while (index < lines.length && lines[index].trim() !== "") {
+      collected.push(lines[index]);
+      index += 1;
+    }
+    blocks.push(makeBlock("paragraph", start, index, collected.join("\n"), slugger));
+  }
+  return blocks;
+}
+function makeBlock(type, startLine, endLine, text, slugger) {
+  const seed = `${type}-${startLine}-${text.slice(0, 80)}`;
+  return {
+    id: slugger.slug(seed || `${type}-${startLine}`),
+    type,
+    startLine,
+    endLine,
+    text
+  };
+}
+
+// src/core/prompt.ts
+function formatPrompt(threads) {
+  return threads.map((thread) => {
+    const line = getAnchorLine(thread);
+    const location = line ? `${thread.filePath}:${line}` : thread.filePath;
+    const [firstComment, ...replies] = thread.comments;
+    const replyText = replies.map((comment, index) => {
+      const author = comment.author === "agent" ? "Agent" : "User";
+      return `Reply ${index + 1} (${author})
+${comment.body.trim()}`;
+    }).join("\n");
+    return [`[thread:${thread.id}]`, location, firstComment?.body.trim(), replyText].filter(Boolean).join("\n");
+  }).join("\n\n");
+}
+function getAnchorLine(thread) {
+  if (thread.anchor.type === "file") return void 0;
+  return thread.anchor.lineNumber;
+}
+
+// src/server/index.ts
+async function startServer(state, port = 4966) {
+  const app = express();
+  app.use(express.json({ limit: "2mb" }));
+  app.get("/api/session", (_req, res) => {
+    res.json(state.session);
+  });
+  app.get("/api/diff", (_req, res) => {
+    res.json({ files: state.diffFiles });
+  });
+  app.get("/api/markdown-preview", async (req, res, next) => {
+    try {
+      const filePath = String(req.query.path ?? "");
+      const file = state.diffFiles.find((item) => item.path === filePath || item.oldPath === filePath);
+      if (!file || !file.isMarkdown) {
+        res.status(404).json({ error: "Markdown file not found in diff" });
+        return;
+      }
+      const { content, deleted } = await readFileForPreview(file, state.session.mode, state.session.repoRoot);
+      const preview = {
+        filePath: file.path,
+        content,
+        deleted,
+        blocks: buildMarkdownBlocks(content)
+      };
+      res.json(preview);
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.get("/api/threads", async (_req, res, next) => {
+    try {
+      res.json(await readComments(state.session.repoRoot));
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.post("/api/threads", async (req, res, next) => {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const body = req.body;
+      const commentBody = body.body?.trim();
+      if (!commentBody) {
+        res.status(400).json({ error: "Comment body is required" });
+        return;
+      }
+      const store = await readComments(state.session.repoRoot);
+      const existingThread = store.threads.find((thread2) => sameAnchor(thread2.anchor, body.anchor));
+      const comment = {
+        id: crypto.randomUUID(),
+        body: commentBody,
+        author: "user",
+        createdAt: now,
+        updatedAt: now
+      };
+      if (existingThread) {
+        existingThread.comments.push(comment);
+        existingThread.status = getOpenThreadStatus(existingThread);
+        existingThread.updatedAt = now;
+        await writeComments(state.session.repoRoot, store);
+        res.status(201).json(existingThread);
+        return;
+      }
+      const thread = {
+        id: crypto.randomUUID(),
+        filePath: body.filePath,
+        anchor: body.anchor,
+        status: "submit",
+        comments: [comment],
+        createdAt: now,
+        updatedAt: now
+      };
+      store.threads.push(thread);
+      await writeComments(state.session.repoRoot, store);
+      res.status(201).json(thread);
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.post("/api/threads/:id/comments", async (req, res, next) => {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const store = await readComments(state.session.repoRoot);
+      const thread = store.threads.find((item) => item.id === req.params.id);
+      if (!thread) {
+        res.status(404).json({ error: "Thread not found" });
+        return;
+      }
+      const body = req.body;
+      const commentBody = body.body?.trim();
+      if (!commentBody) {
+        res.status(400).json({ error: "Comment body is required" });
+        return;
+      }
+      const comment = {
+        id: crypto.randomUUID(),
+        body: commentBody,
+        author: body.author === "agent" ? "agent" : "user",
+        createdAt: now,
+        updatedAt: now
+      };
+      thread.comments.push(comment);
+      if (thread.status !== "resolved") {
+        thread.status = getOpenThreadStatus(thread);
+      }
+      thread.updatedAt = now;
+      await writeComments(state.session.repoRoot, store);
+      res.status(201).json(comment);
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.patch("/api/threads/:id", async (req, res, next) => {
+    try {
+      const store = await readComments(state.session.repoRoot);
+      const thread = store.threads.find((item) => item.id === req.params.id);
+      if (!thread) {
+        res.status(404).json({ error: "Thread not found" });
+        return;
+      }
+      if (req.body.status === "resolved" || req.body.status === "replied" || req.body.status === "submit") {
+        thread.status = req.body.status === "resolved" ? "resolved" : getOpenThreadStatus(thread);
+        thread.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      await writeComments(state.session.repoRoot, store);
+      res.json(thread);
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.delete("/api/threads/:id", async (req, res, next) => {
+    try {
+      const store = await readComments(state.session.repoRoot);
+      store.threads = store.threads.filter((item) => item.id !== req.params.id);
+      await writeComments(state.session.repoRoot, store);
+      res.status(204).end();
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.patch("/api/threads/:id/comments/:commentId", async (req, res, next) => {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const store = await readComments(state.session.repoRoot);
+      const thread = store.threads.find((item) => item.id === req.params.id);
+      if (!thread) {
+        res.status(404).json({ error: "Thread not found" });
+        return;
+      }
+      if (getThreadStatus(thread) !== "submit") {
+        res.status(400).json({ error: "Only submitted comments can be edited" });
+        return;
+      }
+      const comment = thread.comments.find((item) => item.id === req.params.commentId);
+      if (!comment) {
+        res.status(404).json({ error: "Comment not found" });
+        return;
+      }
+      if (comment.author === "agent") {
+        res.status(400).json({ error: "Agent comments are read-only" });
+        return;
+      }
+      const nextBody = String(req.body?.body ?? "").trim();
+      if (!nextBody) {
+        res.status(400).json({ error: "Comment body is required" });
+        return;
+      }
+      comment.body = nextBody;
+      comment.updatedAt = now;
+      thread.updatedAt = now;
+      await writeComments(state.session.repoRoot, store);
+      res.json(comment);
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.delete("/api/threads/:id/comments/:commentId", async (req, res, next) => {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const store = await readComments(state.session.repoRoot);
+      const thread = store.threads.find((item) => item.id === req.params.id);
+      if (!thread) {
+        res.status(404).json({ error: "Thread not found" });
+        return;
+      }
+      if (getThreadStatus(thread) !== "submit") {
+        res.status(400).json({ error: "Only submitted comments can be deleted" });
+        return;
+      }
+      const comment = thread.comments.find((item) => item.id === req.params.commentId);
+      if (!comment) {
+        res.status(404).json({ error: "Comment not found" });
+        return;
+      }
+      if (comment.author === "agent") {
+        res.status(400).json({ error: "Agent comments are read-only" });
+        return;
+      }
+      thread.comments = thread.comments.filter((item) => item.id !== req.params.commentId);
+      thread.updatedAt = now;
+      store.threads = store.threads.filter((item) => item.id !== thread.id || thread.comments.length > 0);
+      await writeComments(state.session.repoRoot, store);
+      res.status(204).end();
+    } catch (error) {
+      next(error);
+    }
+  });
+  app.post("/api/prompt", async (req, res, next) => {
+    try {
+      const scope = req.body;
+      const store = await readComments(state.session.repoRoot);
+      const threads = selectPromptThreads(store.threads, scope);
+      res.json({ prompt: formatPrompt(threads) });
+    } catch (error) {
+      next(error);
+    }
+  });
+  const webDist = state.webDist ?? join3(process.cwd(), "dist", "web");
+  if (existsSync(webDist)) {
+    app.use(express.static(webDist));
+    app.get(/.*/, (_req, res) => res.sendFile(join3(webDist, "index.html")));
+  }
+  app.use((error, _req, res, _next) => {
+    res.status(500).json({ error: error.message });
+  });
+  return new Promise((resolve2) => {
+    const server = app.listen(port, "127.0.0.1", () => {
+      const address = server.address();
+      const actualPort = typeof address === "object" && address ? address.port : port;
+      resolve2(`http://127.0.0.1:${actualPort}`);
+    });
+  });
+}
+function selectPromptThreads(threads, scope) {
+  if (scope.type === "thread") return threads.filter((thread) => thread.id === scope.threadId);
+  if (scope.type === "file-unresolved") {
+    return threads.filter((thread) => thread.filePath === scope.filePath && thread.status !== "resolved");
+  }
+  return threads.filter((thread) => thread.status !== "resolved");
+}
+
+// src/cli/start.ts
+var packageRoot = resolve(dirname2(fileURLToPath(import.meta.url)), "../..");
+var builtWebDist = join4(packageRoot, "dist", "web");
+async function main() {
+  const { dev, reviewArgs, comments } = parseCliOptions(process.argv.slice(2));
+  const mode = parseReviewMode(reviewArgs);
+  const repoRoot = await getRepoRoot(process.cwd());
+  const diff = await getDiff(mode, repoRoot);
+  const diffFiles = parseUnifiedDiff(diff);
+  const session = {
+    id: crypto.randomUUID(),
+    repoRoot,
+    mode,
+    diffHash: diffHash(diff),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const importResult = await importAgentComments(repoRoot, diffFiles, comments);
+  const hasBuiltWeb = existsSync2(join4(builtWebDist, "index.html"));
+  const apiUrl = await startServer({ session, diffFiles, webDist: hasBuiltWeb ? builtWebDist : void 0 });
+  const useVite = dev || !hasBuiltWeb;
+  const uiUrl = useVite ? "http://127.0.0.1:5173" : apiUrl;
+  if (useVite) {
+    startVite();
+  }
+  openBrowser(uiUrl);
+  console.log(`Diff Review is running: ${uiUrl}`);
+  console.log(`Mode: ${modeLabel(mode)}`);
+  console.log(`Files: ${diffFiles.length}`);
+  if (comments.length > 0) {
+    console.log(`Agent comments imported: ${importResult.imported}`);
+    for (const skipped of importResult.skipped) {
+      console.warn(`Skipped ${skipped}`);
+    }
+  }
+}
+function parseCliOptions(args) {
+  const reviewArgs = [];
+  const comments = [];
+  let dev = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--dev") {
+      dev = true;
+      continue;
+    }
+    if (arg === "--comment") {
+      const comment = args[index + 1];
+      if (!comment) throw new Error("--comment requires a JSON value");
+      comments.push(comment);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--comment=")) {
+      const comment = arg.slice("--comment=".length);
+      if (!comment) throw new Error("--comment requires a JSON value");
+      comments.push(comment);
+      continue;
+    }
+    reviewArgs.push(arg);
+  }
+  return { dev, reviewArgs, comments };
+}
+function modeLabel(mode) {
+  if (mode.kind === "revision") return `${mode.base}..${mode.target}`;
+  return mode.kind;
+}
+function startVite() {
+  const child = spawn("npm", ["run", "web:dev"], {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    shell: process.platform === "win32",
+    env: { ...process.env, BROWSER: "none" }
+  });
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+}
+function openBrowser(url) {
+  const child = process.platform === "darwin" ? spawn("open", [url], { stdio: "ignore", detached: true }) : process.platform === "win32" ? spawn("cmd", ["/c", "start", "", url], {
+    stdio: "ignore",
+    detached: true
+  }) : spawn("xdg-open", [url], { stdio: "ignore", detached: true });
+  child.unref();
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});