@mrsf/cli 0.4.3 → 0.6.0

package/dist/index.cjs

@@ -0,0 +1,2184 @@
+const importMetaUrl = require("node:url").pathToFileURL(__filename).href;
+"use strict";
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/serialize.ts
+function parseSidecarContent(content, filenameHint) {
+  const trimmed = content.trim();
+  let parsed;
+  const isJson = trimmed.startsWith("{") || filenameHint && filenameHint.endsWith(".review.json");
+  if (isJson) {
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (e) {
+      throw new Error(`Failed to parse JSON: ${e.message}`);
+    }
+  } else {
+    try {
+      parsed = import_js_yaml2.default.load(trimmed, { schema: import_js_yaml2.default.JSON_SCHEMA });
+    } catch (e) {
+      throw new Error(`Failed to parse YAML: ${e.message}`);
+    }
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("MRSF sidecar must be a YAML/JSON object");
+  }
+  return parsed;
+}
+function parseSidecarContentLenient(content, filenameHint) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return { doc: null, error: "File is empty" };
+  }
+  const isJson = trimmed.startsWith("{") || filenameHint && filenameHint.endsWith(".review.json");
+  let parsed;
+  try {
+    parsed = isJson ? JSON.parse(trimmed) : import_js_yaml2.default.load(trimmed, { schema: import_js_yaml2.default.JSON_SCHEMA });
+  } catch (e) {
+    if (!isJson) {
+      return salvageYaml(trimmed);
+    }
+    return { doc: null, error: `Failed to parse JSON: ${e.message}` };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { doc: null, error: "MRSF sidecar must be a YAML/JSON object" };
+  }
+  const obj = parsed;
+  const doc = {
+    mrsf_version: typeof obj.mrsf_version === "string" ? obj.mrsf_version : "1.0",
+    document: typeof obj.document === "string" ? obj.document : "unknown",
+    comments: []
+  };
+  if (!Array.isArray(obj.comments)) {
+    return {
+      doc,
+      error: "comments field is not an array \u2014 file may be corrupted"
+    };
+  }
+  const good = [];
+  const bad = [];
+  for (let i = 0; i < obj.comments.length; i++) {
+    const c = obj.comments[i];
+    if (c && typeof c === "object" && !Array.isArray(c) && typeof c.id === "string") {
+      good.push(c);
+    } else {
+      bad.push(i);
+    }
+  }
+  doc.comments = good;
+  if (bad.length > 0) {
+    return {
+      doc,
+      error: `${bad.length} comment(s) at indices [${bad.join(", ")}] were malformed and skipped`,
+      partialComments: good
+    };
+  }
+  return { doc };
+}
+function salvageYaml(content) {
+  const salvaged = [];
+  let mrsf_version = "1.0";
+  let document = "unknown";
+  const versionMatch = content.match(/^mrsf_version:\s*["']?([^"'\n]+)/m);
+  if (versionMatch) mrsf_version = versionMatch[1].trim();
+  const docMatch = content.match(/^document:\s*["']?([^"'\n]+)/m);
+  if (docMatch) document = docMatch[1].trim();
+  const blocks = content.split(/(?=^  - id:\s)/m);
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed.startsWith("- id:")) continue;
+    try {
+      const parsed = import_js_yaml2.default.load(trimmed, { schema: import_js_yaml2.default.JSON_SCHEMA });
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        const c = parsed[0];
+        if (c && typeof c === "object" && typeof c.id === "string") {
+          salvaged.push(c);
+        }
+      } else if (parsed && typeof parsed === "object" && typeof parsed.id === "string") {
+        salvaged.push(parsed);
+      }
+    } catch {
+    }
+  }
+  const doc = {
+    mrsf_version,
+    document,
+    comments: salvaged
+  };
+  return {
+    doc: salvaged.length > 0 ? doc : null,
+    error: `YAML parse failed. Salvaged ${salvaged.length} comment(s) from raw content.`,
+    partialComments: salvaged.length > 0 ? salvaged : void 0
+  };
+}
+function toYaml(doc) {
+  const yamlDoc = new import_yaml.Document(doc);
+  return yamlDoc.toString({ lineWidth: 0 });
+}
+function toJson(doc) {
+  return JSON.stringify(doc, null, 2) + "\n";
+}
+var import_js_yaml2, import_yaml;
+var init_serialize = __esm({
+  "src/lib/serialize.ts"() {
+    "use strict";
+    import_js_yaml2 = __toESM(require("js-yaml"), 1);
+    import_yaml = require("yaml");
+  }
+});
+
+// src/lib/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  parseSidecar: () => parseSidecar,
+  parseSidecarContent: () => parseSidecarContent,
+  parseSidecarContentLenient: () => parseSidecarContentLenient,
+  parseSidecarLenient: () => parseSidecarLenient,
+  readDocumentLines: () => readDocumentLines
+});
+async function parseSidecar(filePath) {
+  const abs = import_node_path3.default.resolve(filePath);
+  const content = await (0, import_promises2.readFile)(abs, "utf-8");
+  return parseSidecarContent(content, abs);
+}
+async function parseSidecarLenient(filePath) {
+  const abs = import_node_path3.default.resolve(filePath);
+  let content;
+  try {
+    content = await (0, import_promises2.readFile)(abs, "utf-8");
+  } catch (e) {
+    return { doc: null, error: `Cannot read file: ${e.message}` };
+  }
+  return parseSidecarContentLenient(content, abs);
+}
+async function readDocumentLines(filePath) {
+  const content = await (0, import_promises2.readFile)(import_node_path3.default.resolve(filePath), "utf-8");
+  const lines = content.replace(/\r\n?/g, "\n").split("\n");
+  return ["", ...lines];
+}
+var import_promises2, import_node_path3;
+var init_parser = __esm({
+  "src/lib/parser.ts"() {
+    "use strict";
+    import_promises2 = require("node:fs/promises");
+    import_node_path3 = __toESM(require("node:path"), 1);
+    init_serialize();
+    init_serialize();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD2,
+  HIGH_THRESHOLD: () => HIGH_THRESHOLD2,
+  addComment: () => addComment2,
+  applyReanchorResults: () => applyReanchorResults2,
+  combinedScore: () => combinedScore2,
+  computeHash: () => computeHash2,
+  detectRenames: () => detectRenames2,
+  discoverAllSidecars: () => discoverAllSidecars2,
+  discoverSidecar: () => discoverSidecar3,
+  editComment: () => editComment2,
+  exactMatch: () => exactMatch2,
+  filterComments: () => filterComments2,
+  findRepoRoot: () => findRepoRoot3,
+  findWorkspaceRoot: () => findWorkspaceRoot2,
+  formatAuthor: () => formatAuthor2,
+  fuzzySearch: () => fuzzySearch2,
+  getCurrentCommit: () => getCurrentCommit2,
+  getDiff: () => getDiff2,
+  getFileAtCommit: () => getFileAtCommit3,
+  getLineShift: () => getLineShift4,
+  getStagedFiles: () => getStagedFiles2,
+  getThreads: () => getThreads2,
+  isGitAvailable: () => isGitAvailable2,
+  isStale: () => isStale2,
+  loadConfig: () => loadConfig2,
+  mrsfSchema: () => mrsfSchema,
+  newCommentId: () => newCommentId2,
+  normalizeCommentExtensions: () => normalizeCommentExtensions2,
+  normalizedMatch: () => normalizedMatch2,
+  parseAuthor: () => parseAuthor2,
+  parseDiffHunks: () => parseDiffHunks3,
+  parseSidecar: () => parseSidecar2,
+  parseSidecarContent: () => parseSidecarContent2,
+  parseSidecarContentLenient: () => parseSidecarContentLenient2,
+  parseSidecarLenient: () => parseSidecarLenient2,
+  populateSelectedText: () => populateSelectedText2,
+  readDocumentLines: () => readDocumentLines2,
+  reanchorComment: () => reanchorComment2,
+  reanchorDocument: () => reanchorDocument2,
+  reanchorDocumentLines: () => reanchorDocumentLines2,
+  reanchorDocumentText: () => reanchorDocumentText2,
+  reanchorFile: () => reanchorFile2,
+  removeComment: () => removeComment2,
+  resolveAnchor: () => resolveAnchor2,
+  resolveComment: () => resolveComment2,
+  resolveSidecarPaths: () => resolveSidecarPaths2,
+  sidecarToDocument: () => sidecarToDocument2,
+  summarize: () => summarize2,
+  syncHash: () => syncHash2,
+  toJson: () => toJson2,
+  toReanchorLines: () => toReanchorLines2,
+  toYaml: () => toYaml2,
+  unresolveComment: () => unresolveComment2,
+  validate: () => validate2,
+  validateDocument: () => validateDocument2,
+  validateFile: () => validateFile2,
+  writeSidecar: () => writeSidecar2
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/discovery.ts
+var import_promises = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var CONFIG_FILENAME = ".mrsf.yaml";
+var SIDECAR_SUFFIX = ".review.yaml";
+var SIDECAR_SUFFIX_JSON = ".review.json";
+function findWorkspaceRoot(startDir) {
+  let dir = import_node_path.default.resolve(startDir);
+  const { root } = import_node_path.default.parse(dir);
+  while (dir !== root) {
+    if ((0, import_node_fs.existsSync)(import_node_path.default.join(dir, CONFIG_FILENAME)) || (0, import_node_fs.existsSync)(import_node_path.default.join(dir, ".git"))) {
+      return dir;
+    }
+    dir = import_node_path.default.dirname(dir);
+  }
+  return import_node_path.default.resolve(startDir);
+}
+async function loadConfig(workspaceRoot, configPath) {
+  const cfgPath = configPath ? import_node_path.default.resolve(configPath) : import_node_path.default.join(workspaceRoot, CONFIG_FILENAME);
+  if (!(0, import_node_fs.existsSync)(cfgPath)) return null;
+  const raw = await (0, import_promises.readFile)(cfgPath, "utf-8");
+  const parsed = import_js_yaml.default.load(raw, { schema: import_js_yaml.default.JSON_SCHEMA });
+  if (!parsed || typeof parsed !== "object") return null;
+  const config = {};
+  if (typeof parsed.sidecar_root === "string") {
+    const sr = parsed.sidecar_root;
+    if (import_node_path.default.isAbsolute(sr)) {
+      throw new Error(
+        `.mrsf.yaml: sidecar_root must be a relative path (got "${sr}")`
+      );
+    }
+    if (sr.includes("..")) {
+      throw new Error(
+        `.mrsf.yaml: sidecar_root must not contain ".." (got "${sr}")`
+      );
+    }
+    config.sidecar_root = sr;
+  }
+  return config;
+}
+async function discoverSidecar(documentPath, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  const config = await loadConfig(workspaceRoot, options.configPath);
+  const relDoc = import_node_path.default.isAbsolute(documentPath) ? import_node_path.default.relative(workspaceRoot, documentPath) : documentPath;
+  if (config?.sidecar_root) {
+    return import_node_path.default.join(workspaceRoot, config.sidecar_root, relDoc + SIDECAR_SUFFIX);
+  }
+  return import_node_path.default.join(workspaceRoot, relDoc + SIDECAR_SUFFIX);
+}
+function sidecarToDocument(sidecarPath, options = {}) {
+  const abs = import_node_path.default.resolve(sidecarPath);
+  if (abs.endsWith(SIDECAR_SUFFIX)) {
+    return abs.slice(0, -SIDECAR_SUFFIX.length);
+  } else if (abs.endsWith(SIDECAR_SUFFIX_JSON)) {
+    return abs.slice(0, -SIDECAR_SUFFIX_JSON.length);
+  }
+  return abs;
+}
+async function discoverAllSidecars(dirPath) {
+  const { readdir, stat } = await import("node:fs/promises");
+  const results = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = import_node_path.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        await walk(full);
+      } else if (entry.name.endsWith(SIDECAR_SUFFIX) || entry.name.endsWith(SIDECAR_SUFFIX_JSON)) {
+        results.push(full);
+      }
+    }
+  }
+  const s = await stat(dirPath);
+  if (s.isFile()) {
+    results.push(import_node_path.default.resolve(dirPath));
+  } else {
+    await walk(import_node_path.default.resolve(dirPath));
+  }
+  return results;
+}
+
+// src/lib/resolve-files.ts
+var import_node_path2 = __toESM(require("node:path"), 1);
+var SIDECAR_EXTENSIONS = [".review.yaml", ".review.json"];
+function isSidecarPath(file) {
+  return SIDECAR_EXTENSIONS.some((ext) => file.endsWith(ext));
+}
+async function resolveSidecarPaths(files, cwd) {
+  if (files.length === 0) {
+    const root = findWorkspaceRoot(cwd);
+    return discoverAllSidecars(root ?? cwd);
+  }
+  const resolved = [];
+  for (const f of files) {
+    const abs = import_node_path2.default.resolve(cwd, f);
+    if (isSidecarPath(abs)) {
+      resolved.push(abs);
+    } else {
+      const sidecar = await discoverSidecar(abs, { cwd });
+      resolved.push(sidecar);
+    }
+  }
+  return resolved;
+}
+
+// src/index.ts
+init_parser();
+
+// src/lib/writer.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_fs2 = require("node:fs");
+var import_node_crypto = require("node:crypto");
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_yaml2 = require("yaml");
+init_serialize();
+init_serialize();
+var writeQueue = /* @__PURE__ */ new Map();
+function enqueueWrite(abs, fn) {
+  const prev = writeQueue.get(abs) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  writeQueue.set(abs, next);
+  next.then(() => {
+    if (writeQueue.get(abs) === next) writeQueue.delete(abs);
+  }, () => {
+    if (writeQueue.get(abs) === next) writeQueue.delete(abs);
+  });
+  return next;
+}
+async function atomicWriteFile(filePath, content) {
+  const tmp = filePath + "." + (0, import_node_crypto.randomBytes)(6).toString("hex") + ".tmp";
+  try {
+    await (0, import_promises3.writeFile)(tmp, content, "utf-8");
+    await (0, import_promises3.rename)(tmp, filePath);
+  } catch (err) {
+    try {
+      await (0, import_promises3.unlink)(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function computeHash(text) {
+  return (0, import_node_crypto.createHash)("sha256").update(text, "utf-8").digest("hex");
+}
+function syncHash(comment) {
+  if (comment.selected_text != null && comment.selected_text.length > 0) {
+    comment.selected_text_hash = computeHash(comment.selected_text);
+  } else {
+    delete comment.selected_text_hash;
+  }
+  return comment;
+}
+var COMMENT_KEY_ORDER = [
+  "id",
+  "author",
+  "timestamp",
+  "text",
+  "type",
+  "severity",
+  "resolved",
+  "reply_to",
+  "line",
+  "end_line",
+  "start_column",
+  "end_column",
+  "selected_text",
+  "selected_text_hash",
+  "anchored_text",
+  "commit"
+];
+function valueToSource(v) {
+  if (v instanceof Date) return JSON.stringify(v.toISOString());
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (typeof v === "string") {
+    if (v === "") return JSON.stringify(v);
+    if (v === "true" || v === "false" || v === "null" || v === "True" || v === "False" || v === "Null" || v === "TRUE" || v === "FALSE" || v === "NULL" || v === "yes" || v === "no" || v === "on" || v === "off" || v === "Yes" || v === "No" || v === "On" || v === "Off" || v === "YES" || v === "NO" || v === "ON" || v === "OFF" || v === "~" || v === ".inf" || v === "-.inf" || v === ".nan") {
+      return JSON.stringify(v);
+    }
+    if (/^\d/.test(v)) return JSON.stringify(v);
+    if (/^[A-Za-z_][A-Za-z0-9 _./()\-@+]*$/.test(v) && !v.includes(" #") && !/\s$/.test(v)) {
+      return v;
+    }
+    return JSON.stringify(v);
+  }
+  return String(v);
+}
+function valueType(v) {
+  return valueToSource(v).startsWith('"') ? "double-quoted-scalar" : "scalar";
+}
+function isStructuredValue(value) {
+  if (value == null) return false;
+  if (Array.isArray(value)) return true;
+  return typeof value === "object" && !(value instanceof Date);
+}
+function hasStructuredCommentExtensions(doc) {
+  return doc.comments.some(
+    (comment) => Object.entries(comment).some(
+      ([key, value]) => !COMMENT_KEY_ORDER.includes(key) && value !== void 0 && isStructuredValue(value)
+    )
+  );
+}
+var NL = "\n";
+function makeCstMapItem(key, value, indent, isFirst) {
+  const start = isFirst ? [] : [{ type: "space", offset: 0, indent: 0, source: " ".repeat(indent) }];
+  return {
+    start,
+    key: { type: "scalar", offset: 0, indent, source: key },
+    sep: [
+      { type: "map-value-ind", offset: 0, indent, source: ":" },
+      { type: "space", offset: 0, indent, source: " " }
+    ],
+    value: {
+      type: valueType(value),
+      offset: 0,
+      indent,
+      source: valueToSource(value),
+      end: [{ type: "newline", offset: 0, indent, source: NL }]
+    }
+  };
+}
+function makeCstSeqItem(comment, seqIndent) {
+  const mapIndent = seqIndent + 2;
+  const items = [];
+  for (const key of COMMENT_KEY_ORDER) {
+    const val = comment[key];
+    if (val !== void 0) {
+      items.push(makeCstMapItem(key, val, mapIndent, items.length === 0));
+    }
+  }
+  for (const key of Object.keys(comment)) {
+    if (!COMMENT_KEY_ORDER.includes(key) && comment[key] !== void 0) {
+      items.push(
+        makeCstMapItem(
+          key,
+          comment[key],
+          mapIndent,
+          items.length === 0
+        )
+      );
+    }
+  }
+  return {
+    start: [
+      { type: "newline", offset: 0, indent: 0, source: NL },
+      { type: "space", offset: 0, indent: 0, source: " ".repeat(seqIndent) },
+      { type: "seq-item-ind", offset: 0, indent: seqIndent, source: "-" },
+      { type: "space", offset: 0, indent: seqIndent, source: " " }
+    ],
+    value: { type: "block-map", offset: 0, indent: mapIndent, items }
+  };
+}
+function findCstDocument(tokens) {
+  return tokens.find((t) => t.type === "document") ?? null;
+}
+function findCstMapEntry(blockMap, keyName) {
+  return blockMap.items?.find(
+    (item) => item.key?.source === keyName
+  ) ?? null;
+}
+function findCstMapIndex(blockMap, keyName) {
+  return blockMap.items?.findIndex(
+    (item) => item.key?.source === keyName
+  ) ?? -1;
+}
+function cstCommentId(blockMap) {
+  const entry = findCstMapEntry(blockMap, "id");
+  if (!entry?.value?.source) return null;
+  const src = entry.value.source;
+  if (src.startsWith('"') && src.endsWith('"')) {
+    return src.slice(1, -1);
+  }
+  return src;
+}
+function updateCstScalar(entry, newValue) {
+  const newSrc = valueToSource(newValue);
+  if (entry.value?.source === newSrc) return false;
+  entry.value.source = newSrc;
+  entry.value.type = valueType(newValue);
+  return true;
+}
+function syncCommentToCst(blockMap, comment, currentValues) {
+  const commentRec = comment;
+  const existingKeys = /* @__PURE__ */ new Set();
+  for (const item of blockMap.items ?? []) {
+    if (item.key?.source) existingKeys.add(item.key.source);
+  }
+  const allKeys = /* @__PURE__ */ new Set([...existingKeys, ...Object.keys(comment)]);
+  const indent = blockMap.indent ?? 4;
+  for (const key of allKeys) {
+    const newVal = commentRec[key];
+    if (newVal === void 0) {
+      if (existingKeys.has(key)) {
+        const idx = findCstMapIndex(blockMap, key);
+        if (idx >= 0) blockMap.items.splice(idx, 1);
+      }
+      continue;
+    }
+    const entry = findCstMapEntry(blockMap, key);
+    if (entry) {
+      const currentVal = currentValues[key];
+      if (deepEqual(currentVal, newVal)) {
+        continue;
+      }
+      updateCstScalar(entry, newVal);
+    } else {
+      blockMap.items.push(makeCstMapItem(key, newVal, indent, false));
+    }
+  }
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (typeof a === "number" && typeof b === "number") return a === b;
+  return false;
+}
+async function writeSidecar(filePath, doc) {
+  const abs = import_node_path4.default.resolve(filePath);
+  return enqueueWrite(abs, () => writeSidecarInternal(abs, doc));
+}
+async function writeSidecarInternal(abs, doc) {
+  const isJson = abs.endsWith(".review.json");
+  for (const comment of doc.comments) syncHash(comment);
+  if (isJson) {
+    await atomicWriteFile(abs, toJson(doc));
+    return;
+  }
+  if (hasStructuredCommentExtensions(doc)) {
+    await atomicWriteFile(abs, toYaml(doc));
+    return;
+  }
+  if (!(0, import_node_fs2.existsSync)(abs)) {
+    await atomicWriteFile(abs, toYaml(doc));
+    return;
+  }
+  let raw;
+  try {
+    raw = await (0, import_promises3.readFile)(abs, "utf-8");
+  } catch {
+    await atomicWriteFile(abs, toYaml(doc));
+    return;
+  }
+  let tokens;
+  try {
+    tokens = [...new import_yaml2.Parser().parse(raw)];
+  } catch {
+    await atomicWriteFile(abs, toYaml(doc));
+    return;
+  }
+  let currentDoc = null;
+  try {
+    currentDoc = (0, import_yaml2.parse)(raw);
+  } catch {
+  }
+  if (currentDoc && !Array.isArray(currentDoc.comments)) {
+    await atomicWriteFile(abs, toYaml(doc));
+    return;
+  }
+  const currentById = /* @__PURE__ */ new Map();
+  if (currentDoc?.comments) {
+    for (const c of currentDoc.comments) {
+      if (c.id) currentById.set(c.id, c);
+    }
+  }
+  for (const comment of doc.comments) {
+    const cur = currentById.get(comment.id);
+    if (!cur) {
+      syncHash(comment);
+    } else {
+      const textChanged = !deepEqual(cur.selected_text, comment.selected_text);
+      const hadHash = cur.selected_text_hash !== void 0;
+      if (textChanged || hadHash) {
+        syncHash(comment);
+      } else {
+        delete comment.selected_text_hash;
+      }
+    }
+  }
+  const docToken = findCstDocument(tokens);
+  if (!docToken?.value || docToken.value.type !== "block-map") {
+    await atomicWriteFile(abs, toYaml(doc));
+    return;
+  }
+  const body = docToken.value;
+  const versionEntry = findCstMapEntry(body, "mrsf_version");
+  if (versionEntry && !deepEqual(currentDoc?.mrsf_version, doc.mrsf_version)) {
+    updateCstScalar(versionEntry, doc.mrsf_version);
+  }
+  const documentEntry = findCstMapEntry(body, "document");
+  if (documentEntry && !deepEqual(currentDoc?.document, doc.document)) {
+    updateCstScalar(documentEntry, doc.document);
+  }
+  const commentsEntry = findCstMapEntry(body, "comments");
+  if (!commentsEntry?.value || commentsEntry.value.type !== "block-seq") {
+    await atomicWriteFile(abs, toYaml(doc));
+    return;
+  }
+  const seq = commentsEntry.value;
+  const seqIndent = seq.indent ?? 2;
+  const existingById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < seq.items.length; i++) {
+    const item = seq.items[i];
+    const map = item.value;
+    if (map?.type === "block-map") {
+      const id = cstCommentId(map);
+      if (id) existingById.set(id, { index: i, map });
+    }
+  }
+  const idsInDoc = new Set(doc.comments.map((c) => c.id));
+  const newSeqItems = [];
+  for (const comment of doc.comments) {
+    const existing = existingById.get(comment.id);
+    if (existing) {
+      const currentValues = currentById.get(comment.id) ?? {};
+      syncCommentToCst(existing.map, comment, currentValues);
+      newSeqItems.push(seq.items[existing.index]);
+    } else {
+      newSeqItems.push(makeCstSeqItem(comment, seqIndent));
+    }
+  }
+  seq.items = newSeqItems;
+  if (newSeqItems.length > 0) {
+    const originalFirstIdx = seq.items === newSeqItems ? 0 : -1;
+    const origFirstItem = existingById.size > 0 ? [...existingById.values()].find((e) => e.index === 0) : void 0;
+    const newFirst = newSeqItems[0];
+    const isOriginalFirst = origFirstItem && seq.items[0]?.value === origFirstItem.map;
+    if (!isOriginalFirst && newFirst.start) {
+      const dashIdx = newFirst.start.findIndex(
+        (t) => t.type === "seq-item-ind"
+      );
+      if (dashIdx > 0) {
+        const toRemove = newFirst.start.slice(0, dashIdx).every((t) => t.type === "space" || t.type === "newline");
+        if (toRemove) {
+          newFirst.start.splice(0, dashIdx);
+        }
+      }
+    }
+  }
+  const result = tokens.map((t) => import_yaml2.CST.stringify(t)).join("");
+  await atomicWriteFile(abs, result);
+}
+
+// src/lib/validator.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+
+// src/lib/validate-core.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+
+// mrsf.schema.json
+var mrsf_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://github.com/wictorwilen/MRSF/raw/main/mrsf.schema.json",
+  title: "Markdown Review Sidecar Format (MRSF) v1.0",
+  description: "Schema for MRSF review sidecar files. See MRSF-v1.0.md for the full specification.",
+  type: "object",
+  required: ["mrsf_version", "document", "comments"],
+  additionalProperties: true,
+  properties: {
+    mrsf_version: {
+      type: "string",
+      pattern: "^1\\.\\d+$",
+      description: "MRSF format version. MUST be a supported major.minor version (e.g., 1.0)."
+    },
+    document: {
+      type: "string",
+      description: "Relative path to the Markdown document being reviewed."
+    },
+    comments: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["id", "author", "timestamp", "text", "resolved"],
+        additionalProperties: true,
+        properties: {
+          id: {
+            type: "string",
+            description: "Globally unique, opaque, collision-resistant identifier for the comment."
+          },
+          author: {
+            type: "string",
+            description: "Creator of the comment. SHOULD follow the convention 'Display Name (identifier)'."
+          },
+          timestamp: {
+            type: "string",
+            format: "date-time",
+            description: "ISO 8601 / RFC 3339 timestamp of comment creation; SHOULD include timezone offset."
+          },
+          text: {
+            type: "string",
+            maxLength: 16384,
+            description: "The content of the review comment. MUST be plain text."
+          },
+          resolved: {
+            type: "boolean",
+            description: "Whether the comment has been resolved."
+          },
+          commit: {
+            type: "string",
+            description: "Git commit hash associated with the comment. SHOULD be the full (long) SHA."
+          },
+          type: {
+            type: "string",
+            description: "Categorization of the comment. Recommended values listed in examples.",
+            examples: [
+              "suggestion",
+              "issue",
+              "question",
+              "accuracy",
+              "style",
+              "clarity"
+            ]
+          },
+          severity: {
+            type: "string",
+            description: "Importance level of the comment.",
+            enum: ["low", "medium", "high"]
+          },
+          reply_to: {
+            type: "string",
+            description: "ID of another comment in the same file that this comment replies to."
+          },
+          line: {
+            type: "integer",
+            minimum: 1,
+            description: "Starting line number (1-based) in the target document."
+          },
+          end_line: {
+            type: "integer",
+            minimum: 1,
+            description: "Ending line number (inclusive, 1-based). MUST be >= line."
+          },
+          start_column: {
+            type: "integer",
+            minimum: 0,
+            description: "Starting column index (0-based) within the starting line."
+          },
+          end_column: {
+            type: "integer",
+            minimum: 0,
+            description: "Ending column index. MUST be >= start_column when on the same line."
+          },
+          selected_text: {
+            type: "string",
+            maxLength: 4096,
+            description: "Exact text selected by the reviewer. SHOULD NOT be modified by re-anchoring tools. SHOULD NOT exceed 4096 characters."
+          },
+          anchored_text: {
+            type: "string",
+            maxLength: 4096,
+            description: "Text currently found at the resolved anchor position. Populated by re-anchoring tools when the document text differs from selected_text. SHOULD be omitted when identical to selected_text."
+          },
+          selected_text_hash: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$",
+            description: "Hex-encoded SHA-256 hash of selected_text. Immutable after creation; used for fast exact-match detection during re-anchoring, integrity verification, and staleness checks. SHOULD NOT be modified by re-anchoring tools unless selected_text is also replaced (opt-in behaviour), in which case it MUST be recomputed."
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/lib/schema.ts
+var mrsfSchema = mrsf_schema_default;
+
+// src/lib/validate-core.ts
+var Ajv = import_ajv.default.default ?? import_ajv.default;
+var addFormats = import_ajv_formats.default.default ?? import_ajv_formats.default;
+function validateDocument(doc, schema = mrsfSchema) {
+  const errors = [];
+  const warnings = [];
+  validateSchema(doc, schema, errors);
+  validateCrossFields(doc, errors, warnings);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateSchema(doc, rawSchema, errors) {
+  const { $schema, ...schema } = rawSchema;
+  void $schema;
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const ajvValidate = ajv.compile(schema);
+  const schemaValid = ajvValidate(doc);
+  if (!schemaValid && ajvValidate.errors) {
+    for (const err of ajvValidate.errors) {
+      errors.push({
+        severity: "error",
+        code: "schema-violation",
+        message: `${err.instancePath || "/"}: ${err.message ?? "schema error"}`,
+        path: err.instancePath || "/"
+      });
+    }
+  }
+}
+function validateCrossFields(doc, errors, warnings, hash) {
+  if (!Array.isArray(doc.comments)) return;
+  const ids = /* @__PURE__ */ new Set();
+  const allIds = doc.comments.map((x) => x.id);
+  for (let i = 0; i < doc.comments.length; i++) {
+    const c = doc.comments[i];
+    const prefix = `/comments/${i}`;
+    if (c.id) {
+      if (ids.has(c.id)) {
+        errors.push({
+          severity: "error",
+          code: "duplicate-id",
+          message: `Duplicate comment id "${c.id}"`,
+          path: `${prefix}/id`,
+          commentId: c.id
+        });
+      }
+      ids.add(c.id);
+    }
+    if (c.line != null && c.end_line != null && c.end_line < c.line) {
+      errors.push({
+        severity: "error",
+        code: "end-line-before-line",
+        message: `end_line (${c.end_line}) must be \u2265 line (${c.line})`,
+        path: `${prefix}/end_line`,
+        commentId: c.id
+      });
+    }
+    if (c.start_column != null && c.end_column != null && (c.line == null || c.end_line == null || c.line === c.end_line) && c.end_column < c.start_column) {
+      errors.push({
+        severity: "error",
+        code: "end-column-before-start-column",
+        message: `end_column (${c.end_column}) must be \u2265 start_column (${c.start_column}) on the same line`,
+        path: `${prefix}/end_column`,
+        commentId: c.id
+      });
+    }
+    if (c.selected_text && c.selected_text.length > 4096) {
+      errors.push({
+        severity: "error",
+        code: "selected-text-too-long",
+        message: `selected_text exceeds 4096 characters (${c.selected_text.length})`,
+        path: `${prefix}/selected_text`,
+        commentId: c.id
+      });
+    }
+    if (c.text && c.text.length > 16384) {
+      warnings.push({
+        severity: "warning",
+        code: "text-too-long",
+        message: `text exceeds recommended 16384 characters (${c.text.length})`,
+        path: `${prefix}/text`,
+        commentId: c.id
+      });
+    }
+    if (hash && c.selected_text && c.selected_text_hash) {
+      const expected = hash(c.selected_text);
+      if (c.selected_text_hash !== expected) {
+        warnings.push({
+          severity: "warning",
+          code: "hash-mismatch",
+          message: `selected_text_hash mismatch (expected ${expected.slice(0, 12)}\u2026, got ${c.selected_text_hash.slice(0, 12)}\u2026)`,
+          path: `${prefix}/selected_text_hash`,
+          commentId: c.id
+        });
+      }
+    }
+    if (c.reply_to && !ids.has(c.reply_to) && !allIds.includes(c.reply_to)) {
+      warnings.push({
+        severity: "warning",
+        code: "unresolved-reply-to",
+        message: `reply_to "${c.reply_to}" does not resolve to any comment id in this file`,
+        path: `${prefix}/reply_to`,
+        commentId: c.id
+      });
+    }
+    if (c.line != null && !c.selected_text) {
+      warnings.push({
+        severity: "warning",
+        code: "missing-selected-text",
+        message: "Comment has line anchors but no selected_text \u2014 anchoring will be fragile across edits",
+        path: `${prefix}/selected_text`,
+        commentId: c.id
+      });
+    }
+  }
+}
+
+// src/lib/validator.ts
+var __dirname = import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var _schemaCache = null;
+async function loadSchema() {
+  if (_schemaCache) return _schemaCache;
+  const candidates = [
+    import_node_path5.default.resolve(__dirname, "mrsf.schema.json"),
+    // same dir (esbuild bundle, e.g. MCP server)
+    import_node_path5.default.resolve(__dirname, "../../mrsf.schema.json"),
+    // from dist/lib/ → cli/ (installed package)
+    import_node_path5.default.resolve(__dirname, "../../../mrsf.schema.json"),
+    // from dist/lib/ → repo root (dev)
+    import_node_path5.default.resolve(__dirname, "../../../../mrsf.schema.json"),
+    // fallback
+    import_node_path5.default.resolve(process.cwd(), "mrsf.schema.json")
+    // cwd fallback
+  ];
+  for (const candidate of candidates) {
+    try {
+      const raw = await (0, import_promises4.readFile)(candidate, "utf-8");
+      _schemaCache = JSON.parse(raw);
+      return _schemaCache;
+    } catch {
+    }
+  }
+  throw new Error("Could not locate mrsf.schema.json");
+}
+async function validate(doc, options = {}) {
+  const errors = [];
+  const warnings = [];
+  const rawSchema = await loadSchema();
+  validateSchema(doc, rawSchema, errors);
+  validateCrossFields(doc, errors, warnings, computeHash);
+  const valid = errors.length === 0 && (!options.strict || warnings.length === 0);
+  return { valid, errors, warnings };
+}
+async function validateFile(filePath, options = {}) {
+  const { parseSidecar: parseSidecar3 } = await Promise.resolve().then(() => (init_parser(), parser_exports));
+  try {
+    const doc = await parseSidecar3(filePath);
+    return validate(doc, options);
+  } catch (e) {
+    return {
+      valid: false,
+      errors: [
+        {
+          severity: "error",
+          code: "parse-error",
+          message: `Failed to parse: ${e.message}`
+        }
+      ],
+      warnings: []
+    };
+  }
+}
+
+// src/lib/fuzzy.ts
+var import_fastest_levenshtein = require("fastest-levenshtein");
+function exactMatch(lines, needle) {
+  if (!needle) return [];
+  const results = [];
+  const needleLines = needle.split("\n");
+  const needleLineCount = needleLines.length;
+  for (let startLine = 1; startLine <= lines.length - needleLineCount; startLine++) {
+    const windowLines = lines.slice(startLine, startLine + needleLineCount);
+    const windowText = windowLines.join("\n");
+    if (needleLineCount === 1) {
+      let col = 0;
+      const line = windowLines[0];
+      while (col < line.length) {
+        const idx = line.indexOf(needle, col);
+        if (idx === -1) break;
+        results.push({
+          text: needle,
+          line: startLine,
+          endLine: startLine,
+          startColumn: idx,
+          endColumn: idx + needle.length,
+          score: 1
+        });
+        col = idx + 1;
+      }
+    } else {
+      const idx = windowText.indexOf(needle);
+      if (idx !== -1) {
+        const beforeMatch = windowText.slice(0, idx);
+        const linesBeforeEnd = beforeMatch.split("\n");
+        const startCol = linesBeforeEnd[linesBeforeEnd.length - 1].length;
+        const afterMatch = needle.split("\n");
+        const endCol = afterMatch[afterMatch.length - 1].length;
+        if (startCol === 0 || linesBeforeEnd.length === 1) {
+          results.push({
+            text: needle,
+            line: startLine + linesBeforeEnd.length - 1,
+            endLine: startLine + linesBeforeEnd.length - 1 + afterMatch.length - 1,
+            startColumn: startCol,
+            endColumn: endCol,
+            score: 1
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+function normalize(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizedMatch(lines, needle) {
+  const normNeedle = normalize(needle);
+  if (!normNeedle) return [];
+  const results = [];
+  const needleLineEstimate = needle.split("\n").length;
+  const minWindow = Math.max(1, needleLineEstimate - 1);
+  const maxWindow = Math.min(lines.length - 1, needleLineEstimate + 2);
+  for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
+    for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
+      const windowLines = lines.slice(startLine, startLine + winSize);
+      const windowText = windowLines.join("\n");
+      const normWindow = normalize(windowText);
+      if (normWindow.includes(normNeedle)) {
+        results.push({
+          text: windowText,
+          line: startLine,
+          endLine: startLine + winSize - 1,
+          startColumn: 0,
+          endColumn: windowLines[windowLines.length - 1].length,
+          score: 0.95
+        });
+      }
+    }
+  }
+  return deduplicateCandidates(results);
+}
+function tokenize(text) {
+  return text.split(/\s+/).filter((t) => t.length > 0);
+}
+function lcsLength(a, b) {
+  const m = a.length;
+  const n = b.length;
+  let prev = new Array(n + 1).fill(0);
+  let curr = new Array(n + 1).fill(0);
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        curr[j] = prev[j - 1] + 1;
+      } else {
+        curr[j] = Math.max(prev[j], curr[j - 1]);
+      }
+    }
+    [prev, curr] = [curr, prev];
+    curr.fill(0);
+  }
+  return prev[n];
+}
+function tokenLcsScore(a, b) {
+  const tokA = tokenize(a);
+  const tokB = tokenize(b);
+  if (tokA.length === 0 && tokB.length === 0) return 1;
+  if (tokA.length === 0 || tokB.length === 0) return 0;
+  const lcs = lcsLength(tokA, tokB);
+  return lcs / Math.max(tokA.length, tokB.length);
+}
+function levenshteinScore(a, b) {
+  if (a.length === 0 && b.length === 0) return 1;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  const dist = (0, import_fastest_levenshtein.distance)(a, b);
+  return 1 - dist / maxLen;
+}
+function combinedScore(needle, candidate) {
+  const tScore = tokenLcsScore(needle, candidate);
+  let lScore;
+  if (needle.length < 500 && candidate.length < 500) {
+    lScore = levenshteinScore(needle, candidate);
+  } else {
+    lScore = tScore;
+  }
+  return tScore * 0.6 + lScore * 0.4;
+}
+function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
+  if (!needle) return [];
+  const needleLines = needle.split("\n");
+  const needleLineCount = needleLines.length;
+  const candidates = [];
+  const minWindow = Math.max(1, Math.floor(needleLineCount * 0.7));
+  const maxWindow = Math.min(
+    lines.length - 1,
+    Math.ceil(needleLineCount * 1.3) + 1
+  );
+  for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
+    for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
+      const windowLines = lines.slice(startLine, startLine + winSize);
+      const windowText = windowLines.join("\n");
+      const score = combinedScore(needle, windowText);
+      if (score >= threshold) {
+        candidates.push({
+          text: windowText,
+          line: startLine,
+          endLine: startLine + winSize - 1,
+          startColumn: 0,
+          endColumn: windowLines[windowLines.length - 1].length,
+          score
+        });
+      }
+    }
+  }
+  if (needleLineCount === 1 && needle.length < 200) {
+    for (let lineNum = 1; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      if (!line) continue;
+      const winLen = needle.length;
+      const minWinLen = Math.max(3, Math.floor(winLen * 0.7));
+      const maxWinLen = Math.min(line.length, Math.ceil(winLen * 1.3));
+      for (let len = minWinLen; len <= maxWinLen; len++) {
+        for (let col = 0; col + len <= line.length; col++) {
+          const sub = line.substring(col, col + len);
+          const score = combinedScore(needle, sub);
+          if (score >= threshold) {
+            candidates.push({
+              text: sub,
+              line: lineNum,
+              endLine: lineNum,
+              startColumn: col,
+              endColumn: col + len,
+              score
+            });
+          }
+        }
+      }
+    }
+  }
+  let deduped = deduplicateCandidates(candidates);
+  if (hintLine != null) {
+    deduped = deduped.map((c) => {
+      const dist = Math.abs(c.line - hintLine);
+      const proximityBonus = 0.1 * Math.max(0, 1 - dist / 50);
+      return { ...c, score: Math.min(1, c.score + proximityBonus) };
+    });
+  }
+  return deduped.sort((a, b) => b.score - a.score);
+}
+function deduplicateCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const key = `${c.line}:${c.startColumn}:${c.endLine}:${c.endColumn}`;
+    const existing = seen.get(key);
+    if (!existing || c.score > existing.score) {
+      seen.set(key, c);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+// src/lib/git.ts
+var import_node_child_process = require("node:child_process");
+var import_node_util = require("node:util");
+var execFile = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var GIT_TIMEOUT = 1e4;
+var _gitAvailable = null;
+async function isGitAvailable() {
+  if (_gitAvailable != null) return _gitAvailable;
+  try {
+    await execFile("git", ["--version"], { timeout: GIT_TIMEOUT });
+    _gitAvailable = true;
+  } catch {
+    _gitAvailable = false;
+  }
+  return _gitAvailable;
+}
+async function findRepoRoot(cwd) {
+  if (!await isGitAvailable()) return null;
+  try {
+    const { stdout } = await execFile(
+      "git",
+      ["rev-parse", "--show-toplevel"],
+      { cwd: cwd ?? process.cwd(), timeout: GIT_TIMEOUT }
+    );
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function getCurrentCommit(repoRoot) {
+  if (!await isGitAvailable()) return null;
+  try {
+    const { stdout } = await execFile(
+      "git",
+      ["rev-parse", "HEAD"],
+      { cwd: repoRoot, timeout: GIT_TIMEOUT }
+    );
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function isStale(commentCommit, repoRoot) {
+  const head = await getCurrentCommit(repoRoot);
+  if (!head) return false;
+  const minLen = Math.min(commentCommit.length, head.length);
+  return commentCommit.slice(0, minLen) !== head.slice(0, minLen);
+}
+function parseDiffHunks(diffOutput) {
+  const hunks = [];
+  const lines = diffOutput.split("\n");
+  let current = null;
+  for (const line of lines) {
+    const hunkMatch = line.match(
+      /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/
+    );
+    if (hunkMatch) {
+      current = {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: hunkMatch[2] != null ? parseInt(hunkMatch[2], 10) : 1,
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: hunkMatch[4] != null ? parseInt(hunkMatch[4], 10) : 1,
+        lines: []
+      };
+      hunks.push(current);
+      continue;
+    }
+    if (current && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
+      current.lines.push(line);
+    }
+  }
+  return hunks;
+}
+async function getDiff(fromCommit, toCommit, filePath, repoRoot) {
+  if (!await isGitAvailable()) return [];
+  try {
+    const { stdout } = await execFile(
+      "git",
+      [
+        "diff",
+        `${fromCommit}..${toCommit}`,
+        "--unified=0",
+        "--no-color",
+        "--",
+        filePath
+      ],
+      { cwd: repoRoot, timeout: GIT_TIMEOUT }
+    );
+    return parseDiffHunks(stdout);
+  } catch {
+    return [];
+  }
+}
+function getLineShift(hunks, originalLine) {
+  let cumulativeShift = 0;
+  for (const hunk of hunks) {
+    const oldEnd = hunk.oldStart + hunk.oldCount - 1;
+    if (hunk.oldStart > originalLine) break;
+    if (originalLine >= hunk.oldStart && originalLine <= oldEnd) {
+      return { shift: cumulativeShift, modified: true };
+    }
+    if (oldEnd < originalLine) {
+      cumulativeShift += hunk.newCount - hunk.oldCount;
+    }
+  }
+  return { shift: cumulativeShift, modified: false };
+}
+async function getFileAtCommit(commit, filePath, repoRoot) {
+  if (!await isGitAvailable()) return null;
+  try {
+    const { stdout } = await execFile(
+      "git",
+      ["show", `${commit}:${filePath}`],
+      { cwd: repoRoot, timeout: GIT_TIMEOUT }
+    );
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+async function getStagedFiles(repoRoot, pattern) {
+  if (!await isGitAvailable()) return [];
+  try {
+    const args = ["diff", "--cached", "--name-only", "--diff-filter=d"];
+    if (pattern) args.push("--", pattern);
+    const { stdout } = await execFile("git", args, {
+      cwd: repoRoot,
+      timeout: GIT_TIMEOUT
+    });
+    return stdout.trim().split("\n").filter((f) => f.length > 0);
+  } catch {
+    return [];
+  }
+}
+async function detectRenames(fromCommit, toCommit, repoRoot) {
+  if (!await isGitAvailable()) return /* @__PURE__ */ new Map();
+  try {
+    const { stdout } = await execFile(
+      "git",
+      ["diff", "--name-status", "-M", `${fromCommit}..${toCommit}`],
+      { cwd: repoRoot, timeout: GIT_TIMEOUT }
+    );
+    const renames = /* @__PURE__ */ new Map();
+    for (const line of stdout.trim().split("\n")) {
+      const match = line.match(/^R\d*\t(.+)\t(.+)$/);
+      if (match) {
+        renames.set(match[1], match[2]);
+      }
+    }
+    return renames;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+
+// src/lib/reanchor-core.ts
+var HIGH_THRESHOLD = 0.8;
+var DEFAULT_THRESHOLD = 0.6;
+var DEFAULT_PROXIMITY_WINDOW = 5;
+function toReanchorLines(documentText) {
+  return ["", ...documentText.replace(/\r\n/g, "\n").split("\n")];
+}
+function reanchorComment(comment, documentLines, opts = {}) {
+  const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+  const proximityWindow = opts.proximityWindow ?? DEFAULT_PROXIMITY_WINDOW;
+  const commentId = comment.id;
+  const selectedText = comment.selected_text;
+  if (!selectedText && comment.line == null) {
+    return {
+      commentId,
+      status: "anchored",
+      score: 1,
+      reason: "Document-level comment (no anchor needed)."
+    };
+  }
+  if (comment.line != null && opts.diffHunks?.length) {
+    const { shift, modified } = getLineShift2(opts.diffHunks, comment.line);
+    if (!selectedText) {
+      const shiftedLine = comment.line + shift;
+      const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
+      const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : void 0;
+      return {
+        commentId,
+        status: shift === 0 ? "anchored" : "shifted",
+        score: 1,
+        newLine: shiftedLine,
+        newEndLine: shiftedEndLine,
+        reason: shift === 0 ? "Line-only comment unchanged (diff confirms position)." : `Line-only comment shifted by ${shift > 0 ? "+" : ""}${shift} line(s) via diff.`
+      };
+    }
+    if (!modified) {
+      const shiftedLine = comment.line + shift;
+      const lineSpan = comment.end_line != null ? comment.end_line - comment.line : 0;
+      const shiftedEndLine = comment.end_line != null ? shiftedLine + lineSpan : void 0;
+      const textAtShifted = extractText(
+        documentLines,
+        shiftedLine,
+        shiftedEndLine,
+        comment.start_column,
+        comment.end_column
+      );
+      if (textAtShifted === selectedText) {
+        return {
+          commentId,
+          status: shift === 0 ? "anchored" : "shifted",
+          score: 1,
+          newLine: shiftedLine,
+          newEndLine: shiftedEndLine,
+          reason: shift === 0 ? "Diff confirms text unchanged at original position." : `Diff shifted by ${shift > 0 ? "+" : ""}${shift} line(s).`
+        };
+      }
+    }
+  }
+  if (selectedText) {
+    const exactCandidates = exactMatch(documentLines, selectedText);
+    let chosen;
+    let chosenReason = "";
+    if (exactCandidates.length === 1) {
+      chosen = exactCandidates[0];
+      chosenReason = "Exact text match (unique).";
+    } else if (exactCandidates.length > 1 && comment.line != null) {
+      chosen = closestToLine(exactCandidates, comment.line);
+      chosenReason = `Exact text match (${exactCandidates.length} occurrences; chose nearest to original line ${comment.line}).`;
+    }
+    if (chosen) {
+      if (isImplausibleExactRelocation(comment, chosen, documentLines, proximityWindow)) {
+        const textAtOrigin = extractText(
+          documentLines,
+          comment.line,
+          comment.end_line,
+          comment.start_column,
+          comment.end_column
+        );
+        return {
+          commentId,
+          status: "fuzzy",
+          score: 0.5,
+          newLine: comment.line,
+          newEndLine: comment.end_line,
+          newStartColumn: comment.start_column,
+          newEndColumn: comment.end_column,
+          anchoredText: textAtOrigin ?? void 0,
+          previousSelectedText: selectedText,
+          reason: `Lone exact match at line ${chosen.line} is beyond the proximity window (\xB1${proximityWindow}) of original line ${comment.line} and the text at the original position changed; kept at original position, needs re-anchoring.`
+        };
+      }
+      return {
+        commentId,
+        status: "anchored",
+        score: 1,
+        newLine: chosen.line,
+        newEndLine: chosen.endLine,
+        newStartColumn: chosen.startColumn,
+        newEndColumn: chosen.endColumn,
+        reason: chosenReason
+      };
+    }
+    const normCandidates = normalizedMatch(documentLines, selectedText);
+    if (normCandidates.length === 1) {
+      const candidate = normCandidates[0];
+      return {
+        commentId,
+        status: "fuzzy",
+        score: candidate.score,
+        newLine: candidate.line,
+        newEndLine: candidate.endLine,
+        newStartColumn: candidate.startColumn,
+        newEndColumn: candidate.endColumn,
+        anchoredText: candidate.text,
+        previousSelectedText: selectedText,
+        reason: "Normalized whitespace match."
+      };
+    }
+    const fuzzyCandidates = fuzzySearch(
+      documentLines,
+      selectedText,
+      HIGH_THRESHOLD,
+      comment.line
+    );
+    if (fuzzyCandidates.length === 1 || fuzzyCandidates.length > 0 && fuzzyCandidates[0].score >= HIGH_THRESHOLD) {
+      const best = fuzzyCandidates.length === 1 ? fuzzyCandidates[0] : closestToLine(fuzzyCandidates, comment.line ?? 1);
+      return {
+        commentId,
+        status: "fuzzy",
+        score: best.score,
+        newLine: best.line,
+        newEndLine: best.endLine,
+        newStartColumn: best.startColumn,
+        newEndColumn: best.endColumn,
+        anchoredText: best.text,
+        previousSelectedText: selectedText,
+        reason: `High-confidence fuzzy match (score ${best.score.toFixed(3)}).`
+      };
+    }
+  }
+  if (comment.line != null) {
+    const lineIdx = comment.line;
+    if (lineIdx > 0 && lineIdx < documentLines.length) {
+      const qualifier = opts.commitIsStale ? " (commit is stale \u2014 line may have shifted)" : "";
+      if (selectedText) {
+        const lineText = documentLines[lineIdx];
+        const candidates = fuzzySearch(["", lineText], selectedText, DEFAULT_THRESHOLD);
+        if (candidates.length > 0) {
+          return {
+            commentId,
+            status: "fuzzy",
+            score: candidates[0].score,
+            newLine: comment.line,
+            newEndLine: comment.end_line,
+            anchoredText: candidates[0].text,
+            previousSelectedText: selectedText,
+            reason: `Line-fallback with fuzzy text match (score ${candidates[0].score.toFixed(3)})${qualifier}.`
+          };
+        }
+      }
+      const isLineOnly = !selectedText;
+      return {
+        commentId,
+        status: isLineOnly ? "anchored" : opts.commitIsStale ? "ambiguous" : "anchored",
+        score: isLineOnly ? 1 : opts.commitIsStale ? 0.5 : 0.8,
+        newLine: comment.line,
+        newEndLine: comment.end_line,
+        reason: isLineOnly ? "Line-only comment (no selected_text to verify)." : `Line/column fallback${qualifier}.`
+      };
+    }
+  }
+  if (selectedText) {
+    const lowCandidates = fuzzySearch(
+      documentLines,
+      selectedText,
+      threshold,
+      comment.line
+    );
+    if (lowCandidates.length === 1) {
+      const candidate = lowCandidates[0];
+      return {
+        commentId,
+        status: "fuzzy",
+        score: candidate.score,
+        newLine: candidate.line,
+        newEndLine: candidate.endLine,
+        newStartColumn: candidate.startColumn,
+        newEndColumn: candidate.endColumn,
+        anchoredText: candidate.text,
+        previousSelectedText: selectedText,
+        reason: `Low-threshold fuzzy match (score ${candidate.score.toFixed(3)}).`
+      };
+    }
+    if (lowCandidates.length > 1) {
+      const best = lowCandidates[0];
+      return {
+        commentId,
+        status: "ambiguous",
+        score: best.score,
+        newLine: best.line,
+        newEndLine: best.endLine,
+        reason: `Ambiguous: ${lowCandidates.length} fuzzy matches (best score ${best.score.toFixed(3)}).`
+      };
+    }
+  }
+  return {
+    commentId,
+    status: "orphaned",
+    score: 0,
+    reason: "No match found. Comment is orphaned."
+  };
+}
+function reanchorDocumentLines(doc, documentLines, opts = {}) {
+  return doc.comments.map((comment) => reanchorComment(comment, documentLines, opts));
+}
+function reanchorDocumentText(doc, documentText, opts = {}) {
+  return reanchorDocumentLines(doc, toReanchorLines(documentText), opts);
+}
+function resolveAnchor(comment, documentText, opts = {}) {
+  const normalizedText = documentText.replace(/\r\n/g, "\n");
+  const documentLines = toReanchorLines(documentText);
+  const result = reanchorComment(comment, documentLines, opts);
+  if (result.status === "orphaned") {
+    return {
+      status: "orphaned",
+      score: result.score,
+      reason: result.reason
+    };
+  }
+  const line = result.newLine ?? comment.line;
+  if (line == null) {
+    return {
+      status: result.status,
+      score: result.score,
+      reason: result.reason
+    };
+  }
+  const rawLines = normalizedText.split("\n");
+  const lineStarts = computeLineStarts(rawLines);
+  const endLine = result.newEndLine ?? comment.end_line ?? line;
+  const startColumn = result.newStartColumn ?? comment.start_column ?? 0;
+  const endColumn = result.newEndColumn ?? comment.end_column;
+  const from = offsetFor(lineStarts, rawLines, line, startColumn);
+  const selectedText = comment.selected_text?.replace(/\r\n/g, "\n");
+  const to = endColumn != null ? offsetFor(lineStarts, rawLines, endLine, endColumn) : selectedText ? from + selectedText.length : offsetFor(lineStarts, rawLines, endLine, rawLines[endLine - 1]?.length ?? 0);
+  return {
+    status: result.status,
+    score: result.score,
+    from,
+    to,
+    line,
+    endLine,
+    startColumn,
+    endColumn: endColumn ?? columnForOffset(lineStarts, rawLines, endLine, to),
+    reason: result.reason
+  };
+}
+function computeLineStarts(lines) {
+  const starts = [0];
+  let offset = 0;
+  for (const line of lines) {
+    starts.push(offset);
+    offset += line.length + 1;
+  }
+  return starts;
+}
+function offsetFor(lineStarts, lines, line, column) {
+  const start = lineStarts[line] ?? 0;
+  const maxColumn = lines[line - 1]?.length ?? 0;
+  return start + Math.max(0, Math.min(column, maxColumn));
+}
+function columnForOffset(lineStarts, lines, line, offset) {
+  const start = lineStarts[line] ?? 0;
+  const maxColumn = lines[line - 1]?.length ?? 0;
+  return Math.max(0, Math.min(offset - start, maxColumn));
+}
+function applyReanchorResults(doc, results, opts = {}) {
+  let changed = 0;
+  const resultMap = new Map(results.map((result) => [result.commentId, result]));
+  for (const comment of doc.comments) {
+    const result = resultMap.get(comment.id);
+    if (!result) continue;
+    let isChanged = false;
+    if (result.newLine != null && result.newLine !== comment.line) {
+      comment.line = result.newLine;
+      isChanged = true;
+    }
+    if (result.newEndLine != null && result.newEndLine !== comment.end_line) {
+      comment.end_line = result.newEndLine;
+      isChanged = true;
+    }
+    if (result.newStartColumn != null && result.newStartColumn !== comment.start_column) {
+      comment.start_column = result.newStartColumn;
+      isChanged = true;
+    }
+    if (result.newEndColumn != null && result.newEndColumn !== comment.end_column) {
+      comment.end_column = result.newEndColumn;
+      isChanged = true;
+    }
+    if (result.anchoredText != null && result.anchoredText !== comment.selected_text) {
+      if (opts.updateText) {
+        comment.selected_text = result.anchoredText;
+        delete comment.anchored_text;
+      } else {
+        comment.anchored_text = result.anchoredText;
+      }
+      isChanged = true;
+    } else if (result.anchoredText != null && result.anchoredText === comment.selected_text) {
+      if (comment.anchored_text) {
+        delete comment.anchored_text;
+        isChanged = true;
+      }
+    }
+    if (isChanged || result.status !== "anchored") {
+      comment.x_reanchor_status = result.status;
+      comment.x_reanchor_score = result.score;
+    }
+    if (opts.force && opts.headCommit && (result.status === "anchored" || result.status === "shifted") && result.score >= HIGH_THRESHOLD) {
+      comment.commit = opts.headCommit;
+      delete comment.x_reanchor_status;
+      delete comment.x_reanchor_score;
+      if (comment.anchored_text && comment.anchored_text === comment.selected_text) {
+        delete comment.anchored_text;
+      }
+      isChanged = true;
+    }
+    if (isChanged) {
+      changed += 1;
+    }
+  }
+  return changed;
+}
+function extractText(lines, line, endLine, startColumn, endColumn) {
+  const startIdx = line;
+  const endIdx = endLine ?? line;
+  if (startIdx < 1 || endIdx >= lines.length) return null;
+  if (startIdx === endIdx) {
+    const text = lines[startIdx];
+    if (startColumn != null && endColumn != null) {
+      return text.slice(startColumn, endColumn);
+    }
+    return text;
+  }
+  const result = [];
+  for (let index = startIdx; index <= endIdx; index += 1) {
+    let currentLine = lines[index];
+    if (index === startIdx && startColumn != null) currentLine = currentLine.slice(startColumn);
+    if (index === endIdx && endColumn != null) currentLine = currentLine.slice(0, endColumn);
+    result.push(currentLine);
+  }
+  return result.join("\n");
+}
+function closestToLine(candidates, targetLine) {
+  return candidates.reduce(
+    (best, candidate) => Math.abs(candidate.line - targetLine) < Math.abs(best.line - targetLine) ? candidate : best
+  );
+}
+function isImplausibleExactRelocation(comment, candidate, lines, proximityWindow) {
+  if (comment.line == null) return false;
+  if (comment.line <= 0 || comment.line >= lines.length) return false;
+  if (Math.abs(candidate.line - comment.line) <= proximityWindow) return false;
+  const textAtOrigin = extractText(
+    lines,
+    comment.line,
+    comment.end_line,
+    comment.start_column,
+    comment.end_column
+  );
+  if (textAtOrigin === comment.selected_text) return false;
+  return true;
+}
+function getLineShift2(diffHunks, line) {
+  let shift = 0;
+  let modified = false;
+  for (const hunk of diffHunks) {
+    const oldStart = hunk.oldStart;
+    const oldEnd = hunk.oldStart + Math.max(hunk.oldCount, 1) - 1;
+    if (line >= oldStart && line <= oldEnd && hunk.oldCount > 0) {
+      modified = true;
+    }
+    if (line > oldEnd || hunk.oldCount === 0 && line >= oldStart) {
+      shift += hunk.newCount - hunk.oldCount;
+    }
+  }
+  return { shift, modified };
+}
+
+// src/lib/reanchor.ts
+init_parser();
+init_parser();
+var import_node_path6 = __toESM(require("node:path"), 1);
+async function reanchorDocument(doc, documentLines, opts = {}) {
+  const results = [];
+  const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+  const proximityWindow = opts.proximityWindow;
+  let diffHunks;
+  let commitIsStale = false;
+  if (!opts.noGit && await isGitAvailable()) {
+    const repoRoot = opts.repoRoot ?? await findRepoRoot(opts.cwd);
+    if (repoRoot && opts.documentPath) {
+      const relPath = import_node_path6.default.relative(repoRoot, opts.documentPath);
+      const head = await getCurrentCommit(repoRoot);
+      const globalFrom = opts.fromCommit;
+      for (const comment of doc.comments) {
+        const commentCommit = globalFrom ?? comment.commit;
+        if (commentCommit && head && commentCommit !== head) {
+          commitIsStale = true;
+          const hunks = await getDiff(commentCommit, head, relPath, repoRoot);
+          const result = reanchorComment(comment, documentLines, {
+            diffHunks: hunks,
+            threshold,
+            commitIsStale: true,
+            proximityWindow
+          });
+          results.push(result);
+          continue;
+        }
+        results.push(
+          reanchorComment(comment, documentLines, { threshold, commitIsStale: false, proximityWindow })
+        );
+      }
+      return results;
+    }
+  }
+  return reanchorDocumentLines(doc, documentLines, { threshold, proximityWindow });
+}
+async function reanchorFile(sidecarPath, opts = {}) {
+  const doc = await parseSidecar(sidecarPath);
+  const docPath = sidecarToDocument(sidecarPath);
+  const documentLines = await readDocumentLines(docPath);
+  const repoRoot = !opts.noGit ? await findRepoRoot(opts.cwd) : null;
+  const headCommit = repoRoot ? await getCurrentCommit(repoRoot) : void 0;
+  const results = await reanchorDocument(doc, documentLines, {
+    ...opts,
+    documentPath: docPath,
+    repoRoot: repoRoot ?? void 0
+  });
+  let changed = 0;
+  let written = false;
+  if (!opts.dryRun) {
+    changed = applyReanchorResults(doc, results, {
+      updateText: opts.updateText,
+      force: opts.force,
+      headCommit: headCommit ?? void 0
+    });
+    if (changed > 0 || opts.autoUpdate) {
+      await writeSidecar(sidecarPath, doc);
+      written = true;
+    }
+  }
+  return { results, changed, written };
+}
+
+// src/lib/identity.ts
+var import_uuid = require("uuid");
+function formatAuthor(name, handle) {
+  const trimmedName = name.trim();
+  const trimmedHandle = handle?.trim();
+  return trimmedHandle ? `${trimmedName} (${trimmedHandle})` : trimmedName;
+}
+function parseAuthor(author) {
+  const trimmed = author.trim();
+  const match = /^(.*?)\s*\(([^()]*)\)\s*$/.exec(trimmed);
+  if (!match) return { name: trimmed };
+  const name = match[1].trim();
+  const handle = match[2].trim();
+  return handle ? { name, handle } : { name };
+}
+function newCommentId() {
+  return (0, import_uuid.v4)();
+}
+
+// src/lib/comments.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isCommentExtensionValue(value) {
+  if (value == null) return true;
+  switch (typeof value) {
+    case "boolean":
+    case "string":
+      return true;
+    case "number":
+      return Number.isFinite(value);
+    case "object": {
+      if (Array.isArray(value)) {
+        return value.every((item) => isCommentExtensionValue(item));
+      }
+      if (!isPlainObject(value)) {
+        return false;
+      }
+      return Object.values(value).every((item) => isCommentExtensionValue(item));
+    }
+    default:
+      return false;
+  }
+}
+function normalizeCommentExtensions(extensions) {
+  if (!extensions) return {};
+  const normalizedEntries = [];
+  for (const [key, value] of Object.entries(extensions)) {
+    if (!key.startsWith("x_")) {
+      throw new Error(`Comment extension key '${key}' must start with 'x_'.`);
+    }
+    if (!isCommentExtensionValue(value)) {
+      throw new Error(
+        `Comment extension '${key}' must be JSON-serializable (null, boolean, finite number, string, array, or plain object).`
+      );
+    }
+    normalizedEntries.push([key, value]);
+  }
+  return Object.fromEntries(normalizedEntries);
+}
+async function addComment(doc, opts, repoRoot) {
+  const id = opts.id ?? newCommentId();
+  const timestamp = opts.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  let commit = opts.commit;
+  if (!commit && repoRoot && await isGitAvailable()) {
+    commit = await getCurrentCommit(repoRoot) ?? void 0;
+  }
+  const comment = {
+    id,
+    author: opts.author,
+    timestamp,
+    text: opts.text,
+    resolved: false
+  };
+  if (opts.line != null) comment.line = opts.line;
+  if (opts.end_line != null) comment.end_line = opts.end_line;
+  if (opts.start_column != null) comment.start_column = opts.start_column;
+  if (opts.end_column != null) comment.end_column = opts.end_column;
+  if (opts.type) comment.type = opts.type;
+  if (opts.severity) comment.severity = opts.severity;
+  if (opts.reply_to) comment.reply_to = opts.reply_to;
+  if (commit) comment.commit = commit;
+  Object.assign(comment, normalizeCommentExtensions(opts.extensions));
+  doc.comments.push(comment);
+  return comment;
+}
+function populateSelectedText(comment, documentLines) {
+  if (comment.selected_text) return;
+  if (comment.line == null) return;
+  const startIdx = comment.line - 1;
+  const endIdx = (comment.end_line ?? comment.line) - 1;
+  if (startIdx < 0 || endIdx >= documentLines.length) return;
+  if (startIdx === endIdx) {
+    let line = documentLines[startIdx];
+    if (comment.start_column != null && comment.end_column != null) {
+      line = line.slice(comment.start_column, comment.end_column);
+    }
+    comment.selected_text = line;
+  } else {
+    const lines = [];
+    for (let i = startIdx; i <= endIdx; i++) {
+      let l = documentLines[i];
+      if (i === startIdx && comment.start_column != null) {
+        l = l.slice(comment.start_column);
+      }
+      if (i === endIdx && comment.end_column != null) {
+        l = l.slice(0, comment.end_column);
+      }
+      lines.push(l);
+    }
+    comment.selected_text = lines.join("\n");
+  }
+  if (comment.selected_text) {
+    comment.selected_text_hash = computeHash(comment.selected_text);
+  }
+}
+function editComment(doc, commentId, opts) {
+  const comment = doc.comments.find((entry) => entry.id === commentId);
+  if (!comment) {
+    throw new Error(`Unknown comment '${commentId}'.`);
+  }
+  if (opts.actor && comment.author !== opts.actor) {
+    throw new Error("Only the comment author can edit this comment.");
+  }
+  if (opts.text.trim().length === 0) {
+    throw new Error("Comment text cannot be empty.");
+  }
+  comment.text = opts.text;
+  return comment;
+}
+function resolveComment(doc, commentId, cascade = false) {
+  const comment = doc.comments.find((c) => c.id === commentId);
+  if (!comment) return false;
+  comment.resolved = true;
+  if (cascade) {
+    for (const c of doc.comments) {
+      if (c.reply_to === commentId) {
+        c.resolved = true;
+      }
+    }
+  }
+  return true;
+}
+function unresolveComment(doc, commentId) {
+  const comment = doc.comments.find((c) => c.id === commentId);
+  if (!comment) return false;
+  comment.resolved = false;
+  return true;
+}
+var ANCHOR_FIELDS = [
+  "line",
+  "end_line",
+  "start_column",
+  "end_column",
+  "selected_text",
+  "selected_text_hash",
+  "anchored_text",
+  "commit"
+];
+function removeComment(doc, commentId, opts) {
+  const comment = doc.comments.find((c) => c.id === commentId);
+  if (!comment) return false;
+  if (opts?.cascade) {
+    doc.comments = doc.comments.filter(
+      (c) => c.id === commentId || c.reply_to !== commentId
+    );
+  } else {
+    for (const c of doc.comments) {
+      if (c.reply_to !== commentId) continue;
+      for (const field of ANCHOR_FIELDS) {
+        if (c[field] == null && comment[field] != null) {
+          c[field] = comment[field];
+        }
+      }
+      if (comment.reply_to) {
+        c.reply_to = comment.reply_to;
+      } else {
+        delete c.reply_to;
+      }
+    }
+  }
+  const idx = doc.comments.findIndex((c) => c.id === commentId);
+  if (idx !== -1) doc.comments.splice(idx, 1);
+  return true;
+}
+function filterComments(comments, filter) {
+  return comments.filter((c) => {
+    if (filter.open === true && c.resolved) return false;
+    if (filter.resolved === true && !c.resolved) return false;
+    if (filter.author && c.author !== filter.author) return false;
+    if (filter.type && c.type !== filter.type) return false;
+    if (filter.severity && c.severity !== filter.severity) return false;
+    if (filter.orphaned === true && c.x_reanchor_status !== "orphaned") return false;
+    if (filter.orphaned === false && c.x_reanchor_status === "orphaned") return false;
+    return true;
+  });
+}
+function getThreads(comments) {
+  const threads = /* @__PURE__ */ new Map();
+  const replyMap = /* @__PURE__ */ new Map();
+  for (const c of comments) {
+    if (!c.reply_to) {
+      threads.set(c.id, [c]);
+    } else {
+      replyMap.set(c.id, c.reply_to);
+    }
+  }
+  function findRoot(id) {
+    const parent = replyMap.get(id);
+    if (!parent) return id;
+    return findRoot(parent);
+  }
+  for (const c of comments) {
+    if (c.reply_to) {
+      const rootId = findRoot(c.id);
+      if (!threads.has(rootId)) {
+        threads.set(rootId, []);
+      }
+      threads.get(rootId).push(c);
+    }
+  }
+  return threads;
+}
+function summarize(comments) {
+  const summary = {
+    total: comments.length,
+    open: 0,
+    resolved: 0,
+    orphaned: 0,
+    threads: 0,
+    byType: {},
+    bySeverity: {}
+  };
+  const roots = /* @__PURE__ */ new Set();
+  for (const c of comments) {
+    if (c.resolved) summary.resolved++;
+    else summary.open++;
+    if (c.x_reanchor_status === "orphaned") summary.orphaned++;
+    if (c.type) {
+      summary.byType[c.type] = (summary.byType[c.type] ?? 0) + 1;
+    }
+    if (c.severity) {
+      summary.bySeverity[c.severity] = (summary.bySeverity[c.severity] ?? 0) + 1;
+    }
+    if (!c.reply_to) roots.add(c.id);
+  }
+  summary.threads = roots.size;
+  return summary;
+}
+
+// src/index.ts
+var findWorkspaceRoot2 = findWorkspaceRoot;
+var loadConfig2 = loadConfig;
+var discoverSidecar3 = discoverSidecar;
+var sidecarToDocument2 = sidecarToDocument;
+var discoverAllSidecars2 = discoverAllSidecars;
+var resolveSidecarPaths2 = resolveSidecarPaths;
+var parseSidecar2 = parseSidecar;
+var parseSidecarContent2 = parseSidecarContent;
+var parseSidecarLenient2 = parseSidecarLenient;
+var parseSidecarContentLenient2 = parseSidecarContentLenient;
+var readDocumentLines2 = readDocumentLines;
+var computeHash2 = computeHash;
+var syncHash2 = syncHash;
+var toYaml2 = toYaml;
+var toJson2 = toJson;
+var writeSidecar2 = writeSidecar;
+var validate2 = validate;
+var validateFile2 = validateFile;
+var validateDocument2 = validateDocument;
+var exactMatch2 = exactMatch;
+var normalizedMatch2 = normalizedMatch;
+var fuzzySearch2 = fuzzySearch;
+var combinedScore2 = combinedScore;
+var isGitAvailable2 = isGitAvailable;
+var findRepoRoot3 = findRepoRoot;
+var getCurrentCommit2 = getCurrentCommit;
+var isStale2 = isStale;
+var getDiff2 = getDiff;
+var getLineShift4 = getLineShift;
+var getFileAtCommit3 = getFileAtCommit;
+var getStagedFiles2 = getStagedFiles;
+var detectRenames2 = detectRenames;
+var parseDiffHunks3 = parseDiffHunks;
+var DEFAULT_THRESHOLD2 = DEFAULT_THRESHOLD;
+var HIGH_THRESHOLD2 = HIGH_THRESHOLD;
+var reanchorComment2 = reanchorComment;
+var reanchorDocumentLines2 = reanchorDocumentLines;
+var reanchorDocumentText2 = reanchorDocumentText;
+var toReanchorLines2 = toReanchorLines;
+var resolveAnchor2 = resolveAnchor;
+var reanchorDocument2 = reanchorDocument;
+var applyReanchorResults2 = applyReanchorResults;
+var reanchorFile2 = reanchorFile;
+var addComment2 = addComment;
+var editComment2 = editComment;
+var normalizeCommentExtensions2 = normalizeCommentExtensions;
+var populateSelectedText2 = populateSelectedText;
+var resolveComment2 = resolveComment;
+var unresolveComment2 = unresolveComment;
+var removeComment2 = removeComment;
+var filterComments2 = filterComments;
+var getThreads2 = getThreads;
+var summarize2 = summarize;
+var formatAuthor2 = formatAuthor;
+var parseAuthor2 = parseAuthor;
+var newCommentId2 = newCommentId;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_THRESHOLD,
+  HIGH_THRESHOLD,
+  addComment,
+  applyReanchorResults,
+  combinedScore,
+  computeHash,
+  detectRenames,
+  discoverAllSidecars,
+  discoverSidecar,
+  editComment,
+  exactMatch,
+  filterComments,
+  findRepoRoot,
+  findWorkspaceRoot,
+  formatAuthor,
+  fuzzySearch,
+  getCurrentCommit,
+  getDiff,
+  getFileAtCommit,
+  getLineShift,
+  getStagedFiles,
+  getThreads,
+  isGitAvailable,
+  isStale,
+  loadConfig,
+  mrsfSchema,
+  newCommentId,
+  normalizeCommentExtensions,
+  normalizedMatch,
+  parseAuthor,
+  parseDiffHunks,
+  parseSidecar,
+  parseSidecarContent,
+  parseSidecarContentLenient,
+  parseSidecarLenient,
+  populateSelectedText,
+  readDocumentLines,
+  reanchorComment,
+  reanchorDocument,
+  reanchorDocumentLines,
+  reanchorDocumentText,
+  reanchorFile,
+  removeComment,
+  resolveAnchor,
+  resolveComment,
+  resolveSidecarPaths,
+  sidecarToDocument,
+  summarize,
+  syncHash,
+  toJson,
+  toReanchorLines,
+  toYaml,
+  unresolveComment,
+  validate,
+  validateDocument,
+  validateFile,
+  writeSidecar
+});
+//# sourceMappingURL=index.cjs.map