codetrellis 0.0.0-stage → 0.2.0

package/src/shared/lib/grep-entry.js

@@ -0,0 +1,86 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var grep_entry_exports = {};
+__export(grep_entry_exports, {
+  grepEntries: () => grepEntries,
+  grepKey: () => grepKey,
+  grepLine: () => grepLine,
+  grepPatternWords: () => grepPatternWords,
+  grepWords: () => grepWords,
+  isGrepEntry: () => isGrepEntry,
+  splitGrep: () => splitGrep
+});
+module.exports = __toCommonJS(grep_entry_exports);
+var import_matcher = require("./matcher");
+var import_fuzzy = require("./fuzzy");
+const MAX_TEXT = 200;
+const BINARY_PROBE = 8e3;
+function fnv(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function grepKey(t) {
+  return fnv(JSON.stringify([t.must ? "must" : "mustNot", t.match ?? "exact", t.ignoreCase ? "i" : "", t.mayNotImport, ...t.match === "fuzzy" ? [t.threshold ?? import_fuzzy.DEFAULT_THRESHOLD] : []]));
+}
+const isGrepEntry = (e) => /^grep:[0-9a-f]{8}:[+-]/.test(e);
+function splitGrep(e) {
+  if (!isGrepEntry(e)) return null;
+  return { key: e.slice(5, 13), found: e[14] === "+", text: e.slice(15) };
+}
+function grepEntries(t, text) {
+  if (text.slice(0, BINARY_PROBE).includes("\0")) return [];
+  const key = grepKey(t);
+  const hits = [];
+  for (const line of text.split("\n")) {
+    if (!(0, import_matcher.lineMatches)(t.match ?? null, t.mayNotImport, line, t.ignoreCase, t.threshold)) continue;
+    if (t.must) return [];
+    hits.push(`grep:${key}:+${line.trim().slice(0, MAX_TEXT)}`);
+  }
+  return t.must ? [`grep:${key}:-${t.mayNotImport}`] : [...new Set(hits)];
+}
+function grepPatternWords(t) {
+  const said = t.match === "regex" ? `a line matching /${t.mayNotImport}/` : t.match === "glob" ? `a line like \u201C${t.mayNotImport}\u201D` : t.match === "fuzzy" ? `a word like \u201C${t.mayNotImport}\u201D (${(t.threshold ?? import_fuzzy.DEFAULT_THRESHOLD).toFixed(2)} or closer) but not it` : `\u201C${t.mayNotImport}\u201D`;
+  return `${said}${t.ignoreCase ? " (in any case)" : ""}`;
+}
+function grepWords(e) {
+  const g = splitGrep(e);
+  if (!g) return e;
+  return g.found ? `contains \u201C${g.text}\u201D` : `never contains \u201C${g.text}\u201D`;
+}
+function grepLine(text, e) {
+  const g = splitGrep(e);
+  if (!g) return null;
+  if (!g.found) return text.length ? 1 : null;
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) if (lines[i].trim().slice(0, MAX_TEXT) === g.text) return i + 1;
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  grepEntries,
+  grepKey,
+  grepLine,
+  grepPatternWords,
+  grepWords,
+  isGrepEntry,
+  splitGrep
+});

package/src/shared/lib/grounding-line.js

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var grounding_line_exports = {};
+__export(grounding_line_exports, {
+  GRADE_GLYPH: () => GRADE_GLYPH,
+  GRADE_ORDER: () => GRADE_ORDER,
+  GRADE_WORDS: () => GRADE_WORDS,
+  groundingLine: () => groundingLine
+});
+module.exports = __toCommonJS(grounding_line_exports);
+const GRADE_ORDER = ["grounded", "waiting", "sent_back", "changed", "tests_older", "failing", "no_evidence"];
+const GRADE_WORDS = {
+  grounded: "grounded",
+  waiting: "waiting on a person",
+  sent_back: "sent back",
+  changed: "changed since",
+  tests_older: "with tests older than the code",
+  failing: "failing",
+  no_evidence: "no evidence yet"
+};
+const GRADE_GLYPH = {
+  grounded: "\u2713",
+  waiting: "\u25D0",
+  sent_back: "\u21A9",
+  changed: "\u26A0",
+  tests_older: "\u26A0",
+  failing: "\u2717",
+  no_evidence: "\u25CB"
+};
+function groundingLine(grades) {
+  const counts = Object.fromEntries(GRADE_ORDER.map((g) => [g, 0]));
+  for (const g of grades) counts[g]++;
+  const total = grades.length;
+  if (total === 0) return { words: null, total, counts, grounded: false };
+  const parts = [`${total} criteri${total === 1 ? "on" : "a"}`];
+  if (counts.grounded === total) parts.push(total === 1 ? "grounded" : "all grounded");
+  else for (const g of GRADE_ORDER) if (counts[g]) parts.push(`${counts[g]} ${GRADE_WORDS[g]}`);
+  return { words: parts.join(" \xB7 "), total, counts, grounded: counts.grounded === total };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GRADE_GLYPH,
+  GRADE_ORDER,
+  GRADE_WORDS,
+  groundingLine
+});

package/src/shared/lib/import-line.js

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var import_line_exports = {};
+__export(import_line_exports, {
+  findingAt: () => findingAt,
+  importLine: () => importLine
+});
+module.exports = __toCommonJS(import_line_exports);
+var import_grep_entry = require("./grep-entry");
+const PACKAGE = /^(npm|pypi|go|cargo|maven|nuget|gem|composer|swift):(.+)$/;
+const CALL = /^(http|sql):(.+)$/;
+const SYMBOL = /^([^#\s:]+)#([^#\s/]+)$/;
+const IMPORTISH = /^\s*(import\b|from\b|export\b.*\bfrom\b|use\b|using\b|require\b|#include\b|package\b)|\brequire\s*\(|\bimport\s*\(/;
+const basename = (p) => p.slice(p.lastIndexOf("/") + 1);
+function importLine(text, target) {
+  if ((0, import_grep_entry.isGrepEntry)(target)) return (0, import_grep_entry.grepLine)(text, target);
+  const call = CALL.exec(target);
+  if (call) return callLine(text, call[1], call[2]);
+  if (target.startsWith("folder:")) return text.length ? 1 : null;
+  const pkg = PACKAGE.exec(target);
+  const sym = SYMBOL.exec(target);
+  const base = pkg ? pkg[1] === "go" ? basename(pkg[2]) : pkg[2] : sym ? sym[2] === "*" || sym[2] === "default" ? basename(sym[1]).replace(/\.[^.]+$/, "") : sym[2] : basename(target).replace(/\.[^.]+$/, "");
+  if (!base) return null;
+  const word = new RegExp(`(^|[^A-Za-z0-9_])${base.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^A-Za-z0-9_]|$)`);
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (IMPORTISH.test(lines[i]) && word.test(lines[i])) return i + 1;
+  }
+  return null;
+}
+function findingAt(text, target, found) {
+  if (found && Number.isInteger(found) && found >= 1 && found <= text.split("\n").length) return found;
+  return importLine(text, target);
+}
+function callLine(text, protocol, rest) {
+  const lines = text.split("\n");
+  let test;
+  if (protocol === "sql") {
+    const table = rest.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`\\b(from|into|update|join|table)\\s+[\`"']?${table}\\b`, "i");
+    test = (l) => re.test(l);
+  } else {
+    const slash = rest.indexOf("/");
+    const host = slash < 0 ? rest : rest.slice(0, slash);
+    const word = host || rest.split("/").find((x) => x && !x.startsWith(":")) || "";
+    if (!word) return null;
+    test = (l) => l.toLowerCase().includes(word.toLowerCase());
+  }
+  for (let i = 0; i < lines.length; i++) if (test(lines[i])) return i + 1;
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findingAt,
+  importLine
+});

package/src/shared/lib/item-status.js

@@ -0,0 +1,249 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var item_status_exports = {};
+__export(item_status_exports, {
+  ITEM_STATE_FIELDS: () => ITEM_STATE_FIELDS,
+  atOnceWords: () => atOnceWords,
+  branchLineageWords: () => branchLineageWords,
+  isFinished: () => isFinished,
+  isStateOnly: () => isStateOnly,
+  itemStatuses: () => itemStatuses,
+  planStatusView: () => planStatusView,
+  recordCheckWords: () => recordCheckWords,
+  recordedWords: () => recordedWords,
+  sectionStateWords: () => sectionStateWords,
+  stateFromWords: () => stateFromWords,
+  statusLine: () => statusLine,
+  taskStateWords: () => taskStateWords
+});
+module.exports = __toCommonJS(item_status_exports);
+var import_git_state_words = require("./git-state-words");
+const TASK_STATUS = {
+  pending: "not-started",
+  assigned: "assigned",
+  in_progress: "in-progress",
+  blocked: "blocked",
+  done: "done",
+  skipped: "skipped"
+};
+function criteriaWords(c, state) {
+  if (!c || c.total === 0) return null;
+  if (state === "done" && c.met === c.total && c.signedOffBy) return `signed off by ${c.signedOffBy}`;
+  const parts = [`${c.met} of ${c.total} criteria met`];
+  if (c.awaiting) parts.push(`${c.awaiting} waiting for sign-off`);
+  return parts.join(", ");
+}
+function taskStateWords(f) {
+  const state = TASK_STATUS[f.status ?? "pending"] ?? "not-started";
+  let words;
+  switch (state) {
+    case "assigned":
+      words = f.assignee ? `assigned to ${f.assignee}` : "assigned";
+      break;
+    case "in-progress":
+      words = `in progress${f.progressPercent ? `, ${f.progressPercent}%` : ""}`;
+      break;
+    case "blocked":
+      words = f.blockedReason ? `blocked: ${f.blockedReason}` : "blocked";
+      break;
+    case "not-started":
+      words = "not started";
+      break;
+    default:
+      words = state;
+  }
+  const crit = criteriaWords(f.criteria, state);
+  if (crit) words += state === "done" && crit.startsWith("signed off") ? `, ${crit}` : `; ${crit}`;
+  return { state, words };
+}
+function sectionStateWords(under) {
+  const counted = under.filter((t) => t.state !== "skipped");
+  const total = counted.length;
+  if (total === 0) return { state: "context", words: "no tasks under it" };
+  const done = counted.filter((t) => isFinished(t.state)).length;
+  const blocked = counted.filter((t) => t.state === "blocked").length;
+  const started = counted.filter((t) => t.state !== "not-started" && t.state !== "none").length;
+  const tail = blocked ? `; ${blocked} blocked` : "";
+  if (done === total) return { state: "done", words: `all ${total} task${total === 1 ? "" : "s"} done` };
+  if (started === 0) return { state: "not-started", words: `none of ${total} task${total === 1 ? "" : "s"} started` };
+  return { state: blocked ? "blocked" : "in-progress", words: `${done} of ${total} task${total === 1 ? "" : "s"} done${tail}` };
+}
+function isFinished(state) {
+  return state === "done" || state === "merged";
+}
+function atOnceWords(claims) {
+  const forged = claims.filter((c) => c.forged);
+  if (forged.length) {
+    const who = [...new Set(forged.map((c) => c.name))].join(" and ");
+    return `two different records claim to be the same change by ${who}; neither is taken`;
+  }
+  const said = claims.map((c) => `${c.name} says ${taskStateWords({ status: c.status }).words}`);
+  return `set two ways at once: ${said.join(", ")}`;
+}
+function stateFromWords(source) {
+  return source === "plan" ? "from the plan" : (0, import_git_state_words.sourceWords)({ source });
+}
+function recordedWords(r) {
+  if (!r) return null;
+  const when = (0, import_git_state_words.shortDate)(Math.floor(r.at / 1e3));
+  if (r.byType !== "record") return `recorded by ${r.by}, ${when}`;
+  return r.check?.verified ? `recorded by ${r.by} in their signed record, ${when}` : `recorded by ${r.by} in their record, unverified, ${when}`;
+}
+function recordCheckWords(r) {
+  if (!r || r.byType !== "record") return null;
+  const c = r.check;
+  if (c?.verified) {
+    return c.how === "git" ? `Signed with ${c.who}'s git SSH key, checked against git's allowed signers, as signed commits are.` : `Signed with ${c.who}'s device key, which you trusted in Settings \u2192 Shared task state.`;
+  }
+  const why = c?.why ? `Not proven: ${c.why}. ` : "";
+  return `Read from a record in the project's files, which git or a synced folder brought here. ${why}Anyone who can write to those files could write one in another person's name, so it is shown as unverified.`;
+}
+function statusLine(s) {
+  const from = [stateFromWords(s.source), s.source === "plan" ? recordedWords(s.recorded) : null].filter(Boolean).join(", ");
+  return `${s.words} \u2014 ${from}${s.gitNote ? `; ${s.gitNote}` : ""}${s.atOnce ? `; ${s.atOnce.words}` : ""}`;
+}
+function itemStatuses(items, git) {
+  const children = /* @__PURE__ */ new Map();
+  for (const i of items) {
+    const list = children.get(i.parentUid) ?? [];
+    list.push(i);
+    children.set(i.parentUid, list);
+  }
+  const out = /* @__PURE__ */ new Map();
+  const visit = (f) => {
+    const done = out.get(f.uid);
+    if (done) return done;
+    const kids = (children.get(f.uid) ?? []).map(visit);
+    const g = git.get(f.uid);
+    let s;
+    if (g && g.state !== "none") {
+      s = {
+        itemUid: f.uid,
+        title: f.title,
+        kind: f.kind,
+        state: g.state,
+        source: g.source,
+        words: g.words,
+        from: (0, import_git_state_words.sourceWords)(g),
+        recorded: null,
+        branch: g.branch,
+        git: g
+      };
+    } else {
+      const fromPlan = f.kind === "action" && (f.status || kids.every((k) => k.kind !== "action")) ? taskStateWords(f) : sectionStateWords(tasksUnder(f.uid, children, out));
+      s = {
+        itemUid: f.uid,
+        title: f.title,
+        kind: f.kind,
+        state: fromPlan.state,
+        source: "plan",
+        words: fromPlan.words,
+        from: "from the plan",
+        recorded: f.kind === "action" ? f.recorded ?? null : null,
+        branch: g?.branch ?? null,
+        ...g ? { gitNote: (0, import_git_state_words.gitStateWords)(g) } : {}
+      };
+    }
+    if (f.kind === "action" && f.atOnce?.length) s.atOnce = { words: atOnceWords(f.atOnce), claims: f.atOnce };
+    out.set(f.uid, s);
+    return s;
+  };
+  for (const f of items) visit(f);
+  return items.map((f) => out.get(f.uid));
+}
+function tasksUnder(uid, children, done) {
+  const out = [];
+  const walk = (u) => {
+    for (const c of children.get(u) ?? []) {
+      const s = done.get(c.uid);
+      if (s && c.kind === "action") out.push(s);
+      walk(c.uid);
+    }
+  };
+  walk(uid);
+  return out;
+}
+const ITEM_STATE_FIELDS = /* @__PURE__ */ new Set([
+  "status",
+  "assignee",
+  "assigneeType",
+  "assigneeModel",
+  "assigneeSession",
+  "progressPercent",
+  "blockedReason"
+]);
+function isStateOnly(updates) {
+  const keys = Object.entries(updates).filter(([k, v]) => v !== void 0 && k !== "author" && k !== "authorType").map(([k]) => k);
+  return keys.length > 0 && keys.every((k) => ITEM_STATE_FIELDS.has(k));
+}
+const UNDER_WAY = /* @__PURE__ */ new Set(["assigned", "in-progress", "building", "pushed", "in-review"]);
+function lineOf(s) {
+  return { itemUid: s.itemUid, title: s.title, words: s.atOnce ? `${s.words}; ${s.atOnce.words}` : s.words, source: s.source, from: s.from };
+}
+function branchLineageWords(g) {
+  if (g.review && g.source !== "git") {
+    const what = g.source === "gitlab" ? `MR ${g.review.ref ?? `!${g.review.number}`}` : `PR ${g.review.ref ?? `#${g.review.number}`}`;
+    const state = g.state === "in-review" ? "open" : g.state === "merged" ? "merged" : g.state === "closed" ? "closed" : "open";
+    return `${what} (${state})`;
+  }
+  switch (g.state) {
+    case "merged":
+      return `${g.branch} merged${g.base ? ` into ${g.base}` : ""}`;
+    case "pushed":
+      return `${g.branch} pushed`;
+    case "building":
+      return `${g.branch} not pushed yet`;
+    default:
+      return `no ${g.branch} branch yet`;
+  }
+}
+function planStatusView(statuses, tickets, updatedAt) {
+  const tasks = statuses.filter((s) => s.kind === "action" && s.state !== "skipped");
+  const done = tasks.filter((s) => isFinished(s.state)).length;
+  const waiting = statuses.filter((s) => s.kind === "action" && (s.state === "blocked" || !!s.atOnce || /waiting for sign-off/.test(s.words))).map(lineOf);
+  const inProgress = statuses.filter((s) => s.kind === "action" && UNDER_WAY.has(s.state) && !waiting.some((w) => w.itemUid === s.itemUid)).map(lineOf);
+  const head = [tickets.join(", "), "this plan"].filter(Boolean).join(" \u2192 ");
+  const byBranch = /* @__PURE__ */ new Map();
+  for (const s of statuses) {
+    if (s.git && !byBranch.has(s.git.branch)) byBranch.set(s.git.branch, s.git);
+  }
+  const lineage = byBranch.size ? [...byBranch.values()].map((g) => `${head} \u2192 ${branchLineageWords(g)}`) : [head];
+  return {
+    progress: { done, total: tasks.length, words: `${done} of ${tasks.length} task${tasks.length === 1 ? "" : "s"} done` },
+    waiting,
+    inProgress,
+    lineage,
+    updatedAt
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ITEM_STATE_FIELDS,
+  atOnceWords,
+  branchLineageWords,
+  isFinished,
+  isStateOnly,
+  itemStatuses,
+  planStatusView,
+  recordCheckWords,
+  recordedWords,
+  sectionStateWords,
+  stateFromWords,
+  statusLine,
+  taskStateWords
+});

package/src/shared/lib/line-changes.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var line_changes_exports = {};
+__export(line_changes_exports, {
+  functionList: () => functionList,
+  hunkSentence: () => hunkSentence,
+  hunkWords: () => hunkWords,
+  lineCounts: () => lineCounts
+});
+module.exports = __toCommonJS(line_changes_exports);
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function span(start, lines) {
+  return lines <= 1 ? `line ${start}` : `${start}\u2013${start + lines - 1}`;
+}
+function functionList(names) {
+  if (names.length <= 2) return names.join(" and ");
+  return `${names[0]}, ${names[1]} and ${names.length - 2} more`;
+}
+function hunkWords(h) {
+  const what = h.kind === "added" ? `added ${span(h.new.start, h.new.lines)}` : h.kind === "changed" ? `changed ${span(h.new.start, h.new.lines)}` : `removed ${plural(h.old.lines, "line")} ${h.new.start === 0 ? "at the top" : `after line ${h.new.start}`}`;
+  const where = h.functions.length ? `, in ${functionList(h.functions)}` : "";
+  return `${what}${where}${h.committed ? "" : ", not committed"}`;
+}
+function hunkSentence(who, h) {
+  return `${who} ${hunkWords(h)}`;
+}
+function lineCounts(added, removed) {
+  const short = [added ? `\uFF0B${added}` : "", removed ? `\u2212${removed}` : ""].filter(Boolean).join(" ") || "\xB10";
+  const words = added && removed ? `${plural(added, "line")} added, ${removed} removed` : added ? `${plural(added, "line")} added` : removed ? `${plural(removed, "line")} removed` : "no lines changed";
+  return { short, words };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  functionList,
+  hunkSentence,
+  hunkWords,
+  lineCounts
+});

package/src/shared/lib/locator.js

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locator_exports = {};
+__export(locator_exports, {
+  TEXT_EXTS: () => TEXT_EXTS,
+  describeLocator: () => describeLocator,
+  parseCell: () => parseCell,
+  parseRange: () => parseRange,
+  toSpan: () => toSpan
+});
+module.exports = __toCommonJS(locator_exports);
+var import_xlsx_xml = require("./xlsx-xml");
+function parseCell(ref) {
+  const m = ref.replace(/\$/g, "").match(/^([A-Za-z]{1,3})(\d+)$/);
+  return m ? { col: (0, import_xlsx_xml.colNumber)(m[1]), row: Number(m[2]) } : null;
+}
+function parseRange(ref) {
+  const [a, b] = ref.split(":");
+  const from = parseCell(a ?? "");
+  const to = b === void 0 ? from : parseCell(b);
+  return from && to ? { from, to } : null;
+}
+function toSpan(value) {
+  if (typeof value === "number" && Number.isInteger(value)) return { start: value, end: value };
+  if (Array.isArray(value) && value.length === 2 && value.every((n) => Number.isInteger(n))) {
+    return { start: value[0], end: value[1] };
+  }
+  if (typeof value === "string") {
+    const m = value.trim().match(/^(\d+)(?:\s*[-–]\s*(\d+))?$/);
+    if (m) return { start: Number(m[1]), end: Number(m[2] ?? m[1]) };
+  }
+  return null;
+}
+const TEXT_EXTS = /* @__PURE__ */ new Set(["md", "txt", "json", "log", "csv", "html", "htm", "xml", "svg"]);
+function describeLocator(locator) {
+  if (!locator || typeof locator !== "object") return "";
+  const l = locator;
+  if (typeof l.range === "string") return typeof l.sheet === "string" ? `${l.sheet}!${l.range}` : String(l.range);
+  if (typeof l.sheet === "string") return l.sheet;
+  if (typeof l.page === "number") return `page ${l.page}`;
+  if (l.lines !== void 0) {
+    const v = Array.isArray(l.lines) ? `${l.lines[0]}\u2013${l.lines[1]}` : String(l.lines).replace("-", "\u2013");
+    return /[–]/.test(v) ? `lines ${v}` : `line ${v}`;
+  }
+  if (l.t !== void 0) return `at ${l.t}`;
+  if (typeof l.text === "string") return `\u201C${l.text.slice(0, 40)}${l.text.length > 40 ? "\u2026" : ""}\u201D`;
+  return "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TEXT_EXTS,
+  describeLocator,
+  parseCell,
+  parseRange,
+  toSpan
+});