diffprism 0.34.1 → 0.36.0

package/dist/{chunk-VASCXEMN.js → chunk-OR6PCPZX.js}

@@ -1,28 +1,13 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+import {
+  parseDiff
+} from "./chunk-QGWYCEJN.js";
+import {
+  analyze
+} from "./chunk-DHCVZGHE.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-JSBRDJBE.js";
 
 // node_modules/.pnpm/fast-content-type-parse@2.0.1/node_modules/fast-content-type-parse/index.js
 var require_fast_content_type_parse = __commonJS({
@@ -120,2760 +105,18 @@ var require_fast_content_type_parse = __commonJS({
   }
 });
 
-// packages/git/src/local.ts
+// packages/github/src/auth.ts
 import { execSync } from "child_process";
-import { readFileSync } from "fs";
-import path from "path";
-function getGitDiff(ref, options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    execSync("git --version", { cwd, stdio: "pipe" });
-  } catch {
-    throw new Error(
-      "git is not available. Please install git and make sure it is on your PATH."
-    );
-  }
-  try {
-    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
-  } catch {
-    throw new Error(
-      `The directory "${cwd}" is not inside a git repository.`
-    );
-  }
-  let command;
-  let includeUntracked = false;
-  switch (ref) {
-    case "staged":
-      command = "git diff --staged --no-color";
-      break;
-    case "unstaged":
-      command = "git diff --no-color";
-      includeUntracked = true;
-      break;
-    case "all":
-      command = "git diff HEAD --no-color";
-      includeUntracked = true;
-      break;
-    default:
-      command = `git diff --no-color ${ref}`;
-      break;
-  }
-  let output;
-  try {
-    output = execSync(command, {
-      cwd,
-      encoding: "utf-8",
-      maxBuffer: 50 * 1024 * 1024
-      // 50 MB
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`git diff failed: ${message}`);
-  }
-  if (includeUntracked) {
-    output += getUntrackedDiffs(cwd);
-  }
-  return output;
-}
-function getCurrentBranch(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    return execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return "unknown";
-  }
-}
-function listBranches(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    const output = execSync(
-      "git branch -a --format='%(refname:short)' --sort=-committerdate",
-      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    if (!output) return { local: [], remote: [] };
-    const local = [];
-    const remote = [];
-    for (const line of output.split("\n")) {
-      const name = line.trim();
-      if (!name) continue;
-      if (name.endsWith("/HEAD")) continue;
-      if (name.includes("/")) {
-        remote.push(name);
-      } else {
-        local.push(name);
-      }
-    }
-    return { local, remote };
-  } catch {
-    return { local: [], remote: [] };
-  }
-}
-function listCommits(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  const limit = options?.limit ?? 50;
-  try {
-    const output = execSync(
-      `git log --format='%H<<>>%h<<>>%s<<>>%an<<>>%aI' -n ${limit}`,
-      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    if (!output) return [];
-    const commits = [];
-    for (const line of output.split("\n")) {
-      const parts = line.split("<<>>");
-      if (parts.length < 5) continue;
-      commits.push({
-        hash: parts[0],
-        shortHash: parts[1],
-        subject: parts[2],
-        author: parts[3],
-        date: parts[4]
-      });
-    }
-    return commits;
-  } catch {
-    return [];
-  }
-}
-function detectWorktree(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    const gitDir = execSync("git rev-parse --git-dir", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const gitCommonDir = execSync("git rev-parse --git-common-dir", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const resolvedGitDir = path.resolve(cwd, gitDir);
-    const resolvedCommonDir = path.resolve(cwd, gitCommonDir);
-    const isWorktree = resolvedGitDir !== resolvedCommonDir;
-    if (!isWorktree) {
-      return { isWorktree: false };
-    }
-    const worktreePath = execSync("git rev-parse --show-toplevel", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const mainWorktreePath = path.dirname(resolvedCommonDir);
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return {
-      isWorktree: true,
-      worktreePath,
-      mainWorktreePath,
-      branch: branch === "HEAD" ? void 0 : branch
-    };
-  } catch {
-    return { isWorktree: false };
-  }
-}
-function getUntrackedDiffs(cwd) {
-  let untrackedList;
-  try {
-    untrackedList = execSync(
-      "git ls-files --others --exclude-standard",
-      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-  } catch {
-    return "";
-  }
-  if (!untrackedList) return "";
-  const files = untrackedList.split("\n");
-  let result = "";
-  for (const file of files) {
-    const absPath = path.resolve(cwd, file);
-    let content;
-    try {
-      content = readFileSync(absPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split("\n");
-    const hasTrailingNewline = content.length > 0 && content[content.length - 1] === "\n";
-    const contentLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
-    result += `diff --git a/${file} b/${file}
-`;
-    result += "new file mode 100644\n";
-    result += "--- /dev/null\n";
-    result += `+++ b/${file}
-`;
-    result += `@@ -0,0 +1,${contentLines.length} @@
-`;
-    for (const line of contentLines) {
-      result += `+${line}
-`;
-    }
-    if (!hasTrailingNewline) {
-      result += "\\n";
-    }
-  }
-  return result;
-}
-
-// packages/git/src/parser.ts
-import path2 from "path";
-var EXTENSION_MAP = {
-  ts: "typescript",
-  tsx: "typescript",
-  js: "javascript",
-  jsx: "javascript",
-  py: "python",
-  rb: "ruby",
-  go: "go",
-  rs: "rust",
-  java: "java",
-  c: "c",
-  h: "c",
-  cpp: "cpp",
-  hpp: "cpp",
-  cc: "cpp",
-  cs: "csharp",
-  md: "markdown",
-  json: "json",
-  yaml: "yaml",
-  yml: "yaml",
-  html: "html",
-  css: "css",
-  scss: "scss",
-  sql: "sql",
-  sh: "shell",
-  bash: "shell",
-  zsh: "shell"
-};
-var FILENAME_MAP = {
-  Dockerfile: "dockerfile",
-  Makefile: "makefile"
-};
-function detectLanguage(filePath) {
-  const basename = path2.basename(filePath);
-  if (FILENAME_MAP[basename]) {
-    return FILENAME_MAP[basename];
-  }
-  const ext = basename.includes(".") ? basename.slice(basename.lastIndexOf(".") + 1) : "";
-  return EXTENSION_MAP[ext] ?? "text";
-}
-function stripPrefix(raw) {
-  if (raw === "/dev/null") return raw;
-  return raw.replace(/^[ab]\//, "");
-}
-function parseDiff(rawDiff, baseRef, headRef) {
-  if (!rawDiff.trim()) {
-    return { baseRef, headRef, files: [] };
-  }
-  const files = [];
-  const lines = rawDiff.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    if (!lines[i].startsWith("diff --git ")) {
-      i++;
-      continue;
-    }
-    let oldPath;
-    let newPath;
-    let status = "modified";
-    let binary = false;
-    let renameFrom;
-    let renameTo;
-    const diffLine = lines[i];
-    const gitPathMatch = diffLine.match(/^diff --git a\/(.*) b\/(.*)$/);
-    if (gitPathMatch) {
-      oldPath = gitPathMatch[1];
-      newPath = gitPathMatch[2];
-    }
-    i++;
-    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
-      const line = lines[i];
-      if (line.startsWith("--- ")) {
-        const raw = line.slice(4);
-        oldPath = stripPrefix(raw);
-        if (raw === "/dev/null") {
-          status = "added";
-        }
-      } else if (line.startsWith("+++ ")) {
-        const raw = line.slice(4);
-        newPath = stripPrefix(raw);
-        if (raw === "/dev/null") {
-          status = "deleted";
-        }
-      } else if (line.startsWith("rename from ")) {
-        renameFrom = line.slice("rename from ".length);
-        status = "renamed";
-      } else if (line.startsWith("rename to ")) {
-        renameTo = line.slice("rename to ".length);
-        status = "renamed";
-      } else if (line.startsWith("new file mode")) {
-        status = "added";
-      } else if (line.startsWith("deleted file mode")) {
-        status = "deleted";
-      } else if (line.startsWith("Binary files") || line === "GIT binary patch") {
-        binary = true;
-        if (line.includes("/dev/null") && line.includes(" and b/")) {
-          status = "added";
-        } else if (line.includes("a/") && line.includes("/dev/null")) {
-          status = "deleted";
-        }
-      }
-      if (line.startsWith("@@ ")) {
-        break;
-      }
-      i++;
-    }
-    const filePath = status === "deleted" ? oldPath ?? newPath ?? "unknown" : newPath ?? oldPath ?? "unknown";
-    const fileOldPath = status === "renamed" ? renameFrom ?? oldPath : oldPath;
-    const hunks = [];
-    let additions = 0;
-    let deletions = 0;
-    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
-      const line = lines[i];
-      if (line.startsWith("@@ ")) {
-        const hunkMatch = line.match(
-          /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
-        );
-        if (!hunkMatch) {
-          i++;
-          continue;
-        }
-        const oldStart = parseInt(hunkMatch[1], 10);
-        const oldLines = hunkMatch[2] !== void 0 ? parseInt(hunkMatch[2], 10) : 1;
-        const newStart = parseInt(hunkMatch[3], 10);
-        const newLines = hunkMatch[4] !== void 0 ? parseInt(hunkMatch[4], 10) : 1;
-        const changes = [];
-        let oldLineNum = oldStart;
-        let newLineNum = newStart;
-        i++;
-        while (i < lines.length) {
-          const changeLine = lines[i];
-          if (changeLine.startsWith("@@ ") || changeLine.startsWith("diff --git ")) {
-            break;
-          }
-          if (changeLine.startsWith("\")) {
-            i++;
-            continue;
-          }
-          if (changeLine.startsWith("+")) {
-            changes.push({
-              type: "add",
-              lineNumber: newLineNum,
-              content: changeLine.slice(1)
-            });
-            newLineNum++;
-            additions++;
-          } else if (changeLine.startsWith("-")) {
-            changes.push({
-              type: "delete",
-              lineNumber: oldLineNum,
-              content: changeLine.slice(1)
-            });
-            oldLineNum++;
-            deletions++;
-          } else {
-            changes.push({
-              type: "context",
-              lineNumber: newLineNum,
-              content: changeLine.length > 0 ? changeLine.slice(1) : ""
-            });
-            oldLineNum++;
-            newLineNum++;
-          }
-          i++;
-        }
-        hunks.push({ oldStart, oldLines, newStart, newLines, changes });
-      } else {
-        i++;
-      }
-    }
-    const diffFile = {
-      path: filePath,
-      status,
-      hunks,
-      language: detectLanguage(filePath),
-      binary,
-      additions,
-      deletions
-    };
-    if (status === "renamed" && fileOldPath) {
-      diffFile.oldPath = fileOldPath;
-    }
-    files.push(diffFile);
-  }
-  return { baseRef, headRef, files };
-}
-
-// packages/git/src/index.ts
-function getDiff(ref, options) {
-  if (ref === "working-copy") {
-    return getWorkingCopyDiff(options);
-  }
-  const rawDiff = getGitDiff(ref, options);
-  let baseRef;
-  let headRef;
-  if (ref === "staged") {
-    baseRef = "HEAD";
-    headRef = "staged";
-  } else if (ref === "unstaged") {
-    baseRef = "staged";
-    headRef = "working tree";
-  } else if (ref.includes("..")) {
-    const [base, head] = ref.split("..");
-    baseRef = base;
-    headRef = head;
-  } else {
-    baseRef = ref;
-    headRef = "HEAD";
-  }
-  const diffSet = parseDiff(rawDiff, baseRef, headRef);
-  return { diffSet, rawDiff };
-}
-function getWorkingCopyDiff(options) {
-  const stagedRaw = getGitDiff("staged", options);
-  const unstagedRaw = getGitDiff("unstaged", options);
-  const stagedDiffSet = parseDiff(stagedRaw, "HEAD", "staged");
-  const unstagedDiffSet = parseDiff(unstagedRaw, "staged", "working tree");
-  const stagedFiles = stagedDiffSet.files.map((f) => ({
-    ...f,
-    stage: "staged"
-  }));
-  const unstagedFiles = unstagedDiffSet.files.map((f) => ({
-    ...f,
-    stage: "unstaged"
-  }));
-  const rawDiff = [stagedRaw, unstagedRaw].filter(Boolean).join("");
-  return {
-    diffSet: {
-      baseRef: "HEAD",
-      headRef: "working tree",
-      files: [...stagedFiles, ...unstagedFiles]
-    },
-    rawDiff
-  };
-}
-
-// packages/analysis/src/deterministic.ts
-var MECHANICAL_CONFIG_PATTERNS = [
-  /\.config\./,
-  /\.eslintrc/,
-  /\.prettierrc/,
-  /tsconfig.*\.json$/,
-  /\.gitignore$/,
-  /\.lock$/
-];
-var API_SURFACE_PATTERNS = [
-  /\/api\//,
-  /\/routes\//
-];
-function isFormattingOnly(file) {
-  if (file.hunks.length === 0) return false;
-  for (const hunk of file.hunks) {
-    const adds = hunk.changes.filter((c) => c.type === "add").map((c) => c.content.replace(/\s/g, ""));
-    const deletes = hunk.changes.filter((c) => c.type === "delete").map((c) => c.content.replace(/\s/g, ""));
-    if (adds.length === 0 || deletes.length === 0) return false;
-    const deleteBag = [...deletes];
-    for (const add of adds) {
-      const idx = deleteBag.indexOf(add);
-      if (idx === -1) return false;
-      deleteBag.splice(idx, 1);
-    }
-    if (deleteBag.length > 0) return false;
-  }
-  return true;
-}
-function isImportOnly(file) {
-  if (file.hunks.length === 0) return false;
-  const importPattern = /^\s*(import\s|export\s.*from\s|const\s+\w+\s*=\s*require\(|require\()/;
-  for (const hunk of file.hunks) {
-    for (const change of hunk.changes) {
-      if (change.type === "context") continue;
-      const trimmed = change.content.trim();
-      if (trimmed === "") continue;
-      if (!importPattern.test(trimmed)) return false;
-    }
-  }
-  return true;
-}
-function isMechanicalConfigFile(path8) {
-  return MECHANICAL_CONFIG_PATTERNS.some((re) => re.test(path8));
-}
-function isApiSurface(file) {
-  if (API_SURFACE_PATTERNS.some((re) => re.test(file.path))) return true;
-  const basename = file.path.slice(file.path.lastIndexOf("/") + 1);
-  if ((basename === "index.ts" || basename === "index.js") && file.additions >= 10) {
-    return true;
-  }
-  return false;
-}
-function categorizeFiles(files) {
-  const critical = [];
-  const notable = [];
-  const mechanical = [];
-  const securityFlags = detectSecurityPatterns(files);
-  const complexityScores = computeComplexityScores(files);
-  const securityByFile = /* @__PURE__ */ new Map();
-  for (const flag of securityFlags) {
-    const existing = securityByFile.get(flag.file) || [];
-    existing.push(flag);
-    securityByFile.set(flag.file, existing);
-  }
-  const complexityByFile = /* @__PURE__ */ new Map();
-  for (const score of complexityScores) {
-    complexityByFile.set(score.path, score);
-  }
-  for (const file of files) {
-    const description = `${file.status} (${file.language || "unknown"}) +${file.additions} -${file.deletions}`;
-    const fileSecurityFlags = securityByFile.get(file.path);
-    const fileComplexity = complexityByFile.get(file.path);
-    const criticalReasons = [];
-    if (fileSecurityFlags && fileSecurityFlags.length > 0) {
-      const patterns = fileSecurityFlags.map((f) => f.pattern);
-      const unique = [...new Set(patterns)];
-      criticalReasons.push(`security patterns detected: ${unique.join(", ")}`);
-    }
-    if (fileComplexity && fileComplexity.score >= 8) {
-      criticalReasons.push(`high complexity score (${fileComplexity.score}/10)`);
-    }
-    if (isApiSurface(file)) {
-      criticalReasons.push("modifies public API surface");
-    }
-    if (criticalReasons.length > 0) {
-      critical.push({
-        file: file.path,
-        description,
-        reason: `Critical: ${criticalReasons.join("; ")}`
-      });
-      continue;
-    }
-    const isPureRename = file.status === "renamed" && file.additions === 0 && file.deletions === 0;
-    if (isPureRename) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: pure rename with no content changes"
-      });
-      continue;
-    }
-    if (isFormattingOnly(file)) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: formatting/whitespace-only changes"
-      });
-      continue;
-    }
-    if (isMechanicalConfigFile(file.path)) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: config file change"
-      });
-      continue;
-    }
-    if (file.hunks.length > 0 && isImportOnly(file)) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: import/require-only changes"
-      });
-      continue;
-    }
-    notable.push({
-      file: file.path,
-      description,
-      reason: "Notable: requires review"
-    });
-  }
-  return { critical, notable, mechanical };
-}
-function computeFileStats(files) {
-  return files.map((f) => ({
-    path: f.path,
-    language: f.language,
-    status: f.status,
-    additions: f.additions,
-    deletions: f.deletions
-  }));
-}
-function detectAffectedModules(files) {
-  const dirs = /* @__PURE__ */ new Set();
-  for (const f of files) {
-    const lastSlash = f.path.lastIndexOf("/");
-    if (lastSlash > 0) {
-      dirs.add(f.path.slice(0, lastSlash));
-    }
-  }
-  return [...dirs].sort();
-}
-var TEST_PATTERNS = [
-  /\.test\./,
-  /\.spec\./,
-  /\/__tests__\//,
-  /\/test\//
-];
-function detectAffectedTests(files) {
-  return files.filter((f) => TEST_PATTERNS.some((re) => re.test(f.path))).map((f) => f.path);
-}
-var DEPENDENCY_FIELDS = [
-  '"dependencies"',
-  '"devDependencies"',
-  '"peerDependencies"',
-  '"optionalDependencies"'
-];
-function detectNewDependencies(files) {
-  const deps = /* @__PURE__ */ new Set();
-  const packageFiles = files.filter(
-    (f) => f.path.endsWith("package.json") && f.hunks.length > 0
-  );
-  for (const file of packageFiles) {
-    for (const hunk of file.hunks) {
-      let inDependencyBlock = false;
-      for (const change of hunk.changes) {
-        const line = change.content;
-        if (DEPENDENCY_FIELDS.some((field) => line.includes(field))) {
-          inDependencyBlock = true;
-          continue;
-        }
-        if (inDependencyBlock && line.trim().startsWith("}")) {
-          inDependencyBlock = false;
-          continue;
-        }
-        if (change.type === "add" && inDependencyBlock) {
-          const match = line.match(/"([^"]+)"\s*:/);
-          if (match) {
-            deps.add(match[1]);
-          }
-        }
-      }
-    }
-  }
-  return [...deps].sort();
-}
-function generateSummary(files) {
-  const totalFiles = files.length;
-  const counts = {
-    added: 0,
-    modified: 0,
-    deleted: 0,
-    renamed: 0
-  };
-  let totalAdditions = 0;
-  let totalDeletions = 0;
-  for (const f of files) {
-    counts[f.status]++;
-    totalAdditions += f.additions;
-    totalDeletions += f.deletions;
-  }
-  const parts = [];
-  if (counts.modified > 0) parts.push(`${counts.modified} modified`);
-  if (counts.added > 0) parts.push(`${counts.added} added`);
-  if (counts.deleted > 0) parts.push(`${counts.deleted} deleted`);
-  if (counts.renamed > 0) parts.push(`${counts.renamed} renamed`);
-  const breakdown = parts.length > 0 ? `: ${parts.join(", ")}` : "";
-  return `${totalFiles} files changed${breakdown} (+${totalAdditions} -${totalDeletions})`;
-}
-var BRANCH_PATTERN = /\b(if|else|switch|case|catch)\b|\?\s|&&|\|\|/;
-function computeComplexityScores(files) {
-  const results = [];
-  for (const file of files) {
-    let score = 0;
-    const factors = [];
-    const totalChanges = file.additions + file.deletions;
-    if (totalChanges > 100) {
-      score += 3;
-      factors.push(`large diff (+${file.additions} -${file.deletions})`);
-    } else if (totalChanges > 50) {
-      score += 2;
-      factors.push(`medium diff (+${file.additions} -${file.deletions})`);
-    } else if (totalChanges > 20) {
-      score += 1;
-      factors.push(`moderate diff (+${file.additions} -${file.deletions})`);
-    }
-    const hunkCount = file.hunks.length;
-    if (hunkCount > 4) {
-      score += 2;
-      factors.push(`many hunks (${hunkCount})`);
-    } else if (hunkCount > 2) {
-      score += 1;
-      factors.push(`multiple hunks (${hunkCount})`);
-    }
-    let branchCount = 0;
-    let deepNestCount = 0;
-    for (const hunk of file.hunks) {
-      for (const change of hunk.changes) {
-        if (change.type !== "add") continue;
-        const line = change.content;
-        if (BRANCH_PATTERN.test(line)) {
-          branchCount++;
-        }
-        const leadingSpaces = line.match(/^(\s*)/);
-        if (leadingSpaces) {
-          const ws = leadingSpaces[1];
-          const tabCount = (ws.match(/\t/g) || []).length;
-          const spaceCount = ws.replace(/\t/g, "").length;
-          if (tabCount >= 4 || spaceCount >= 16) {
-            deepNestCount++;
-          }
-        }
-      }
-    }
-    const branchScore = Math.floor(branchCount / 5);
-    if (branchScore > 0) {
-      score += branchScore;
-      factors.push(`${branchCount} logic branches`);
-    }
-    const nestScore = Math.floor(deepNestCount / 5);
-    if (nestScore > 0) {
-      score += nestScore;
-      factors.push(`${deepNestCount} deeply nested lines`);
-    }
-    score = Math.max(1, Math.min(10, score));
-    results.push({ path: file.path, score, factors });
-  }
-  results.sort((a, b) => b.score - a.score);
-  return results;
-}
-var NON_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".json",
-  ".md",
-  ".css",
-  ".scss",
-  ".less",
-  ".svg",
-  ".png",
-  ".jpg",
-  ".gif",
-  ".ico",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".lock",
-  ".html"
-]);
-var CONFIG_PATTERNS = [
-  /\.config\./,
-  /\.rc\./,
-  /eslint/,
-  /prettier/,
-  /tsconfig/,
-  /tailwind/,
-  /vite\.config/,
-  /vitest\.config/
-];
-function isTestFile(path8) {
-  return TEST_PATTERNS.some((re) => re.test(path8));
-}
-function isNonCodeFile(path8) {
-  const ext = path8.slice(path8.lastIndexOf("."));
-  return NON_CODE_EXTENSIONS.has(ext);
-}
-function isConfigFile(path8) {
-  return CONFIG_PATTERNS.some((re) => re.test(path8));
-}
-function detectTestCoverageGaps(files) {
-  const filePaths = new Set(files.map((f) => f.path));
-  const results = [];
-  for (const file of files) {
-    if (file.status !== "added" && file.status !== "modified") continue;
-    if (isTestFile(file.path)) continue;
-    if (isNonCodeFile(file.path)) continue;
-    if (isConfigFile(file.path)) continue;
-    const dir = file.path.slice(0, file.path.lastIndexOf("/") + 1);
-    const basename = file.path.slice(file.path.lastIndexOf("/") + 1);
-    const extDot = basename.lastIndexOf(".");
-    const name = extDot > 0 ? basename.slice(0, extDot) : basename;
-    const ext = extDot > 0 ? basename.slice(extDot) : "";
-    const candidates = [
-      `${dir}${name}.test${ext}`,
-      `${dir}${name}.spec${ext}`,
-      `${dir}__tests__/${name}${ext}`,
-      `${dir}__tests__/${name}.test${ext}`,
-      `${dir}__tests__/${name}.spec${ext}`
-    ];
-    const matchedTest = candidates.find((c) => filePaths.has(c));
-    results.push({
-      sourceFile: file.path,
-      testFile: matchedTest ?? null
-    });
-  }
-  return results;
-}
-var PATTERN_MATCHERS = [
-  { pattern: "todo", test: (l) => /\btodo\b/i.test(l) },
-  { pattern: "fixme", test: (l) => /\bfixme\b/i.test(l) },
-  { pattern: "hack", test: (l) => /\bhack\b/i.test(l) },
-  {
-    pattern: "console",
-    test: (l) => /\bconsole\.(log|debug|warn|error)\b/.test(l)
-  },
-  { pattern: "debug", test: (l) => /\bdebugger\b/.test(l) },
-  {
-    pattern: "disabled_test",
-    test: (l) => /\.(skip)\(|(\bxit|xdescribe|xtest)\(/.test(l)
-  }
-];
-function detectPatterns(files) {
-  const results = [];
-  for (const file of files) {
-    if (file.status === "added" && file.additions > 500) {
-      results.push({
-        file: file.path,
-        line: 0,
-        pattern: "large_file",
-        content: `Large added file: ${file.additions} lines`
-      });
-    }
-    for (const hunk of file.hunks) {
-      for (const change of hunk.changes) {
-        if (change.type !== "add") continue;
-        for (const matcher of PATTERN_MATCHERS) {
-          if (matcher.test(change.content)) {
-            results.push({
-              file: file.path,
-              line: change.lineNumber,
-              pattern: matcher.pattern,
-              content: change.content.trim()
-            });
-          }
-        }
-      }
-    }
-  }
-  results.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-  return results;
-}
-var SECURITY_MATCHERS = [
-  {
-    pattern: "eval",
-    severity: "critical",
-    test: (l) => /\beval\s*\(/.test(l)
-  },
-  {
-    pattern: "inner_html",
-    severity: "warning",
-    test: (l) => /\.innerHTML\b|dangerouslySetInnerHTML/.test(l)
-  },
-  {
-    pattern: "sql_injection",
-    severity: "critical",
-    test: (l) => /`[^`]*\b(SELECT|INSERT|UPDATE|DELETE)\b/i.test(l) || /\b(SELECT|INSERT|UPDATE|DELETE)\b[^`]*\$\{/i.test(l)
-  },
-  {
-    pattern: "exec",
-    severity: "critical",
-    test: (l) => /child_process/.test(l) || /\bexec\s*\(/.test(l) || /\bexecSync\s*\(/.test(l)
-  },
-  {
-    pattern: "hardcoded_secret",
-    severity: "critical",
-    test: (l) => /\b(token|secret|api_key|apikey|password|passwd|credential)\s*=\s*["']/i.test(l)
-  },
-  {
-    pattern: "insecure_url",
-    severity: "warning",
-    test: (l) => /http:\/\/(?!localhost|127\.0\.0\.1|0\.0\.0\.0)/.test(l)
-  }
-];
-function detectSecurityPatterns(files) {
-  const results = [];
-  for (const file of files) {
-    for (const hunk of file.hunks) {
-      for (const change of hunk.changes) {
-        if (change.type !== "add") continue;
-        for (const matcher of SECURITY_MATCHERS) {
-          if (matcher.test(change.content)) {
-            results.push({
-              file: file.path,
-              line: change.lineNumber,
-              pattern: matcher.pattern,
-              content: change.content.trim(),
-              severity: matcher.severity
-            });
-          }
-        }
-      }
-    }
-  }
-  results.sort((a, b) => {
-    const severityOrder = { critical: 0, warning: 1 };
-    const aSev = severityOrder[a.severity];
-    const bSev = severityOrder[b.severity];
-    if (aSev !== bSev) return aSev - bSev;
-    return a.file.localeCompare(b.file) || a.line - b.line;
-  });
-  return results;
-}
-
-// packages/analysis/src/index.ts
-function analyze(diffSet) {
-  const { files } = diffSet;
-  const triage = categorizeFiles(files);
-  const fileStats = computeFileStats(files);
-  const affectedModules = detectAffectedModules(files);
-  const affectedTests = detectAffectedTests(files);
-  const newDependencies = detectNewDependencies(files);
-  const summary = generateSummary(files);
-  const complexity = computeComplexityScores(files);
-  const testCoverage = detectTestCoverageGaps(files);
-  const codePatterns = detectPatterns(files);
-  const securityPatterns = detectSecurityPatterns(files);
-  const patterns = [...securityPatterns, ...codePatterns];
-  return {
-    summary,
-    triage,
-    impact: {
-      affectedModules,
-      affectedTests,
-      publicApiChanges: false,
-      breakingChanges: [],
-      newDependencies
-    },
-    verification: {
-      testsPass: null,
-      typeCheck: null,
-      lintClean: null
-    },
-    fileStats,
-    complexity,
-    testCoverage,
-    patterns
-  };
-}
-
-// packages/core/src/watch-file.ts
 import fs from "fs";
-import path3 from "path";
-import { execSync as execSync2 } from "child_process";
-function findGitRoot(cwd) {
-  const root = execSync2("git rev-parse --show-toplevel", {
-    cwd: cwd ?? process.cwd(),
-    encoding: "utf-8"
-  }).trim();
-  return root;
-}
-function watchFilePath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path3.join(gitRoot, ".diffprism", "watch.json");
-}
-function isPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function writeWatchFile(cwd, info) {
-  const filePath = watchFilePath(cwd);
-  const dir = path3.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(filePath, JSON.stringify(info, null, 2) + "\n");
-}
-function readWatchFile(cwd) {
-  const filePath = watchFilePath(cwd);
-  if (!fs.existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const info = JSON.parse(raw);
-    if (!isPidAlive(info.pid)) {
-      fs.unlinkSync(filePath);
-      return null;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function removeWatchFile(cwd) {
-  try {
-    const filePath = watchFilePath(cwd);
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath);
-    }
-  } catch {
-  }
-}
-function reviewResultPath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path3.join(gitRoot, ".diffprism", "last-review.json");
-}
-function writeReviewResult(cwd, result) {
-  const filePath = reviewResultPath(cwd);
-  const dir = path3.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  const data = {
-    result,
-    timestamp: Date.now(),
-    consumed: false
-  };
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-}
-function readReviewResult(cwd) {
-  try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs.existsSync(filePath)) {
-      return null;
-    }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    if (data.consumed) {
-      return null;
-    }
-    return data;
-  } catch {
-    return null;
-  }
-}
-function consumeReviewResult(cwd) {
-  try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs.existsSync(filePath)) {
-      return;
-    }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    data.consumed = true;
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-  } catch {
-  }
-}
-
-// packages/core/src/pipeline.ts
-import getPort from "get-port";
-import open from "open";
-
-// packages/core/src/review-history.ts
-import fs2 from "fs";
-import path4 from "path";
-import { randomUUID } from "crypto";
-function generateEntryId() {
-  return randomUUID();
-}
-function getHistoryPath(projectDir) {
-  return path4.join(projectDir, ".diffprism", "history", "reviews.json");
-}
-function readHistory(projectDir) {
-  const filePath = getHistoryPath(projectDir);
-  if (!fs2.existsSync(filePath)) {
-    return { version: 1, entries: [] };
-  }
-  try {
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return parsed;
-  } catch {
-    return { version: 1, entries: [] };
-  }
-}
-function appendHistory(projectDir, entry) {
-  const filePath = getHistoryPath(projectDir);
-  const dir = path4.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  const history = readHistory(projectDir);
-  history.entries.push(entry);
-  history.entries.sort((a, b) => a.timestamp - b.timestamp);
-  fs2.writeFileSync(filePath, JSON.stringify(history, null, 2) + "\n");
-}
-function getRecentHistory(projectDir, limit = 50) {
-  const history = readHistory(projectDir);
-  return history.entries.slice(-limit);
-}
-
-// packages/core/src/watch-bridge.ts
-import http from "http";
-import { WebSocketServer, WebSocket } from "ws";
-function createWatchBridge(port, callbacks) {
-  let client = null;
-  let initPayload = null;
-  let pendingInit = null;
-  let closeTimer = null;
-  let submitCallback = null;
-  let resultReject = null;
-  const httpServer = http.createServer(async (req, res) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    if (req.method === "GET" && req.url === "/api/status") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ running: true, pid: process.pid }));
-      return;
-    }
-    if (req.method === "POST" && req.url === "/api/context") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk.toString();
-      });
-      req.on("end", () => {
-        try {
-          const payload = JSON.parse(body);
-          callbacks.onContextUpdate(payload);
-          sendToClient({ type: "context:update", payload });
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: true }));
-        } catch {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Invalid JSON" }));
-        }
-      });
-      return;
-    }
-    if (req.method === "POST" && req.url === "/api/refresh") {
-      callbacks.onRefreshRequest();
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true }));
-      return;
-    }
-    const pathname = (req.url ?? "").split("?")[0];
-    if (req.method === "GET" && (pathname === "/api/refs" || /^\/api\/reviews\/[^/]+\/refs$/.test(pathname))) {
-      if (callbacks.onRefsRequest) {
-        const refsPayload = await callbacks.onRefsRequest();
-        if (refsPayload) {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(refsPayload));
-        } else {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Failed to list git refs" }));
-        }
-      } else {
-        res.writeHead(404);
-        res.end("Not found");
-      }
-      return;
-    }
-    if (req.method === "POST" && (pathname === "/api/compare" || /^\/api\/reviews\/[^/]+\/compare$/.test(pathname))) {
-      if (callbacks.onCompareRequest) {
-        let body = "";
-        req.on("data", (chunk) => {
-          body += chunk.toString();
-        });
-        req.on("end", async () => {
-          try {
-            const { ref } = JSON.parse(body);
-            if (!ref) {
-              res.writeHead(400, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: "Missing ref" }));
-              return;
-            }
-            const success = await callbacks.onCompareRequest(ref);
-            if (success) {
-              res.writeHead(200, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ ok: true }));
-            } else {
-              res.writeHead(400, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: "Failed to compute diff" }));
-            }
-          } catch {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Invalid JSON" }));
-          }
-        });
-      } else {
-        res.writeHead(404);
-        res.end("Not found");
-      }
-      return;
-    }
-    res.writeHead(404);
-    res.end("Not found");
-  });
-  const wss2 = new WebSocketServer({ server: httpServer });
-  function sendToClient(msg) {
-    if (client && client.readyState === WebSocket.OPEN) {
-      client.send(JSON.stringify(msg));
-    }
-  }
-  wss2.on("connection", (ws) => {
-    if (closeTimer) {
-      clearTimeout(closeTimer);
-      closeTimer = null;
-    }
-    client = ws;
-    const payload = pendingInit ?? initPayload;
-    if (payload) {
-      sendToClient({ type: "review:init", payload });
-      pendingInit = null;
-    }
-    ws.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "review:submit" && submitCallback) {
-          submitCallback(msg.payload);
-        } else if (msg.type === "diff:change_ref" && callbacks.onDiffRefChange) {
-          callbacks.onDiffRefChange(msg.payload.diffRef);
-        }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      client = null;
-      if (resultReject) {
-        closeTimer = setTimeout(() => {
-          closeTimer = null;
-          if (resultReject) {
-            resultReject(new Error("Browser closed before review was submitted"));
-            resultReject = null;
-            submitCallback = null;
-          }
-        }, 2e3);
-      } else {
-        closeTimer = setTimeout(() => {
-          closeTimer = null;
-        }, 2e3);
-      }
-    });
-  });
-  return new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, () => {
-      resolve({
-        port,
-        sendInit(payload) {
-          initPayload = payload;
-          if (client && client.readyState === WebSocket.OPEN) {
-            sendToClient({ type: "review:init", payload });
-          } else {
-            pendingInit = payload;
-          }
-        },
-        storeInitPayload(payload) {
-          initPayload = payload;
-        },
-        sendDiffUpdate(payload) {
-          sendToClient({ type: "diff:update", payload });
-        },
-        sendContextUpdate(payload) {
-          sendToClient({ type: "context:update", payload });
-        },
-        sendDiffError(payload) {
-          sendToClient({ type: "diff:error", payload });
-        },
-        onSubmit(callback) {
-          submitCallback = callback;
-        },
-        waitForResult() {
-          return new Promise((resolve2, reject2) => {
-            submitCallback = resolve2;
-            resultReject = reject2;
-          });
-        },
-        triggerRefresh() {
-          callbacks.onRefreshRequest();
-        },
-        async close() {
-          if (closeTimer) {
-            clearTimeout(closeTimer);
-          }
-          for (const ws of wss2.clients) {
-            ws.close();
-          }
-          wss2.close();
-          await new Promise((resolve2) => {
-            httpServer.close(() => resolve2());
-          });
-        }
-      });
-    });
-  });
-}
-
-// packages/core/src/diff-utils.ts
-import { createHash } from "crypto";
-function hashDiff(rawDiff) {
-  return createHash("sha256").update(rawDiff).digest("hex");
-}
-function fileKey(file) {
-  return file.stage ? `${file.stage}:${file.path}` : file.path;
-}
-function detectChangedFiles(oldDiffSet, newDiffSet) {
-  if (!oldDiffSet) {
-    return newDiffSet.files.map(fileKey);
-  }
-  const oldFiles = new Map(
-    oldDiffSet.files.map((f) => [fileKey(f), f])
-  );
-  const changed = [];
-  for (const newFile of newDiffSet.files) {
-    const key = fileKey(newFile);
-    const oldFile = oldFiles.get(key);
-    if (!oldFile) {
-      changed.push(key);
-    } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
-      changed.push(key);
-    }
-  }
-  for (const oldFile of oldDiffSet.files) {
-    if (!newDiffSet.files.some((f) => fileKey(f) === fileKey(oldFile))) {
-      changed.push(fileKey(oldFile));
-    }
-  }
-  return changed;
-}
-
-// packages/core/src/diff-poller.ts
-function createDiffPoller(options) {
-  let { diffRef } = options;
-  const { cwd, pollInterval, onDiffChanged, onError, silent } = options;
-  let lastDiffHash = null;
-  let lastDiffSet = null;
-  let refreshRequested = false;
-  let interval = null;
-  let running = false;
-  function poll() {
-    if (!running) return;
-    try {
-      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(diffRef, { cwd });
-      const newHash = hashDiff(newRawDiff);
-      if (newHash !== lastDiffHash || refreshRequested) {
-        refreshRequested = false;
-        const newBriefing = analyze(newDiffSet);
-        const changedFiles = detectChangedFiles(lastDiffSet, newDiffSet);
-        lastDiffHash = newHash;
-        lastDiffSet = newDiffSet;
-        const updatePayload = {
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing,
-          changedFiles,
-          timestamp: Date.now()
-        };
-        onDiffChanged(updatePayload);
-      }
-    } catch (err) {
-      if (onError && err instanceof Error) {
-        onError(err);
-      }
-    }
-  }
-  return {
-    start() {
-      if (running) return;
-      running = true;
-      try {
-        const { diffSet: initialDiffSet, rawDiff: initialRawDiff } = getDiff(diffRef, { cwd });
-        lastDiffHash = hashDiff(initialRawDiff);
-        lastDiffSet = initialDiffSet;
-      } catch {
-      }
-      interval = setInterval(poll, pollInterval);
-    },
-    stop() {
-      running = false;
-      if (interval) {
-        clearInterval(interval);
-        interval = null;
-      }
-    },
-    setDiffRef(newRef) {
-      diffRef = newRef;
-      lastDiffHash = null;
-      lastDiffSet = null;
-    },
-    refresh() {
-      refreshRequested = true;
-    }
-  };
-}
-
-// packages/core/src/review-manager.ts
-var sessions = /* @__PURE__ */ new Map();
-var idCounter = 0;
-function createSession(options) {
-  const id = `review-${Date.now()}-${++idCounter}`;
-  const session = {
-    id,
-    options,
-    status: "pending",
-    createdAt: Date.now()
-  };
-  sessions.set(id, session);
-  return session;
-}
-function updateSession(id, update) {
-  const session = sessions.get(id);
-  if (session) {
-    Object.assign(session, update);
-  }
-}
-
-// packages/core/src/ui-server.ts
-import http2 from "http";
-import fs3 from "fs";
-import path5 from "path";
-import { fileURLToPath } from "url";
-var MIME_TYPES = {
-  ".html": "text/html",
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2"
-};
-function resolveUiDist() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path5.dirname(thisFile);
-  const publishedUiDist = path5.resolve(thisDir, "..", "ui-dist");
-  if (fs3.existsSync(path5.join(publishedUiDist, "index.html"))) {
-    return publishedUiDist;
-  }
-  const workspaceRoot = path5.resolve(thisDir, "..", "..", "..");
-  const devUiDist = path5.join(workspaceRoot, "packages", "ui", "dist");
-  if (fs3.existsSync(path5.join(devUiDist, "index.html"))) {
-    return devUiDist;
-  }
-  throw new Error(
-    "Could not find built UI. Run 'pnpm -F @diffprism/ui build' first."
-  );
-}
-function resolveUiRoot() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path5.dirname(thisFile);
-  const workspaceRoot = path5.resolve(thisDir, "..", "..", "..");
-  const uiRoot = path5.join(workspaceRoot, "packages", "ui");
-  if (fs3.existsSync(path5.join(uiRoot, "index.html"))) {
-    return uiRoot;
-  }
-  throw new Error(
-    "Could not find UI source directory. Dev mode requires the diffprism workspace."
-  );
-}
-async function startViteDevServer(uiRoot, port, silent) {
-  const { createServer } = await import("vite");
-  const vite = await createServer({
-    root: uiRoot,
-    server: { port, strictPort: true, open: false },
-    logLevel: silent ? "silent" : "warn"
-  });
-  await vite.listen();
-  return vite;
-}
-function createStaticServer(distPath, port) {
-  const server = http2.createServer((req, res) => {
-    const urlPath = req.url?.split("?")[0] ?? "/";
-    let filePath = path5.join(distPath, urlPath === "/" ? "index.html" : urlPath);
-    if (!fs3.existsSync(filePath)) {
-      filePath = path5.join(distPath, "index.html");
-    }
-    const ext = path5.extname(filePath);
-    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
-    try {
-      const content = fs3.readFileSync(filePath);
-      res.writeHead(200, { "Content-Type": contentType });
-      res.end(content);
-    } catch {
-      res.writeHead(404);
-      res.end("Not found");
-    }
-  });
-  return new Promise((resolve, reject) => {
-    server.on("error", reject);
-    server.listen(port, () => resolve(server));
-  });
-}
-
-// packages/core/src/pipeline.ts
-async function startReview(options) {
-  const { diffRef, title, description, reasoning, cwd, silent, dev, injectedPayload } = options;
-  let diffSet;
-  let rawDiff;
-  let briefing;
-  let metadata;
-  if (injectedPayload) {
-    diffSet = injectedPayload.diffSet;
-    rawDiff = injectedPayload.rawDiff;
-    briefing = injectedPayload.briefing;
-    metadata = { ...injectedPayload.metadata };
-  } else {
-    const result = getDiff(diffRef, { cwd });
-    diffSet = result.diffSet;
-    rawDiff = result.rawDiff;
-    const currentBranch = getCurrentBranch({ cwd });
-    if (diffSet.files.length === 0) {
-      if (!silent) {
-        console.log("No changes to review.");
-      }
-      return {
-        decision: "approved",
-        comments: [],
-        summary: "No changes to review."
-      };
-    }
-    briefing = analyze(diffSet);
-    const worktreeInfo = detectWorktree({ cwd });
-    metadata = {
-      title,
-      description,
-      reasoning,
-      currentBranch,
-      worktree: worktreeInfo.isWorktree ? {
-        isWorktree: true,
-        worktreePath: worktreeInfo.worktreePath,
-        mainWorktreePath: worktreeInfo.mainWorktreePath
-      } : void 0
-    };
-  }
-  if (diffSet.files.length === 0) {
-    if (!silent) {
-      console.log("No changes to review.");
-    }
-    return {
-      decision: "approved",
-      comments: [],
-      summary: "No changes to review."
-    };
-  }
-  const session = createSession(options);
-  updateSession(session.id, { status: "in_progress" });
-  const isInjected = !!injectedPayload;
-  let poller = null;
-  const [bridgePort, httpPort] = await Promise.all([
-    getPort(),
-    getPort()
-  ]);
-  function handleDiffRefChange(newRef) {
-    if (isInjected) return;
-    const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, { cwd });
-    const newBriefing = analyze(newDiffSet);
-    bridge.sendDiffUpdate({
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      changedFiles: newDiffSet.files.map((f) => f.path),
-      timestamp: Date.now()
-    });
-    bridge.storeInitPayload({
-      reviewId: session.id,
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      metadata,
-      watchMode: true
-    });
-    poller?.setDiffRef(newRef);
-  }
-  const bridge = await createWatchBridge(bridgePort, {
-    onRefreshRequest: () => {
-      poller?.refresh();
-    },
-    onContextUpdate: (payload) => {
-      if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
-      if (payload.title !== void 0) metadata.title = payload.title;
-      if (payload.description !== void 0) metadata.description = payload.description;
-    },
-    onDiffRefChange: (newRef) => {
-      if (isInjected) return;
-      try {
-        handleDiffRefChange(newRef);
-      } catch (err) {
-        bridge.sendDiffError({
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    },
-    onRefsRequest: async () => {
-      if (isInjected) return null;
-      try {
-        const resolvedCwd = cwd ?? process.cwd();
-        const branches = listBranches({ cwd: resolvedCwd });
-        const commits = listCommits({ cwd: resolvedCwd });
-        const branch = getCurrentBranch({ cwd: resolvedCwd });
-        return { branches, commits, currentBranch: branch };
-      } catch {
-        return null;
-      }
-    },
-    onCompareRequest: async (ref) => {
-      if (isInjected) return false;
-      try {
-        handleDiffRefChange(ref);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  });
-  let httpServer = null;
-  let viteServer = null;
-  try {
-    if (dev) {
-      const uiRoot = resolveUiRoot();
-      viteServer = await startViteDevServer(uiRoot, httpPort, !!silent);
-    } else {
-      const uiDist = resolveUiDist();
-      httpServer = await createStaticServer(uiDist, httpPort);
-    }
-    writeWatchFile(cwd, {
-      wsPort: bridgePort,
-      uiPort: httpPort,
-      pid: process.pid,
-      cwd: cwd ?? process.cwd(),
-      diffRef,
-      startedAt: Date.now()
-    });
-    const url = `http://localhost:${httpPort}?wsPort=${bridgePort}&httpPort=${bridgePort}&reviewId=${session.id}`;
-    if (!silent) {
-      console.log(`
-DiffPrism Review: ${title ?? briefing.summary}`);
-      console.log(`Opening browser at ${url}
-`);
-    }
-    await open(url);
-    const initPayload = {
-      reviewId: session.id,
-      diffSet,
-      rawDiff,
-      briefing,
-      metadata,
-      watchMode: !isInjected
-    };
-    bridge.sendInit(initPayload);
-    if (!isInjected) {
-      poller = createDiffPoller({
-        diffRef,
-        cwd: cwd ?? process.cwd(),
-        pollInterval: 1e3,
-        onDiffChanged: (updatePayload) => {
-          bridge.storeInitPayload({
-            reviewId: session.id,
-            diffSet: updatePayload.diffSet,
-            rawDiff: updatePayload.rawDiff,
-            briefing: updatePayload.briefing,
-            metadata,
-            watchMode: true
-          });
-          bridge.sendDiffUpdate(updatePayload);
-          if (!silent && updatePayload.changedFiles.length > 0) {
-            console.log(
-              `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${updatePayload.changedFiles.length} file(s) changed`
-            );
-          }
-        }
-      });
-      poller.start();
-    }
-    const result = await bridge.waitForResult();
-    poller?.stop();
-    updateSession(session.id, { status: "completed", result });
-    try {
-      const projectDir = cwd ?? process.cwd();
-      const entry = {
-        id: generateEntryId(),
-        timestamp: Date.now(),
-        diffRef,
-        decision: result.decision,
-        filesReviewed: diffSet.files.length,
-        additions: diffSet.files.reduce((sum, f) => sum + f.additions, 0),
-        deletions: diffSet.files.reduce((sum, f) => sum + f.deletions, 0),
-        commentCount: result.comments.length,
-        branch: metadata.currentBranch,
-        title: metadata.title,
-        summary: result.summary ?? briefing.summary
-      };
-      appendHistory(projectDir, entry);
-    } catch {
-    }
-    return result;
-  } finally {
-    poller?.stop();
-    await bridge.close();
-    removeWatchFile(cwd);
-    if (viteServer) {
-      await viteServer.close();
-    }
-    if (httpServer) {
-      httpServer.close();
-    }
-  }
-}
-
-// packages/core/src/server-file.ts
-import fs4 from "fs";
-import path6 from "path";
+import path from "path";
 import os from "os";
-function serverDir() {
-  return path6.join(os.homedir(), ".diffprism");
-}
-function serverFilePath() {
-  return path6.join(serverDir(), "server.json");
-}
-function isPidAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function writeServerFile(info) {
-  const dir = serverDir();
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
-  }
-  fs4.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
-}
-function readServerFile() {
-  const filePath = serverFilePath();
-  if (!fs4.existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const raw = fs4.readFileSync(filePath, "utf-8");
-    const info = JSON.parse(raw);
-    if (!isPidAlive2(info.pid)) {
-      fs4.unlinkSync(filePath);
-      return null;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function removeServerFile() {
-  try {
-    const filePath = serverFilePath();
-    if (fs4.existsSync(filePath)) {
-      fs4.unlinkSync(filePath);
-    }
-  } catch {
-  }
-}
-async function isServerAlive() {
-  const info = readServerFile();
-  if (!info) {
-    return null;
-  }
-  try {
-    const response = await fetch(`http://localhost:${info.httpPort}/api/status`, {
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (response.ok) {
-      return info;
-    }
-    return null;
-  } catch {
-    removeServerFile();
-    return null;
-  }
-}
-
-// packages/core/src/watch.ts
-import getPort2 from "get-port";
-import open2 from "open";
-async function startWatch(options) {
-  const {
-    diffRef,
-    title,
-    description,
-    reasoning,
-    cwd,
-    silent,
-    dev,
-    pollInterval = 1e3
-  } = options;
-  const { diffSet: initialDiffSet, rawDiff: initialRawDiff } = getDiff(diffRef, { cwd });
-  const currentBranch = getCurrentBranch({ cwd });
-  const initialBriefing = analyze(initialDiffSet);
-  const metadata = {
-    title,
-    description,
-    reasoning,
-    currentBranch
-  };
-  const [bridgePort, uiPort] = await Promise.all([
-    getPort2(),
-    getPort2()
-  ]);
-  const reviewId = "watch-session";
-  function handleDiffRefChange(newRef) {
-    const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, { cwd });
-    const newBriefing = analyze(newDiffSet);
-    bridge.sendDiffUpdate({
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      changedFiles: newDiffSet.files.map((f) => f.path),
-      timestamp: Date.now()
-    });
-    bridge.storeInitPayload({
-      reviewId,
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      metadata,
-      watchMode: true
-    });
-    poller.setDiffRef(newRef);
-  }
-  const bridge = await createWatchBridge(bridgePort, {
-    onRefreshRequest: () => {
-      poller.refresh();
-    },
-    onContextUpdate: (payload) => {
-      if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
-      if (payload.title !== void 0) metadata.title = payload.title;
-      if (payload.description !== void 0) metadata.description = payload.description;
-    },
-    onDiffRefChange: (newRef) => {
-      try {
-        handleDiffRefChange(newRef);
-      } catch (err) {
-        bridge.sendDiffError({
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    },
-    onRefsRequest: async () => {
-      try {
-        const resolvedCwd = cwd ?? process.cwd();
-        const branches = listBranches({ cwd: resolvedCwd });
-        const commits = listCommits({ cwd: resolvedCwd });
-        const branch = getCurrentBranch({ cwd: resolvedCwd });
-        return { branches, commits, currentBranch: branch };
-      } catch {
-        return null;
-      }
-    },
-    onCompareRequest: async (ref) => {
-      try {
-        handleDiffRefChange(ref);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  });
-  let httpServer = null;
-  let viteServer = null;
-  if (dev) {
-    const uiRoot = resolveUiRoot();
-    viteServer = await startViteDevServer(uiRoot, uiPort, !!silent);
-  } else {
-    const uiDist = resolveUiDist();
-    httpServer = await createStaticServer(uiDist, uiPort);
-  }
-  writeWatchFile(cwd, {
-    wsPort: bridgePort,
-    uiPort,
-    pid: process.pid,
-    cwd: cwd ?? process.cwd(),
-    diffRef,
-    startedAt: Date.now()
-  });
-  const url = `http://localhost:${uiPort}?wsPort=${bridgePort}&httpPort=${bridgePort}&reviewId=${reviewId}`;
-  if (!silent) {
-    console.log(`
-DiffPrism Watch: ${title ?? `watching ${diffRef}`}`);
-    console.log(`Browser: ${url}`);
-    console.log(`API: http://localhost:${bridgePort}`);
-    console.log(`Polling every ${pollInterval}ms
-`);
-  }
-  await open2(url);
-  const initPayload = {
-    reviewId,
-    diffSet: initialDiffSet,
-    rawDiff: initialRawDiff,
-    briefing: initialBriefing,
-    metadata,
-    watchMode: true
-  };
-  bridge.sendInit(initPayload);
-  bridge.onSubmit((result) => {
-    if (!silent) {
-      console.log(`
-Review submitted: ${result.decision}`);
-      if (result.comments.length > 0) {
-        console.log(`  ${result.comments.length} comment(s)`);
-      }
-      console.log("Continuing to watch...\n");
-    }
-    writeReviewResult(cwd, result);
-  });
-  const poller = createDiffPoller({
-    diffRef,
-    cwd: cwd ?? process.cwd(),
-    pollInterval,
-    onDiffChanged: (updatePayload) => {
-      bridge.storeInitPayload({
-        reviewId,
-        diffSet: updatePayload.diffSet,
-        rawDiff: updatePayload.rawDiff,
-        briefing: updatePayload.briefing,
-        metadata,
-        watchMode: true
-      });
-      bridge.sendDiffUpdate(updatePayload);
-      if (!silent && updatePayload.changedFiles.length > 0) {
-        console.log(
-          `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${updatePayload.changedFiles.length} file(s) changed`
-        );
-      }
-    }
-  });
-  poller.start();
-  async function stop() {
-    poller.stop();
-    await bridge.close();
-    if (viteServer) {
-      await viteServer.close();
-    }
-    if (httpServer) {
-      httpServer.close();
-    }
-    removeWatchFile(cwd);
-  }
-  function updateContext(payload) {
-    if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
-    if (payload.title !== void 0) metadata.title = payload.title;
-    if (payload.description !== void 0) metadata.description = payload.description;
-    bridge.sendContextUpdate(payload);
-  }
-  return { stop, updateContext };
-}
-
-// packages/core/src/global-server.ts
-import http3 from "http";
-import { randomUUID as randomUUID2 } from "crypto";
-import getPort3 from "get-port";
-import open3 from "open";
-import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket2 } from "ws";
-var SUBMITTED_TTL_MS = 5 * 60 * 1e3;
-var ABANDONED_TTL_MS = 60 * 60 * 1e3;
-var CLEANUP_INTERVAL_MS = 60 * 1e3;
-var sessions2 = /* @__PURE__ */ new Map();
-var clientSessions = /* @__PURE__ */ new Map();
-var sessionWatchers = /* @__PURE__ */ new Map();
-var serverPollInterval = 2e3;
-var reopenBrowserIfNeeded = null;
-function toSummary(session) {
-  const { payload } = session;
-  const fileCount = payload.diffSet.files.length;
-  let additions = 0;
-  let deletions = 0;
-  for (const file of payload.diffSet.files) {
-    additions += file.additions;
-    deletions += file.deletions;
-  }
-  return {
-    id: session.id,
-    projectPath: session.projectPath,
-    branch: payload.metadata.currentBranch,
-    title: payload.metadata.title,
-    fileCount,
-    additions,
-    deletions,
-    status: session.status,
-    decision: session.result?.decision,
-    createdAt: session.createdAt,
-    hasNewChanges: session.hasNewChanges
-  };
-}
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
-    });
-    req.on("end", () => resolve(body));
-    req.on("error", reject);
-  });
-}
-function jsonResponse(res, status, data) {
-  res.writeHead(status, { "Content-Type": "application/json" });
-  res.end(JSON.stringify(data));
-}
-function matchRoute(method, url, expectedMethod, pattern) {
-  if (method !== expectedMethod) return null;
-  const patternParts = pattern.split("/");
-  const urlParts = url.split("/");
-  if (patternParts.length !== urlParts.length) return null;
-  const params = {};
-  for (let i = 0; i < patternParts.length; i++) {
-    if (patternParts[i].startsWith(":")) {
-      params[patternParts[i].slice(1)] = urlParts[i];
-    } else if (patternParts[i] !== urlParts[i]) {
-      return null;
-    }
-  }
-  return params;
-}
-var wss = null;
-function broadcastToAll(msg) {
-  if (!wss) return;
-  const data = JSON.stringify(msg);
-  for (const client of wss.clients) {
-    if (client.readyState === WebSocket2.OPEN) {
-      client.send(data);
-    }
-  }
-}
-function sendToSessionClients(sessionId, msg) {
-  if (!wss) return;
-  const data = JSON.stringify(msg);
-  for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
-      client.send(data);
-    }
-  }
-}
-function broadcastSessionUpdate(session) {
-  broadcastToAll({
-    type: "session:updated",
-    payload: toSummary(session)
-  });
-}
-function broadcastSessionRemoved(sessionId) {
-  for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId) {
-      clientSessions.delete(client);
-    }
-  }
-  broadcastToAll({
-    type: "session:removed",
-    payload: { sessionId }
-  });
-}
-function hasViewersForSession(sessionId) {
-  for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
-      return true;
-    }
-  }
-  return false;
-}
-function startSessionWatcher(sessionId) {
-  if (sessionWatchers.has(sessionId)) return;
-  const session = sessions2.get(sessionId);
-  if (!session?.diffRef) return;
-  const poller = createDiffPoller({
-    diffRef: session.diffRef,
-    cwd: session.projectPath,
-    pollInterval: serverPollInterval,
-    onDiffChanged: (updatePayload) => {
-      const s = sessions2.get(sessionId);
-      if (!s) return;
-      s.payload = {
-        ...s.payload,
-        diffSet: updatePayload.diffSet,
-        rawDiff: updatePayload.rawDiff,
-        briefing: updatePayload.briefing
-      };
-      s.lastDiffHash = hashDiff(updatePayload.rawDiff);
-      s.lastDiffSet = updatePayload.diffSet;
-      if (hasViewersForSession(sessionId)) {
-        sendToSessionClients(sessionId, {
-          type: "diff:update",
-          payload: updatePayload
-        });
-        s.hasNewChanges = false;
-      } else {
-        s.hasNewChanges = true;
-        broadcastSessionList();
-      }
-    }
-  });
-  poller.start();
-  sessionWatchers.set(sessionId, poller);
-}
-function stopSessionWatcher(sessionId) {
-  const poller = sessionWatchers.get(sessionId);
-  if (poller) {
-    poller.stop();
-    sessionWatchers.delete(sessionId);
-  }
-}
-function startAllWatchers() {
-  for (const [id, session] of sessions2.entries()) {
-    if (session.diffRef && !sessionWatchers.has(id)) {
-      startSessionWatcher(id);
-    }
-  }
-}
-function stopAllWatchers() {
-  for (const [, poller] of sessionWatchers.entries()) {
-    poller.stop();
-  }
-  sessionWatchers.clear();
-}
-function hasConnectedClients() {
-  if (!wss) return false;
-  for (const client of wss.clients) {
-    if (client.readyState === WebSocket2.OPEN) return true;
-  }
-  return false;
-}
-function broadcastSessionList() {
-  const summaries = Array.from(sessions2.values()).map(toSummary);
-  broadcastToAll({ type: "session:list", payload: summaries });
-}
-function recordReviewHistory(session, result) {
-  if (session.projectPath.startsWith("github:")) return;
-  try {
-    const { payload } = session;
-    const entry = {
-      id: generateEntryId(),
-      timestamp: Date.now(),
-      diffRef: session.diffRef ?? "unknown",
-      decision: result.decision,
-      filesReviewed: payload.diffSet.files.length,
-      additions: payload.diffSet.files.reduce((sum, f) => sum + f.additions, 0),
-      deletions: payload.diffSet.files.reduce((sum, f) => sum + f.deletions, 0),
-      commentCount: result.comments.length,
-      branch: payload.metadata.currentBranch,
-      title: payload.metadata.title,
-      summary: result.summary ?? payload.briefing.summary
-    };
-    appendHistory(session.projectPath, entry);
-  } catch {
-  }
-}
-async function handleApiRequest(req, res) {
-  const method = req.method ?? "GET";
-  const url = (req.url ?? "/").split("?")[0];
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-  if (method === "OPTIONS") {
-    res.writeHead(204);
-    res.end();
-    return true;
-  }
-  if (!url.startsWith("/api/")) {
-    return false;
-  }
-  if (method === "GET" && url === "/api/status") {
-    jsonResponse(res, 200, {
-      running: true,
-      pid: process.pid,
-      sessions: sessions2.size,
-      uptime: process.uptime()
-    });
-    return true;
-  }
-  if (method === "POST" && url === "/api/reviews") {
-    try {
-      const body = await readBody(req);
-      const { payload, projectPath, diffRef } = JSON.parse(body);
-      let existingSession;
-      for (const session of sessions2.values()) {
-        if (session.projectPath === projectPath) {
-          existingSession = session;
-          break;
-        }
-      }
-      if (existingSession) {
-        const sessionId = existingSession.id;
-        payload.reviewId = sessionId;
-        if (diffRef) {
-          payload.watchMode = true;
-        }
-        stopSessionWatcher(sessionId);
-        existingSession.payload = payload;
-        existingSession.status = "pending";
-        existingSession.result = null;
-        existingSession.createdAt = Date.now();
-        existingSession.diffRef = diffRef;
-        existingSession.lastDiffHash = diffRef ? hashDiff(payload.rawDiff) : void 0;
-        existingSession.lastDiffSet = diffRef ? payload.diffSet : void 0;
-        existingSession.hasNewChanges = false;
-        existingSession.annotations = [];
-        if (diffRef && hasConnectedClients()) {
-          startSessionWatcher(sessionId);
-        }
-        if (hasViewersForSession(sessionId)) {
-          sendToSessionClients(sessionId, {
-            type: "review:init",
-            payload
-          });
-        }
-        broadcastSessionUpdate(existingSession);
-        reopenBrowserIfNeeded?.();
-        jsonResponse(res, 200, { sessionId });
-      } else {
-        const sessionId = `session-${randomUUID2().slice(0, 8)}`;
-        payload.reviewId = sessionId;
-        if (diffRef) {
-          payload.watchMode = true;
-        }
-        const session = {
-          id: sessionId,
-          payload,
-          projectPath,
-          status: "pending",
-          createdAt: Date.now(),
-          result: null,
-          diffRef,
-          lastDiffHash: diffRef ? hashDiff(payload.rawDiff) : void 0,
-          lastDiffSet: diffRef ? payload.diffSet : void 0,
-          hasNewChanges: false,
-          annotations: []
-        };
-        sessions2.set(sessionId, session);
-        if (diffRef && hasConnectedClients()) {
-          startSessionWatcher(sessionId);
-        }
-        broadcastToAll({
-          type: "session:added",
-          payload: toSummary(session)
-        });
-        reopenBrowserIfNeeded?.();
-        jsonResponse(res, 201, { sessionId });
-      }
-    } catch {
-      jsonResponse(res, 400, { error: "Invalid request body" });
-    }
-    return true;
-  }
-  if (method === "GET" && url === "/api/reviews") {
-    const summaries = Array.from(sessions2.values()).map(toSummary);
-    jsonResponse(res, 200, { sessions: summaries });
-    return true;
-  }
-  const getReviewParams = matchRoute(method, url, "GET", "/api/reviews/:id");
-  if (getReviewParams) {
-    const session = sessions2.get(getReviewParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    jsonResponse(res, 200, toSummary(session));
-    return true;
-  }
-  const postResultParams = matchRoute(method, url, "POST", "/api/reviews/:id/result");
-  if (postResultParams) {
-    const session = sessions2.get(postResultParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    try {
-      const body = await readBody(req);
-      const result = JSON.parse(body);
-      session.result = result;
-      session.status = "submitted";
-      recordReviewHistory(session, result);
-      if (result.decision === "dismissed") {
-        broadcastSessionRemoved(postResultParams.id);
-      } else {
-        broadcastSessionUpdate(session);
-      }
-      jsonResponse(res, 200, { ok: true });
-    } catch {
-      jsonResponse(res, 400, { error: "Invalid request body" });
-    }
-    return true;
-  }
-  const getResultParams = matchRoute(method, url, "GET", "/api/reviews/:id/result");
-  if (getResultParams) {
-    const session = sessions2.get(getResultParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    if (session.result) {
-      jsonResponse(res, 200, { result: session.result, status: "submitted" });
-    } else {
-      jsonResponse(res, 200, { result: null, status: session.status });
-    }
-    return true;
-  }
-  const postContextParams = matchRoute(method, url, "POST", "/api/reviews/:id/context");
-  if (postContextParams) {
-    const session = sessions2.get(postContextParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    try {
-      const body = await readBody(req);
-      const contextPayload = JSON.parse(body);
-      if (contextPayload.reasoning !== void 0) {
-        session.payload.metadata.reasoning = contextPayload.reasoning;
-      }
-      if (contextPayload.title !== void 0) {
-        session.payload.metadata.title = contextPayload.title;
-      }
-      if (contextPayload.description !== void 0) {
-        session.payload.metadata.description = contextPayload.description;
-      }
-      sendToSessionClients(session.id, {
-        type: "context:update",
-        payload: contextPayload
-      });
-      jsonResponse(res, 200, { ok: true });
-    } catch {
-      jsonResponse(res, 400, { error: "Invalid request body" });
-    }
-    return true;
-  }
-  const postAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations");
-  if (postAnnotationParams) {
-    const session = sessions2.get(postAnnotationParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    try {
-      const body = await readBody(req);
-      const { file, line, body: annotationBody, type, confidence, category, source } = JSON.parse(body);
-      const annotation = {
-        id: randomUUID2(),
-        sessionId: session.id,
-        file,
-        line,
-        body: annotationBody,
-        type,
-        confidence: confidence ?? 1,
-        category: category ?? "other",
-        source,
-        createdAt: Date.now()
-      };
-      session.annotations.push(annotation);
-      sendToSessionClients(session.id, {
-        type: "annotation:added",
-        payload: annotation
-      });
-      jsonResponse(res, 200, { annotationId: annotation.id });
-    } catch {
-      jsonResponse(res, 400, { error: "Invalid request body" });
-    }
-    return true;
-  }
-  const getAnnotationsParams = matchRoute(method, url, "GET", "/api/reviews/:id/annotations");
-  if (getAnnotationsParams) {
-    const session = sessions2.get(getAnnotationsParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    jsonResponse(res, 200, { annotations: session.annotations });
-    return true;
-  }
-  const dismissAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations/:annotationId/dismiss");
-  if (dismissAnnotationParams) {
-    const session = sessions2.get(dismissAnnotationParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    const annotation = session.annotations.find((a) => a.id === dismissAnnotationParams.annotationId);
-    if (!annotation) {
-      jsonResponse(res, 404, { error: "Annotation not found" });
-      return true;
-    }
-    annotation.dismissed = true;
-    sendToSessionClients(dismissAnnotationParams.id, {
-      type: "annotation:dismissed",
-      payload: { annotationId: dismissAnnotationParams.annotationId }
-    });
-    jsonResponse(res, 200, { ok: true });
-    return true;
-  }
-  const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
-  if (deleteParams) {
-    stopSessionWatcher(deleteParams.id);
-    if (sessions2.delete(deleteParams.id)) {
-      broadcastSessionRemoved(deleteParams.id);
-      jsonResponse(res, 200, { ok: true });
-    } else {
-      jsonResponse(res, 404, { error: "Session not found" });
-    }
-    return true;
-  }
-  const getRefsParams = matchRoute(method, url, "GET", "/api/reviews/:id/refs");
-  if (getRefsParams) {
-    const session = sessions2.get(getRefsParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    if (session.projectPath.startsWith("github:")) {
-      jsonResponse(res, 400, { error: "Ref listing not available for GitHub PRs" });
-      return true;
-    }
-    try {
-      const branches = listBranches({ cwd: session.projectPath });
-      const commits = listCommits({ cwd: session.projectPath });
-      const currentBranch = getCurrentBranch({ cwd: session.projectPath });
-      jsonResponse(res, 200, { branches, commits, currentBranch });
-    } catch {
-      jsonResponse(res, 500, { error: "Failed to list git refs" });
-    }
-    return true;
-  }
-  const postCompareParams = matchRoute(method, url, "POST", "/api/reviews/:id/compare");
-  if (postCompareParams) {
-    const session = sessions2.get(postCompareParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    if (session.projectPath.startsWith("github:")) {
-      jsonResponse(res, 400, { error: "Ref comparison not available for GitHub PRs" });
-      return true;
-    }
-    try {
-      const body = await readBody(req);
-      const { ref } = JSON.parse(body);
-      if (!ref) {
-        jsonResponse(res, 400, { error: "Missing ref in request body" });
-        return true;
-      }
-      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(ref, {
-        cwd: session.projectPath
-      });
-      const newBriefing = analyze(newDiffSet);
-      const changedFiles = detectChangedFiles(session.lastDiffSet ?? null, newDiffSet);
-      session.payload = {
-        ...session.payload,
-        diffSet: newDiffSet,
-        rawDiff: newRawDiff,
-        briefing: newBriefing
-      };
-      session.lastDiffHash = hashDiff(newRawDiff);
-      session.lastDiffSet = newDiffSet;
-      stopSessionWatcher(session.id);
-      session.diffRef = ref;
-      if (hasConnectedClients()) {
-        startSessionWatcher(session.id);
-      }
-      sendToSessionClients(session.id, {
-        type: "diff:update",
-        payload: {
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing,
-          changedFiles,
-          timestamp: Date.now()
-        }
-      });
-      jsonResponse(res, 200, { ok: true, fileCount: newDiffSet.files.length });
-    } catch {
-      jsonResponse(res, 400, { error: "Failed to compute diff for the given ref" });
-    }
-    return true;
-  }
-  const getSessionHistoryParams = matchRoute(method, url, "GET", "/api/reviews/:id/history");
-  if (getSessionHistoryParams) {
-    const session = sessions2.get(getSessionHistoryParams.id);
-    if (!session) {
-      jsonResponse(res, 404, { error: "Session not found" });
-      return true;
-    }
-    if (session.projectPath.startsWith("github:")) {
-      jsonResponse(res, 200, { history: [] });
-      return true;
-    }
-    const history = getRecentHistory(session.projectPath);
-    jsonResponse(res, 200, { history });
-    return true;
-  }
-  if (method === "GET" && req.url) {
-    const parsedUrl = new URL(req.url, "http://localhost");
-    if (parsedUrl.pathname === "/api/history") {
-      const projectPath = parsedUrl.searchParams.get("project");
-      if (!projectPath) {
-        jsonResponse(res, 400, { error: "Missing required query parameter: project" });
-        return true;
-      }
-      if (projectPath.startsWith("github:")) {
-        jsonResponse(res, 200, { history: [] });
-        return true;
-      }
-      const history = getRecentHistory(projectPath);
-      jsonResponse(res, 200, { history });
-      return true;
-    }
-  }
-  jsonResponse(res, 404, { error: "Not found" });
-  return true;
-}
-async function startGlobalServer(options = {}) {
-  const {
-    httpPort: preferredHttpPort = 24680,
-    wsPort: preferredWsPort = 24681,
-    silent = false,
-    dev = false,
-    pollInterval = 2e3
-  } = options;
-  serverPollInterval = pollInterval;
-  const [httpPort, wsPort] = await Promise.all([
-    getPort3({ port: preferredHttpPort }),
-    getPort3({ port: preferredWsPort })
-  ]);
-  let uiPort;
-  let uiHttpServer = null;
-  let viteServer = null;
-  if (dev) {
-    uiPort = await getPort3();
-    const uiRoot = resolveUiRoot();
-    viteServer = await startViteDevServer(uiRoot, uiPort, silent);
-  } else {
-    uiPort = await getPort3();
-    const uiDist = resolveUiDist();
-    uiHttpServer = await createStaticServer(uiDist, uiPort);
-  }
-  const httpServer = http3.createServer(async (req, res) => {
-    const handled = await handleApiRequest(req, res);
-    if (!handled) {
-      res.writeHead(404);
-      res.end("Not found");
-    }
-  });
-  wss = new WebSocketServer2({ port: wsPort });
-  wss.on("connection", (ws, req) => {
-    startAllWatchers();
-    const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
-    const sessionId = url.searchParams.get("sessionId");
-    if (sessionId) {
-      clientSessions.set(ws, sessionId);
-      const session = sessions2.get(sessionId);
-      if (session) {
-        session.status = "in_review";
-        session.hasNewChanges = false;
-        broadcastSessionUpdate(session);
-        const msg = {
-          type: "review:init",
-          payload: session.payload
-        };
-        ws.send(JSON.stringify(msg));
-        for (const annotation of session.annotations) {
-          ws.send(JSON.stringify({
-            type: "annotation:added",
-            payload: annotation
-          }));
-        }
-      }
-    } else {
-      const summaries = Array.from(sessions2.values()).map(toSummary);
-      const msg = {
-        type: "session:list",
-        payload: summaries
-      };
-      ws.send(JSON.stringify(msg));
-      if (summaries.length === 1) {
-        const session = sessions2.get(summaries[0].id);
-        if (session) {
-          clientSessions.set(ws, session.id);
-          session.status = "in_review";
-          session.hasNewChanges = false;
-          broadcastSessionUpdate(session);
-          ws.send(JSON.stringify({
-            type: "review:init",
-            payload: session.payload
-          }));
-          for (const annotation of session.annotations) {
-            ws.send(JSON.stringify({
-              type: "annotation:added",
-              payload: annotation
-            }));
-          }
-        }
-      }
-    }
-    ws.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "review:submit") {
-          const sid = clientSessions.get(ws);
-          if (sid) {
-            const session = sessions2.get(sid);
-            if (session) {
-              session.result = msg.payload;
-              session.status = "submitted";
-              recordReviewHistory(session, msg.payload);
-              if (msg.payload.decision === "dismissed") {
-                broadcastSessionRemoved(sid);
-              } else {
-                broadcastSessionUpdate(session);
-              }
-            }
-          }
-        } else if (msg.type === "session:select") {
-          const session = sessions2.get(msg.payload.sessionId);
-          if (session) {
-            clientSessions.set(ws, session.id);
-            session.status = "in_review";
-            session.hasNewChanges = false;
-            startSessionWatcher(session.id);
-            broadcastSessionUpdate(session);
-            ws.send(JSON.stringify({
-              type: "review:init",
-              payload: session.payload
-            }));
-            for (const annotation of session.annotations) {
-              ws.send(JSON.stringify({
-                type: "annotation:added",
-                payload: annotation
-              }));
-            }
-          }
-        } else if (msg.type === "session:close") {
-          const closedId = msg.payload.sessionId;
-          stopSessionWatcher(closedId);
-          const closedSession = sessions2.get(closedId);
-          if (closedSession && !closedSession.result) {
-            closedSession.result = { decision: "dismissed", comments: [] };
-            closedSession.status = "submitted";
-          }
-          broadcastSessionRemoved(closedId);
-        } else if (msg.type === "diff:change_ref") {
-          const sid = clientSessions.get(ws);
-          if (sid) {
-            const session = sessions2.get(sid);
-            if (session) {
-              const newRef = msg.payload.diffRef;
-              try {
-                const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, {
-                  cwd: session.projectPath
-                });
-                const newBriefing = analyze(newDiffSet);
-                session.payload = {
-                  ...session.payload,
-                  diffSet: newDiffSet,
-                  rawDiff: newRawDiff,
-                  briefing: newBriefing
-                };
-                session.diffRef = newRef;
-                session.lastDiffHash = hashDiff(newRawDiff);
-                session.lastDiffSet = newDiffSet;
-                stopSessionWatcher(sid);
-                startSessionWatcher(sid);
-                sendToSessionClients(sid, {
-                  type: "diff:update",
-                  payload: {
-                    diffSet: newDiffSet,
-                    rawDiff: newRawDiff,
-                    briefing: newBriefing,
-                    changedFiles: newDiffSet.files.map((f) => f.path),
-                    timestamp: Date.now()
-                  }
-                });
-              } catch (err) {
-                const errorMsg = {
-                  type: "diff:error",
-                  payload: {
-                    error: err instanceof Error ? err.message : String(err)
-                  }
-                };
-                ws.send(JSON.stringify(errorMsg));
-              }
-            }
-          }
-        }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      clientSessions.delete(ws);
-      if (!hasConnectedClients()) {
-        stopAllWatchers();
-      }
-    });
-  });
-  await new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(httpPort, () => resolve());
-  });
-  function cleanupExpiredSessions() {
-    const now = Date.now();
-    for (const [id, session] of sessions2.entries()) {
-      const age = now - session.createdAt;
-      const expired = session.status === "submitted" && age > SUBMITTED_TTL_MS || session.status === "pending" && age > ABANDONED_TTL_MS;
-      if (expired) {
-        stopSessionWatcher(id);
-        sessions2.delete(id);
-        broadcastSessionRemoved(id);
-      }
-    }
-  }
-  const cleanupTimer = setInterval(cleanupExpiredSessions, CLEANUP_INTERVAL_MS);
-  const serverInfo = {
-    httpPort,
-    wsPort,
-    pid: process.pid,
-    startedAt: Date.now()
-  };
-  writeServerFile(serverInfo);
-  if (!silent) {
-    console.log(`
-DiffPrism Global Server`);
-    console.log(`  API:  http://localhost:${httpPort}`);
-    console.log(`  WS:   ws://localhost:${wsPort}`);
-    console.log(`  UI:   http://localhost:${uiPort}`);
-    console.log(`  PID:  ${process.pid}`);
-    console.log(`
-Waiting for reviews...
-`);
-  }
-  const uiUrl = `http://localhost:${uiPort}?wsPort=${wsPort}&httpPort=${httpPort}&serverMode=true`;
-  await open3(uiUrl);
-  reopenBrowserIfNeeded = () => {
-    if (!hasConnectedClients()) {
-      open3(uiUrl);
-    }
-  };
-  async function stop() {
-    clearInterval(cleanupTimer);
-    stopAllWatchers();
-    if (wss) {
-      for (const client of wss.clients) {
-        client.close();
-      }
-      wss.close();
-      wss = null;
-    }
-    clientSessions.clear();
-    sessions2.clear();
-    reopenBrowserIfNeeded = null;
-    await new Promise((resolve) => {
-      httpServer.close(() => resolve());
-    });
-    if (viteServer) {
-      await viteServer.close();
-    }
-    if (uiHttpServer) {
-      uiHttpServer.close();
-    }
-    removeServerFile();
-  }
-  return { httpPort, wsPort, stop };
-}
-
-// packages/github/src/auth.ts
-import { execSync as execSync3 } from "child_process";
-import fs5 from "fs";
-import path7 from "path";
-import os2 from "os";
 function resolveGitHubToken() {
   const envToken = process.env.GITHUB_TOKEN;
   if (envToken) {
     return envToken;
   }
   try {
-    const token = execSync3("gh auth token", {
+    const token = execSync("gh auth token", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -2882,10 +125,10 @@ function resolveGitHubToken() {
     }
   } catch {
   }
-  const configPath = path7.join(os2.homedir(), ".diffprism", "config.json");
+  const configPath = path.join(os.homedir(), ".diffprism", "config.json");
   try {
-    if (fs5.existsSync(configPath)) {
-      const raw = fs5.readFileSync(configPath, "utf-8");
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, "utf-8");
       const config = JSON.parse(raw);
       const github = config.github;
       if (github?.token && typeof github.token === "string") {
@@ -3390,8 +633,8 @@ function isPlainObject2(value) {
   return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
 }
 async function fetchWrapper(requestOptions) {
-  const fetch2 = requestOptions.request?.fetch || globalThis.fetch;
-  if (!fetch2) {
+  const fetch = requestOptions.request?.fetch || globalThis.fetch;
+  if (!fetch) {
     throw new Error(
       "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing"
     );
@@ -3407,7 +650,7 @@ async function fetchWrapper(requestOptions) {
   );
   let fetchResponse;
   try {
-    fetchResponse = await fetch2(requestOptions.url, {
+    fetchResponse = await fetch(requestOptions.url, {
       method: requestOptions.method,
       body,
       redirect: requestOptions.request?.redirect,
@@ -3846,17 +1089,17 @@ function requestLog(octokit) {
     octokit.log.debug("request", options);
     const start = Date.now();
     const requestOptions = octokit.request.endpoint.parse(options);
-    const path8 = requestOptions.url.replace(options.baseUrl, "");
+    const path2 = requestOptions.url.replace(options.baseUrl, "");
     return request2(options).then((response) => {
       const requestId = response.headers["x-github-request-id"];
       octokit.log.info(
-        `${requestOptions.method} ${path8} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path2} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       return response;
     }).catch((error) => {
       const requestId = error.response?.headers["x-github-request-id"] || "UNKNOWN";
       octokit.log.error(
-        `${requestOptions.method} ${path8} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path2} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       throw error;
     });
@@ -6595,18 +3838,6 @@ function buildReviewBody(result) {
 }
 
 export {
-  getCurrentBranch,
-  detectWorktree,
-  getDiff,
-  analyze,
-  readWatchFile,
-  readReviewResult,
-  consumeReviewResult,
-  startReview,
-  startWatch,
-  readServerFile,
-  isServerAlive,
-  startGlobalServer,
   resolveGitHubToken,
   createGitHubClient,
   fetchPullRequest,