mixdog 0.9.2 → 0.9.4

package/src/runtime/agent/orchestrator/tools/code-graph/graph-binary.mjs

@@ -0,0 +1,295 @@
+// Native mixdog-graph binary runner — single source of truth for per-file
+// parsing. NO JS parse fallback: absent binary throws. Extracted verbatim
+// from code-graph.mjs, except _graphBinaryPath's local-build relative path,
+// which gains one extra `../` because this module sits one directory deeper
+// (tools/code-graph/ vs tools/). The resolved absolute path is unchanged.
+import { resolve as pathResolve, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getPluginData } from '../../config.mjs';
+import { ensureGraphBinary, findCachedGraphBinary } from '../graph-binary-fetcher.mjs';
+import { acquire as acquireChildSpawnSlot } from '../../../../shared/child-spawn-gate.mjs';
+import { CODE_GRAPH_BINARY_TIMEOUT_MS, CODE_GRAPH_MAX_FILES } from './constants.mjs';
+
+// ── Native graph binary (mixdog-graph) — single source of truth for
+// per-file parsing. There is NO JS parsing fallback: if the binary is
+// absent the build throws so the caller surfaces a clear, fixable error
+// instead of silently degrading to a slow path.
+function _graphBinaryPath() {
+  const override = process.env.MIXDOG_GRAPH_BIN;
+  if (override && existsSync(override)) return override;
+  // fileURLToPath correctly decodes percent-encoded bytes (spaces, non-ASCII)
+  // and strips the leading-slash/drive-letter quirk on Windows. Using
+  // URL.pathname directly leaves `%20` etc. encoded, breaking paths with
+  // spaces or non-ASCII characters.
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const binName = process.platform === 'win32' ? 'mixdog-graph.exe' : 'mixdog-graph';
+  // Prefer a local cargo build, then a previously fetched/cached prebuilt.
+  // This module is one dir deeper than the legacy code-graph.mjs, so the
+  // relative walk to repo-root native/ needs six `../` hops
+  // (code-graph → tools → orchestrator → agent → runtime → src → root).
+  const localBuild = pathResolve(moduleDir, '../../../../../../native/mixdog-graph/target/release', binName);
+  if (existsSync(localBuild)) return localBuild;
+  try { return findCachedGraphBinary(getPluginData()); } catch { return null; }
+}
+
+async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null) {
+  let binPath = _graphBinaryPath();
+  if (!binPath) {
+    // No local build or cached binary — fetch the prebuilt from the release
+    // manifest (sha256-verified). No JS parse fallback: if the platform has
+    // no asset or the download fails, the build throws with a fixable error.
+    try {
+      binPath = await ensureGraphBinary(getPluginData());
+    } catch (err) {
+      throw new Error(
+        `[code-graph] mixdog-graph binary unavailable and could not be fetched: ${err?.message || err}. `
+        + 'Build it (cargo build --release in native/mixdog-graph) or check network/release manifest.',
+      );
+    }
+  }
+  const { spawn } = await import('node:child_process');
+  const timeoutMs = CODE_GRAPH_BINARY_TIMEOUT_MS;
+  let retried = false;
+
+  // Inner spawn + promise — extracted so we can retry once on EAGAIN.
+  //
+  // child-spawn-gate is NOT acquired here. This function runs inside the
+  // code-graph prewarm WORKER THREAD (via _buildCodeGraph), and worker_threads
+  // do not share module-level state with the main thread — acquiring here would
+  // create a SECOND, independent semaphore that never coordinates with the
+  // main-thread rg gate. Instead the gate is held on the MAIN THREAD across the
+  // whole graph-build worker's lifetime (see buildCodeGraphAsync). The binary
+  // child is spawned exclusively from this worker path, so one main-side slot
+  // per worker correctly bounds native graph spawns against rg.
+  const _spawnOnce = () => new Promise((resolve, reject) => {
+    // When stdinLines is supplied (--files mode), stream one JSON object per
+    // line to the child's STDIN — the reused nodes' metadata — so Rust can
+    // resolve imports across the WHOLE tree (fresh + reused) while only
+    // full-parsing the changed subset passed as argv.
+    const wantsStdin = Array.isArray(stdinLines);
+    const proc = spawn(binPath, [absRoot, ...extraArgs], {
+      stdio: [wantsStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+      // windowsHide: native code-graph binary is a console exe; without this each
+      // call flashes a console window when spawned under the detached daemon.
+      windowsHide: true,
+    });
+    const chunks = [];
+    let stderrText = '';
+    const STDERR_CAP = 8 * 1024;
+    let settled = false;
+    let timedOut = false;
+
+    // ── timeout + kill helpers (mirrors rg-runner's _killRgProc/_escalateRgKill) ──
+    let timeoutTimer = null;
+    let killGraceTimer = null;
+    let forceSettleTimer = null;
+
+    const _procGone = () => proc.exitCode != null || proc.signalCode != null;
+
+    const _escalateKill = () => {
+      if (_procGone()) return;
+      const pid = proc.pid;
+      if (!pid) return;
+      try {
+        if (process.platform === 'win32') {
+          spawn('taskkill', ['/pid', String(pid), '/t', '/f'], {
+            windowsHide: true,
+            stdio: 'ignore',
+          });
+        } else {
+          try { proc.kill('SIGKILL'); } catch { /* ignore */ }
+        }
+      } catch { /* ignore */ }
+    };
+
+    const _killProc = () => {
+      if (_procGone()) return;
+      try { proc.kill('SIGTERM'); } catch { /* ignore */ }
+      if (killGraceTimer) {
+        clearTimeout(killGraceTimer);
+        killGraceTimer = null;
+      }
+      killGraceTimer = setTimeout(() => {
+        killGraceTimer = null;
+        _escalateKill();
+      }, 3000);
+      if (killGraceTimer.unref) killGraceTimer.unref();
+    };
+
+    const _clearTimers = () => {
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = null;
+      }
+      if (killGraceTimer) {
+        clearTimeout(killGraceTimer);
+        killGraceTimer = null;
+      }
+      if (forceSettleTimer) {
+        clearTimeout(forceSettleTimer);
+        forceSettleTimer = null;
+      }
+    };
+
+    // Arm timeout — unref so it doesn't keep the process alive. On timeout we
+    // start SIGTERM→grace→force-kill but do NOT settle yet: the promise stays
+    // pending until the child's 'close' fires (so the build worker — and the
+    // main-thread gate slot it holds — is only released once the process is
+    // actually gone). A separate force-settle deadline guarantees the promise
+    // still resolves if 'close' never arrives. Mirrors rg-runner exactly.
+    timeoutTimer = setTimeout(() => {
+      timeoutTimer = null;
+      timedOut = true;
+      _killProc();
+      // Hard backstop: if 'close' never fires after the kill escalation,
+      // escalate again and settle so we never hang (and never release the
+      // gate while the child is provably still alive without a final attempt).
+      if (forceSettleTimer) clearTimeout(forceSettleTimer);
+      forceSettleTimer = setTimeout(() => {
+        forceSettleTimer = null;
+        if (settled) return;
+        _escalateKill();
+        settled = true;
+        _clearTimers();
+        reject(new Error(`[code-graph] mixdog-graph timed out after ${timeoutMs}ms`));
+      }, 5000);
+      if (forceSettleTimer.unref) forceSettleTimer.unref();
+    }, timeoutMs);
+    if (timeoutTimer.unref) timeoutTimer.unref();
+
+    proc.stdout.on('data', (c) => chunks.push(c));
+    proc.stderr.on('data', (c) => {
+      if (stderrText.length >= STDERR_CAP) return;
+      const piece = c.toString('utf8');
+      const room = STDERR_CAP - stderrText.length;
+      stderrText += piece.length > room ? piece.slice(0, room) : piece;
+    });
+    proc.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      _clearTimers();
+      reject(err);
+    });
+    if (wantsStdin) {
+      proc.stdin.on('error', () => { /* child may close stdin early; ignore EPIPE */ });
+      proc.stdin.write(stdinLines.length ? `${stdinLines.join('\n')}\n` : '');
+      proc.stdin.end();
+    }
+    proc.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      _clearTimers();
+      if (timedOut) {
+        // Our timeout kill won the race: the child is gone now, so the gate
+        // slot releases here (not at timeout-fire time). Report as a timeout.
+        reject(new Error(`[code-graph] mixdog-graph timed out after ${timeoutMs}ms`));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`[code-graph] mixdog-graph exited ${code}: ${stderrText.trim().slice(0, 200)}`));
+        return;
+      }
+      const out = [];
+      const buf = Buffer.concat(chunks).toString('utf8');
+      for (const line of buf.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const rec = JSON.parse(trimmed);
+          if (rec && typeof rec.rel === 'string') out.push(rec);
+        } catch { /* skip malformed line */ }
+      }
+      resolve(out);
+    });
+  });
+
+  // Outer call with one EAGAIN retry (mirrors rg-runner runRg / runRgWindowedLines).
+  try {
+    return await _spawnOnce();
+  } catch (err) {
+    if (!retried && (err?.code === 'EAGAIN' || /EAGAIN/i.test(String(err?.message || err?.stderr || '')))) {
+      retried = true;
+      return _spawnOnce();
+    }
+    throw err;
+  }
+}
+export function _runGraphManifest(absRoot) { return _runGraphBinaryJsonl(absRoot, ['--manifest']); }
+export function _runGraphWalk(absRoot) { return _runGraphBinaryJsonl(absRoot, []); }
+// --files (design A: full-graph resolution) full-parses only `rels` (argv) but
+// resolves imports across the WHOLE tree. The reused nodes' metas are streamed
+// to the child via STDIN as JSONL — one JSON object per line:
+// {rel, lang, rawImports, packageName, namespaceName, goPackageName,
+// topLevelTypes}. Rust builds the index + resolves over ALL nodes (fresh +
+// reused) and emits fresh rels as full records, reused rels as lightweight
+// {rel, resolvedImports, importedBy}.
+export function _runGraphFiles(absRoot, rels, reusedMetas) {
+  const lines = Array.isArray(reusedMetas)
+    ? reusedMetas.map((m) => JSON.stringify({
+        rel: m.rel,
+        lang: m.lang,
+        rawImports: Array.isArray(m.rawImports) ? m.rawImports : [],
+        packageName: m.packageName || '',
+        namespaceName: m.namespaceName || '',
+        goPackageName: m.goPackageName || '',
+        topLevelTypes: Array.isArray(m.topLevelTypes) ? m.topLevelTypes : [],
+      }))
+    : [];
+  return _runGraphBinaryJsonl(absRoot, ['--files', ...rels], lines);
+}
+
+// Map a Rust FileRecord (rel/lang/fp/tokens/rawImports/resolvedImports/
+// importedBy/...) onto the JS fileInfo shape the graph assembler expects.
+// Import resolution — including Go module paths — now happens entirely in
+// Rust; resolvedImports/importedBy are repo-relative path lists passed
+// straight through.
+export function _fileInfoFromRustRecord(rec, absRoot) {
+  const rel = rec.rel;
+  const abs = pathResolve(absRoot, rel);
+  const lang = rec.lang;
+  return {
+    abs,
+    rel,
+    lang,
+    fingerprint: typeof rec.fp === 'string' ? rec.fp : '',
+    sourceText: null,
+    rawImports: Array.isArray(rec.rawImports) ? rec.rawImports : [],
+    resolvedImports: Array.isArray(rec.resolvedImports)
+      ? rec.resolvedImports.filter((v) => typeof v === 'string')
+      : [],
+    importedBy: Array.isArray(rec.importedBy)
+      ? rec.importedBy.filter((v) => typeof v === 'string')
+      : [],
+    packageName: typeof rec.packageName === 'string' ? rec.packageName : '',
+    namespaceName: typeof rec.namespaceName === 'string' ? rec.namespaceName : '',
+    goPackageName: typeof rec.goPackageName === 'string' ? rec.goPackageName : '',
+    topLevelTypes: Array.isArray(rec.topLevelTypes) ? rec.topLevelTypes : [],
+    tokenSymbols: Array.isArray(rec.tokens) ? rec.tokens : null,
+    symbols: Array.isArray(rec.symbols) ? rec.symbols : [],
+  };
+}
+
+// Reuse a node from the previous graph whose fp is unchanged — skips both
+// the Rust call and re-parsing for files that did not change.
+export function _reuseFileInfo(prevNode, previousGraph, absRoot) {
+  const rel = prevNode.rel;
+  const fp = prevNode.fingerprint || '';
+  const cachedText = previousGraph?._sourceTextCache?.get(rel);
+  return {
+    abs: prevNode.abs || pathResolve(absRoot, rel),
+    rel,
+    lang: prevNode.lang,
+    fingerprint: fp,
+    sourceText: cachedText?.fingerprint === fp ? cachedText.text : null,
+    rawImports: Array.isArray(prevNode.rawImports) ? prevNode.rawImports : [],
+    resolvedImports: Array.isArray(prevNode.resolvedImportsRel) ? prevNode.resolvedImportsRel : [],
+    importedBy: Array.isArray(prevNode.importedBy) ? prevNode.importedBy : [],
+    packageName: prevNode.packageName || '',
+    namespaceName: prevNode.namespaceName || '',
+    goPackageName: prevNode.goPackageName || '',
+    topLevelTypes: Array.isArray(prevNode.topLevelTypes) ? prevNode.topLevelTypes : [],
+    tokenSymbols: Array.isArray(prevNode.tokenSymbols) ? prevNode.tokenSymbols : null,
+    symbols: Array.isArray(prevNode.symbols) ? prevNode.symbols : [],
+  };
+}

package/src/runtime/agent/orchestrator/tools/code-graph/graph-model.mjs

@@ -0,0 +1,158 @@
+// Graph (de)serialization, runtime-cache lifecycle, and signature hashing.
+// Extracted verbatim from code-graph.mjs. Graph shape: { cwd, nodes:
+// Map<rel,node>, reverse: Map<rel,Set<rel>>, schemaVersion, builtAt,
+// signature, +runtime caches }. Persisted form omits empty fields.
+import { createHash } from 'node:crypto';
+import { resolve as pathResolve } from 'node:path';
+import { SYMBOL_SCHEMA_VERSION, CODE_GRAPH_MAX_FILES } from './constants.mjs';
+
+export function _computeGraphSignature(fileMetas) {
+  const hash = createHash('sha1');
+  hash.update(`${SYMBOL_SCHEMA_VERSION}\n`);
+  // R5-③: include rel/path alongside fp so renames and path-swaps (same
+  // bytes moved to a different rel, or two files exchanging paths) flip
+  // the signature and invalidate the memory/disk cache checks at the
+  // call sites just below in buildCodeGraphAsync. Without rel, an fp-only
+  // hash collides across rename pairs and the cache serves stale graph
+  // topology where node.rel no longer matches what's on disk.
+  for (const meta of fileMetas) hash.update(`${meta.rel || ''}\0${meta.fp}\n`);
+  return hash.digest('hex');
+}
+
+export function _serializeGraph(graph) {
+  // Compact-on-disk: omit empty / falsy fields. Saves ~30-50% on disk
+  // for typical mixed-language graphs because most nodes don't carry
+  // packageName / namespaceName / topLevelTypes. Smaller
+  // payload → faster JSON.parse on cold-process boot. _deserializeGraph
+  // tolerates missing fields by defaulting to '' / [].
+  return {
+    schemaVersion: SYMBOL_SCHEMA_VERSION,
+    builtAt: Number(graph?.builtAt || Date.now()),
+    signature: String(graph?.signature || ''),
+    truncated: Boolean(graph?.truncated),
+    maxFiles: CODE_GRAPH_MAX_FILES,
+    nodes: [...(graph?.nodes?.values?.() || [])].map((node) => {
+      const out = {
+        rel: node.rel,
+        lang: node.lang,
+      };
+      if (node.fingerprint) out.fingerprint = node.fingerprint;
+      if (Array.isArray(node.rawImports) && node.rawImports.length) out.rawImports = node.rawImports;
+      if (Array.isArray(node.resolvedImportsRel) && node.resolvedImportsRel.length) {
+        out.resolvedImports = node.resolvedImportsRel;
+      }
+      if (Array.isArray(node.importedBy) && node.importedBy.length) {
+        out.importedBy = node.importedBy;
+      }
+      if (node.packageName) out.packageName = node.packageName;
+      if (node.namespaceName) out.namespaceName = node.namespaceName;
+      if (node.goPackageName) out.goPackageName = node.goPackageName;
+      if (Array.isArray(node.topLevelTypes) && node.topLevelTypes.length) {
+        out.topLevelTypes = node.topLevelTypes;
+      }
+      if (Array.isArray(node.tokenSymbols) && node.tokenSymbols.length) {
+        out.tokenSymbols = node.tokenSymbols;
+      }
+      if (Array.isArray(node.symbols) && node.symbols.length) {
+        out.symbols = node.symbols;
+      }
+      return out;
+    }),
+  };
+}
+
+export function _deserializeGraph(cwd, payload) {
+  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.nodes)) return null;
+  const nodes = new Map();
+  const reverse = new Map();
+  for (const item of payload.nodes) {
+    if (!item || typeof item.rel !== 'string' || typeof item.lang !== 'string') continue;
+    // Persisted fields are repo-relative, mirroring the live build. The
+    // JS resolution layer is gone — resolvedImports/resolvedImportsRel are
+    // restored straight from disk; the reverse index is rederived below from
+    // the forward edges of every node.
+    const resolvedImportsRel = Array.isArray(item.resolvedImports) ? item.resolvedImports.filter((v) => typeof v === 'string') : [];
+    const importedBy = Array.isArray(item.importedBy) ? item.importedBy.filter((v) => typeof v === 'string') : [];
+    const node = {
+      abs: pathResolve(cwd, item.rel),
+      rel: item.rel,
+      lang: item.lang,
+      fingerprint: item.fingerprint || '',
+      rawImports: Array.isArray(item.rawImports) ? item.rawImports : [],
+      resolvedImportsRel,
+      resolvedImports: resolvedImportsRel.map((rel) => pathResolve(cwd, rel)),
+      importedBy,
+      packageName: item.packageName || '',
+      namespaceName: item.namespaceName || '',
+      goPackageName: item.goPackageName || '',
+      topLevelTypes: Array.isArray(item.topLevelTypes) ? item.topLevelTypes : [],
+      tokenSymbols: Array.isArray(item.tokenSymbols) ? item.tokenSymbols : null,
+      symbols: Array.isArray(item.symbols) ? item.symbols : [],
+    };
+    nodes.set(node.rel, node);
+    // reverse is derived from the FORWARD edges of every node, not from the
+    // persisted importedBy. On the incremental --files path reused nodes carry
+    // a stale importedBy, so a fresh edge A→B (A parsed, B reused) would drop
+    // B's reverse entry. Walking resolvedImportsRel keeps reverse self-consistent.
+    for (const rel of resolvedImportsRel) {
+      if (!reverse.has(rel)) reverse.set(rel, new Set());
+      reverse.get(rel).add(node.rel);
+    }
+  }
+  const graph = _attachGraphRuntimeCaches({
+    cwd,
+    nodes,
+    reverse,
+    // Pre-endLine disk payloads have no schemaVersion → null → dropped by the
+    // previousGraph schema guard so their endLine-less nodes never seed reuse.
+    schemaVersion: typeof payload.schemaVersion === 'string' ? payload.schemaVersion : null,
+    builtAt: Number(payload.builtAt || Date.now()),
+    signature: String(payload.signature || ''),
+  });
+  // Restore the truncation flag persisted from the live build so disk-cache
+  // hits keep emitting the WARN line in find_symbol/overview output instead
+  // of silently working with a partial graph.
+  if (graph && payload.truncated) graph.truncated = true;
+  return graph;
+}
+
+export function _attachGraphRuntimeCaches(graph) {
+  if (!graph || typeof graph !== 'object') return graph;
+  if (!graph._referenceSearchCache) graph._referenceSearchCache = new Map();
+  if (!graph._maskedLinesCache) graph._maskedLinesCache = new Map();
+  if (!graph._sourceLinesCache) graph._sourceLinesCache = new Map();
+  if (!graph._sourceTextCache) graph._sourceTextCache = new Map();
+  if (!graph._symbolTokenIndex) graph._symbolTokenIndex = new Map();
+  if (typeof graph._symbolTokenIndexDirty !== 'boolean') graph._symbolTokenIndexDirty = true;
+  return graph;
+}
+
+export function _estimateGraphRuntimeCacheBytes(graph) {
+  if (!graph) return 0;
+  let total = 0;
+  for (const entry of graph._sourceTextCache?.values() || []) {
+    total += Buffer.byteLength(String(entry?.text || ''), 'utf8');
+  }
+  for (const lines of graph._maskedLinesCache?.values() || []) {
+    if (!Array.isArray(lines)) continue;
+    for (const line of lines) total += Buffer.byteLength(String(line || ''), 'utf8');
+  }
+  for (const lines of graph._sourceLinesCache?.values() || []) {
+    if (!Array.isArray(lines)) continue;
+    for (const line of lines) total += Buffer.byteLength(String(line || ''), 'utf8');
+  }
+  for (const memo of graph._referenceSearchCache?.values() || []) {
+    total += Buffer.byteLength(String(memo || ''), 'utf8');
+  }
+  return total;
+}
+
+export function _clearGraphRuntimeCaches(graph) {
+  if (!graph) return;
+  graph._sourceTextCache?.clear();
+  graph._maskedLinesCache?.clear();
+  graph._sourceLinesCache?.clear();
+  graph._referenceSearchCache?.clear();
+  graph._symbolTokenIndex?.clear();
+  graph._symbolTokenIndexDirty = true;
+}

package/src/runtime/agent/orchestrator/tools/code-graph/keyword-match.mjs

@@ -0,0 +1,82 @@
+// Keyword-to-symbol fuzzy matching: tokenization, token-aligned contiguous
+// match, ordered token match, and ranking key. Pure string helpers with no
+// graph/cache state. Extracted from search.mjs.
+
+export function _keywordSymbolSortKey(symbolName, keyword) {
+  const lowerName = String(symbolName || '').toLowerCase();
+  const lowerKey = String(keyword || '').toLowerCase();
+  const idx = lowerName.indexOf(lowerKey);
+  if (idx < 0) return null;
+  const atStart = idx === 0 ? 0 : 1;
+  return [lowerName.length, atStart, idx, symbolName];
+}
+
+export function _tokenizeKeyword(s) {
+  return String(s || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((t) => t.toLowerCase());
+}
+
+function _tokenStartOffsets(sym) {
+  const starts = new Set();
+  let prevAlnum = false;
+  let prevUpper = false;
+  for (let i = 0; i < sym.length; i += 1) {
+    const c = sym[i];
+    const isAlnum = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
+    if (!isAlnum) { prevAlnum = false; prevUpper = false; continue; }
+    const isUpper = c >= 'A' && c <= 'Z';
+    if (!prevAlnum) starts.add(i);
+    else if (isUpper && !prevUpper) starts.add(i);
+    prevAlnum = true;
+    prevUpper = isUpper;
+  }
+  return starts;
+}
+
+function _contiguousMatchTokenAligned(sym, lowerKey) {
+  const len = lowerKey.length;
+  if (!len) return false;
+  const symLower = sym.toLowerCase();
+  const starts = _tokenStartOffsets(sym);
+  let lead = 0;
+  while (lead < len) {
+    const c = lowerKey[lead];
+    const isAlnum = (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9');
+    if (isAlnum) break;
+    lead += 1;
+  }
+  let from = 0;
+  for (;;) {
+    const idx = symLower.indexOf(lowerKey, from);
+    if (idx < 0) return false;
+    const end = idx + len;
+    const effectiveIdx = idx + lead;
+    if (starts.has(effectiveIdx)) return true;
+    let interiorBoundary = false;
+    for (const s of starts) {
+      if (s > effectiveIdx && s < end) { interiorBoundary = true; break; }
+    }
+    if (!interiorBoundary) return true;
+    from = idx + 1;
+  }
+}
+
+function _orderedTokenMatch(symLower, tokens) {
+  let from = 0;
+  for (const t of tokens) {
+    const i = symLower.indexOf(t, from);
+    if (i < 0) return false;
+    from = i + t.length;
+  }
+  return true;
+}
+
+export function _keywordMatchesSymbolName(name, lowerKey, keyTokens) {
+  const sym = String(name || '').trim();
+  if (!sym || !lowerKey) return false;
+  if (_contiguousMatchTokenAligned(sym, lowerKey)) return true;
+  return keyTokens.length >= 2 && _orderedTokenMatch(sym.toLowerCase(), keyTokens);
+}

package/src/runtime/agent/orchestrator/tools/code-graph/lang-predicates.mjs

@@ -0,0 +1,128 @@
+// Per-language lexical predicates + JS tokenizer character/keyword sets.
+// Pure functions, no state. Extracted verbatim from code-graph.mjs; shared
+// by the text masker, symbol index, and search/format layers.
+
+export function _langUsesDollarInIdentifiers(lang) {
+  // `$` is a valid identifier char only in JS/TS/PHP. The 5 new langs are
+  // deliberately excluded: kotlin/swift/scala/lua have no `$` in identifiers,
+  // and bash's `$` is a variable-expansion sigil (`$var`), not an identifier
+  // char — treating it as a word-boundary char would mis-tokenize.
+  // Second batch (dart/objc/elixir/zig/r) likewise excluded: none use `$` as
+  // an identifier char (objc `$` is invalid; elixir/dart/zig/r have no `$` in
+  // names), so they stay out.
+  return lang === 'javascript' || lang === 'typescript' || lang === 'php';
+}
+
+export function _langAllowsBangQuestionSuffix(lang) {
+  // Method names may end in `!`/`?` only in ruby (`save!`/`empty?`) and rust
+  // (`!` macros). Kotlin is NOT here: its `!!` is the not-null assertion
+  // OPERATOR, not an identifier suffix — including it would fold `foo!!` into
+  // the `foo` reference and break matching. swift `?`/`!` are optional/
+  // force-unwrap operators (not name chars); scala/bash/lua have no suffix.
+  // Second batch: elixir function names may end in `?`/`!` (`valid?`/`save!`)
+  // exactly like ruby → included. dart/objc/zig/r have no such suffix.
+  return lang === 'ruby' || lang === 'rust' || lang === 'elixir';
+}
+
+export function _supportsHashComments(lang) {
+  // Hash-comment langs: python/ruby/php plus bash. lua is NOT hash — it uses
+  // `--` line + `--[[ ]]` block comments (see _maskNonCodeText). kotlin/
+  // swift/scala are slash-comment C-family (see _supportsSlashComments).
+  // Second batch: elixir and r are `#`-only line-comment langs → included.
+  // (dart/objc/zig are slash-comment, handled by _supportsSlashComments.)
+  return lang === 'python' || lang === 'ruby' || lang === 'php'
+    || lang === 'bash' || lang === 'elixir' || lang === 'r';
+}
+
+export function _supportsSlashComments(lang) {
+  // Slash-comment langs: everything C-family, incl. new kotlin/swift/scala.
+  // Excluded: python/ruby/bash (hash) and lua (`--` comments; `//` is lua
+  // integer division, so it must not be treated as a comment opener).
+  // Second batch: dart/objc/zig are C-family slash-comment (kept by the
+  // default). Excluded here: elixir/r (hash-only, see _supportsHashComments).
+  return lang !== 'python' && lang !== 'ruby'
+    && lang !== 'bash' && lang !== 'lua'
+    && lang !== 'elixir' && lang !== 'r';
+}
+
+export function _supportsSingleQuoteStrings(lang) {
+  return lang === 'typescript'
+    || lang === 'javascript'
+    || lang === 'python'
+    || lang === 'ruby'
+    || lang === 'php'
+    // New langs with single-quote string literals: swift uses double quotes
+    // only (excluded); kotlin uses double/triple-double (excluded); scala
+    // single-quotes are Char literals not strings (excluded); bash and lua
+    // both support `'...'` single-quoted strings.
+    || lang === 'bash'
+    || lang === 'lua'
+    // Second batch. dart: `'...'` is a primary string form → included. r:
+    // `'...'` is a string literal equivalent to `"..."` → included. objc:
+    // `'x'` is a char literal — INCLUDED here so its contents are masked as a
+    // single-quote string. This deliberately DIVERGES from c/cpp, which are
+    // NOT in this list: objc's masker benefits from neutralizing char-literal
+    // bytes, whereas c/cpp char literals are left unmasked.
+    // elixir: EXCLUDED — `'...'` is a charlist, not a string; but charlists
+    // are single-line and `\\`-escaped just like a string, so masking them as
+    // strings would be safe — they are nonetheless left out to keep elixir
+    // string handling limited to `"..."`/`"""` (charlist contents are rare in
+    // code-graph anchors and excluding avoids masking a stray apostrophe in a
+    // comment-less context). zig: EXCLUDED — `'c'` is a char literal only and
+    // zig multiline strings are `\\`-prefixed lines (out of scope), so no
+    // single-quote string form applies.
+    || lang === 'dart'
+    || lang === 'r'
+    || lang === 'objc';
+}
+
+export function _supportsBacktickStrings(lang) {
+  return lang === 'typescript' || lang === 'javascript' || lang === 'go';
+}
+
+export function _supportsTripleSingleQuoteStrings(lang) {
+  // `'''` triple-single-quote strings: python, and dart (which supports BOTH
+  // `'''` and `"""` multiline strings). kotlin/scala/swift have `"""` but NOT
+  // `'''`; treating `'''` as a string opener there would mis-mask a
+  // single-quote char/string followed by an empty string.
+  return lang === 'python' || lang === 'dart';
+}
+
+export function _supportsTripleDoubleQuoteStrings(lang) {
+  // `"""` triple-double-quote raw/multiline strings: python, kotlin, scala
+  // and swift. bash/lua have no triple-quote form (lua long strings use
+  // `[[ ]]`).
+  // Second batch: elixir `"""` heredoc docstrings → included. dart supports
+  // BOTH `'''` and `"""` multiline strings → included here (and in the triple-
+  // single predicate). objc/zig/r have no `"""` form.
+  return lang === 'python' || lang === 'kotlin'
+    || lang === 'scala' || lang === 'swift' || lang === 'elixir'
+    || lang === 'dart';
+}
+
+export function _isJsLike(lang) {
+  return lang === 'javascript' || lang === 'typescript';
+}
+
+export function _isWordStartChar(c) {
+  return c === '_' || c === '$'
+    || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+export function _isWordChar(c) {
+  return _isWordStartChar(c) || (c >= '0' && c <= '9');
+}
+
+// ECMAScript expression-context keywords that can precede a regex literal.
+// After any of these, a `/` opens a RegExp literal; after a value (identifier,
+// number, `)`, `]`), `/` is the division operator. This list is from the
+// language spec — not a heuristic — and resolves the `/`-ambiguity.
+export const REGEX_PRECEDENT_KEYWORDS = new Set([
+  'return', 'typeof', 'delete', 'void', 'new', 'throw', 'await', 'yield',
+  'in', 'of', 'instanceof', 'case', 'do', 'else', 'if', 'while',
+]);
+
+export const REGEX_PRECEDENT_CHARS = new Set([
+  '=', '(', ',', ';', ':', '?', '!', '~', '&', '|', '^', '+', '-',
+  '*', '%', '<', '>', '{', '[',
+]);