@vibgrate/cli 2026.721.3 → 2026.722.2

package/dist/chunk-WNIIKCNF.js

@@ -0,0 +1,972 @@
+import { hashString } from './chunk-JFGYT6BI.js';
+import * as fs3 from 'fs';
+import { createRequire } from 'module';
+import * as os from 'os';
+import * as path3 from 'path';
+import { pathToFileURL } from 'url';
+
+// src/engine/serialize.ts
+function serializeGraph(graph) {
+  return `${stableStringify(graph, 2)}
+`;
+}
+function stableStringify(value, indent = 2) {
+  return JSON.stringify(sortKeys(value), null, indent);
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const input = value;
+    const out = {};
+    for (const key of Object.keys(input).sort()) {
+      const v = input[key];
+      if (v === void 0) continue;
+      out[key] = sortKeys(v);
+    }
+    return out;
+  }
+  return value;
+}
+function parseGraph(json) {
+  return JSON.parse(json);
+}
+var CACHE_VERSION = "vg-parse-cache/3";
+function cacheDir(root) {
+  return path3.join(root, ".vibgrate", "cache");
+}
+function cachePath(root) {
+  return path3.join(cacheDir(root), "parse-cache.json");
+}
+function loadCache(root, opts) {
+  const file = cachePath(root);
+  let data = {
+    version: CACHE_VERSION,
+    toolVersion: opts.toolVersion,
+    grammars: opts.grammars,
+    entries: {}
+  };
+  if (!opts.disabled && fs3.existsSync(file)) {
+    try {
+      const loaded = JSON.parse(fs3.readFileSync(file, "utf8"));
+      if (loaded.version === CACHE_VERSION && loaded.toolVersion === opts.toolVersion && loaded.grammars === opts.grammars && loaded.entries) {
+        data = loaded;
+      }
+    } catch {
+    }
+  }
+  return {
+    get(rel, hash) {
+      const entry = data.entries[rel];
+      return entry && entry.hash === hash ? entry.parse : void 0;
+    },
+    set(rel, parse) {
+      data.entries[rel] = { hash: parse.hash, parse };
+    },
+    prune(currentRels) {
+      for (const rel of Object.keys(data.entries)) {
+        if (!currentRels.has(rel)) delete data.entries[rel];
+      }
+    },
+    save() {
+      fs3.mkdirSync(cacheDir(root), { recursive: true });
+      fs3.writeFileSync(file, stableStringify(data, 0));
+    }
+  };
+}
+var DEFAULT_LOCK_STALE_MS = 15 * 60 * 1e3;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function lockIsStale(file, staleMs) {
+  try {
+    const { pid, at } = JSON.parse(fs3.readFileSync(file, "utf8"));
+    if (typeof at === "number" && Date.now() - at > staleMs) return true;
+    if (typeof pid === "number" && !isProcessAlive(pid)) return true;
+    return false;
+  } catch {
+    return true;
+  }
+}
+function acquireLock(file, staleMs = DEFAULT_LOCK_STALE_MS) {
+  const write = () => {
+    try {
+      fs3.mkdirSync(path3.dirname(file), { recursive: true });
+      const fd = fs3.openSync(file, "wx");
+      fs3.writeFileSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+      fs3.closeSync(fd);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (write()) return true;
+  if (lockIsStale(file, staleMs)) {
+    try {
+      fs3.rmSync(file, { force: true });
+    } catch {
+    }
+    return write();
+  }
+  return false;
+}
+function releaseLock(file) {
+  try {
+    fs3.rmSync(file, { force: true });
+  } catch {
+  }
+}
+
+// src/engine/embeddings.ts
+function resolveEmbedModel(model) {
+  return model ?? "bge-small-en-v1.5";
+}
+function modelCacheDir() {
+  const base = process.env.XDG_CACHE_HOME || path3.join(os.homedir(), ".cache");
+  return path3.join(base, "vibgrate", "models");
+}
+function modelReadyMarker(modelId) {
+  return path3.join(modelCacheDir(), `.ready-${safe(modelId)}`);
+}
+function isModelReady(modelId = resolveEmbedModel()) {
+  return fs3.existsSync(modelReadyMarker(modelId));
+}
+function unavailableMessage(reason) {
+  switch (reason) {
+    case "no-permission":
+      return `semantic search couldn't write its model cache at ${modelCacheDir()} \u2014 using fast lexical search instead. Relocate it with the standard XDG_CACHE_HOME, or run with --local to stay lexical quietly. (No admin/sudo is ever needed \u2014 the cache lives in your home folder.)`;
+    case "download-failed":
+      return `the semantic model isn't downloaded yet and couldn't be fetched (offline?) \u2014 using fast lexical search. It'll try again next time; run with --local to keep lexical without retrying.`;
+    case "not-installed":
+      return `the optional semantic backend isn't available here \u2014 using fast lexical search.`;
+    case "init-failed":
+    default:
+      return `the semantic model couldn't load \u2014 using fast lexical search.`;
+  }
+}
+function modelCacheInfo(modelId = resolveEmbedModel()) {
+  const dir = modelCacheDir();
+  return { dir, present: isModelReady(modelId) || fs3.existsSync(dir), bytes: dirSize(dir) };
+}
+function clearModelCache() {
+  const dir = modelCacheDir();
+  const bytes = dirSize(dir);
+  try {
+    fs3.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+  return bytes;
+}
+function dirSize(dir) {
+  let total = 0;
+  let entries;
+  try {
+    entries = fs3.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const e of entries) {
+    const p = path3.join(dir, e.name);
+    if (e.isDirectory()) total += dirSize(p);
+    else {
+      try {
+        total += fs3.statSync(p).size;
+      } catch {
+      }
+    }
+  }
+  return total;
+}
+function isPermissionError(e) {
+  const code = e?.code;
+  return code === "EACCES" || code === "EPERM" || code === "EROFS";
+}
+function embeddingsCached(root, modelId) {
+  return fs3.existsSync(path3.join(cacheDir(root), `embeddings-${safe(modelId)}.json`));
+}
+async function loadEmbedder(options = {}) {
+  if (options.local) return null;
+  const modelId = resolveEmbedModel(options.model);
+  if (options.noDownload && !isModelReady(modelId)) return null;
+  const fail = (reason) => {
+    options.onUnavailable?.(reason);
+    return null;
+  };
+  const mod = await importEmbedBackend();
+  if (!mod?.FlagEmbedding) return fail("not-installed");
+  const cache = modelCacheDir();
+  try {
+    fs3.mkdirSync(cache, { recursive: true });
+  } catch (e) {
+    return fail(isPermissionError(e) ? "no-permission" : "init-failed");
+  }
+  try {
+    const model = await withTimeout(
+      mod.FlagEmbedding.init({
+        model: mapModel(mod, modelId),
+        cacheDir: cache,
+        showDownloadProgress: options.showDownloadProgress ?? false
+      }),
+      embedInitTimeoutMs(),
+      "embedding model init timed out"
+    );
+    try {
+      fs3.writeFileSync(modelReadyMarker(modelId), (/* @__PURE__ */ new Date(0)).toISOString());
+    } catch {
+    }
+    return {
+      id: modelId,
+      async embed(texts) {
+        const out = [];
+        for await (const batch of model.embed(texts, 64)) {
+          for (const v of batch) out.push(Array.from(v));
+        }
+        return out;
+      },
+      async embedQuery(text) {
+        const v = await model.queryEmbed(text);
+        return Array.from(v);
+      }
+    };
+  } catch (e) {
+    return fail(isPermissionError(e) ? "no-permission" : "download-failed");
+  }
+}
+async function importEmbedBackend() {
+  const hostDir = process.env.VIBGRATE_EMBEDDER_PATH;
+  if (hostDir) {
+    try {
+      const req = createRequire(path3.join(hostDir, "package.json"));
+      const mod = await import(pathToFileURL(req.resolve("fastembed")).href);
+      const resolved = mod?.FlagEmbedding ? mod : mod?.default;
+      if (resolved?.FlagEmbedding) return resolved;
+    } catch {
+    }
+  }
+  return await import('fastembed').catch(() => null);
+}
+function embedInitTimeoutMs() {
+  const n = Number(process.env.VG_EMBED_TIMEOUT_MS);
+  return Number.isFinite(n) && n > 0 ? n : 6e4;
+}
+async function withTimeout(promise, ms, message) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), ms);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function mapModel(mod, id) {
+  const m = mod.EmbeddingModel ?? {};
+  if (/bge-small/i.test(id)) return m.BGESmallENV15 ?? m.BGESmallEN ?? id;
+  if (/bge-base/i.test(id)) return m.BGEBaseENV15 ?? id;
+  if (/all-minilm/i.test(id)) return m.AllMiniLML6V2 ?? id;
+  return id;
+}
+var PATH_NOISE = /* @__PURE__ */ new Set([
+  "src",
+  "app",
+  "apps",
+  "lib",
+  "libs",
+  "dist",
+  "build",
+  "out",
+  "index",
+  "main",
+  "packages",
+  "pkg",
+  "test",
+  "tests",
+  "__tests__",
+  "spec",
+  "node_modules",
+  "internal",
+  "com",
+  "example",
+  "demo",
+  "java",
+  "net",
+  "org",
+  "www"
+]);
+function pathContext(file) {
+  const parts = file.split("/");
+  const stem = (parts.pop() ?? "").replace(/\.[^.]+$/, "");
+  const dirs = parts.filter((p) => p && !PATH_NOISE.has(p.toLowerCase()));
+  return [...dirs.slice(-2), stem].filter(Boolean).join(" ");
+}
+function nodeEmbedText(node, areaLabel) {
+  return [node.qualifiedName, node.kind, node.signature ?? "", node.doc ?? "", pathContext(node.file), areaLabel ?? ""].filter(Boolean).join(" ");
+}
+function cosine(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+var EMBED_CHUNK = 256;
+var CACHE_WRITE_INTERVAL_MS = 1500;
+function vectorCachePath(root, modelId) {
+  return path3.join(cacheDir(root), `embeddings-${safe(modelId)}.json`);
+}
+function countPending(graph, root, modelId) {
+  const entries = readCacheEntries(vectorCachePath(root, modelId), modelId);
+  const areaLabel = new Map(graph.areas.map((a) => [a.id, a.label]));
+  let pending = 0;
+  for (const n of graph.nodes) {
+    if (n.kind === "file" || n.kind === "external") continue;
+    const h = hashString(nodeEmbedText(n, areaLabel.get(n.area)));
+    const cached = entries[n.id];
+    if (!cached || cached.hash !== h) pending++;
+  }
+  return pending;
+}
+function readCacheEntries(file, modelId) {
+  if (!fs3.existsSync(file)) return {};
+  try {
+    const loaded = JSON.parse(fs3.readFileSync(file, "utf8"));
+    if (loaded.model === modelId && loaded.entries) return loaded.entries;
+  } catch {
+  }
+  return {};
+}
+async function getNodeEmbeddings(graph, embedder, root, onProgress) {
+  const file = vectorCachePath(root, embedder.id);
+  let cache = { model: embedder.id, entries: {} };
+  if (fs3.existsSync(file)) {
+    try {
+      const loaded = JSON.parse(fs3.readFileSync(file, "utf8"));
+      if (loaded.model === embedder.id && loaded.entries) cache = loaded;
+    } catch {
+    }
+  }
+  const areaLabel = new Map(graph.areas.map((a) => [a.id, a.label]));
+  const targets = graph.nodes.filter((n) => n.kind !== "file" && n.kind !== "external");
+  const toEmbed = [];
+  const vectors = /* @__PURE__ */ new Map();
+  for (const n of targets) {
+    const text = nodeEmbedText(n, areaLabel.get(n.area));
+    const h = hashString(text);
+    const cached = cache.entries[n.id];
+    if (cached && cached.hash === h) vectors.set(n.id, cached.vec);
+    else toEmbed.push({ id: n.id, text, hash: h });
+  }
+  const persist = () => {
+    try {
+      fs3.mkdirSync(cacheDir(root), { recursive: true });
+      const tmp = `${file}.tmp.${process.pid}`;
+      fs3.writeFileSync(tmp, JSON.stringify(cache));
+      fs3.renameSync(tmp, file);
+    } catch {
+    }
+  };
+  if (toEmbed.length) {
+    const lock = `${file}.lock`;
+    if (!acquireLock(lock)) return vectors;
+    try {
+      onProgress?.(0, toEmbed.length);
+      let lastWrite = Date.now();
+      for (let i = 0; i < toEmbed.length; i += EMBED_CHUNK) {
+        const slice = toEmbed.slice(i, i + EMBED_CHUNK);
+        const vecs = await embedder.embed(slice.map((t) => t.text));
+        slice.forEach((t, j) => {
+          const vec = vecs[j] ?? [];
+          vectors.set(t.id, vec);
+          cache.entries[t.id] = { hash: t.hash, vec };
+        });
+        onProgress?.(Math.min(i + EMBED_CHUNK, toEmbed.length), toEmbed.length);
+        if (Date.now() - lastWrite >= CACHE_WRITE_INTERVAL_MS) {
+          persist();
+          lastWrite = Date.now();
+        }
+      }
+      const live = new Set(targets.map((n) => n.id));
+      for (const id of Object.keys(cache.entries)) if (!live.has(id)) delete cache.entries[id];
+      persist();
+    } finally {
+      releaseLock(lock);
+    }
+  }
+  return vectors;
+}
+function safe(id) {
+  return id.replace(/[^a-z0-9.-]+/gi, "_");
+}
+
+// src/engine/relations.ts
+var GraphIndex = class {
+  constructor(graph) {
+    this.graph = graph;
+    for (const n of graph.nodes) this.nodeById.set(n.id, n);
+    for (const e of graph.edges) {
+      push(this.outById, e.src, e);
+      push(this.inById, e.dst, e);
+    }
+  }
+  graph;
+  nodeById = /* @__PURE__ */ new Map();
+  outById = /* @__PURE__ */ new Map();
+  inById = /* @__PURE__ */ new Map();
+  out(id, kind) {
+    const all = this.outById.get(id) ?? [];
+    return kind ? all.filter((e) => e.kind === kind) : all;
+  }
+  in(id, kind) {
+    const all = this.inById.get(id) ?? [];
+    return kind ? all.filter((e) => e.kind === kind) : all;
+  }
+  node(id) {
+    return this.nodeById.get(id);
+  }
+  /**
+   * Resolved nodes called by `id` — invocations (`call`) plus structural
+   * dependency references (`references`, e.g. a constructor-injected field's
+   * type), since both represent real usage a caller/impact question cares
+   * about. `references` is otherwise only emitted by the precise SCIP/tsc
+   * rungs and (for Java DI wiring) the heuristic rung — never a guess.
+   */
+  callees(id) {
+    return this.resolveTargets(this.out(id).filter(isUsageEdge), "dst");
+  }
+  /** Resolved nodes that call or structurally reference `id`. */
+  callers(id) {
+    return this.resolveTargets(this.in(id).filter(isUsageEdge), "src");
+  }
+  resolveTargets(edges, end) {
+    const out = [];
+    for (const e of edges) {
+      const node = this.nodeById.get(e[end]);
+      if (node) out.push({ edge: e, node });
+    }
+    return out;
+  }
+};
+var USAGE_KINDS = /* @__PURE__ */ new Set(["call", "references"]);
+function isUsageEdge(e) {
+  return USAGE_KINDS.has(e.kind);
+}
+function push(map, key, value) {
+  const list = map.get(key);
+  if (list) list.push(value);
+  else map.set(key, [value]);
+}
+var INDEX_CACHE = /* @__PURE__ */ new WeakMap();
+function indexFor(graph) {
+  let idx = INDEX_CACHE.get(graph);
+  if (!idx) {
+    idx = new GraphIndex(graph);
+    INDEX_CACHE.set(graph, idx);
+  }
+  return idx;
+}
+
+// src/engine/query.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "to",
+  "of",
+  "in",
+  "on",
+  "for",
+  "and",
+  "or",
+  "where",
+  "what",
+  "which",
+  "how",
+  "do",
+  "does",
+  "did",
+  "i",
+  "we",
+  "it",
+  "this",
+  "that",
+  "with",
+  "when",
+  "who",
+  "why",
+  "can",
+  "should",
+  "my",
+  "our",
+  "you",
+  "your",
+  "from",
+  "by",
+  "at",
+  "as",
+  // Discovery-question scaffolding: words a caller uses to FRAME the ask
+  // ("find the code responsible for X", "I need to modify X, where do I
+  // start?", "explain how X works in this codebase") rather than to name the
+  // target. Left in, these compete on equal footing with the real identifier
+  // terms and can outrank it outright — e.g. "find the code responsible for
+  // deleteAsync" let "find" alone drag in every FindByIdAsync/FindAll method
+  // in the repo, none of them the target (VG-LOCATE-FAILURE-ANALYSIS.md).
+  "find",
+  "code",
+  "responsible",
+  "need",
+  "modify",
+  "me",
+  "implementation",
+  "explain",
+  "works",
+  "codebase",
+  "contains",
+  "file"
+]);
+function queryGraph(graph, question, options = {}) {
+  const budget = options.budget ?? 2e3;
+  const limit = options.limit ?? 12;
+  const terms = tokenize(question);
+  const weightOf = termWeights(graph, terms);
+  const index = indexFor(graph);
+  const scored = [];
+  for (const node of graph.nodes) {
+    if (node.kind === "file" || node.kind === "external") continue;
+    const { score, why } = scoreNode(node, terms, weightOf);
+    if (score > 0) scored.push({ node, score: round(score * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
+  }
+  scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
+  const seeds = scored.slice(0, limit);
+  const { context, tokensEstimate } = buildContext(graph, index, question, seeds, budget);
+  return { question, matches: seeds, context, tokensEstimate };
+}
+async function queryGraphSemantic(graph, question, options) {
+  const budget = options.budget ?? 2e3;
+  const limit = options.limit ?? 12;
+  const terms = tokenize(question);
+  const weightOf = termWeights(graph, terms);
+  const index = indexFor(graph);
+  const queryVec = await options.embedder.embedQuery(question);
+  const lexRaw = /* @__PURE__ */ new Map();
+  let lexMax = 0;
+  const whyById = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (node.kind === "file" || node.kind === "external") continue;
+    const { score, why } = scoreNode(node, terms, weightOf);
+    lexRaw.set(node.id, score);
+    whyById.set(node.id, why);
+    if (score > lexMax) lexMax = score;
+  }
+  const scored = [];
+  for (const node of graph.nodes) {
+    if (node.kind === "file" || node.kind === "external") continue;
+    const lexNorm = lexMax > 0 ? (lexRaw.get(node.id) ?? 0) / lexMax : 0;
+    const vec = options.nodeVectors.get(node.id);
+    const sem = vec ? Math.max(0, cosine(queryVec, vec)) : 0;
+    const hybrid = 0.5 * lexNorm + 0.5 * sem;
+    if (hybrid <= 0) continue;
+    const lexWhy = whyById.get(node.id);
+    const why = lexWhy || (sem > 0.3 ? `semantic match (${sem.toFixed(2)})` : "weak match");
+    scored.push({ node, score: round(hybrid * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
+  }
+  scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
+  const seeds = scored.slice(0, limit);
+  const { context, tokensEstimate } = buildContext(graph, index, question, seeds, budget);
+  return { question, matches: seeds, context, tokensEstimate };
+}
+function tokenize(q) {
+  return [
+    ...new Set(
+      q.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 1 && !STOPWORDS.has(t))
+    )
+  ];
+}
+function scoreNode(node, terms, weightOf = () => 1) {
+  let score = 0;
+  const hits = [];
+  const name = node.name.toLowerCase();
+  const qn = node.qualifiedName.toLowerCase();
+  const file = node.file.toLowerCase();
+  const nameParts = identifierParts(node.name);
+  for (const t of terms) {
+    const w = weightOf(t);
+    if (name === t) {
+      score += 10 * w;
+      hits.push(t);
+    } else if (nameParts.has(t)) {
+      score += 6 * w;
+      hits.push(t);
+    } else if (name.includes(t)) {
+      score += 4 * w;
+      hits.push(t);
+    } else if (qn.includes(t)) {
+      score += 3 * w;
+      hits.push(t);
+    } else if (fuzzyPartMatch(t, nameParts)) {
+      score += 2 * w;
+      hits.push(`~${t}`);
+    } else if (file.includes(t)) {
+      score += 1 * w;
+      hits.push(t);
+    }
+  }
+  return { score, why: hits.length ? `matched: ${hits.join(", ")}` : "" };
+}
+var IMPORTANCE_WEIGHT = 0.4;
+function termWeights(graph, terms) {
+  if (terms.length === 0) return () => 1;
+  const df = /* @__PURE__ */ new Map();
+  let n = 0;
+  for (const node of graph.nodes) {
+    if (node.kind === "file" || node.kind === "external") continue;
+    n++;
+    const name = node.name.toLowerCase();
+    const parts = identifierParts(node.name);
+    for (const t of terms) {
+      if (parts.has(t) || name.includes(t)) df.set(t, (df.get(t) ?? 0) + 1);
+    }
+  }
+  const w = /* @__PURE__ */ new Map();
+  for (const t of terms) {
+    const idf = Math.log((n + 1) / ((df.get(t) ?? 0) + 1)) + 1;
+    w.set(t, Math.max(0.5, Math.min(8, idf)));
+  }
+  return (t) => w.get(t) ?? 1;
+}
+function identifierParts(name) {
+  return new Set(
+    name.split(/[^\p{L}\p{N}]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/u).filter(Boolean).map((s) => s.toLowerCase())
+  );
+}
+function fuzzyPartMatch(term, parts) {
+  for (const part of parts) {
+    const shared = sharedPrefixLen(term, part);
+    if (shared >= 5 && shared >= 0.6 * Math.min(term.length, part.length)) return true;
+  }
+  return false;
+}
+function sharedPrefixLen(a, b) {
+  const n = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < n && a[i] === b[i]) i++;
+  return i;
+}
+function buildContext(graph, index, question, seeds, budget) {
+  const lines = [];
+  lines.push(`# Context for: ${question}`);
+  lines.push("");
+  if (seeds.length === 0) {
+    lines.push("_No matching symbols found in the map. Try different terms, or `vg hubs` for the most important code._");
+    const text2 = lines.join("\n");
+    return { context: text2, tokensEstimate: estimateTokens(text2) };
+  }
+  for (const { node, why } of seeds) {
+    const block = [];
+    block.push(`## ${node.qualifiedName}  (${node.kind}, ${node.file}:${node.span.start})`);
+    if (node.signature) block.push("`" + node.signature + "`");
+    const callees = index.callees(node.id).map((x) => x.node.qualifiedName);
+    const callers = index.callers(node.id).map((x) => x.node.qualifiedName);
+    if (callees.length) block.push(`calls: ${unique(callees).slice(0, 8).join(", ")}`);
+    if (callers.length) block.push(`called by: ${unique(callers).slice(0, 8).join(", ")}`);
+    block.push(`importance ${node.importance.toFixed(3)} \xB7 area #${node.area}${node.isHub ? " \xB7 hub" : ""} \xB7 ${why}`);
+    block.push("");
+    const candidate = lines.concat(block).join("\n");
+    if (estimateTokens(candidate) > budget && lines.length > 2) break;
+    lines.push(...block);
+  }
+  const text = lines.join("\n");
+  return { context: text, tokensEstimate: estimateTokens(text) };
+}
+function unique(xs) {
+  return [...new Set(xs)];
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function round(x) {
+  return Math.round(x * 1e6) / 1e6;
+}
+
+// src/engine/impact.ts
+var DEPEND_EDGES = /* @__PURE__ */ new Set(["call", "import", "extends", "implements", "references"]);
+function impactOf(graph, rootId, opts = {}) {
+  const maxDepth = Math.max(1, opts.depth ?? 4);
+  const index = indexFor(graph);
+  const root = index.node(rootId);
+  const affected = /* @__PURE__ */ new Map();
+  let minEdgeConfidence = 1;
+  let frontier = [{ id: rootId, conf: 1 }];
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    const nextFrontier = [];
+    for (const { id, conf } of frontier) {
+      for (const e of index.in(id)) {
+        if (!DEPEND_EDGES.has(e.kind)) continue;
+        minEdgeConfidence = Math.min(minEdgeConfidence, e.confidence);
+        const dependentId = e.src;
+        if (dependentId === rootId || affected.has(dependentId)) continue;
+        const node = index.node(dependentId);
+        if (!node) continue;
+        const conf2 = round2(conf * e.confidence * 0.9);
+        affected.set(dependentId, {
+          id: node.id,
+          name: node.qualifiedName,
+          kind: node.kind,
+          file: node.file,
+          line: node.span.start,
+          depth,
+          confidence: conf2
+        });
+        nextFrontier.push({ id: dependentId, conf: conf2 });
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+  const items = [...affected.values()].sort(
+    (a, b) => a.depth - b.depth || b.confidence - a.confidence || a.name.localeCompare(b.name)
+  );
+  return {
+    root: { id: rootId, name: root?.qualifiedName ?? rootId },
+    depth: maxDepth,
+    affected: items,
+    direct: items.filter((i) => i.depth === 1).length,
+    transitive: items.filter((i) => i.depth > 1).length,
+    minEdgeConfidence: round2(minEdgeConfidence)
+  };
+}
+function round2(x) {
+  return Math.round(x * 1e6) / 1e6;
+}
+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 path3.join(cacheDir(root), LEDGER);
+}
+function ledgerPath(root) {
+  return savingsLedgerPath(root);
+}
+function savingsRecorded(root) {
+  return fs3.existsSync(ledgerPath(root));
+}
+function clearSavings(root) {
+  const file = ledgerPath(root);
+  const existed = fs3.existsSync(file);
+  fs3.rmSync(file, { force: true });
+  fs3.rmSync(path3.join(cacheDir(root), "stats-share.json"), { force: true });
+  return existed;
+}
+function recordSaving(root, entry, now) {
+  try {
+    fs3.mkdirSync(cacheDir(root), { recursive: true });
+    const line = JSON.stringify({ ts: now, ...entry });
+    fs3.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 (fs3.existsSync(file)) {
+    for (const line of fs3.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: round22(estCostVg),
+    estCostBaseline: round22(estCostBaseline),
+    saved: round22(estCostBaseline - estCostVg),
+    rateLabel: DEFAULT_RATE_LABEL
+  };
+}
+function round22(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 (fs3.existsSync(file)) {
+    for (const line of fs3.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: round22((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 (fs3.existsSync(file)) {
+    for (const line of fs3.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
+  };
+}
+
+export { CLI_TOOL_ALIASES, GraphIndex, PER_FILE_TOKENS, SAVINGS_TOOLS, acquireLock, cacheDir, clearModelCache, clearSavings, cosine, countPending, embeddingsCached, getNodeEmbeddings, identifierParts, impactOf, indexFor, isModelReady, loadCache, loadEmbedder, modelCacheInfo, nodeEmbedText, parseGraph, queryGraph, queryGraphSemantic, readModelSavings, readSavings, readUsage, recordCliCall, recordSaving, releaseLock, resolveEmbedModel, sanitizeClient, savingsLedgerPath, savingsRecorded, serializeGraph, stableStringify, unavailableMessage, withTimeout };
+//# sourceMappingURL=chunk-WNIIKCNF.js.map
+//# sourceMappingURL=chunk-WNIIKCNF.js.map