codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/workstream-symbols.js

@@ -0,0 +1,223 @@
+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 workstream_symbols_exports = {};
+__export(workstream_symbols_exports, {
+  MAX_PARSED_FILES: () => MAX_PARSED_FILES,
+  MAX_PARSE_BYTES: () => MAX_PARSE_BYTES,
+  baseContent: () => baseContent,
+  clearSymbolCache: () => clearSymbolCache,
+  currentContent: () => currentContent,
+  diffSymbols: () => diffSymbols,
+  fileSymbolChanges: () => fileSymbolChanges,
+  flatSymbols: () => flatSymbols,
+  isExported: () => isExported,
+  pythonAll: () => pythonAll,
+  uncachedSymbolFiles: () => uncachedSymbolFiles,
+  withSymbolChanges: () => withSymbolChanges
+});
+module.exports = __toCommonJS(workstream_symbols_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_confined_fs = require("./confined-fs");
+var import_git_safety = require("./git-safety");
+var import_git_env = require("./git-env");
+const MAX_PARSE_BYTES = 1e6;
+const MAX_PARSED_FILES = 200;
+function pythonAll(source) {
+  const out = /* @__PURE__ */ new Set();
+  const decl = /^__all__\s*(?::[^=\n]*)?(?:\+)?=\s*[[(]([^\])]*)[\])]/gm;
+  for (const m of source.matchAll(decl)) {
+    for (const lit of m[1].matchAll(/(['"])([A-Za-z_][A-Za-z0-9_]*)\1/g)) out.add(lit[2]);
+  }
+  return out;
+}
+function isExported(filePath, s, pyAll) {
+  if (/\.py$/.test(filePath)) return !s.name.startsWith("_") || (pyAll?.has(s.name) ?? false);
+  if (/\.[cm]?[jt]sx?$/.test(filePath)) return s.modifiers.includes("export");
+  if (/\.go$/.test(filePath)) return s.modifiers.includes("exported");
+  if (/\.rs$/.test(filePath)) return s.modifiers.includes("pub");
+  if (/\.(rb|php)$/.test(filePath)) return true;
+  if (/\.cs$/.test(filePath) && s.name.includes(".")) return CSHARP_VISIBLE.some((m) => s.modifiers.includes(m));
+  if (/\.(java|cs|kts?|swift)$/.test(filePath)) return !isPrivate(s);
+  return void 0;
+}
+const CSHARP_VISIBLE = ["public", "internal", "protected"];
+const isPrivate = (s) => s.modifiers.includes("private") || s.modifiers.includes("fileprivate");
+function memberExported(filePath, s, typeExported) {
+  if (!typeExported) return typeExported;
+  if (/\.cs$/.test(filePath)) return CSHARP_VISIBLE.some((m) => s.modifiers.includes(m));
+  if (/\.(java|kts?|swift|php)$/.test(filePath)) return !isPrivate(s);
+  return typeExported;
+}
+const QUALIFIED = /[.#)]/;
+function flatSymbols(symbols, source, filePath = "") {
+  const lines = source.split("\n");
+  const pyAll = /\.py$/.test(filePath) ? pythonAll(source) : null;
+  const all = [];
+  const visit = (list, parent, exported) => {
+    for (const s of list) {
+      const name = parent && !QUALIFIED.test(s.name) ? `${parent}.${s.name}` : s.name;
+      const mine = parent === null ? isExported(filePath, s, pyAll) : memberExported(filePath, s, exported);
+      all.push({ name, kind: s.kind, start: s.startLine, end: s.endLine, signature: s.signature, exported: mine });
+      if (s.children.length) visit(s.children, name, mine);
+    }
+  };
+  visit(symbols, null, void 0);
+  return all.map((s) => {
+    const inner = all.filter((o) => o !== s && o.start >= s.start && o.end <= s.end && (o.start > s.start || o.end < s.end));
+    const own = [];
+    for (let n = s.start; n <= s.end; n++) {
+      if (inner.some((o) => n >= o.start && n <= o.end)) continue;
+      own.push((lines[n - 1] ?? "").trimEnd());
+    }
+    return {
+      name: s.name,
+      kind: s.kind,
+      line: s.start,
+      body: (0, import_node_crypto.createHash)("sha1").update(own.join("\n")).digest("hex"),
+      ...s.signature ? { signature: s.signature } : {},
+      ...s.exported ? { exported: true } : {}
+    };
+  });
+}
+const exportedOf = (...versions) => versions.some((v) => v.exported) ? { exported: true } : {};
+function diffSymbols(before, after) {
+  const key = (s) => `${s.kind}\0${s.name}`;
+  const old = new Map((before ?? []).map((s) => [key(s), s]));
+  const now = new Map((after ?? []).map((s) => [key(s), s]));
+  const changes = [];
+  for (const [k, s] of now) {
+    const was = old.get(k);
+    if (!was) changes.push({ name: s.name, kind: s.kind, change: "added", line: s.line, ...exportedOf(s) });
+    else if (was.body !== s.body) {
+      const signature = was.signature && s.signature ? was.signature !== s.signature ? { signature: { before: was.signature, after: s.signature } } : {} : { signatureUnknown: true };
+      changes.push({ name: s.name, kind: s.kind, change: "modified", line: s.line, ...signature, ...exportedOf(was, s) });
+    }
+  }
+  for (const [k, s] of old) {
+    if (!now.has(k)) changes.push({ name: s.name, kind: s.kind, change: "removed", line: s.line, ...exportedOf(s) });
+  }
+  return changes.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name));
+}
+const SHA = /^[0-9a-f]{40}$/;
+async function baseContent(folder, base, relPath) {
+  if (!SHA.test(base)) return null;
+  (0, import_git_safety.assertSafeGitPathArg)(relPath, "workstream base file");
+  try {
+    return await (0, import_git_env.gitAsync)(folder, ["show", `${base}:${relPath}`], { maxBuffer: MAX_PARSE_BYTES * 2 });
+  } catch {
+    return null;
+  }
+}
+function currentContent(folder, relPath) {
+  try {
+    const abs = import_node_path.default.join(folder, relPath);
+    if (import_node_fs.default.statSync(abs).size > MAX_PARSE_BYTES) return null;
+    return (0, import_confined_fs.readTextWithin)(folder, relPath, "workstream file");
+  } catch {
+    return null;
+  }
+}
+async function fileSymbolChanges(folder, base, file, parse, readCurrent = (rel) => currentContent(folder, rel)) {
+  const abs = import_node_path.default.join(folder, file.path);
+  const after = file.status === "deleted" ? null : await readCurrent(file.path);
+  const beforePath = file.status === "renamed" && file.from ? file.from : file.path;
+  const before = file.status === "added" || !base ? null : await baseContent(folder, base, beforePath);
+  if (after === null && before === null) return void 0;
+  const afterSyms = after === null ? null : parse(abs, after);
+  const beforeSyms = before === null ? null : parse(import_node_path.default.join(folder, beforePath), before);
+  if (afterSyms === null && beforeSyms === null) return void 0;
+  return diffSymbols(
+    beforeSyms && before !== null ? flatSymbols(beforeSyms, before, beforePath) : null,
+    afterSyms && after !== null ? flatSymbols(afterSyms, after, file.path) : null
+  );
+}
+const MAX_CACHED = 5e3;
+const cache = /* @__PURE__ */ new Map();
+function stampOf(folder, base, file) {
+  let st = "gone";
+  try {
+    const s = import_node_fs.default.statSync(import_node_path.default.join(folder, file.path));
+    st = `${s.size}:${s.mtimeMs}:${s.ctimeMs}`;
+  } catch {
+  }
+  return `${base}|${file.status}|${file.from ?? ""}|${st}`;
+}
+async function withSymbolChanges(folder, changes, parse, atCommit) {
+  const files = [];
+  for (const [i, f] of changes.files.entries()) files.push(await symbolsFor(i, f));
+  return { ...changes, files };
+  async function symbolsFor(i, f) {
+    if (i >= MAX_PARSED_FILES) return f;
+    const k = `${folder}\0${atCommit ? `@${atCommit.head}` : ""}\0${f.path}`;
+    const stamp = atCommit ? `${changes.base}|${atCommit.head}|${f.status}|${f.from ?? ""}` : stampOf(folder, changes.base, f);
+    let hit = cache.get(k);
+    if (!hit || hit.stamp !== stamp) {
+      let symbols;
+      try {
+        symbols = await fileSymbolChanges(folder, changes.base, f, parse, atCommit?.read);
+      } catch {
+        symbols = void 0;
+      }
+      hit = { stamp, symbols };
+      if (cache.size > MAX_CACHED) cache.clear();
+      cache.set(k, hit);
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+    return hit.symbols === void 0 ? f : { ...f, symbols: hit.symbols };
+  }
+}
+function uncachedSymbolFiles(folder, changes, atCommit) {
+  let n = 0;
+  for (const [i, f] of changes.files.entries()) {
+    if (i >= MAX_PARSED_FILES) break;
+    const k = `${folder}\0${atCommit ? `@${atCommit.head}` : ""}\0${f.path}`;
+    const stamp = atCommit ? `${changes.base}|${atCommit.head}|${f.status}|${f.from ?? ""}` : stampOf(folder, changes.base, f);
+    if (cache.get(k)?.stamp !== stamp) n++;
+  }
+  return n;
+}
+function clearSymbolCache() {
+  cache.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_PARSED_FILES,
+  MAX_PARSE_BYTES,
+  baseContent,
+  clearSymbolCache,
+  currentContent,
+  diffSymbols,
+  fileSymbolChanges,
+  flatSymbols,
+  isExported,
+  pythonAll,
+  uncachedSymbolFiles,
+  withSymbolChanges
+});

package/src/backend/services/workstream-watch-service.js

@@ -0,0 +1,391 @@
+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 workstream_watch_service_exports = {};
+__export(workstream_watch_service_exports, {
+  MAX_CHANGED_FILES: () => MAX_CHANGED_FILES,
+  combineChanges: () => combineChanges,
+  computeChanges: () => computeChanges,
+  countStatusEntries: () => countStatusEntries,
+  getChanges: () => getChanges,
+  isWatchedFolder: () => isWatchedFolder,
+  nudgeWorkstream: () => nudgeWorkstream,
+  parseNameStatusZ: () => parseNameStatusZ,
+  parseNumstatZ: () => parseNumstatZ,
+  setExternallyWatchedFolder: () => setExternallyWatchedFolder,
+  setRefsChangedListener: () => setRefsChangedListener,
+  setWorkstreamChangesListener: () => setWorkstreamChangesListener,
+  setWorkstreamWatchStartedListener: () => setWorkstreamWatchStartedListener,
+  stopWorkstreamWatchers: () => stopWorkstreamWatchers,
+  syncWorkstreamWatchers: () => syncWorkstreamWatchers,
+  watchRefs: () => watchRefs,
+  watchedWorkstreamFolders: () => watchedWorkstreamFolders,
+  withLineCounts: () => withLineCounts
+});
+module.exports = __toCommonJS(workstream_watch_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_git_safety = require("./git-safety");
+var import_git_env = require("./git-env");
+var import_watch_ignore = require("./watch-ignore");
+var import_tree_watcher = require("./tree-watcher");
+const MAX_CHANGED_FILES = 500;
+const debounceMs = () => Number(process.env.CODETRELLIS_WORKSTREAM_DEBOUNCE_MS) || 750;
+const UNWATCHED_TTL_MS = 2e4;
+const git = (folder, args) => (0, import_git_env.gitAsync)(folder, args);
+const STATUS = { A: "added", M: "modified", D: "deleted", T: "modified", R: "renamed", C: "added" };
+function parseNameStatusZ(out) {
+  const fields = out.split("\0");
+  const files = [];
+  for (let i = 0; i < fields.length; ) {
+    const code = fields[i++];
+    if (!code) continue;
+    const kind = STATUS[code[0]];
+    if (code[0] === "R" || code[0] === "C") {
+      const from = fields[i++];
+      const to = fields[i++];
+      if (!to) break;
+      files.push(code[0] === "R" ? { path: to, status: "renamed", from } : { path: to, status: "added" });
+    } else {
+      const p = fields[i++];
+      if (!p || !kind) continue;
+      files.push({ path: p, status: kind });
+    }
+  }
+  return files;
+}
+function parseNumstatZ(out) {
+  const counts = /* @__PURE__ */ new Map();
+  const fields = out.split("\0");
+  for (let i = 0; i < fields.length; i++) {
+    const m = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(fields[i]);
+    if (!m) continue;
+    let p = m[3];
+    if (p === "") {
+      p = fields[i + 2] ?? "";
+      i += 2;
+    }
+    if (p && m[1] !== "-" && m[2] !== "-") counts.set(p, { added: Number(m[1]), removed: Number(m[2]) });
+  }
+  return counts;
+}
+function withLineCounts(files, counts) {
+  return files.map((f) => {
+    const c = counts.get(f.path);
+    return c ? { ...f, added: c.added, removed: c.removed } : f;
+  });
+}
+function combineChanges(tracked, untracked, max = MAX_CHANGED_FILES) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const f of tracked) byPath.set(f.path, f);
+  for (const p of untracked) if (p && !byPath.has(p)) byPath.set(p, { path: p, status: "added" });
+  const all = [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+  return { files: all.slice(0, max), truncated: all.length > max };
+}
+async function computeChanges(folder, mainRef) {
+  await (0, import_git_env.refreshIndexOccasionallyAsync)(folder);
+  let base = null;
+  try {
+    const ref = mainRef && (0, import_git_safety.isSafeGitRef)(mainRef) ? mainRef : "HEAD";
+    base = (await git(folder, ["merge-base", "HEAD", ref])).trim() || null;
+  } catch {
+    try {
+      base = (await git(folder, ["rev-parse", "--verify", "HEAD"])).trim() || null;
+    } catch {
+      base = null;
+    }
+  }
+  let tracked = [];
+  if (base) {
+    try {
+      tracked = parseNameStatusZ(await git(folder, ["diff", "--name-status", "-z", "-M", base, "--"]));
+      tracked = withLineCounts(tracked, parseNumstatZ(await git(folder, ["diff", "--numstat", "-z", "-M", base, "--"])));
+    } catch {
+    }
+  }
+  let untracked = [];
+  try {
+    untracked = (await git(folder, ["ls-files", "--others", "--exclude-standard", "-z"])).split("\0");
+  } catch {
+  }
+  return { base, ...combineChanges(tracked, untracked), ...await distanceFromMain(folder, mainRef) };
+}
+function countStatusEntries(out) {
+  const parts = out.split("\0");
+  let n = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4 || entry[2] !== " ") continue;
+    n += 1;
+    if (entry[0] === "R" || entry[0] === "C") i += 1;
+  }
+  return n;
+}
+async function distanceFromMain(folder, mainRef) {
+  const out = {};
+  if (mainRef && (0, import_git_safety.isSafeGitRef)(mainRef)) {
+    try {
+      const [behind, ahead] = (await git(folder, ["rev-list", "--left-right", "--count", `${mainRef}...HEAD`])).trim().split(/\s+/).map(Number);
+      if (Number.isFinite(ahead) && Number.isFinite(behind)) {
+        out.ahead = ahead;
+        out.behind = behind;
+      }
+    } catch {
+    }
+  }
+  try {
+    out.uncommitted = countStatusEntries(await git(folder, ["status", "--porcelain", "-z"]));
+  } catch {
+  }
+  return out;
+}
+const entries = /* @__PURE__ */ new Map();
+const canonical = (p) => {
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return import_node_path.default.resolve(p);
+  }
+};
+let externallyWatched = null;
+function setExternallyWatchedFolder(folder) {
+  externallyWatched = folder ? canonical(folder) : null;
+}
+const isExternal = (folder) => externallyWatched !== null && canonical(folder) === externallyWatched;
+function nudgeWorkstream(folder) {
+  const target = canonical(folder);
+  for (const [f, entry] of entries) {
+    if (canonical(f) === target) schedule(f, entry);
+  }
+}
+function schedule(folder, entry, why = "event") {
+  if (entry.timer) clearTimeout(entry.timer);
+  if (why === "event") entry.pendingEvent = true;
+  entry.timer = setTimeout(() => {
+    entry.timer = null;
+    const event = entry.pendingEvent === true;
+    entry.pendingEvent = false;
+    void (0, import_git_env.inBackground)(() => recompute(folder, entry, event));
+  }, debounceMs());
+}
+let onChanged = () => {
+};
+function setWorkstreamChangesListener(listener) {
+  onChanged = listener;
+}
+const sameChanges = (a, b) => a.base === b.base && a.truncated === b.truncated && a.files.length === b.files.length && a.files.every((f, i) => f.path === b.files[i].path && f.status === b.files[i].status && f.from === b.files[i].from);
+function recompute(folder, entry, fileEvent = false) {
+  if (entry.running) {
+    entry.again = { fileEvent: fileEvent || (entry.again?.fileEvent ?? false) };
+    return entry.running;
+  }
+  const run = (async () => {
+    try {
+      let event = fileEvent;
+      for (; ; ) {
+        const next = await computeChanges(folder, entry.mainRef);
+        const changed = event || !sameChanges(entry.changes, next);
+        entry.changes = next;
+        entry.computedAt = Date.now();
+        if (changed) onChanged(folder, next);
+        if (!entry.again) break;
+        event = entry.again.fileEvent;
+        entry.again = null;
+      }
+    } catch {
+    } finally {
+      entry.running = null;
+    }
+  })();
+  entry.running = run;
+  return run;
+}
+async function getChanges(folder, mainRef, opts = {}) {
+  let entry = entries.get(folder);
+  if (entry?.first) await entry.first;
+  const live = entry?.watcher || isExternal(folder);
+  if (entry && entry.mainRef === mainRef && (live || !opts.fresh && Date.now() - entry.computedAt < UNWATCHED_TTL_MS)) {
+    return entry.changes;
+  }
+  if (!entry) {
+    entry = { mainRef, changes: { base: null, files: [], truncated: false }, computedAt: 0, watcher: null, timer: null };
+    entries.set(folder, entry);
+  }
+  if (!opts.fresh && entry.computing && entry.mainRef === mainRef) return entry.computing;
+  entry.mainRef = mainRef;
+  const target = entry;
+  const startedAt = Date.now();
+  const computing = computeChanges(folder, mainRef);
+  target.computing = computing;
+  try {
+    const changes = await computing;
+    if (target.mainRef === mainRef && target.computedAt <= startedAt) {
+      target.changes = changes;
+      target.computedAt = Date.now();
+    }
+    return changes;
+  } finally {
+    if (target.computing === computing) target.computing = null;
+  }
+}
+let onWatchStarted = () => {
+};
+function setWorkstreamWatchStartedListener(listener) {
+  onWatchStarted = listener;
+}
+function watch(folder, entry) {
+  const watcher = (0, import_tree_watcher.watchTree)(folder, {
+    ...(0, import_watch_ignore.checkoutWatchOptions)(folder),
+    ignoreInitial: true,
+    persistent: true
+  });
+  watcher.on("all", () => schedule(folder, entry));
+  watcher.on("ready", () => {
+    schedule(folder, entry, "check");
+    onWatchStarted(folder);
+  });
+  watcher.on("error", () => {
+  });
+  entry.watcher = watcher;
+}
+async function unwatch(folder, entry) {
+  if (entry.timer) clearTimeout(entry.timer);
+  entry.timer = null;
+  const w = entry.watcher;
+  entry.watcher = null;
+  if (w) await w.close().catch(() => {
+  });
+}
+async function syncWorkstreamWatchers(folders, scope = folders.map((f) => f.folder)) {
+  const wanted = new Map(folders.map((f) => [f.folder, f.mainRef]));
+  const inScope = new Set(scope);
+  for (const [folder, entry] of entries) {
+    if (entry.watcher && inScope.has(folder) && !wanted.has(folder)) await unwatch(folder, entry);
+  }
+  for (const [folder, mainRef] of wanted) {
+    const entry = entries.get(folder);
+    if (!entry) {
+      const created = { mainRef, changes: { base: null, files: [], truncated: false }, computedAt: 0, watcher: null, timer: null };
+      entries.set(folder, created);
+      if (!isExternal(folder)) watch(folder, created);
+      const startedAt = Date.now();
+      created.first = computeChanges(folder, mainRef);
+      try {
+        const changes = await created.first;
+        if (created.computedAt <= startedAt) {
+          created.changes = changes;
+          created.computedAt = Date.now();
+        }
+      } finally {
+        created.first = null;
+      }
+      continue;
+    }
+    if (entry.mainRef !== mainRef) {
+      entry.mainRef = mainRef;
+      void recompute(folder, entry);
+    }
+    if (!entry.watcher && !isExternal(folder)) watch(folder, entry);
+  }
+}
+const refWatchers = /* @__PURE__ */ new Map();
+const commonDirOf = /* @__PURE__ */ new Map();
+let onRefsChanged = () => {
+};
+function setRefsChangedListener(listener) {
+  onRefsChanged = listener;
+}
+async function watchRefs(repo) {
+  let common = commonDirOf.get(repo);
+  if (!common) {
+    try {
+      common = canonical(import_node_path.default.resolve(repo, (await git(repo, ["rev-parse", "--git-common-dir"])).trim()));
+    } catch {
+      return;
+    }
+    commonDirOf.set(repo, common);
+  }
+  if (refWatchers.has(common)) return;
+  const targets = ["refs/heads", "refs/remotes", "packed-refs"].map((p) => import_node_path.default.join(common, p)).filter((p) => import_node_fs.default.existsSync(p));
+  const watcher = import_chokidar.default.watch(targets, { ignoreInitial: true, persistent: true });
+  const state = { watcher, timer: null };
+  watcher.on("all", () => {
+    if (state.timer) clearTimeout(state.timer);
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      onRefsChanged(repo);
+    }, debounceMs());
+  });
+  watcher.on("error", () => {
+  });
+  refWatchers.set(common, state);
+}
+function isWatchedFolder(folder) {
+  if (isExternal(folder)) return true;
+  const target = canonical(folder);
+  for (const [f, entry] of entries) {
+    if (entry.watcher && canonical(f) === target) return true;
+  }
+  return false;
+}
+function watchedWorkstreamFolders() {
+  return [...entries].filter(([, e]) => e.watcher).map(([f]) => f).sort();
+}
+async function stopWorkstreamWatchers() {
+  for (const [folder, entry] of entries) await unwatch(folder, entry);
+  entries.clear();
+  for (const { watcher, timer } of refWatchers.values()) {
+    if (timer) clearTimeout(timer);
+    await watcher.close().catch(() => {
+    });
+  }
+  refWatchers.clear();
+  commonDirOf.clear();
+  externallyWatched = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_CHANGED_FILES,
+  combineChanges,
+  computeChanges,
+  countStatusEntries,
+  getChanges,
+  isWatchedFolder,
+  nudgeWorkstream,
+  parseNameStatusZ,
+  parseNumstatZ,
+  setExternallyWatchedFolder,
+  setRefsChangedListener,
+  setWorkstreamChangesListener,
+  setWorkstreamWatchStartedListener,
+  stopWorkstreamWatchers,
+  syncWorkstreamWatchers,
+  watchRefs,
+  watchedWorkstreamFolders,
+  withLineCounts
+});