@vibgrate/cli 2026.722.2 → 2026.727.2

package/dist/chunk-KSBHGWRV.js

@@ -0,0 +1,613 @@
+import { indexFor, queryGraph, impactOf } from './chunk-6ABXHZRN.js';
+import { cacheDir } from './chunk-K3MZIVZW.js';
+import { hashString } from './chunk-JFGYT6BI.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+var LEDGER = "savings.jsonl";
+var PER_FILE_TOKENS = 400;
+var SAVINGS_TOOLS = /* @__PURE__ */ new Set(["query_graph", "get_node", "search_symbols"]);
+var CLI_TOOL_ALIASES = {
+  ask: "query_graph",
+  show: "get_node",
+  impact: "impact_of",
+  path: "find_path",
+  hubs: "list_hubs",
+  areas: "list_areas",
+  tree: "tree"
+};
+function sanitizeClient(name) {
+  if (typeof name !== "string") return "unknown";
+  const cleaned = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return cleaned || "unknown";
+}
+function sanitizeModelId(name) {
+  if (typeof name !== "string") return void 0;
+  const cleaned = name.trim().toLowerCase().replace(/[^a-z0-9._:/-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+  return cleaned || void 0;
+}
+function recordCliCall(root, entry, now) {
+  recordSaving(
+    root,
+    {
+      tool: entry.tool,
+      source: "cli",
+      client: sanitizeClient(entry.client),
+      provider: entry.provider ? sanitizeClient(entry.provider) : void 0,
+      model: sanitizeModelId(entry.model),
+      outcome: entry.outcome,
+      vgTokens: entry.vgTokens ?? 0,
+      baselineTokens: (entry.baselineFiles ?? 0) * PER_FILE_TOKENS
+    },
+    now
+  );
+}
+function savingsLedgerPath(root) {
+  return path.join(cacheDir(root), LEDGER);
+}
+function ledgerPath(root) {
+  return savingsLedgerPath(root);
+}
+function savingsRecorded(root) {
+  return fs.existsSync(ledgerPath(root));
+}
+function clearSavings(root) {
+  const file = ledgerPath(root);
+  const existed = fs.existsSync(file);
+  fs.rmSync(file, { force: true });
+  fs.rmSync(path.join(cacheDir(root), "stats-share.json"), { force: true });
+  return existed;
+}
+function recordSaving(root, entry, now) {
+  try {
+    fs.mkdirSync(cacheDir(root), { recursive: true });
+    const line = JSON.stringify({ ts: now, ...entry });
+    fs.appendFileSync(ledgerPath(root), line + "\n");
+  } catch {
+  }
+}
+var DEFAULT_RATE_PER_M = 3;
+var DEFAULT_RATE_LABEL = "input @ $3/1M";
+function readSavings(root, days, now, ratePerM = DEFAULT_RATE_PER_M) {
+  const file = ledgerPath(root);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  let queries = 0;
+  let vgTokens = 0;
+  let baselineTokens = 0;
+  if (fs.existsSync(file)) {
+    for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.ts < cutoff) continue;
+        if (!SAVINGS_TOOLS.has(e.tool)) continue;
+        queries++;
+        vgTokens += e.vgTokens;
+        baselineTokens += e.baselineTokens;
+      } catch {
+      }
+    }
+  }
+  const estCostVg = vgTokens / 1e6 * ratePerM;
+  const estCostBaseline = baselineTokens / 1e6 * ratePerM;
+  return {
+    enabled: savingsRecorded(root),
+    days,
+    queries,
+    vgTokens,
+    baselineTokens,
+    ratio: vgTokens > 0 ? Math.round(baselineTokens / vgTokens * 100) / 100 : 0,
+    estCostVg: round2(estCostVg),
+    estCostBaseline: round2(estCostBaseline),
+    saved: round2(estCostBaseline - estCostVg),
+    rateLabel: DEFAULT_RATE_LABEL
+  };
+}
+function round2(x) {
+  return Math.round(x * 100) / 100;
+}
+function readModelSavings(root, days, now, ratePerM = DEFAULT_RATE_PER_M) {
+  const file = ledgerPath(root);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  const byModel = /* @__PURE__ */ new Map();
+  if (fs.existsSync(file)) {
+    for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.ts < cutoff || !e.model || !SAVINGS_TOOLS.has(e.tool)) continue;
+        const provider = e.provider ?? "unknown";
+        const key = `${provider}/${e.model}`;
+        const row = byModel.get(key) ?? { provider, model: e.model, queries: 0, vg: 0, base: 0 };
+        row.queries++;
+        row.vg += e.vgTokens;
+        row.base += e.baselineTokens;
+        byModel.set(key, row);
+      } catch {
+      }
+    }
+  }
+  return [...byModel.entries()].map(([key, r]) => ({
+    key,
+    provider: r.provider,
+    model: r.model,
+    queries: r.queries,
+    vgTokens: r.vg,
+    baselineTokens: r.base,
+    saved: round2((r.base - r.vg) / 1e6 * ratePerM)
+  })).sort((a, b) => b.saved - a.saved || a.key.localeCompare(b.key));
+}
+function toDimensionStats(byKey) {
+  return [...byKey.entries()].map(([key, r]) => {
+    const calls = r.complete + r.partial + r.miss;
+    return {
+      key,
+      calls,
+      complete: r.complete,
+      partial: r.partial,
+      miss: r.miss,
+      successPct: calls ? Math.round((r.complete + r.partial) / calls * 100) : 0
+    };
+  }).sort((a, b) => b.calls - a.calls || a.key.localeCompare(b.key));
+}
+function readUsage(root, days, now) {
+  const file = ledgerPath(root);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  const byTool = /* @__PURE__ */ new Map();
+  const bySource = /* @__PURE__ */ new Map();
+  const byClient = /* @__PURE__ */ new Map();
+  const msByTool = /* @__PURE__ */ new Map();
+  const bump = (m, key, outcome) => {
+    const row = m.get(key) ?? { complete: 0, partial: 0, miss: 0 };
+    row[outcome]++;
+    m.set(key, row);
+  };
+  if (fs.existsSync(file)) {
+    for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const e = JSON.parse(line);
+        if (e.ts < cutoff) continue;
+        const outcome = e.outcome ?? "complete";
+        bump(byTool, e.tool, outcome);
+        bump(bySource, e.source ?? "mcp", outcome);
+        bump(byClient, e.client ?? "unknown", outcome);
+        if (typeof e.ms === "number" && e.ms >= 0) {
+          const timing = msByTool.get(e.tool) ?? { sum: 0, n: 0 };
+          timing.sum += e.ms;
+          timing.n++;
+          msByTool.set(e.tool, timing);
+        }
+      } catch {
+      }
+    }
+  }
+  const commands = toDimensionStats(byTool).map((d) => {
+    const timing = msByTool.get(d.key);
+    return {
+      tool: d.key,
+      calls: d.calls,
+      complete: d.complete,
+      partial: d.partial,
+      miss: d.miss,
+      successPct: d.successPct,
+      avgMs: timing && timing.n > 0 ? Math.round(timing.sum / timing.n) : null
+    };
+  });
+  const totals = commands.reduce(
+    (t, c) => ({
+      calls: t.calls + c.calls,
+      complete: t.complete + c.complete,
+      partial: t.partial + c.partial,
+      miss: t.miss + c.miss
+    }),
+    { calls: 0, complete: 0, partial: 0, miss: 0 }
+  );
+  const avgSuccessPct = commands.length ? Math.round(commands.reduce((s, c) => s + c.successPct, 0) / commands.length) : 0;
+  return {
+    enabled: savingsRecorded(root),
+    days,
+    commands,
+    sources: toDimensionStats(bySource),
+    clients: toDimensionStats(byClient),
+    totals,
+    avgSuccessPct
+  };
+}
+
+// src/code/context.ts
+function buildCodeContext(graph, instruction, options = {}) {
+  const budget = options.budget ?? 3e3;
+  const seedLimit = options.seeds ?? 8;
+  const impactDepth = options.impactDepth ?? 2;
+  const index = indexFor(graph);
+  const q = queryGraph(graph, instruction, { budget: Math.floor(budget * 0.6), limit: seedLimit * 2 });
+  let seeds = q.matches.map((m) => ({ node: m.node, why: m.why }));
+  if (options.files && options.files.length) {
+    const set = new Set(options.files.map(normalize));
+    const inScope = seeds.filter((s) => set.has(normalize(s.node.file)));
+    if (inScope.length) seeds = inScope;
+  }
+  seeds = seeds.slice(0, seedLimit);
+  const impacted = /* @__PURE__ */ new Map();
+  for (const s of seeds) {
+    const impact = impactOf(graph, s.node.id, { depth: impactDepth });
+    for (const item of impact.affected.slice(0, 6)) {
+      const node = index.node(item.id);
+      if (node && !impacted.has(node.id)) impacted.set(node.id, { node, via: s.node.qualifiedName });
+    }
+  }
+  const targetFiles = options.files?.length ? [...new Set(options.files.map(normalize))].sort() : [...new Set(seeds.map((s) => s.node.file))].sort();
+  const seedIds = new Set(seeds.map((s) => s.node.id));
+  const pinnedFacts = pinnedFactsFor(graph, seedIds);
+  const rendered = render(instruction, seeds, [...impacted.values()], targetFiles, pinnedFacts, index, budget);
+  return {
+    instruction,
+    seeds,
+    targetFiles,
+    impacted: [...impacted.values()],
+    pinnedFacts,
+    rendered,
+    tokensEstimate: estimateTokens(rendered)
+  };
+}
+function pinnedFactsFor(graph, seedIds) {
+  if (!graph.facts?.length) return [];
+  const out = [];
+  for (const f of graph.facts) {
+    if (f.kind === "characterization") continue;
+    if (!f.subjectIds.some((id) => seedIds.has(id))) continue;
+    const subjects = f.subjectIds.map((id) => graph.nodes.find((n) => n.id === id)?.qualifiedName ?? id).join(", ");
+    out.push(`${f.kind}: ${subjects} \u2014 ${JSON.stringify(f.predicate)}`);
+  }
+  return out.sort().slice(0, 12);
+}
+function render(instruction, seeds, impacted, targetFiles, pinnedFacts, index, budget) {
+  const lines = [];
+  lines.push("# Repository context (from the deterministic code graph)");
+  lines.push("");
+  if (pinnedFacts.length) {
+    lines.push("## Hard constraints (do not violate)");
+    for (const f of pinnedFacts) lines.push(`- ${f}`);
+    lines.push("");
+  }
+  lines.push("## Relevant symbols");
+  for (const { node, why } of seeds) {
+    const block = [];
+    block.push(`### ${node.qualifiedName}  (${node.kind}, ${node.file}:${node.span.start}-${node.span.end})`);
+    if (node.signature) block.push("`" + node.signature + "`");
+    const callees = uniqueNames(index.callees(node.id).map((x) => x.node.qualifiedName)).slice(0, 6);
+    const callers = uniqueNames(index.callers(node.id).map((x) => x.node.qualifiedName)).slice(0, 6);
+    if (callees.length) block.push(`calls: ${callees.join(", ")}`);
+    if (callers.length) block.push(`called by: ${callers.join(", ")}`);
+    block.push(`importance ${node.importance.toFixed(3)}${node.isHub ? " \xB7 hub (high blast radius)" : ""} \xB7 ${why}`);
+    block.push("");
+    const candidate = lines.concat(block).join("\n");
+    if (estimateTokens(candidate) > budget && lines.length > 3) break;
+    lines.push(...block);
+  }
+  if (impacted.length) {
+    lines.push("## Blast radius (would be affected by a change here)");
+    for (const { node, via } of impacted.slice(0, 10)) {
+      lines.push(`- ${node.qualifiedName} (${node.file}:${node.span.start}) \u2014 depends on ${via}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Files in scope for this edit");
+  for (const f of targetFiles) lines.push(`- ${f}`);
+  lines.push("");
+  lines.push("## Task");
+  lines.push(instruction);
+  return lines.join("\n");
+}
+function uniqueNames(xs) {
+  return [...new Set(xs)];
+}
+function normalize(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// src/code/capsule.ts
+var TASK_CAPSULE_SCHEMA_VERSION = "task-capsule/0";
+var CAPSULE_RANKING_VERSION = "capsule-rank@2026.07.0";
+var CAPSULE_COMPILER_ID = "vg-task-capsule/0";
+function summarizeCapsule(capsule) {
+  const sourceFiles = [...new Set(capsule.sourceSlices.map((s) => s.file))].sort();
+  const preview = capsule.rendered.length > 4e3 ? `${capsule.rendered.slice(0, 4e3)}
+\u2026 (truncated)` : capsule.rendered;
+  return {
+    schemaVersion: capsule.schemaVersion,
+    instruction: capsule.instruction,
+    primary: capsule.primary.map((p) => ({ qualifiedName: p.qualifiedName, file: p.file, kind: p.kind })),
+    supporting: capsule.supporting.map((p) => ({ qualifiedName: p.qualifiedName, file: p.file, kind: p.kind })),
+    sourceSliceCount: capsule.sourceSlices.length,
+    sourceFiles,
+    tokensEstimate: capsule.tokensEstimate,
+    rankingVersion: capsule.provenance.rankingVersion,
+    preview
+  };
+}
+function buildTaskCapsule(graph, instruction, options = {}) {
+  const base = buildCodeContext(graph, instruction, options);
+  const padding = options.padding ?? 1;
+  const maxSlices = options.maxSlices ?? 12;
+  const budget = options.budget ?? 3e3;
+  const index = indexFor(graph);
+  const primary = base.seeds.map((s) => toRef(s.node, s.why));
+  const primaryIds = new Set(primary.map((p) => p.id));
+  const supporting = [];
+  for (const { node, via } of base.impacted) {
+    if (primaryIds.has(node.id)) continue;
+    supporting.push(toRef(node, `depends on ${via}`));
+  }
+  const relationships = collectRelationships(base, index);
+  const sourceSlices = options.readFile ? buildSourceSlices(
+    [...base.seeds.map((s) => s.node), ...base.impacted.map((i) => i.node)],
+    options.readFile,
+    padding,
+    maxSlices
+  ) : [];
+  const extraFacts = (options.extraPinnedFacts ?? []).filter((f) => typeof f === "string" && f.trim());
+  const pinnedFacts = [...base.pinnedFacts, ...extraFacts];
+  const verificationPlan = buildVerificationPlan(graph, base);
+  const rendered = renderCapsule(instruction, primary, supporting, sourceSlices, pinnedFacts, base.targetFiles, verificationPlan, relationships, budget);
+  return {
+    schemaVersion: TASK_CAPSULE_SCHEMA_VERSION,
+    instruction,
+    primary,
+    supporting,
+    sourceSlices,
+    relationships,
+    pinnedFacts,
+    targetFiles: base.targetFiles,
+    verificationPlan,
+    rendered,
+    tokensEstimate: estimateTokens2(rendered),
+    provenance: {
+      compiler: CAPSULE_COMPILER_ID,
+      rankingVersion: CAPSULE_RANKING_VERSION,
+      graphCorpusHash: graph.provenance?.corpusHash ?? null,
+      repositoryId: options.repositoryId ?? null,
+      modelProfileId: options.provenance?.modelProfileId ?? null,
+      securityTier: options.provenance?.securityTier ?? null,
+      policyVersion: options.provenance?.policyVersion ?? null
+    }
+  };
+}
+function capsuleToCodeContext(capsule) {
+  return {
+    instruction: capsule.instruction,
+    seeds: capsule.primary.map((p) => ({
+      node: {
+        id: p.id,
+        qualifiedName: p.qualifiedName,
+        kind: p.kind,
+        file: p.file,
+        span: p.span,
+        signature: p.signature ?? void 0,
+        importance: p.importance
+      },
+      why: p.why
+    })),
+    targetFiles: capsule.targetFiles,
+    impacted: capsule.supporting.map((s) => ({
+      node: {
+        id: s.id,
+        qualifiedName: s.qualifiedName,
+        kind: s.kind,
+        file: s.file,
+        span: s.span,
+        signature: s.signature ?? void 0,
+        importance: s.importance
+      },
+      via: s.why.replace(/^depends on /, "")
+    })),
+    pinnedFacts: capsule.pinnedFacts,
+    rendered: capsule.rendered,
+    tokensEstimate: capsule.tokensEstimate
+  };
+}
+function toRef(node, why) {
+  return {
+    id: node.id,
+    qualifiedName: node.qualifiedName,
+    kind: node.kind,
+    file: normalize2(node.file),
+    span: { start: node.span.start, end: node.span.end },
+    signature: node.signature ?? null,
+    why,
+    importance: node.importance
+  };
+}
+function collectRelationships(base, index) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (kind, from, to) => {
+    const key = `${kind}|${from}|${to}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ kind, from, to });
+  };
+  for (const { node } of base.seeds) {
+    for (const c of index.callees(node.id).slice(0, 6)) {
+      push("calls", node.qualifiedName, c.node.qualifiedName);
+    }
+    for (const c of index.callers(node.id).slice(0, 6)) {
+      push("called-by", node.qualifiedName, c.node.qualifiedName);
+    }
+  }
+  for (const { node, via } of base.impacted.slice(0, 10)) {
+    push("impacts", via, node.qualifiedName);
+  }
+  return out.sort((a, b) => a.kind.localeCompare(b.kind) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+}
+function buildSourceSlices(nodes, readFile, padding, maxSlices) {
+  const eligible = nodes.filter((n) => !["file", "module", "package"].includes(n.kind));
+  const byFile = /* @__PURE__ */ new Map();
+  for (const n of eligible) {
+    const file = normalize2(n.file);
+    const list = byFile.get(file) ?? [];
+    list.push(n);
+    byFile.set(file, list);
+  }
+  const ranges = [];
+  for (const [file, fileNodes] of [...byFile.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const sorted = [...fileNodes].sort((a, b) => a.span.start - b.span.start || b.importance - a.importance);
+    let current = null;
+    for (const n of sorted) {
+      const start = Math.max(1, n.span.start - padding);
+      const end = n.span.end + padding;
+      const score = n.importance + (n.isHub ? 0.25 : 0);
+      if (current && current.file === file && start <= current.end + 2) {
+        current.end = Math.max(current.end, end);
+        current.symbolIds.push(n.id);
+        current.score = Math.max(current.score, score);
+      } else {
+        if (current) ranges.push(current);
+        current = { file, start, end, symbolIds: [n.id], score };
+      }
+    }
+    if (current) ranges.push(current);
+  }
+  ranges.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file) || a.start - b.start);
+  const slices = [];
+  for (const range of ranges) {
+    if (slices.length >= maxSlices) break;
+    const raw = readFile(range.file);
+    if (raw === null) continue;
+    const lines = raw.split("\n");
+    const start = Math.min(range.start, lines.length);
+    const end = Math.min(range.end, lines.length);
+    if (start < 1 || end < start) continue;
+    const content = lines.slice(start - 1, end).join("\n");
+    slices.push({
+      file: range.file,
+      start,
+      end,
+      content,
+      contentHash: hashString(content),
+      symbolIds: [...new Set(range.symbolIds)].sort()
+    });
+  }
+  return slices.sort((a, b) => a.file.localeCompare(b.file) || a.start - b.start);
+}
+function buildVerificationPlan(graph, base) {
+  const syntaxFiles = [...base.targetFiles].sort();
+  const seedIds = new Set(base.seeds.map((s) => s.node.id));
+  const suggestedTests = [];
+  for (const n of graph.nodes) {
+    if (n.kind !== "test") continue;
+    const sameFile = base.seeds.some((s) => normalize2(s.node.file) === normalize2(n.file));
+    const nameHit = base.seeds.some((s) => n.qualifiedName.toLowerCase().includes(s.node.name.toLowerCase()));
+    if (sameFile || nameHit || seedIds.has(n.id)) {
+      suggestedTests.push(n.qualifiedName);
+    }
+  }
+  suggestedTests.sort();
+  const notes = [];
+  if (!suggestedTests.length) {
+    notes.push("No graph-linked tests found for seed symbols; run the nearest project test command after apply.");
+  }
+  if (base.impacted.some((i) => i.node.isHub || i.node.importance >= 0.7)) {
+    notes.push("High-importance dependents in blast radius \u2014 prefer targeted tests before a full build.");
+  }
+  return {
+    syntaxFiles,
+    suggestedTests: suggestedTests.slice(0, 12),
+    notes
+  };
+}
+function renderCapsule(instruction, primary, supporting, slices, pinnedFacts, targetFiles, verification, relationships, budget) {
+  const lines = [];
+  lines.push("# Task capsule (source-bearing, from the deterministic code graph)");
+  lines.push("");
+  lines.push("Use the exact source evidence below. Search or read outside it only if this capsule is insufficient.");
+  lines.push("");
+  if (pinnedFacts.length) {
+    lines.push("## Hard constraints (do not violate)");
+    for (const f of pinnedFacts) lines.push(`- ${f}`);
+    lines.push("");
+  }
+  lines.push("## Primary symbols");
+  for (const s of primary) {
+    lines.push(`- ${s.qualifiedName} (${s.kind}, ${s.file}:${s.span.start}-${s.span.end})${s.signature ? ` \u2014 \`${s.signature}\`` : ""} \u2014 ${s.why}`);
+  }
+  lines.push("");
+  if (supporting.length) {
+    lines.push("## Supporting / blast radius");
+    for (const s of supporting.slice(0, 10)) {
+      lines.push(`- ${s.qualifiedName} (${s.file}:${s.span.start}) \u2014 ${s.why}`);
+    }
+    lines.push("");
+  }
+  if (relationships.length) {
+    lines.push("## Relationships");
+    for (const r of relationships.slice(0, 24)) {
+      lines.push(`- ${r.kind}: ${r.from} \u2192 ${r.to}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Exact source evidence");
+  if (!slices.length) {
+    lines.push("_No source slices available (file reader missing or spans unreadable)._");
+    lines.push("");
+  } else {
+    let included = 0;
+    for (const slice of slices) {
+      const block = [
+        `### ${slice.file}:${slice.start}-${slice.end}`,
+        `\`\`\`${langFor(slice.file)}`,
+        slice.content,
+        "```",
+        ""
+      ];
+      const candidate = [...lines, ...block, "## Task", instruction].join("\n");
+      if (estimateTokens2(candidate) > budget && included > 0) break;
+      lines.push(...block);
+      included += 1;
+    }
+  }
+  lines.push("## Files in scope");
+  for (const f of targetFiles) lines.push(`- ${f}`);
+  lines.push("");
+  lines.push("## Verification plan");
+  for (const f of verification.syntaxFiles) lines.push(`- syntax: ${f}`);
+  for (const t of verification.suggestedTests) lines.push(`- test: ${t}`);
+  for (const n of verification.notes) lines.push(`- note: ${n}`);
+  lines.push("");
+  lines.push("## Task");
+  lines.push(instruction);
+  return lines.join("\n");
+}
+function langFor(file) {
+  const ext = file.split(".").pop()?.toLowerCase() ?? "";
+  const map = {
+    ts: "ts",
+    tsx: "tsx",
+    js: "js",
+    jsx: "jsx",
+    mjs: "js",
+    cjs: "js",
+    py: "python",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    cs: "csharp",
+    md: "md",
+    json: "json"
+  };
+  return map[ext] ?? "";
+}
+function normalize2(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function estimateTokens2(text) {
+  return Math.ceil(text.length / 4);
+}
+
+export { CAPSULE_COMPILER_ID, CAPSULE_RANKING_VERSION, CLI_TOOL_ALIASES, PER_FILE_TOKENS, SAVINGS_TOOLS, TASK_CAPSULE_SCHEMA_VERSION, buildCodeContext, buildTaskCapsule, capsuleToCodeContext, clearSavings, readModelSavings, readSavings, readUsage, recordCliCall, recordSaving, sanitizeClient, savingsLedgerPath, savingsRecorded, summarizeCapsule };
+//# sourceMappingURL=chunk-KSBHGWRV.js.map
+//# sourceMappingURL=chunk-KSBHGWRV.js.map