@vibgrate/cli 2026.819.2 → 2026.824.3

package/dist/chunk-USW5WHUG.js

@@ -0,0 +1,605 @@
+import { cosine } from './chunk-3PNAQUZM.js';
+
+// 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/user-ask.ts
+function userAskFromInstruction(instruction) {
+  if (!instruction) return instruction;
+  const fenced = /\n---\s*\n## User attachments\b[^\n]*\n?/;
+  const m = fenced.exec(instruction);
+  if (m && m.index != null) {
+    return instruction.slice(0, m.index).trimEnd();
+  }
+  const bare = instruction.search(/(?:^|\n)## User attachments\b/);
+  if (bare > 0) {
+    return instruction.slice(0, bare).trimEnd();
+  }
+  if (bare === 0) {
+    return "";
+  }
+  return instruction;
+}
+
+// src/engine/query.ts
+var FUNCTION_WORDS = /* @__PURE__ */ new Set([
+  // Closed-class English: could only ever match by coincidence.
+  "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",
+  // Process verbs. A caller says what they want DONE with these; they never
+  // name the code it should be done to. Left in, bare `add` seeds every
+  // Add*/*Add* symbol in the repo ahead of the terms that carry the subject.
+  "add",
+  "adds",
+  "added",
+  "adding",
+  "create",
+  "creates",
+  "created",
+  "creating",
+  "make",
+  "makes",
+  "making",
+  "made",
+  "remove",
+  "removes",
+  "removed",
+  "removing",
+  "delete",
+  "deletes",
+  "deleted",
+  "deleting",
+  "update",
+  "updates",
+  "updated",
+  "updating",
+  "change",
+  "changes",
+  "changed",
+  "changing",
+  "set",
+  "sets",
+  "setting",
+  "setup",
+  "get",
+  "gets",
+  "getting",
+  "use",
+  "uses",
+  "used",
+  "using",
+  "want",
+  "wants",
+  "wanted",
+  "doing",
+  "done",
+  "support",
+  "supports",
+  "supported",
+  "supporting",
+  "enable",
+  "enables",
+  "enabled",
+  "enabling",
+  "disable",
+  "disables",
+  "disabled",
+  "disabling",
+  "allow",
+  "allows",
+  "allowed",
+  "handle",
+  "handles",
+  "handling",
+  "implement",
+  "implements",
+  "implemented",
+  "implementing",
+  "build",
+  "builds",
+  "building",
+  "built",
+  "need",
+  "needs",
+  "needed",
+  // Filler nouns and connectives: the generic scaffolding of a request.
+  "new",
+  "newly",
+  "via",
+  "through",
+  "into",
+  "onto",
+  "way",
+  "ways",
+  "thing",
+  "things",
+  "stuff",
+  "feature",
+  "features",
+  "functionality",
+  "method",
+  "methods",
+  "option",
+  "options",
+  "ability",
+  "form",
+  "forms",
+  "page",
+  "pages",
+  "screen",
+  "screens",
+  "button",
+  "buttons",
+  "help",
+  "start",
+  "begin",
+  "work",
+  "works",
+  "working",
+  "also",
+  "currently",
+  "properly",
+  "correctly",
+  "please",
+  "happens",
+  "happen",
+  "something",
+  "somewhere",
+  "step",
+  "steps",
+  "flow",
+  "process",
+  // Discovery-question scaffolding: words that FRAME the search itself
+  // ("find the code responsible for X", "explain how X works").
+  "find",
+  "code",
+  "responsible",
+  "modify",
+  "me",
+  "implementation",
+  "explain",
+  "codebase",
+  "contains",
+  "file",
+  // Bug-report framing: says something is WRONG, never what is wrong.
+  // `fix` alone lit up `export_fixed_width_records`, `out` lit up every
+  // *Router*/*rollout* symbol (vg code prompt-relevance corpus).
+  "fix",
+  "fixes",
+  "fixing",
+  "bug",
+  "bugs",
+  "broken",
+  "busted",
+  "borked",
+  "wrong",
+  "incorrect",
+  "incorrectly",
+  "figure",
+  "out",
+  "sure"
+]);
+function cleanUrlNeedle(raw) {
+  let s = raw.trim();
+  s = s.replace(/[.,;:!)\]}>]+$/g, "");
+  if (s.endsWith("?")) {
+    const qi = s.lastIndexOf("?");
+    if (qi === s.length - 1) s = s.slice(0, -1);
+  }
+  return s;
+}
+function extractLiteralNeedles(question) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push2 = (raw, kind) => {
+    let s = raw.trim();
+    s = kind === "url" ? cleanUrlNeedle(s) : s.replace(/[.,;:!)\]}>?]+$/g, "");
+    if (s.length < 2 || seen.has(s)) return;
+    seen.add(s);
+    out.push(s);
+  };
+  for (const m of question.matchAll(/https?:\/\/[^\s"'`<>]+/gi)) push2(m[0], "url");
+  for (const m of question.matchAll(/(["'`])((?:(?!\1)[^\\]|\\.){2,})\1/g)) {
+    push2(m[2].replace(/\\(.)/g, "$1"), "quote");
+  }
+  return out;
+}
+function stripLiteralNeedles(question) {
+  let s = question;
+  for (const m of question.matchAll(/https?:\/\/[^\s"'`<>]+/gi)) {
+    s = s.split(m[0]).join(" ");
+  }
+  for (const lit of extractLiteralNeedles(question)) {
+    s = s.split(lit).join(" ");
+  }
+  s = s.replace(/(["'`])\s*\1/g, " ");
+  return s.replace(/\s+/g, " ").trim();
+}
+function residualForSymbolSearch(question) {
+  const literals = extractLiteralNeedles(question);
+  if (literals.length === 0) return question.trim();
+  const stripped = stripLiteralNeedles(question);
+  return tokenize(stripped).length === 0 ? "" : stripped;
+}
+function isLocateOnlyInstruction(instruction) {
+  const q = userAskFromInstruction(instruction).trim();
+  if (!q) return false;
+  const needles = extractLiteralNeedles(q);
+  const hasLocateFrame = /\b(where\s+is|where\s+are|find\s+(all\s+|every\s+)?occurrence|find\s+occurrences|does\s+not\s+exist|locate|search\s+for)\b/i.test(
+    q
+  ) || needles.length > 0 && /^https?:\/\//i.test(q);
+  const withoutExist = q.replace(/\bdoes\s+not\s+exist\b/gi, " ");
+  if (/\b(fix|edit|change|replace|implement|refactor|rename|patch|create\s+file|delete\s+file|add\s+a\b|remove\s+the\b)\b/i.test(
+    withoutExist
+  )) {
+    return false;
+  }
+  if (needles.some((n) => /^https?:\/\//i.test(n))) return true;
+  return hasLocateFrame && needles.length > 0;
+}
+function queryGraph(graph, question, options = {}) {
+  const budget = options.budget ?? 2e3;
+  const limit = options.limit ?? 12;
+  const literals = extractLiteralNeedles(question);
+  const index = indexFor(graph);
+  let seeds;
+  if (options.ranked) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const node of graph.nodes) byId.set(node.id, node);
+    seeds = options.ranked.hasContent ? options.ranked.seeds.map((s) => {
+      const node = byId.get(s.id);
+      return node ? { node, score: s.score, why: s.why } : null;
+    }).filter((m) => m !== null).slice(0, limit) : [];
+  } else {
+    seeds = mechanicalRank(graph, question, literals).slice(0, limit);
+  }
+  const { context, tokensEstimate } = buildContext(graph, index, question, seeds, budget, literals);
+  return { question, matches: seeds, context, tokensEstimate };
+}
+function mechanicalRank(graph, question, literals) {
+  const forTokens = literals.length > 0 ? stripLiteralNeedles(question) : question;
+  let tokens = tokenize(forTokens);
+  if (literals.length > 0) tokens = tokens.filter((t) => !LOCATE_SCAFFOLD.has(t));
+  if (tokens.length === 0) return [];
+  const scored = [];
+  for (const node of graph.nodes) {
+    if (node.kind === "file" || node.kind === "external") continue;
+    const name = node.name.toLowerCase();
+    const qn = node.qualifiedName.toLowerCase();
+    const parts = identifierParts(node.name);
+    let score = 0;
+    const hits = [];
+    for (const t of tokens) {
+      if (name === t) {
+        score += 10;
+        hits.push(t);
+      } else if (parts.has(t)) {
+        score += 6;
+        hits.push(t);
+      } else if (t.length >= 4 && qn.includes(t)) {
+        score += 3;
+        hits.push(t);
+      }
+    }
+    if (score > 0) {
+      scored.push({
+        node,
+        score: round(score * (1 + IMPORTANCE_WEIGHT * node.importance)),
+        why: `matched: ${hits.join(", ")}`
+      });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
+  return diversifyByFile(scored);
+}
+function tokenize(q) {
+  return [
+    ...new Set(
+      q.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 1 && !FUNCTION_WORDS.has(t))
+    )
+  ];
+}
+var IMPORTANCE_WEIGHT = 0.4;
+var LOCATE_SCAFFOLD = /* @__PURE__ */ new Set([
+  "not",
+  "no",
+  "exist",
+  "exists",
+  "existing",
+  "occurrence",
+  "occurrences",
+  "occurence",
+  "occurences",
+  "find",
+  "every",
+  "place",
+  "places",
+  "string",
+  "literal",
+  "text",
+  "search",
+  "locate",
+  "look",
+  "looking",
+  "show",
+  "list",
+  "all"
+]);
+function diversifyByFile(matches) {
+  const seen = /* @__PURE__ */ new Set();
+  const firstPerFile = [];
+  const rest = [];
+  for (const m of matches) {
+    if (seen.has(m.node.file)) {
+      rest.push(m);
+    } else {
+      seen.add(m.node.file);
+      firstPerFile.push(m);
+    }
+  }
+  return firstPerFile.concat(rest);
+}
+var RRF_K = 60;
+function ranksOf(scores, nameOf) {
+  const ids = [...scores.entries()].filter(([, s]) => s > 0).sort((a, b) => b[1] - a[1] || nameOf(a[0]).localeCompare(nameOf(b[0]))).map(([id]) => id);
+  return new Map(ids.map((id, i) => [id, i + 1]));
+}
+async function queryGraphSemantic(graph, question, options) {
+  const budget = options.budget ?? 2e3;
+  const limit = options.limit ?? 12;
+  const literals = extractLiteralNeedles(question);
+  const forTokens = literals.length > 0 ? stripLiteralNeedles(question) : question;
+  const residualTokens = tokenize(forTokens);
+  const queryVec = options.semanticRanked ? null : await options.embedder?.embedQuery(forTokens || question);
+  const index = indexFor(graph);
+  const lexRaw = /* @__PURE__ */ new Map();
+  const whyById = /* @__PURE__ */ new Map();
+  const lexSeeds = options.ranked ? options.ranked.hasContent ? options.ranked.seeds.map((s) => ({ id: s.id, score: s.score, why: s.why })) : [] : mechanicalRank(graph, question, literals).map((m) => ({ id: m.node.id, score: m.score, why: m.why }));
+  for (const s of lexSeeds) {
+    lexRaw.set(s.id, s.score);
+    whyById.set(s.id, s.why);
+  }
+  const scored = [];
+  if (residualTokens.length > 0 || literals.length === 0) {
+    const semRaw = /* @__PURE__ */ new Map();
+    const nodeById = /* @__PURE__ */ new Map();
+    for (const node of graph.nodes) {
+      if (node.kind === "file" || node.kind === "external") continue;
+      nodeById.set(node.id, node);
+      if (options.semanticRanked || !queryVec) continue;
+      const vec = options.nodeVectors?.get(node.id);
+      const sem = vec && residualTokens.length > 0 ? Math.max(0, cosine(queryVec, vec)) : 0;
+      if (sem > 0) semRaw.set(node.id, sem);
+    }
+    if (options.semanticRanked && residualTokens.length > 0) {
+      for (const { id, score } of options.semanticRanked) {
+        if (score > 0 && nodeById.has(id)) semRaw.set(id, score);
+      }
+    }
+    const nameOf = (id) => nodeById.get(id)?.qualifiedName ?? id;
+    const lexRanks = ranksOf(lexRaw, nameOf);
+    const semRanks = ranksOf(semRaw, nameOf);
+    for (const [id, node] of nodeById) {
+      const lr = lexRanks.get(id);
+      const sr = semRanks.get(id);
+      if (lr === void 0 && sr === void 0) continue;
+      const fused = (lr !== void 0 ? 1 / (RRF_K + lr) : 0) + (sr !== void 0 ? 1 / (RRF_K + sr) : 0);
+      const sem = semRaw.get(id) ?? 0;
+      const lexWhy = whyById.get(id);
+      const why = lexWhy || (sem > 0.3 ? `semantic match (${sem.toFixed(2)})` : "weak match");
+      scored.push({ node, score: round(fused * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
+    }
+    scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
+  }
+  const seeds = diversifyByFile(scored).slice(0, limit);
+  const { context, tokensEstimate } = buildContext(graph, index, question, seeds, budget, literals);
+  return { question, matches: seeds, context, tokensEstimate };
+}
+function identifierParts(name) {
+  return new Set(
+    name.split(/[^\p{L}\p{N}]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[\p{L}])(?=[0-9])|(?<=[0-9])(?=[\p{L}])/u).filter(Boolean).map((s) => s.toLowerCase())
+  );
+}
+function buildContext(graph, index, question, seeds, budget, literals = []) {
+  const lines = [];
+  lines.push(`# Context for: ${question}`);
+  lines.push("");
+  if (literals.length) {
+    lines.push("## Literal string(s) to locate (exact text, not symbol names)");
+    for (const lit of literals) lines.push(`- \`${lit}\``);
+    lines.push(
+      "_Use a quoted phrase / URL search (`search_symbols` or `search_code` with the exact needle) for occurrences. Graph symbols below (if any) are residual identifier hints only._"
+    );
+    lines.push("");
+  }
+  if (seeds.length === 0) {
+    lines.push(
+      literals.length ? "_No graph symbols matched residual terms \u2014 this is expected for a pure string/URL occurrence search. Run a literal sweep on the needle(s) above._" : "_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;
+}
+
+export { GraphIndex, extractLiteralNeedles, identifierParts, impactOf, indexFor, isLocateOnlyInstruction, queryGraph, queryGraphSemantic, residualForSymbolSearch, userAskFromInstruction };
+//# sourceMappingURL=chunk-USW5WHUG.js.map
+//# sourceMappingURL=chunk-USW5WHUG.js.map