@vibgrate/cli 2026.722.2 → 2026.727.2

package/dist/chunk-J7LKEB2R.js

@@ -0,0 +1,51 @@
+// src/engine/lookup.ts
+function findNodes(graph, query) {
+  const q = query.trim();
+  if (!q) return [];
+  const byId = graph.nodes.filter((n) => n.id === q);
+  if (byId.length) return byId;
+  const fileLine = /^(.*):(\d+)$/.exec(q);
+  if (fileLine) {
+    const file = fileLine[1];
+    const line = Number(fileLine[2]);
+    const spanning = graph.nodes.filter((n) => n.file === file && n.span.start <= line && n.span.end >= line && n.kind !== "file").sort((a, b) => a.span.end - a.span.start - (b.span.end - b.span.start));
+    if (spanning.length) return spanning;
+  }
+  if (/[*?]/.test(q)) {
+    const re = globToRegExp(q);
+    return rank(graph.nodes.filter((n) => re.test(n.qualifiedName) || re.test(n.name) || re.test(n.file)));
+  }
+  const byQn = graph.nodes.filter((n) => n.qualifiedName === q);
+  if (byQn.length) return rank(byQn);
+  const byName = graph.nodes.filter((n) => n.name === q);
+  if (byName.length) return rank(byName);
+  const lower = q.toLowerCase();
+  const ci = graph.nodes.filter(
+    (n) => n.qualifiedName.toLowerCase() === lower || n.name.toLowerCase() === lower
+  );
+  if (ci.length) return rank(ci);
+  return rank(graph.nodes.filter((n) => n.qualifiedName.toLowerCase().includes(lower))).slice(0, 25);
+}
+function resolveOne(graph, query, pick) {
+  const candidates = findNodes(graph, query);
+  if (candidates.length === 0) return { candidates };
+  if (pick && pick >= 1 && pick <= candidates.length) return { node: candidates[pick - 1], candidates };
+  if (candidates.length === 1) return { node: candidates[0], candidates };
+  return { candidates };
+}
+function nodeById(graph, id) {
+  return graph.nodes.find((n) => n.id === id);
+}
+function rank(nodes) {
+  return [...nodes].sort(
+    (a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName)
+  );
+}
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+
+export { findNodes, nodeById, resolveOne };
+//# sourceMappingURL=chunk-J7LKEB2R.js.map
+//# sourceMappingURL=chunk-J7LKEB2R.js.map

package/dist/chunk-J7LKEB2R.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/lookup.ts"],"names":[],"mappings":"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","file":"chunk-J7LKEB2R.js","sourcesContent":["import type { GraphNode, VgGraph } from '../schema.js';\n\n/**\n * Lenient node resolution (VG-CLI-SPEC §3.3): resolve `<name>` by content-hash\n * id, qualified name, `file:line`, short name, or glob. Returns candidates\n * ranked by importance so the best match is first; ambiguity is surfaced (the\n * caller offers `--pick`). Deterministic ordering throughout.\n */\nexport function findNodes(graph: VgGraph, query: string): GraphNode[] {\n  const q = query.trim();\n  if (!q) return [];\n\n  // 1. exact content-hash id\n  const byId = graph.nodes.filter((n) => n.id === q);\n  if (byId.length) return byId;\n\n  // 2. file:line (e.g. src/order.ts:12) → smallest node spanning that line\n  const fileLine = /^(.*):(\\d+)$/.exec(q);\n  if (fileLine) {\n    const file = fileLine[1];\n    const line = Number(fileLine[2]);\n    const spanning = graph.nodes\n      .filter((n) => n.file === file && n.span.start <= line && n.span.end >= line && n.kind !== 'file')\n      .sort((a, b) => a.span.end - a.span.start - (b.span.end - b.span.start));\n    if (spanning.length) return spanning;\n  }\n\n  // 3. glob (contains * or ?)\n  if (/[*?]/.test(q)) {\n    const re = globToRegExp(q);\n    return rank(graph.nodes.filter((n) => re.test(n.qualifiedName) || re.test(n.name) || re.test(n.file)));\n  }\n\n  // 4. exact qualified name, then short name, then case-insensitive\n  const byQn = graph.nodes.filter((n) => n.qualifiedName === q);\n  if (byQn.length) return rank(byQn);\n  const byName = graph.nodes.filter((n) => n.name === q);\n  if (byName.length) return rank(byName);\n\n  const lower = q.toLowerCase();\n  const ci = graph.nodes.filter(\n    (n) => n.qualifiedName.toLowerCase() === lower || n.name.toLowerCase() === lower,\n  );\n  if (ci.length) return rank(ci);\n\n  // 5. substring on qualified name (last resort, ranked)\n  return rank(graph.nodes.filter((n) => n.qualifiedName.toLowerCase().includes(lower))).slice(0, 25);\n}\n\n/** Resolve to a single node, honoring a 1-based `--pick`. */\nexport function resolveOne(\n  graph: VgGraph,\n  query: string,\n  pick?: number,\n): { node?: GraphNode; candidates: GraphNode[] } {\n  const candidates = findNodes(graph, query);\n  if (candidates.length === 0) return { candidates };\n  if (pick && pick >= 1 && pick <= candidates.length) return { node: candidates[pick - 1], candidates };\n  if (candidates.length === 1) return { node: candidates[0], candidates };\n  return { candidates }; // ambiguous\n}\n\nexport function nodeById(graph: VgGraph, id: string): GraphNode | undefined {\n  return graph.nodes.find((n) => n.id === id);\n}\n\nfunction rank(nodes: GraphNode[]): GraphNode[] {\n  return [...nodes].sort(\n    (a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName),\n  );\n}\n\nfunction globToRegExp(glob: string): RegExp {\n  const escaped = glob.replace(/[.+^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\*/g, '.*').replace(/\\?/g, '.');\n  return new RegExp(`^${escaped}$`, 'i');\n}\n"]}

package/dist/chunk-JIBOJTGS.js

@@ -0,0 +1,313 @@
+import { createHash } from 'crypto';
+
+// src/runtime/identifier-trie.ts
+function createTrieNode() {
+  return { children: /* @__PURE__ */ new Map(), terminal: false };
+}
+function trieInsert(root, word) {
+  let node = root;
+  for (const ch of word) {
+    let next = node.children.get(ch);
+    if (!next) {
+      next = createTrieNode();
+      node.children.set(ch, next);
+    }
+    node = next;
+  }
+  node.terminal = true;
+}
+function trieHas(root, word) {
+  let node = root;
+  for (const ch of word) {
+    const next = node.children.get(ch);
+    if (!next) return false;
+    node = next;
+  }
+  return node.terminal;
+}
+function trieHasPrefix(root, prefix) {
+  let node = root;
+  for (const ch of prefix) {
+    const next = node.children.get(ch);
+    if (!next) return false;
+    node = next;
+  }
+  return true;
+}
+function buildIdentifierTrieFromGraph(graph) {
+  const root = createTrieNode();
+  const seen = /* @__PURE__ */ new Set();
+  const add = (s) => {
+    const t = (s ?? "").trim();
+    if (!t || seen.has(t)) return;
+    seen.add(t);
+    trieInsert(root, t);
+    for (const part of t.split(/[./:#]/)) {
+      const p = part.trim();
+      if (!p || seen.has(p)) continue;
+      seen.add(p);
+      trieInsert(root, p);
+    }
+  };
+  for (const n of graph.nodes) {
+    add(n.name);
+    add(n.qualifiedName);
+    add(n.id);
+  }
+  return root;
+}
+function trieAllowedNextChars(root, prefix) {
+  let node = root;
+  for (const ch of prefix) {
+    const next = node.children.get(ch);
+    if (!next) return [];
+    node = next;
+  }
+  return [...node.children.keys()].sort();
+}
+function trieEnumerateWords(root, limit = 4096) {
+  const out = [];
+  const walk = (n, acc) => {
+    if (out.length >= limit) return;
+    if (n.terminal && acc.length > 0) out.push(acc);
+    for (const [ch, child] of [...n.children.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+      walk(child, acc + ch);
+      if (out.length >= limit) return;
+    }
+  };
+  walk(root, "");
+  return out;
+}
+
+// src/runtime/identifier-mask.ts
+var IDENT_RE = /\b[A-Za-z_][A-Za-z0-9_]{2,}\b/g;
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "var",
+  "let",
+  "const",
+  "function",
+  "class",
+  "return",
+  "import",
+  "export",
+  "from",
+  "async",
+  "await",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "this",
+  "new",
+  "typeof",
+  "interface",
+  "type",
+  "string",
+  "number",
+  "boolean",
+  "void",
+  "any",
+  "unknown",
+  "Promise",
+  "Array",
+  "Object",
+  "Error",
+  "console",
+  "process",
+  "require",
+  "module",
+  "exports",
+  "default",
+  "extends",
+  "implements",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "readonly",
+  "if",
+  "else",
+  "while",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "with",
+  "yield",
+  "of",
+  "in",
+  "as",
+  "is",
+  "get",
+  "set"
+]);
+function extractIdentifiers(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(IDENT_RE)) {
+    const t = m[0];
+    if (STOP.has(t) || STOP.has(t.toLowerCase())) continue;
+    out.add(t);
+  }
+  return [...out].sort();
+}
+function scanIdentifiersAgainstTrie(text, trie) {
+  const known = [];
+  const unknown = [];
+  for (const id of extractIdentifiers(text)) {
+    if (trieHas(trie, id) || trieHasPrefix(trie, id)) known.push(id);
+    else unknown.push(id);
+  }
+  return { known, unknown, clean: unknown.length === 0 };
+}
+function maskAllowedNextChars(trie, partialIdent) {
+  return trieAllowedNextChars(trie, partialIdent);
+}
+function annotateUnknownIdentifiers(text, trie) {
+  const scan = scanIdentifiersAgainstTrie(text, trie);
+  if (scan.clean) return { text, unknown: [] };
+  const note = `
+
+/* vg: unknown identifiers vs graph (not rewritten): ${scan.unknown.slice(0, 12).join(", ")}${scan.unknown.length > 12 ? "\u2026" : ""} */`;
+  return { text: text + note, unknown: scan.unknown };
+}
+var KV_CACHE_SCHEMA = "kv-cache/0";
+function contentHash(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+function approxTokens(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function blockMeta(kind, text, now = Date.now()) {
+  return {
+    hash: contentHash(text),
+    kind,
+    bytes: Buffer.byteLength(text, "utf8"),
+    approxTokens: approxTokens(text),
+    createdAt: now
+  };
+}
+var KvBlockRegistry = class {
+  warm = /* @__PURE__ */ new Map();
+  markWarm(meta) {
+    this.warm.set(meta.hash, meta);
+  }
+  isWarm(hash) {
+    return this.warm.has(hash);
+  }
+  get(hash) {
+    return this.warm.get(hash);
+  }
+  clear() {
+    this.warm.clear();
+  }
+  size() {
+    return this.warm.size;
+  }
+  /**
+   * Plan assembly for ordered text segments. Hits reuse warm blocks; misses
+   * need prefill. After a successful forward pass, call {@link commit} on miss hashes.
+   */
+  plan(segments, cursor) {
+    const order = [];
+    const hit = [];
+    const miss = [];
+    let hitTokens = 0;
+    let totalTokens = 0;
+    for (const seg of segments) {
+      const meta = blockMeta(seg.kind, seg.text);
+      order.push(meta.hash);
+      totalTokens += meta.approxTokens;
+      if (this.isWarm(meta.hash)) {
+        hit.push(meta.hash);
+        hitTokens += meta.approxTokens;
+      } else {
+        miss.push({ hash: meta.hash, kind: meta.kind, approxTokens: meta.approxTokens });
+      }
+    }
+    let cursorSkipBlocks = 0;
+    let deltaTokens = totalTokens;
+    if (cursor) {
+      const d = cursor.delta(order, segments);
+      cursorSkipBlocks = d.skipBlocks;
+      deltaTokens = d.evaluateTokens;
+    }
+    return {
+      schemaVersion: KV_CACHE_SCHEMA,
+      hit,
+      miss,
+      order,
+      hitTokens,
+      totalTokens,
+      cursorSkipBlocks,
+      deltaTokens
+    };
+  }
+  /** After prefill, mark miss segments warm. */
+  commit(segments) {
+    for (const seg of segments) {
+      this.markWarm(blockMeta(seg.kind, seg.text));
+    }
+  }
+};
+var SessionPrefixCursor = class {
+  chain = [];
+  /** Hashes currently considered evaluated on the sequence. */
+  get evaluatedHashes() {
+    return this.chain;
+  }
+  /**
+   * Compute how many leading blocks match the previous chain and how many
+   * approx tokens still need evaluate (from the fork point).
+   */
+  delta(order, segments) {
+    let skip = 0;
+    while (skip < order.length && skip < this.chain.length && order[skip] === this.chain[skip]) {
+      skip++;
+    }
+    let evaluateTokens = 0;
+    const parts = [];
+    for (let i = skip; i < segments.length; i++) {
+      const meta = blockMeta(segments[i].kind, segments[i].text);
+      evaluateTokens += meta.approxTokens;
+      parts.push(segments[i].text);
+    }
+    return { skipBlocks: skip, evaluateTokens, evaluateText: parts.join("\n") };
+  }
+  /** After successful evaluate of full ordered hashes, advance the cursor. */
+  commit(order) {
+    this.chain = [...order];
+  }
+  /** Reset after sequence dispose / model reload. */
+  reset() {
+    this.chain = [];
+  }
+};
+function longestWarmPrefix(registry, segments) {
+  let count = 0;
+  let tokens = 0;
+  const hashes = [];
+  const parts = [];
+  for (const seg of segments) {
+    const meta = blockMeta(seg.kind, seg.text);
+    if (!registry.isWarm(meta.hash)) break;
+    count++;
+    tokens += meta.approxTokens;
+    hashes.push(meta.hash);
+    parts.push(seg.text);
+  }
+  return { count, tokens, text: parts.join("\n"), hashes };
+}
+function graphDraftCandidates(knownVerbatim, max = 8) {
+  return knownVerbatim.map((s) => s.trim()).filter((s) => s.length >= 8 && s.length <= 400).slice(0, max);
+}
+
+export { KvBlockRegistry, SessionPrefixCursor, annotateUnknownIdentifiers, buildIdentifierTrieFromGraph, contentHash, extractIdentifiers, graphDraftCandidates, longestWarmPrefix, maskAllowedNextChars, scanIdentifiersAgainstTrie, trieEnumerateWords, trieHas, trieHasPrefix };
+//# sourceMappingURL=chunk-JIBOJTGS.js.map
+//# sourceMappingURL=chunk-JIBOJTGS.js.map

package/dist/chunk-JIBOJTGS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime/identifier-trie.ts","../src/runtime/identifier-mask.ts","../src/runtime/kv-cache.ts"],"names":[],"mappings":"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","file":"chunk-JIBOJTGS.js","sourcesContent":["/**\n * Identifier trie for future logit masking (Approach B sampler hooks).\n *\n * Built from ActiveGraph symbol short/qualified names so constrained generation\n * can refuse identifiers that do not exist in the repo. Pure data structure —\n * no model binding required to unit-test.\n */\n\nexport interface TrieNode {\n  children: Map<string, TrieNode>;\n  terminal: boolean;\n}\n\nexport function createTrieNode(): TrieNode {\n  return { children: new Map(), terminal: false };\n}\n\nexport function trieInsert(root: TrieNode, word: string): void {\n  let node = root;\n  for (const ch of word) {\n    let next = node.children.get(ch);\n    if (!next) {\n      next = createTrieNode();\n      node.children.set(ch, next);\n    }\n    node = next;\n  }\n  node.terminal = true;\n}\n\nexport function trieHas(root: TrieNode, word: string): boolean {\n  let node = root;\n  for (const ch of word) {\n    const next = node.children.get(ch);\n    if (!next) return false;\n    node = next;\n  }\n  return node.terminal;\n}\n\nexport function trieHasPrefix(root: TrieNode, prefix: string): boolean {\n  let node = root;\n  for (const ch of prefix) {\n    const next = node.children.get(ch);\n    if (!next) return false;\n    node = next;\n  }\n  return true;\n}\n\n/** Completions that extend `prefix` (capped). */\nexport function trieComplete(root: TrieNode, prefix: string, limit = 32): string[] {\n  let node = root;\n  for (const ch of prefix) {\n    const next = node.children.get(ch);\n    if (!next) return [];\n    node = next;\n  }\n  const out: string[] = [];\n  const walk = (n: TrieNode, acc: string): void => {\n    if (out.length >= limit) return;\n    if (n.terminal) out.push(acc);\n    for (const [ch, child] of [...n.children.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {\n      walk(child, acc + ch);\n      if (out.length >= limit) return;\n    }\n  };\n  walk(node, prefix);\n  return out;\n}\n\nexport interface GraphLikeForTrie {\n  nodes: Array<{ name?: string; qualifiedName?: string; id?: string }>;\n}\n\n/**\n * Build a trie of symbol identifiers from a graph. Includes short names and\n * the last segment of qualified names (e.g. `Foo` from `pkg.Foo`).\n */\nexport function buildIdentifierTrieFromGraph(graph: GraphLikeForTrie): TrieNode {\n  const root = createTrieNode();\n  const seen = new Set<string>();\n  const add = (s: string | undefined): void => {\n    const t = (s ?? '').trim();\n    if (!t || seen.has(t)) return;\n    seen.add(t);\n    trieInsert(root, t);\n    // Path segments for dotted / slash-qualified names (e.g. pkg.util.Foo → util, Foo).\n    for (const part of t.split(/[./:#]/)) {\n      const p = part.trim();\n      if (!p || seen.has(p)) continue;\n      seen.add(p);\n      trieInsert(root, p);\n    }\n  };\n  for (const n of graph.nodes) {\n    add(n.name);\n    add(n.qualifiedName);\n    add(n.id);\n  }\n  return root;\n}\n\n/** Characters allowed to continue after `prefix` under the trie (for logit mask). */\nexport function trieAllowedNextChars(root: TrieNode, prefix: string): string[] {\n  let node = root;\n  for (const ch of prefix) {\n    const next = node.children.get(ch);\n    if (!next) return [];\n    node = next;\n  }\n  return [...node.children.keys()].sort();\n}\n\n/**\n * Enumerate terminal words in the trie (capped). Used to positively bias known\n * graph identifiers when building a TokenBias without scanning the full vocab.\n */\nexport function trieEnumerateWords(root: TrieNode, limit = 4096): string[] {\n  const out: string[] = [];\n  const walk = (n: TrieNode, acc: string): void => {\n    if (out.length >= limit) return;\n    if (n.terminal && acc.length > 0) out.push(acc);\n    for (const [ch, child] of [...n.children.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {\n      walk(child, acc + ch);\n      if (out.length >= limit) return;\n    }\n  };\n  walk(root, '');\n  return out;\n}\n","/**\n * Identifier masking helpers for Approach B sampler integration.\n *\n * Full logit masking needs the llama.cpp binding's token callback. Until that\n * hook is universal across binding versions, we:\n *  1. Expose allowed-next-char sets from the trie (for native mask hooks)\n *  2. Post-validate free-text model output for repo identifiers\n *  3. Optionally rewrite / flag unknown identifiers in code-like spans\n */\n\nimport type { TrieNode } from './identifier-trie.js';\nimport { trieAllowedNextChars, trieHas, trieHasPrefix } from './identifier-trie.js';\n\n/** JS/TS-ish identifier token (conservative). */\nconst IDENT_RE = /\\b[A-Za-z_][A-Za-z0-9_]{2,}\\b/g;\n\n/** Tokens we never treat as \"must exist in the graph\". */\nconst STOP = new Set([\n  'the',\n  'and',\n  'for',\n  'var',\n  'let',\n  'const',\n  'function',\n  'class',\n  'return',\n  'import',\n  'export',\n  'from',\n  'async',\n  'await',\n  'true',\n  'false',\n  'null',\n  'undefined',\n  'this',\n  'new',\n  'typeof',\n  'interface',\n  'type',\n  'string',\n  'number',\n  'boolean',\n  'void',\n  'any',\n  'unknown',\n  'Promise',\n  'Array',\n  'Object',\n  'Error',\n  'console',\n  'process',\n  'require',\n  'module',\n  'exports',\n  'default',\n  'extends',\n  'implements',\n  'public',\n  'private',\n  'protected',\n  'static',\n  'readonly',\n  'if',\n  'else',\n  'while',\n  'switch',\n  'case',\n  'break',\n  'continue',\n  'try',\n  'catch',\n  'finally',\n  'throw',\n  'with',\n  'yield',\n  'of',\n  'in',\n  'as',\n  'is',\n  'get',\n  'set',\n]);\n\nexport interface IdentifierScanResult {\n  /** Identifiers that appear in text and exist in the trie. */\n  known: string[];\n  /** Identifiers that appear in text but are absent from the trie. */\n  unknown: string[];\n  /** True when every scanned identifier is known (or stopword). */\n  clean: boolean;\n}\n\n/** Extract candidate identifiers from model text. */\nexport function extractIdentifiers(text: string): string[] {\n  const out = new Set<string>();\n  for (const m of text.matchAll(IDENT_RE)) {\n    const t = m[0];\n    if (STOP.has(t) || STOP.has(t.toLowerCase())) continue;\n    out.add(t);\n  }\n  return [...out].sort();\n}\n\nexport function scanIdentifiersAgainstTrie(text: string, trie: TrieNode): IdentifierScanResult {\n  const known: string[] = [];\n  const unknown: string[] = [];\n  for (const id of extractIdentifiers(text)) {\n    if (trieHas(trie, id) || trieHasPrefix(trie, id)) known.push(id);\n    else unknown.push(id);\n  }\n  return { known, unknown, clean: unknown.length === 0 };\n}\n\n/**\n * Allowed next characters for a partial identifier under the trie — the hook\n * surface for real logit masks when the binding supports custom samplers.\n */\nexport function maskAllowedNextChars(trie: TrieNode, partialIdent: string): string[] {\n  return trieAllowedNextChars(trie, partialIdent);\n}\n\n/**\n * Annotate model output when unknown identifiers appear (non-destructive).\n * Returns original text when clean; otherwise appends a short warning block the\n * agent/tools can surface without rewriting the patch body blindly.\n */\nexport function annotateUnknownIdentifiers(text: string, trie: TrieNode): { text: string; unknown: string[] } {\n  const scan = scanIdentifiersAgainstTrie(text, trie);\n  if (scan.clean) return { text, unknown: [] };\n  const note = `\\n\\n/* vg: unknown identifiers vs graph (not rewritten): ${scan.unknown.slice(0, 12).join(', ')}${scan.unknown.length > 12 ? '…' : ''} */`;\n  return { text: text + note, unknown: scan.unknown };\n}\n","/**\n * Block-level KV / prompt prefix cache keyed by content hash (Approach B).\n *\n * Pure planning layer + multi-turn prefix cursor (P1/P2). The warm host uses\n * {@link longestWarmPrefix} / {@link SessionPrefixCursor} and may call the\n * binding's `evaluateWithoutGeneratingNewTokens` so RoPE state for warm\n * system/capsule blocks is not rebuilt every turn.\n *\n * schemaVersion: kv-cache/0\n */\n\nimport { createHash } from 'node:crypto';\n\nexport const KV_CACHE_SCHEMA = 'kv-cache/0' as const;\n\nexport interface KvBlockMeta {\n  /** Content hash (sha256 hex, truncated in keys for path safety). */\n  hash: string;\n  /** Human label (system, capsule, tools, …). */\n  kind: string;\n  /** UTF-8 byte length of the source text. */\n  bytes: number;\n  /** Approx token count (chars/4 heuristic when unknown). */\n  approxTokens: number;\n  /** When this block entered the registry. */\n  createdAt: number;\n}\n\nexport interface KvAssemblyPlan {\n  schemaVersion: typeof KV_CACHE_SCHEMA;\n  /** Blocks to reuse from cache (hashes). */\n  hit: string[];\n  /** Blocks that must be prefilled (hash + kind). */\n  miss: Array<{ hash: string; kind: string; approxTokens: number }>;\n  /** Ordered sequence of block hashes for the full prompt. */\n  order: string[];\n  /** Estimated tokens already “warm” vs total. */\n  hitTokens: number;\n  totalTokens: number;\n  /**\n   * P2: tokens that must be re-evaluated because the multi-turn cursor\n   * diverged (subset of miss + trailing hits after fork).\n   */\n  deltaTokens?: number;\n  /** How many leading blocks the session cursor already has evaluated. */\n  cursorSkipBlocks?: number;\n}\n\nexport function contentHash(text: string): string {\n  return createHash('sha256').update(text, 'utf8').digest('hex');\n}\n\nexport function approxTokens(text: string): number {\n  return Math.max(1, Math.ceil(text.length / 4));\n}\n\nexport function blockMeta(kind: string, text: string, now = Date.now()): KvBlockMeta {\n  return {\n    hash: contentHash(text),\n    kind,\n    bytes: Buffer.byteLength(text, 'utf8'),\n    approxTokens: approxTokens(text),\n    createdAt: now,\n  };\n}\n\n/** In-memory registry of which content hashes are considered warm. */\nexport class KvBlockRegistry {\n  private readonly warm = new Map<string, KvBlockMeta>();\n\n  markWarm(meta: KvBlockMeta): void {\n    this.warm.set(meta.hash, meta);\n  }\n\n  isWarm(hash: string): boolean {\n    return this.warm.has(hash);\n  }\n\n  get(hash: string): KvBlockMeta | undefined {\n    return this.warm.get(hash);\n  }\n\n  clear(): void {\n    this.warm.clear();\n  }\n\n  size(): number {\n    return this.warm.size;\n  }\n\n  /**\n   * Plan assembly for ordered text segments. Hits reuse warm blocks; misses\n   * need prefill. After a successful forward pass, call {@link commit} on miss hashes.\n   */\n  plan(segments: Array<{ kind: string; text: string }>, cursor?: SessionPrefixCursor): KvAssemblyPlan {\n    const order: string[] = [];\n    const hit: string[] = [];\n    const miss: KvAssemblyPlan['miss'] = [];\n    let hitTokens = 0;\n    let totalTokens = 0;\n    for (const seg of segments) {\n      const meta = blockMeta(seg.kind, seg.text);\n      order.push(meta.hash);\n      totalTokens += meta.approxTokens;\n      if (this.isWarm(meta.hash)) {\n        hit.push(meta.hash);\n        hitTokens += meta.approxTokens;\n      } else {\n        miss.push({ hash: meta.hash, kind: meta.kind, approxTokens: meta.approxTokens });\n      }\n    }\n    let cursorSkipBlocks = 0;\n    let deltaTokens = totalTokens;\n    if (cursor) {\n      const d = cursor.delta(order, segments);\n      cursorSkipBlocks = d.skipBlocks;\n      deltaTokens = d.evaluateTokens;\n    }\n    return {\n      schemaVersion: KV_CACHE_SCHEMA,\n      hit,\n      miss,\n      order,\n      hitTokens,\n      totalTokens,\n      cursorSkipBlocks,\n      deltaTokens,\n    };\n  }\n\n  /** After prefill, mark miss segments warm. */\n  commit(segments: Array<{ kind: string; text: string }>): void {\n    for (const seg of segments) {\n      this.markWarm(blockMeta(seg.kind, seg.text));\n    }\n  }\n}\n\n/**\n * Multi-turn cursor: remembers the hash chain last evaluated on the sequence\n * so we only re-evaluate from the first divergence (P2 RoPE-friendly delta).\n */\nexport class SessionPrefixCursor {\n  private chain: string[] = [];\n\n  /** Hashes currently considered evaluated on the sequence. */\n  get evaluatedHashes(): readonly string[] {\n    return this.chain;\n  }\n\n  /**\n   * Compute how many leading blocks match the previous chain and how many\n   * approx tokens still need evaluate (from the fork point).\n   */\n  delta(\n    order: string[],\n    segments: Array<{ kind: string; text: string }>,\n  ): { skipBlocks: number; evaluateTokens: number; evaluateText: string } {\n    let skip = 0;\n    while (skip < order.length && skip < this.chain.length && order[skip] === this.chain[skip]) {\n      skip++;\n    }\n    let evaluateTokens = 0;\n    const parts: string[] = [];\n    for (let i = skip; i < segments.length; i++) {\n      const meta = blockMeta(segments[i].kind, segments[i].text);\n      evaluateTokens += meta.approxTokens;\n      parts.push(segments[i].text);\n    }\n    return { skipBlocks: skip, evaluateTokens, evaluateText: parts.join('\\n') };\n  }\n\n  /** After successful evaluate of full ordered hashes, advance the cursor. */\n  commit(order: string[]): void {\n    this.chain = [...order];\n  }\n\n  /** Reset after sequence dispose / model reload. */\n  reset(): void {\n    this.chain = [];\n  }\n}\n\n/**\n * Longest leading run of warm segments (stable system/capsule prefix).\n * Host can skip re-prefilling these when the sequence API allows evaluate-only.\n */\nexport function longestWarmPrefix(\n  registry: KvBlockRegistry,\n  segments: Array<{ kind: string; text: string }>,\n): {\n  count: number;\n  tokens: number;\n  text: string;\n  hashes: string[];\n} {\n  let count = 0;\n  let tokens = 0;\n  const hashes: string[] = [];\n  const parts: string[] = [];\n  for (const seg of segments) {\n    const meta = blockMeta(seg.kind, seg.text);\n    if (!registry.isWarm(meta.hash)) break;\n    count++;\n    tokens += meta.approxTokens;\n    hashes.push(meta.hash);\n    parts.push(seg.text);\n  }\n  return { count, tokens, text: parts.join('\\n'), hashes };\n}\n\n/**\n * Speculative draft tokens for quotational spans the graph already knows\n * verbatim (signatures / imports). The big model verifies; high acceptance\n * expected on code. Pure: returns candidate draft strings, does not call a model.\n */\nexport function graphDraftCandidates(\n  knownVerbatim: string[],\n  max = 8,\n): string[] {\n  return knownVerbatim\n    .map((s) => s.trim())\n    .filter((s) => s.length >= 8 && s.length <= 400)\n    .slice(0, max);\n}\n"]}

package/dist/chunk-K3MZIVZW.js

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// 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/4";
+function cacheDir(root) {
+  return path.join(root, ".vibgrate", "cache");
+}
+function cachePath(root) {
+  return path.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 && fs.existsSync(file)) {
+    try {
+      const loaded = JSON.parse(fs.readFileSync(file, "utf8"));
+      if ((loaded.version === CACHE_VERSION || loaded.version === "vg-parse-cache/3") && loaded.toolVersion === opts.toolVersion && loaded.grammars === opts.grammars && loaded.entries) {
+        data = { ...loaded, version: CACHE_VERSION };
+      }
+    } catch {
+    }
+  }
+  return {
+    get(rel, hash) {
+      const entry = data.entries[rel];
+      return entry && entry.hash === hash ? entry.parse : void 0;
+    },
+    getByStat(rel, mtimeMs, size) {
+      const entry = data.entries[rel];
+      if (!entry) return void 0;
+      if (entry.mtimeMs === mtimeMs && entry.size === size && entry.parse) {
+        return { parse: entry.parse, hash: entry.hash };
+      }
+      return void 0;
+    },
+    set(rel, parse, stat) {
+      data.entries[rel] = {
+        hash: parse.hash,
+        parse,
+        mtimeMs: stat?.mtimeMs,
+        size: stat?.size
+      };
+    },
+    prune(currentRels) {
+      for (const rel of Object.keys(data.entries)) {
+        if (!currentRels.has(rel)) delete data.entries[rel];
+      }
+    },
+    save() {
+      fs.mkdirSync(cacheDir(root), { recursive: true });
+      fs.writeFileSync(file, stableStringify(data, 0));
+    }
+  };
+}
+
+export { cacheDir, loadCache, parseGraph, serializeGraph, stableStringify };
+//# sourceMappingURL=chunk-K3MZIVZW.js.map
+//# sourceMappingURL=chunk-K3MZIVZW.js.map

package/dist/chunk-K3MZIVZW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/serialize.ts","../src/engine/cache.ts"],"names":[],"mappings":"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","file":"chunk-K3MZIVZW.js","sourcesContent":["import type { VgGraph } from '../schema.js';\n\n/**\n * Deterministic serialization of `graph.json`.\n *\n * Object keys are sorted recursively and arrays are emitted in the (already\n * stable) order the engine produced them, so two runs over identical content\n * yield byte-identical output — the determinism contract (VG-CLI-SPEC §1.3).\n * Pretty-printed (2-space) and newline-terminated so the committed artifact is\n * human-diffable and plays well with the union merge driver.\n */\nexport function serializeGraph(graph: VgGraph): string {\n  return `${stableStringify(graph, 2)}\\n`;\n}\n\nexport function stableStringify(value: unknown, indent = 2): string {\n  return JSON.stringify(sortKeys(value), null, indent);\n}\n\nfunction sortKeys(value: unknown): unknown {\n  if (Array.isArray(value)) return value.map(sortKeys);\n  if (value && typeof value === 'object') {\n    const input = value as Record<string, unknown>;\n    const out: Record<string, unknown> = {};\n    for (const key of Object.keys(input).sort()) {\n      const v = input[key];\n      if (v === undefined) continue; // omit undefined for stable output\n      out[key] = sortKeys(v);\n    }\n    return out;\n  }\n  return value;\n}\n\nexport function parseGraph(json: string): VgGraph {\n  return JSON.parse(json) as VgGraph;\n}\n","import * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport { stableStringify } from './serialize.js';\nimport type { FileParse } from './types.js';\n\n/**\n * Incremental parse cache. Maps a file's content hash to its parsed\n * symbol/edge tables, so a rebuild re-parses only files whose content actually\n * changed (VG-DEVELOPMENT-PLAN Phase 0.4). Lives under `.vibgrate/cache/` and is\n * gitignored — never part of the committed artifact.\n *\n * The cache is a pure performance optimisation: a reused FileParse is identical\n * to a freshly-parsed one (parsing is pure over content), so the graph is\n * byte-identical whether or not the cache was warm. `--no-cache` / `vg verify`\n * prove this.\n */\n\n// Bumped to /4: optional mtime+size fingerprint for stat-skip fast path.\nconst CACHE_VERSION = 'vg-parse-cache/4';\n\ninterface CacheEntry {\n  hash: string;\n  mtimeMs?: number;\n  size?: number;\n  parse: FileParse;\n}\n\ninterface CacheFile {\n  version: string;\n  toolVersion: string;\n  grammars: string;\n  entries: Record<string, CacheEntry>;\n}\n\nexport interface ParseCache {\n  get(rel: string, hash: string): FileParse | undefined;\n  /** Fast path: mtime+size match → reuse parse without re-reading bytes. */\n  getByStat(rel: string, mtimeMs: number, size: number): { parse: FileParse; hash: string } | undefined;\n  set(rel: string, parse: FileParse, stat?: { mtimeMs: number; size: number }): void;\n  /** Drop entries for files no longer present. */\n  prune(currentRels: Set<string>): void;\n  save(): void;\n}\n\nexport function cacheDir(root: string): string {\n  return path.join(root, '.vibgrate', 'cache');\n}\n\nfunction cachePath(root: string): string {\n  return path.join(cacheDir(root), 'parse-cache.json');\n}\n\nexport function loadCache(\n  root: string,\n  opts: { toolVersion: string; grammars: string; disabled?: boolean },\n): ParseCache {\n  const file = cachePath(root);\n  let data: CacheFile = {\n    version: CACHE_VERSION,\n    toolVersion: opts.toolVersion,\n    grammars: opts.grammars,\n    entries: {},\n  };\n\n  if (!opts.disabled && fs.existsSync(file)) {\n    try {\n      const loaded = JSON.parse(fs.readFileSync(file, 'utf8')) as CacheFile;\n      // Accept v3 → v4 (stat fields optional).\n      if (\n        (loaded.version === CACHE_VERSION || loaded.version === 'vg-parse-cache/3') &&\n        loaded.toolVersion === opts.toolVersion &&\n        loaded.grammars === opts.grammars &&\n        loaded.entries\n      ) {\n        data = { ...loaded, version: CACHE_VERSION };\n      }\n    } catch {\n      /* corrupt cache — start fresh */\n    }\n  }\n\n  return {\n    get(rel, hash) {\n      const entry = data.entries[rel];\n      return entry && entry.hash === hash ? entry.parse : undefined;\n    },\n    getByStat(rel, mtimeMs, size) {\n      const entry = data.entries[rel];\n      if (!entry) return undefined;\n      if (entry.mtimeMs === mtimeMs && entry.size === size && entry.parse) {\n        return { parse: entry.parse, hash: entry.hash };\n      }\n      return undefined;\n    },\n    set(rel, parse, stat) {\n      data.entries[rel] = {\n        hash: parse.hash,\n        parse,\n        mtimeMs: stat?.mtimeMs,\n        size: stat?.size,\n      };\n    },\n    prune(currentRels) {\n      for (const rel of Object.keys(data.entries)) {\n        if (!currentRels.has(rel)) delete data.entries[rel];\n      }\n    },\n    save() {\n      fs.mkdirSync(cacheDir(root), { recursive: true });\n      fs.writeFileSync(file, stableStringify(data, 0));\n    },\n  };\n}\n"]}