codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/external-pointer-service.js

@@ -0,0 +1,195 @@
+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 __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);
+var external_pointer_service_exports = {};
+__export(external_pointer_service_exports, {
+  discoverPointers: () => discoverPointers,
+  isPointerFile: () => isPointerFile,
+  readPointer: () => readPointer,
+  removePointer: () => removePointer,
+  startPointerWatcher: () => startPointerWatcher,
+  stopPointerWatcher: () => stopPointerWatcher,
+  wasPointerJustWrittenByUs: () => wasPointerJustWrittenByUs,
+  writePointer: () => writePointer
+});
+module.exports = __toCommonJS(external_pointer_service_exports);
+var _lazy____server = __toESM(require("../server"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_yaml = require("yaml");
+var import_self_write_tracker = require("./self-write-tracker");
+function writePointer(input) {
+  const dir = import_node_path.default.join(input.projectRoot, ".codetrellis", "external");
+  ensureDir(dir);
+  const filePath = import_node_path.default.join(dir, `${input.planUid}.yaml`);
+  const pointer = {
+    planUid: input.planUid,
+    homeRepo: input.homeRepo,
+    title: input.title,
+    status: input.status,
+    summary: input.summary,
+    contribution: input.contribution,
+    cachedAt: Date.now()
+  };
+  const tmp = `${filePath}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, (0, import_yaml.stringify)(pointer), "utf-8");
+  import_node_fs.default.renameSync(tmp, filePath);
+  (0, import_self_write_tracker.stampSelfWrite)(filePath);
+  return filePath;
+}
+function removePointer(planUid, projectRoot) {
+  const filePath = import_node_path.default.join(projectRoot, ".codetrellis", "external", `${planUid}.yaml`);
+  if (!import_node_fs.default.existsSync(filePath)) return false;
+  (0, import_self_write_tracker.stampSelfWrite)(filePath);
+  try {
+    import_node_fs.default.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readPointer(planUid, projectRoot) {
+  const filePath = import_node_path.default.join(projectRoot, ".codetrellis", "external", `${planUid}.yaml`);
+  if (!import_node_fs.default.existsSync(filePath)) return null;
+  try {
+    const raw = (0, import_yaml.parse)(import_node_fs.default.readFileSync(filePath, "utf-8"));
+    return validatePointer(raw);
+  } catch {
+    return null;
+  }
+}
+function discoverPointers(projectRoot) {
+  const dir = import_node_path.default.join(projectRoot, ".codetrellis", "external");
+  if (!import_node_fs.default.existsSync(dir)) return [];
+  const out = [];
+  for (const fname of import_node_fs.default.readdirSync(dir)) {
+    if (!fname.endsWith(".yaml") && !fname.endsWith(".yml")) continue;
+    const filePath = import_node_path.default.join(dir, fname);
+    try {
+      const raw = (0, import_yaml.parse)(import_node_fs.default.readFileSync(filePath, "utf-8"));
+      const pointer = validatePointer(raw);
+      if (pointer) out.push({ filePath, pointer });
+    } catch {
+    }
+  }
+  return out;
+}
+function isPointerFile(filePath) {
+  const normalised = filePath.replace(/\\/g, "/");
+  return /\/\.codetrellis\/external\/[^/]+\.ya?ml$/.test(normalised);
+}
+function wasPointerJustWrittenByUs(filePath) {
+  return (0, import_self_write_tracker.wasJustWrittenByUs)(filePath);
+}
+const watchersByProject = /* @__PURE__ */ new Map();
+function projectKey(projectRoot) {
+  return import_node_path.default.resolve(projectRoot).replace(/[/\\]+$/, "");
+}
+function startPointerWatcher(projectRoot, onChange) {
+  const key = projectKey(projectRoot);
+  if (watchersByProject.has(key)) return;
+  const dir = import_node_path.default.join(key, ".codetrellis", "external");
+  try {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    console.warn("[ExternalPointer] Could not pre-create dir:", err);
+  }
+  const watcher = import_chokidar.default.watch(dir, {
+    ignoreInitial: true,
+    persistent: true,
+    depth: 0,
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 }
+  });
+  watcher.on("all", (event, filePath) => {
+    if (event !== "add" && event !== "change" && event !== "unlink") return;
+    if (!filePath) return;
+    if (!filePath.endsWith(".yaml") && !filePath.endsWith(".yml")) return;
+    if ((0, import_self_write_tracker.wasJustWrittenByUs)(filePath)) return;
+    try {
+      if (onChange) {
+        onChange(key, event, filePath);
+      } else {
+        const { broadcast } = _lazy____server;
+        broadcast("external-pointers-changed", {
+          projectRoot: key,
+          event,
+          filePath
+        });
+      }
+    } catch (err) {
+      console.warn("[ExternalPointer] change handler failed:", err);
+    }
+  });
+  watcher.on("error", (err) => {
+    console.warn("[ExternalPointer] Watcher error:", err);
+  });
+  watchersByProject.set(key, watcher);
+}
+async function stopPointerWatcher(projectRoot) {
+  const key = projectKey(projectRoot);
+  const watcher = watchersByProject.get(key);
+  if (!watcher) return;
+  watchersByProject.delete(key);
+  try {
+    await watcher.close();
+  } catch {
+  }
+}
+function validatePointer(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.planUid !== "string" || !r.planUid) return null;
+  if (typeof r.homeRepo !== "string" || !r.homeRepo) return null;
+  if (typeof r.title !== "string") return null;
+  if (typeof r.status !== "string") return null;
+  const cachedAt = typeof r.cachedAt === "number" ? r.cachedAt : typeof r.cachedAt === "string" ? Date.parse(r.cachedAt) : NaN;
+  if (!Number.isFinite(cachedAt)) return null;
+  return {
+    planUid: r.planUid,
+    homeRepo: r.homeRepo,
+    title: r.title,
+    status: r.status,
+    summary: typeof r.summary === "string" ? r.summary : void 0,
+    contribution: typeof r.contribution === "string" ? r.contribution : void 0,
+    cachedAt
+  };
+}
+function ensureDir(dir) {
+  if (!import_node_fs.default.existsSync(dir)) import_node_fs.default.mkdirSync(dir, { recursive: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  discoverPointers,
+  isPointerFile,
+  readPointer,
+  removePointer,
+  startPointerWatcher,
+  stopPointerWatcher,
+  wasPointerJustWrittenByUs,
+  writePointer
+});

package/src/backend/services/external-refs-service.js

@@ -0,0 +1,214 @@
+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 __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);
+var external_refs_service_exports = {};
+__export(external_refs_service_exports, {
+  createExternalRef: () => createExternalRef,
+  deleteExternalRef: () => deleteExternalRef,
+  getExternalRef: () => getExternalRef,
+  getExternalRefs: () => getExternalRefs,
+  getExternalRefsByPlan: () => getExternalRefsByPlan,
+  inferKind: () => inferKind,
+  updateExternalRef: () => updateExternalRef
+});
+module.exports = __toCommonJS(external_refs_service_exports);
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var _lazy___plan_file_service = __toESM(require("./plan-file-service"));
+const KIND_PATTERNS = [
+  { pattern: /github\.com\/[^/]+\/[^/]+\/issues\/\d+/i, kind: "github_issue" },
+  { pattern: /github\.com\/[^/]+\/[^/]+\/pull\/\d+/i, kind: "github_pr" },
+  { pattern: /github\.com\/[^/]+\/[^/]+\/commit\/[0-9a-f]+/i, kind: "github_commit" },
+  { pattern: /\.atlassian\.net\/browse\/[A-Z]+-\d+/i, kind: "jira" },
+  { pattern: /linear\.app\/[^/]+\/issue\//i, kind: "linear" },
+  { pattern: /figma\.com\/(file|design|proto)/i, kind: "figma" },
+  { pattern: /notion\.so\//i, kind: "notion" },
+  { pattern: /slack\.com\/archives\//i, kind: "slack" }
+];
+function inferKind(url) {
+  for (const { pattern, kind } of KIND_PATTERNS) {
+    if (pattern.test(url)) return kind;
+  }
+  return "url";
+}
+function titleFromUrl(url, kind) {
+  try {
+    const u = new URL(url);
+    switch (kind) {
+      case "github_issue": {
+        const m = u.pathname.match(/\/([^/]+\/[^/]+)\/issues\/(\d+)/);
+        return m ? `${m[1]}#${m[2]}` : u.hostname + u.pathname;
+      }
+      case "github_pr": {
+        const m = u.pathname.match(/\/([^/]+\/[^/]+)\/pull\/(\d+)/);
+        return m ? `${m[1]}#${m[2]}` : u.hostname + u.pathname;
+      }
+      case "github_commit": {
+        const m = u.pathname.match(/\/([^/]+\/[^/]+)\/commit\/([0-9a-f]{7})/);
+        return m ? `${m[1]}@${m[2]}` : u.hostname + u.pathname;
+      }
+      case "jira": {
+        const m = u.pathname.match(/\/browse\/([A-Z]+-\d+)/i);
+        return m ? m[1] : u.hostname + u.pathname;
+      }
+      case "linear": {
+        const m = u.pathname.match(/\/issue\/([A-Z]+-\d+)/i);
+        return m ? m[1] : u.hostname + u.pathname;
+      }
+      case "figma":
+        return "Figma \u2013 " + (u.pathname.split("/").pop() ?? "").replace(/-/g, " ").slice(0, 60);
+      case "notion":
+        return "Notion \u2013 " + (u.pathname.split("/").pop() ?? "").replace(/-/g, " ").slice(0, 60);
+      case "slack":
+        return "Slack thread";
+      default:
+        return u.hostname + (u.pathname.length > 1 ? u.pathname.slice(0, 60) : "");
+    }
+  } catch {
+    return url.slice(0, 80);
+  }
+}
+function rowToRef(row) {
+  return {
+    uid: row[0],
+    itemUid: row[1],
+    kind: row[2],
+    url: row[3],
+    title: row[4],
+    metadata: row[5] ? JSON.parse(row[5]) : null,
+    externalKey: row[6] ?? null,
+    author: row[7],
+    authorType: row[8],
+    createdAt: row[9]
+  };
+}
+function getExternalRefs(itemUid) {
+  const d = (0, import_database.getDb)();
+  const result = d.exec(
+    `SELECT uid, item_uid, kind, url, title, metadata, external_key, author, author_type, created_at
+     FROM external_refs WHERE item_uid = ? ORDER BY created_at ASC`,
+    [itemUid]
+  );
+  return (result[0]?.values ?? []).map(rowToRef);
+}
+function getExternalRef(uid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT uid, item_uid, kind, url, title, metadata, external_key, author, author_type, created_at
+     FROM external_refs WHERE uid = ?`,
+    [uid]
+  );
+  const row = result[0]?.values[0];
+  return row ? rowToRef(row) : null;
+}
+function getExternalRefsByPlan(planUid) {
+  const d = (0, import_database.getDb)();
+  const result = d.exec(
+    `SELECT r.uid, r.item_uid, r.kind, r.url, r.title, r.metadata, r.external_key, r.author, r.author_type, r.created_at
+     FROM external_refs r
+     JOIN plan_items i ON i.uid = r.item_uid
+     WHERE i.plan_uid = ?
+     ORDER BY r.created_at ASC`,
+    [planUid]
+  );
+  return (result[0]?.values ?? []).map(rowToRef);
+}
+function writeThroughFor(itemUid) {
+  try {
+    const r = (0, import_database.getDb)().exec(`SELECT plan_uid FROM plan_items WHERE uid = ?`, [itemUid])[0]?.values[0];
+    if (r) _lazy___plan_file_service.scheduleWriteThrough(r[0]);
+  } catch {
+  }
+}
+function createExternalRef(input) {
+  const d = (0, import_database.getDb)();
+  const uid = (0, import_node_crypto.randomUUID)();
+  const kind = input.kind ?? inferKind(input.url);
+  const title = input.title?.trim() || titleFromUrl(input.url, kind);
+  const now = Date.now();
+  d.run(
+    `INSERT INTO external_refs (uid, item_uid, kind, url, title, metadata, external_key, author, author_type, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      uid,
+      input.itemUid,
+      kind,
+      input.url,
+      title,
+      input.metadata ? JSON.stringify(input.metadata) : null,
+      input.externalKey ?? null,
+      input.author ?? "human",
+      input.authorType ?? "human",
+      now
+    ]
+  );
+  writeThroughFor(input.itemUid);
+  return {
+    uid,
+    itemUid: input.itemUid,
+    kind,
+    url: input.url,
+    title,
+    metadata: input.metadata ?? null,
+    author: input.author ?? "human",
+    authorType: input.authorType ?? "human",
+    createdAt: now
+  };
+}
+function updateExternalRef(uid, updates) {
+  const d = (0, import_database.getDb)();
+  const sets = [];
+  const vals = [];
+  if (updates.title !== void 0) {
+    sets.push("title = ?");
+    vals.push(updates.title);
+  }
+  if (updates.metadata !== void 0) {
+    sets.push("metadata = ?");
+    vals.push(updates.metadata ? JSON.stringify(updates.metadata) : null);
+  }
+  if (sets.length === 0) return;
+  vals.push(uid);
+  d.run(`UPDATE external_refs SET ${sets.join(", ")} WHERE uid = ?`, vals);
+  const ref = getExternalRef(uid);
+  if (ref) writeThroughFor(ref.itemUid);
+}
+function deleteExternalRef(uid) {
+  const d = (0, import_database.getDb)();
+  const ref = getExternalRef(uid);
+  d.run(`DELETE FROM external_refs WHERE uid = ?`, [uid]);
+  if (ref) writeThroughFor(ref.itemUid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExternalRef,
+  deleteExternalRef,
+  getExternalRef,
+  getExternalRefs,
+  getExternalRefsByPlan,
+  inferKind,
+  updateExternalRef
+});

package/src/backend/services/file-history.js

@@ -0,0 +1,158 @@
+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 __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);
+var file_history_exports = {};
+__export(file_history_exports, {
+  FileHistoryError: () => FileHistoryError,
+  MAX_POSITIONS: () => MAX_POSITIONS,
+  agentOfBody: () => agentOfBody,
+  fileHistory: () => fileHistory,
+  parseFileLog: () => parseFileLog
+});
+module.exports = __toCommonJS(file_history_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_path = __toESM(require("node:path"));
+var import_git_safety = require("./git-safety");
+var import_git_refs = require("./git-refs");
+var import_commit_attribution = require("./commit-attribution");
+const MAX_POSITIONS = 200;
+const SHA = /^[0-9a-f]{7,64}$/;
+class FileHistoryError extends Error {
+}
+function startOf(projectRoot, spec, workstreams) {
+  if (spec === "live" || spec === "index") return { commit: "HEAD", working: spec, name: "HEAD", checkout: projectRoot };
+  if (spec.startsWith("commit:")) {
+    const ref = spec.slice("commit:".length);
+    if (!(0, import_git_safety.isSafeGitRef)(ref)) throw new FileHistoryError(`\u201C${ref}\u201D is not a ref this app passes to git.`);
+    return { commit: ref, working: null, name: (0, import_git_refs.shortRefName)(ref), checkout: null };
+  }
+  const mb = (0, import_git_refs.parseMergeBase)(spec);
+  if (mb) {
+    const sha = (0, import_git_refs.mergeBase)(projectRoot, mb.a, mb.b);
+    if (!sha) throw new FileHistoryError(`${(0, import_git_refs.shortRefName)(mb.a)} and ${(0, import_git_refs.shortRefName)(mb.b)} share no history here.`);
+    return { commit: sha, working: null, name: sha.slice(0, 7), checkout: null };
+  }
+  if (spec.startsWith("workstream:")) {
+    const w = (0, import_git_refs.findWorkstream)(workstreams, spec.slice("workstream:".length));
+    if (!w) throw new FileHistoryError("No such worktree in this project.");
+    const head = w.head && SHA.test(w.head) ? w.head : null;
+    if (!head) throw new FileHistoryError(`${w.branch ?? import_node_path.default.basename(w.root)} has no commit yet.`);
+    return { commit: head, working: w.root.startsWith("branch:") ? null : spec, name: w.branch ?? head.slice(0, 7), checkout: w.root.startsWith("branch:") ? null : w.root };
+  }
+  throw new FileHistoryError(`Unknown side \u201C${spec}\u201D.`);
+}
+const STATUS = { A: "added", M: "modified", R: "renamed", D: "deleted", C: "copied", T: "modified" };
+function parseFileLog(out) {
+  const rows = [];
+  for (const chunk of out.split("")) {
+    const end = chunk.indexOf("");
+    if (end < 0) continue;
+    const [sha, author, email, unix, body = ""] = chunk.slice(0, end).split("");
+    if (!SHA.test(sha ?? "")) continue;
+    const change = chunk.slice(end + 1).split("\n").map((l) => l.trim()).find(Boolean) ?? "";
+    const parts = change.split("	");
+    const letter = (parts[0] ?? "").charAt(0);
+    const renamed = letter === "R" || letter === "C";
+    rows.push({
+      sha,
+      short: sha.slice(0, 7),
+      at: Number(unix) * 1e3,
+      author: author || null,
+      email: email || null,
+      subject: body.split("\n")[0]?.trim() || null,
+      body,
+      status: STATUS[letter] ?? null,
+      path: (renamed ? parts[2] : parts[1]) ?? "",
+      ...renamed && parts[1] ? { from: parts[1] } : {}
+    });
+  }
+  return rows;
+}
+function agentOfBody(body) {
+  return (0, import_commit_attribution.agentFromMessage)(body)?.agent ?? null;
+}
+function fileHistory(projectRoot, spec, relativePath, workstreams, know = import_commit_attribution.NO_KNOWLEDGE) {
+  const start = startOf(projectRoot, spec, workstreams);
+  let out;
+  try {
+    out = (0, import_node_child_process.execFileSync)("git", [
+      "log",
+      "--follow",
+      "-M",
+      "--relative",
+      `-n${MAX_POSITIONS + 1}`,
+      "--format=%x1e%H%x1f%an%x1f%ae%x1f%at%x1f%B%x1d",
+      "--name-status",
+      start.commit,
+      "--",
+      relativePath
+    ], { cwd: projectRoot, encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    throw new FileHistoryError("git could not read this file's history here.");
+  }
+  const rows = parseFileLog(out);
+  const truncated = rows.length > MAX_POSITIONS;
+  const kept = rows.slice(0, MAX_POSITIONS);
+  const attributed = (0, import_commit_attribution.attributeCommits)(kept.map((r) => ({ sha: r.sha, at: r.at, body: r.body })), start.checkout, know);
+  const positions = [];
+  if (start.working) {
+    positions.push({
+      spec: start.working,
+      kind: "working",
+      path: relativePath,
+      sha: null,
+      short: null,
+      at: null,
+      author: null,
+      email: null,
+      subject: null,
+      status: null,
+      attribution: null
+    });
+  }
+  for (const r of kept) {
+    const { body: _body, ...row } = r;
+    const attribution = attributed.get(r.sha) ?? null;
+    positions.push({ ...row, spec: `commit:${r.sha}`, kind: "commit", attribution });
+  }
+  return {
+    at: spec,
+    label: (0, import_git_refs.sideLabel)(projectRoot, spec, workstreams),
+    path: relativePath,
+    positions,
+    truncated,
+    command: `git log --follow ${start.name === "HEAD" ? "" : `${start.name} `}-- ${relativePath}`.replace("  ", " ")
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileHistoryError,
+  MAX_POSITIONS,
+  agentOfBody,
+  fileHistory,
+  parseFileLog
+});