codetrellis 0.0.0-stage → 0.2.0

package/src/shared/lib/agent-turns.js

@@ -0,0 +1,140 @@
+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 agent_turns_exports = {};
+__export(agent_turns_exports, {
+  TURN_GAP_MS: () => import_turn_gap.TURN_GAP_MS,
+  formatDuration: () => formatDuration,
+  formatRelative: () => formatRelative,
+  groupIntoTurns: () => groupIntoTurns
+});
+module.exports = __toCommonJS(agent_turns_exports);
+var import_tool_phrasing = require("./tool-phrasing");
+var import_turn_gap = require("./turn-gap");
+function sessionOf(event) {
+  const s = event.payload?.sessionId;
+  return typeof s === "string" ? s : null;
+}
+function stringField(event, key) {
+  const v = event.payload?.[key];
+  return typeof v === "string" ? v : null;
+}
+function fileOf(event) {
+  const f = event.payload?.file ?? event.payload?.path ?? event.payload?.relativePath;
+  if (typeof f !== "string" || !f) return null;
+  return f.split("/").pop() ?? null;
+}
+function groupIntoTurns(events, gapMs = import_turn_gap.TURN_GAP_MS, vocabulary = "code") {
+  if (events.length === 0) return [];
+  const sorted = [...events].sort((a, b) => a.timestamp - b.timestamp);
+  const openBySession = /* @__PURE__ */ new Map();
+  const turns = [];
+  for (const event of sorted) {
+    const sessionId = sessionOf(event);
+    const key = sessionId ?? `__no_session__:${stringField(event, "workstreamRoot") ?? ""}`;
+    const open = openBySession.get(key);
+    if (open && event.timestamp - open.endedAt <= gapMs) {
+      open.events.push(event);
+      open.endedAt = event.timestamp;
+      open.durationMs = open.endedAt - open.startedAt;
+      continue;
+    }
+    const turn = {
+      id: event.id,
+      sessionId,
+      agentType: stringField(event, "agentType"),
+      agentModel: stringField(event, "agentModel"),
+      startedAt: event.timestamp,
+      endedAt: event.timestamp,
+      durationMs: 0,
+      events: [event],
+      summary: "",
+      mutating: false,
+      hasError: false,
+      files: []
+    };
+    openBySession.set(key, turn);
+    turns.push(turn);
+  }
+  for (const turn of turns) finalise(turn, vocabulary);
+  return turns;
+}
+function finalise(turn, vocabulary) {
+  const phrased = turn.events.map((e) => ({ event: e, phrased: (0, import_tool_phrasing.phraseEvent)(e, vocabulary) }));
+  turn.hasError = phrased.some((p) => p.phrased.intent === "error");
+  turn.mutating = phrased.some((p) => p.phrased.mutating);
+  const files = [];
+  for (const { event } of phrased) {
+    const f = fileOf(event);
+    if (f && !files.includes(f)) files.push(f);
+  }
+  turn.files = files;
+  if (!turn.agentType) {
+    turn.agentType = phrased.map((p) => stringField(p.event, "agentType")).find((v) => v) ?? null;
+  }
+  if (!turn.agentModel) {
+    turn.agentModel = phrased.map((p) => stringField(p.event, "agentModel")).find((v) => v) ?? null;
+  }
+  turn.summary = summarise(turn, phrased.map((p) => p.phrased));
+}
+function summarise(turn, phrased) {
+  const count = turn.events.length;
+  const suffix = count > 1 ? ` \xB7 ${count} calls` : "";
+  const error = phrased.find((p) => p.intent === "error");
+  if (error) return `${error.text}${suffix}`;
+  const ask = phrased.find((p) => p.intent === "ask");
+  if (ask) return `${ask.text}${suffix}`;
+  const mutations = phrased.filter((p) => p.mutating);
+  if (mutations.length > 0) {
+    const headline = mutations[mutations.length - 1].text;
+    const others = mutations.length > 1 ? ` (+${mutations.length - 1} more)` : "";
+    return `${headline}${others}${suffix}`;
+  }
+  const session = phrased.find((p) => p.intent === "session");
+  if (session && count === 1) return session.text;
+  const reads = phrased.filter((p) => p.intent === "read");
+  if (reads.length > 0) {
+    return reads.length === 1 ? reads[0].text : `${reads[0].text}${suffix}`;
+  }
+  return phrased[0]?.text ?? `${count} events`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return "\u2014";
+  const totalSeconds = Math.round(ms / 1e3);
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}
+function formatRelative(timestamp, now = Date.now()) {
+  const delta = Math.max(0, now - timestamp);
+  const seconds = Math.round(delta / 1e3);
+  if (seconds < 45) return "just now";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const days = Math.round(hours / 24);
+  return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TURN_GAP_MS,
+  formatDuration,
+  formatRelative,
+  groupIntoTurns
+});

package/src/shared/lib/awareness-digest.js

@@ -0,0 +1,120 @@
+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 awareness_digest_exports = {};
+__export(awareness_digest_exports, {
+  DIGEST_MAX_LINES: () => DIGEST_MAX_LINES,
+  buildDigest: () => buildDigest,
+  digestText: () => digestText
+});
+module.exports = __toCommonJS(awareness_digest_exports);
+const DIGEST_MAX_LINES = 5;
+const RANK = { high: 0, medium: 1, low: 2 };
+const QUESTION = {
+  collision: "who goes first, or is it intended?",
+  contract: "keep the old signature, or update the callers?",
+  drift: "is the wider scope meant?",
+  "stale-base": "rebase now, or later?",
+  "version-split": "which version should both use?",
+  "state-split": "which state is right?",
+  rule: "route it through what the rule allows, or change the rule?"
+};
+const MATERIAL_QUESTION = {
+  contract: "check the cited parts again, or keep the old version?",
+  collision: "which task writes it?",
+  drift: "is the file meant to be shared?",
+  "stale-base": "read it again, or keep the old version?"
+};
+const listed = (names, max = 2) => names.length <= max ? names.join(", ") : `${names.slice(0, max).join(", ")} and ${names.length - max} more`;
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function subjectOf(s) {
+  if (s.subject.file && s.subject.symbol) return `${s.subject.file} \u2192 ${s.subject.symbol}`;
+  return s.subject.file ?? (s.subject.files ?? []).join(", ");
+}
+function lineText(kind, group, label) {
+  const first = group[0];
+  if (first.subject.material) return first.summary;
+  const names = (roots) => roots.map((r) => `\`${label(r)}\``);
+  if (kind === "contract") {
+    const by = first.subject.by ?? first.workstreams[0];
+    const others = names(first.workstreams.filter((w) => w !== by)).join(" and ");
+    const symbols = [...new Set(group.map((s) => s.subject.symbol ?? "?"))];
+    const removed = group.every((s) => s.subject.change === "removed");
+    if (group.length === 1) {
+      return removed ? `\`${label(by)}\` removed ${symbols[0]}; ${others} imports it` : `\`${label(by)}\` changed ${symbols[0]}'s signature; ${others} imports it`;
+    }
+    return `\`${label(by)}\` changed ${plural(symbols.length, "exported name")} ${others} imports: ${listed(symbols)}`;
+  }
+  if (kind === "drift") {
+    const files = [...new Set(group.flatMap((s) => s.subject.files ?? []))];
+    const rules = [...new Set(group.flatMap((s) => (s.subject.rules ?? []).map((r) => r.id)))];
+    return `${names(first.workstreams)[0]} changes ${plural(files.length, "file")} outside its scope: ${listed(files)}${rules.length ? `, where ${rules.length === 1 ? "the rule" : "the rules"} ${rules.length <= 2 ? rules.join(" and ") : listed(rules)} ${rules.length === 1 ? "applies" : "apply"}` : ""}`;
+  }
+  if (kind === "rule") {
+    const rules = [...new Set(group.map((s) => s.subject.rule?.words ?? "?"))];
+    const edges = group.flatMap((s) => (s.subject.edges ?? []).map((e) => `${e.from} \u2192 ${e.to}`));
+    return `${names(first.workstreams)[0]} now imports across ${rules.length === 1 ? `the rule \u201C${rules[0]}\u201D` : plural(rules.length, "rule")}: ${listed(edges)}`;
+  }
+  const pair = names(first.workstreams).join(" and ");
+  if (group.length === 1) {
+    const declared = first.subject.intended?.length ? " (declared, not yet edited)" : "";
+    return `${pair} both change ${subjectOf(first)}${declared}`;
+  }
+  return `${pair} both change ${plural(group.length, "thing")}: ${listed(group.map(subjectOf))}`;
+}
+function buildDigest(signals, label, opts = {}) {
+  const live = signals.filter((s) => s.state !== "resolved");
+  const needs = live.filter((s) => s.state === "open" && s.severity !== "low");
+  const low = live.filter((s) => s.state === "open" && s.severity === "low").length;
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of needs) {
+    const key = s.subject.material ? `material\0${s.id}` : `${s.kind}\0${s.kind === "contract" ? `${s.subject.by ?? ""}\0` : ""}${[...s.workstreams].sort().join("\0")}`;
+    groups.set(key, [...groups.get(key) ?? [], s]);
+  }
+  const ordered = [...groups.values()].map((g) => g.sort((a, b) => RANK[a.severity] - RANK[b.severity] || b.lastSeen - a.lastSeen)).sort((a, b) => RANK[a[0].severity] - RANK[b[0].severity] || b[0].lastSeen - a[0].lastSeen);
+  const max = opts.maxLines ?? DIGEST_MAX_LINES;
+  const lines = ordered.slice(0, max).map((g) => ({
+    kind: g[0].kind,
+    severity: g[0].severity,
+    signalIds: g.map((s) => s.id),
+    text: lineText(g[0].kind, g, label),
+    told: g.every((s) => (s.told ?? []).some((t) => t.toldAt !== null)),
+    question: (g[0].subject.material ? MATERIAL_QUESTION[g[0].kind] : void 0) ?? QUESTION[g[0].kind]
+  }));
+  return {
+    needsYou: needs.length,
+    lines,
+    moreLines: Math.max(0, ordered.length - max),
+    low,
+    newSince: opts.since == null ? null : needs.filter((s) => s.firstSeen > opts.since).length
+  };
+}
+function digestText(d) {
+  if (d.needsYou === 0) {
+    return d.low ? `Nothing needs attention; ${plural(d.low, "low-priority note")}.` : "Nothing overlaps with other work right now.";
+  }
+  const lines = d.lines.map((l) => `${l.text}.${l.told ? " Agents told." : ""} Waiting on the person: ${l.question}`);
+  if (d.moreLines) lines.push(`And ${plural(d.moreLines, "more overlap")}.`);
+  if (d.low) lines.push(`${plural(d.low, "low-priority note")}.`);
+  return `${plural(d.needsYou, "signal")} ${d.needsYou === 1 ? "needs" : "need"} attention. ${lines.join(" ")}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DIGEST_MAX_LINES,
+  buildDigest,
+  digestText
+});

package/src/shared/lib/branch-name.js

@@ -0,0 +1,45 @@
+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 branch_name_exports = {};
+__export(branch_name_exports, {
+  slugPart: () => slugPart,
+  suggestSectionBranch: () => suggestSectionBranch,
+  worktreeDirFor: () => worktreeDirFor
+});
+module.exports = __toCommonJS(branch_name_exports);
+function slugPart(text, max = 40) {
+  return text.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max).replace(/-+$/g, "");
+}
+function suggestSectionBranch(planTitle, sectionTitle) {
+  const parts = [slugPart(planTitle, 30), slugPart(sectionTitle, 40)].filter(Boolean);
+  return parts.join("-") || "section";
+}
+function worktreeDirFor(projectRoot, branch) {
+  const root = projectRoot.replace(/[\\/]+$/, "");
+  const sep = root.includes("\\") && !root.includes("/") ? "\\" : "/";
+  const i = Math.max(root.lastIndexOf("/"), root.lastIndexOf("\\"));
+  const parent = i > 0 ? root.slice(0, i) : root;
+  const name = i >= 0 ? root.slice(i + 1) : root;
+  return `${parent}${sep}${name}-${branch.replace(/[/\\]+/g, "-")}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  slugPart,
+  suggestSectionBranch,
+  worktreeDirFor
+});

package/src/shared/lib/breakpoint-words.js

@@ -0,0 +1,118 @@
+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 breakpoint_words_exports = {};
+__export(breakpoint_words_exports, {
+  agentName: () => agentName,
+  changedLines: () => changedLines,
+  decisionLabels: () => decisionLabels,
+  hitHeadline: () => hitHeadline,
+  hitWhy: () => hitWhy,
+  reliedOnLine: () => reliedOnLine,
+  subjectOf: () => subjectOf
+});
+module.exports = __toCommonJS(breakpoint_words_exports);
+function agentName(agent) {
+  if (!agent) return "An agent";
+  if (agent === "claude-code" || agent === "claude-code-hook") return "Claude Code";
+  if (agent === "mcp-agent") return "An agent";
+  return agent;
+}
+const DOING = {
+  claim: "claim",
+  done: "mark done",
+  edit: "change the description of",
+  delete: "delete",
+  edit_code: "change",
+  breach: "change",
+  propose: "change the spec",
+  disk: "change"
+};
+function subjectOf(hit) {
+  const at = hit.breakpointTarget ? hit.breakpointTarget.indexOf("#") : -1;
+  if (hit.path && at > 0) return `${hit.breakpointTarget.slice(at + 1)} in ${hit.path}`;
+  return hit.path ?? hit.itemTitle ?? hit.itemUid;
+}
+function hitHeadline(hit, where) {
+  const who = agentName(hit.agent);
+  const inWs = where ? ` in ${where}` : "";
+  if (hit.breach) return `${who}${inWs} changed ${subjectOf(hit)} past a breakpoint`;
+  if (hit.action === "disk") return `\u201C${subjectOf(hit)}\u201D changed on disk`;
+  return `${who}${inWs} wants to ${DOING[hit.action]} \u201C${subjectOf(hit)}\u201D`;
+}
+function reliedOnLine(r) {
+  const tasks = `${r.tasks} ${r.tasks === 1 ? "task" : "tasks"}`;
+  const plans = `${r.plans} ${r.plans === 1 ? "plan" : "plans"}`;
+  return `${tasks} in ${plans} ${r.tasks === 1 ? "relies" : "rely"} on this page`;
+}
+function hitWhy(hit) {
+  if (hit.breach) return "It could not be paused: this agent edits with its own editor. It has been told to stop and wait.";
+  switch (hit.kind) {
+    case "task":
+      return "You asked to be asked before an agent claims or finishes this task.";
+    case "spec":
+      if (hit.action === "disk") {
+        return "You guard this document. Its file changed on disk, and the app kept its own version until you decide: apply the file to take its version, or keep the app's and it is written back to the file.";
+      }
+      if (hit.reliedOn && hit.reliedOn.tasks > 0) {
+        return `You asked to be asked before an agent changes this description. ${reliedOnLine(hit.reliedOn)}; the agent was told a proposal would let their agents weigh in.`;
+      }
+      return "You asked to be asked before an agent changes this description.";
+    case "code":
+      return "You asked to be asked before this code changes. The edit was not made.";
+    case "signal":
+      return "A serious signal names this workstream, and you asked to be asked while one is open.";
+    case "proposal":
+      return "A spec others rely on would change. Nothing changes until you decide.";
+    default:
+      return "You set a breakpoint here.";
+  }
+}
+function decisionLabels(hit) {
+  if (hit.action === "disk") return { continue: "Apply the file", steer: "Apply the file, with a note", stop: "Keep the app's version" };
+  if (hit.action === "propose") return { continue: "Accept", steer: "Accept, with a note", stop: "Reject" };
+  return hit.breach ? { continue: "Carry on", steer: "Carry on with this note", stop: "Stop" } : { continue: "Continue", steer: "Continue with steer", stop: "Stop" };
+}
+function changedLines(before, after, context = 1) {
+  if (before.replace(/\n+$/, "") === after.replace(/\n+$/, "")) return { before: "", after: "", from: 1 };
+  const a = before.replace(/\n+$/, "").split("\n");
+  const b = after.replace(/\n+$/, "").split("\n");
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const from = Math.max(0, start - context);
+  return {
+    before: a.slice(from, Math.min(a.length, endA + context)).join("\n"),
+    after: b.slice(from, Math.min(b.length, endB + context)).join("\n"),
+    from: from + 1
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  agentName,
+  changedLines,
+  decisionLabels,
+  hitHeadline,
+  hitWhy,
+  reliedOnLine,
+  subjectOf
+});

package/src/shared/lib/budget-words.js

@@ -0,0 +1,56 @@
+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 budget_words_exports = {};
+__export(budget_words_exports, {
+  describeBudgetChange: () => describeBudgetChange,
+  formatCost: () => formatCost,
+  formatMinutes: () => formatMinutes
+});
+module.exports = __toCommonJS(budget_words_exports);
+function formatMinutes(mins) {
+  if (mins < 1) return "<1m";
+  if (mins < 60) return `${Math.round(mins)}m`;
+  const h = Math.floor(mins / 60);
+  const m = Math.round(mins % 60);
+  return m === 0 ? `${h}h` : `${h}h ${m}m`;
+}
+function formatCost(usd) {
+  if (usd === null) return "not reported";
+  if (usd < 0.01) return "<$0.01";
+  return `$${usd.toFixed(2)}`;
+}
+function describeBudgetChange(before, after) {
+  const was = before ?? { minutes: null, costUsd: null, exempt: false };
+  const parts = [];
+  const dimension = (label, from, to, fmt) => {
+    if (from === to) return;
+    if (to === null) parts.push(`cleared the ${label} ceiling (was ${fmt(from)})`);
+    else if (from === null) parts.push(`set a ${label} ceiling of ${fmt(to)}`);
+    else parts.push(`${to > from ? "raised" : "lowered"} the ${label} ceiling ${fmt(from)} \u2192 ${fmt(to)}`);
+  };
+  dimension("time", was.minutes, after.minutes, formatMinutes);
+  dimension("cost", was.costUsd, after.costUsd, (n) => formatCost(n));
+  if (was.exempt !== after.exempt) parts.push(after.exempt ? "exempted the plan from its ceiling" : "ended the exemption");
+  return parts.join(", ") || "changed the budget";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  describeBudgetChange,
+  formatCost,
+  formatMinutes
+});

package/src/shared/lib/burst.js

@@ -0,0 +1,69 @@
+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 burst_exports = {};
+__export(burst_exports, {
+  burst: () => burst
+});
+module.exports = __toCommonJS(burst_exports);
+const realTimers = {
+  set: (fn, ms) => {
+    const t = setTimeout(fn, ms);
+    t.unref?.();
+    return t;
+  },
+  clear: (h) => clearTimeout(h),
+  now: () => Date.now()
+};
+function burst(onFlush, opts) {
+  const timers = opts.timers ?? realTimers;
+  const open = /* @__PURE__ */ new Map();
+  const fire = (key) => {
+    const b = open.get(key);
+    if (!b) return;
+    timers.clear(b.handle);
+    open.delete(key);
+    onFlush(key, [...b.items]);
+  };
+  const arm = (key) => {
+    const b = open.get(key);
+    timers.clear(b.handle);
+    const untilQuiet = opts.quietMs;
+    const untilMax = Math.max(0, b.firstAt + opts.maxWaitMs - timers.now());
+    b.handle = timers.set(() => fire(key), Math.min(untilQuiet, untilMax));
+  };
+  return {
+    add(key, item) {
+      let b = open.get(key);
+      if (!b) open.set(key, b = { items: /* @__PURE__ */ new Set(), firstAt: timers.now(), handle: null });
+      b.items.add(item);
+      arm(key);
+    },
+    flush(key) {
+      for (const k of key === void 0 ? [...open.keys()] : [key]) fire(k);
+    },
+    cancel() {
+      for (const b of open.values()) timers.clear(b.handle);
+      open.clear();
+    },
+    pending: () => [...open.keys()]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  burst
+});

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

@@ -0,0 +1,105 @@
+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 call_entry_exports = {};
+__export(call_entry_exports, {
+  callEntry: () => callEntry,
+  callMatches: () => callMatches,
+  callProblem: () => callProblem,
+  callWords: () => callWords,
+  isCallEntry: () => isCallEntry,
+  isOwnKind: () => isOwnKind,
+  normaliseCall: () => normaliseCall
+});
+module.exports = __toCommonJS(call_entry_exports);
+var import_package_entry = require("./package-entry");
+const CALL_RE = /^([a-z][a-z0-9-]{0,30}):(\S.*)$/;
+const NOT_CALLS = /* @__PURE__ */ new Set([...import_package_entry.PACKAGE_ECOSYSTEMS, "grep", "file", "folder"]);
+const callParts = (s) => {
+  const m = CALL_RE.exec(s);
+  return m && !NOT_CALLS.has(m[1]) ? [m[1], m[2]] : null;
+};
+function isCallEntry(s) {
+  return callParts(s) !== null;
+}
+function isOwnKind(s) {
+  const p = callParts(s);
+  return !!p && p[0] !== "http" && p[0] !== "sql";
+}
+function callEntry(cs) {
+  if (cs.kind === "http_call") {
+    const p = cs.urlPattern ?? "";
+    if (!cs.host && !p) return null;
+    return `http:${cs.host ?? ""}${p === "/" && cs.host ? "" : p}`;
+  }
+  if (cs.kind === "sql_query" && cs.urlPattern) return `sql:${cs.urlPattern.toLowerCase()}`;
+  if (cs.kind === "subprocess" && cs.urlPattern) return `exec:${cs.urlPattern}`;
+  if (cs.kind === "env_lookup" && cs.urlPattern) return `env:${cs.urlPattern}`;
+  if (cs.kind === "entry" && cs.urlPattern && isOwnKind(cs.urlPattern)) return cs.urlPattern;
+  return null;
+}
+function callProblem(s) {
+  const m = typeof s === "string" ? callParts(s.trim()) : null;
+  if (!m) return "calls must be http: and a host or a path, sql: and a table, or a kind of your own and a name, like http:api.stripe.com, sql:payments or queue:orders";
+  const rest = m[1];
+  if (m[0] !== "http" && m[0] !== "sql") return /\s/.test(rest) ? `a ${m[0]} entry is one name, with no spaces, like ${m[0]}:orders.created` : null;
+  if (m[0] === "http" && !/^(?:[a-z0-9-]+(?:\.[a-z0-9-]+)+|localhost)?(?:\/\S*)?$/i.test(rest)) return "an http call is a host, a path, or both, like api.stripe.com/v1/charges";
+  if (m[0] === "sql" && !/^[A-Za-z_][\w.]*$/.test(rest)) return "a sql call is a table name, like payments";
+  return null;
+}
+function normaliseCall(s) {
+  const m = CALL_RE.exec(s.trim());
+  if (m[1] === "sql") return `sql:${m[2].toLowerCase()}`;
+  if (m[1] !== "http") return `${m[1]}:${m[2]}`;
+  const slash = m[2].indexOf("/");
+  const host = (slash < 0 ? m[2] : m[2].slice(0, slash)).toLowerCase();
+  const path = slash < 0 ? "" : m[2].slice(slash).replace(/\/+$/, "");
+  return `http:${host}${path}`;
+}
+function callMatches(ruleCall, entry) {
+  const r = callParts(ruleCall);
+  const e = callParts(entry);
+  if (!r || !e || r[0] !== e[0]) return false;
+  if (r[0] === "sql") return r[1] === e[1];
+  if (r[0] !== "http") return e[1] === r[1] || [".", "/", ":"].some((sep) => e[1].startsWith(r[1] + sep));
+  const under = (path, prefix) => prefix === "" || path === prefix || path.startsWith(`${prefix}/`);
+  const split = (x) => {
+    const i = x.indexOf("/");
+    return i < 0 ? [x, ""] : [x.slice(0, i), x.slice(i)];
+  };
+  const [rh, rp] = split(r[1]);
+  const [eh, ep] = split(e[1]);
+  if (rh === "") return under(ep, rp);
+  return rh === eh && under(ep, rp);
+}
+function callWords(entry) {
+  const m = callParts(entry);
+  if (!m) return entry;
+  if (m[0] === "exec") return m[1] === "*" ? "any command" : `the command ${m[1]}`;
+  if (m[0] === "env") return m[1] === "*" ? "any environment variable" : `the environment variable ${m[1]}`;
+  return m[0] === "sql" ? `the table ${m[1]}` : m[0] === "http" ? m[1] : entry;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callEntry,
+  callMatches,
+  callProblem,
+  callWords,
+  isCallEntry,
+  isOwnKind,
+  normaliseCall
+});