mixdog 0.9.3 → 0.9.5

package/src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs

@@ -1,8 +1,6 @@
-import { spawn, spawnSync } from 'child_process';
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, watch as fsWatch, writeFileSync } from 'fs';
-import * as fsPromises from 'fs/promises';
-import { basename, join } from 'path';
-import { getPluginData } from '../../config.mjs';
+import { spawn } from 'child_process';
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, watch as fsWatch, writeFileSync } from 'fs';
+import { basename } from 'path';
 import { stripAnsi } from '../shell-command.mjs';
 import { scrubLoaderVars, scrubProviderSecrets } from '../env-scrub.mjs';
 import {
@@ -21,6 +19,31 @@ import {
     getBackgroundTask,
 } from '../../../../shared/background-tasks.mjs';
 import { startChildGuardian } from '../../../../shared/child-guardian.mjs';
+import {
+    getShellJobsDir,
+    shellJobStdoutPath,
+    shellJobStderrPath,
+    shellJobExitPath,
+    shellJobDonePath,
+    shellJobEnforcedPath,
+    resolveJobOwnerHostPid,
+    writeShellJobDetail,
+    readShellJobDetail,
+} from './shell-job-paths.mjs';
+import {
+    isPidAlive,
+    killProcessTree,
+    _unregisterLiveJobPid,
+    _installShellJobsExitHook,
+    _registerLiveJobPid,
+    _liveJobPids,
+    _liveJobIdsByPid,
+    _killLiveJobPid,
+} from './shell-job-process.mjs';
+
+// Facade re-exports: path/detail helpers and the job-not-found message moved
+// to sibling modules; keep existing importers of shell-jobs.mjs resolving.
+export { buildJobNotFoundMessage } from './shell-job-paths.mjs';
 
 globalThis.__mixdogShellJobsRuntimeLoaded = true;
 
@@ -28,269 +51,9 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// One-shot sweep of stale shell-job artefacts. Each backgrounded `bash`
-// emits five files (.json/.done/.exit/.stdout.log/.stderr.log); the .done
-// flag is written when the job exits, so a .done file older than
-// SHELL_JOB_STALE_MS is the invariant proof its sibling files are also
-// safe to remove. Active and recently-completed jobs are kept so
-// `task` status/read/wait readers still find them. Runs once per mcp child
-// lifetime on first getShellJobsDir() call. Async dirent walk + parallel
-// stat/unlink keeps the main event loop free; fire-and-forget so the
-// synchronous caller receives `dir` immediately.
-const SHELL_JOB_STALE_MS = 24 * 60 * 60 * 1000;
-let shellJobsSwept = false;
-async function sweepStaleShellJobs(dir) {
-    if (shellJobsSwept) return;
-    shellJobsSwept = true;
-    const cutoff = Date.now() - SHELL_JOB_STALE_MS;
-    let names;
-    try { names = await fsPromises.readdir(dir); } catch { return; }
-    const expired = [];
-    await Promise.all(names.map(async (name) => {
-        if (!name.endsWith('.done')) return;
-        const p = join(dir, name);
-        try {
-            const st = await fsPromises.stat(p);
-            if (st.mtimeMs < cutoff) expired.push(name.slice(0, -5));
-        } catch {}
-    }));
-    // Orphan reclaim: a crashed wrapper leaves <id>.json with no .done —
-    // forever. Invariant proofs of death (either suffices, both gated on the
-    // stale cutoff so a young orphan can't race its own spawn):
-    //   a) deadline: the wrapper enforces timeoutMs, so an entry older than
-    //      timeoutMs + grace cannot still be running — pid-reuse-proof. Only
-    //      trusted on runtime proof: detail.timeoutEnforced:true (PS wrapper,
-    //      unconditional) or the <id>.enforced marker the posix wrapper
-    //      touches when its `timeout` branch actually runs.
-    //   b) ESRCH: the recorded pid no longer exists. Alone this misses pids
-    //      recycled by unrelated live processes, hence (a).
-    const ORPHAN_DEADLINE_GRACE_MS = 30 * 60_000;
-    const doneSet = new Set(names.filter(n => n.endsWith('.done')).map(n => n.slice(0, -5)));
-    await Promise.all(names.map(async (name) => {
-        if (!name.endsWith('.json')) return;
-        const jobId = name.slice(0, -5);
-        if (doneSet.has(jobId)) return;
-        const p = join(dir, name);
-        try {
-            const st = await fsPromises.stat(p);
-            if (st.mtimeMs >= cutoff) return;
-            const detail = JSON.parse(await fsPromises.readFile(p, 'utf-8'));
-            const tmo = Number(detail?.timeoutMs);
-            const enforced = detail?.timeoutEnforced === true
-                || existsSync(join(dir, `${jobId}.enforced`));
-            const deadlinePassed = enforced
-                && Number.isFinite(tmo) && tmo > 0
-                && (Date.now() - st.mtimeMs) > tmo + ORPHAN_DEADLINE_GRACE_MS;
-            if (!deadlinePassed) {
-                const pid = Number(detail?.pid);
-                if (Number.isFinite(pid) && pid > 0) {
-                    try { process.kill(pid, 0); return; } // alive (or EPERM → treated dead only via ESRCH below)
-                    catch (e) { if (e?.code !== 'ESRCH') return; }
-                }
-            }
-            expired.push(jobId);
-        } catch {}
-    }));
-    // Owner sidecar markers carry a dynamic `.owner-<pid>` suffix, so they
-    // can't sit in the fixed-extension list — map each expired jobId to the
-    // marker name(s) actually present in this listing and unlink those too.
-    const expiredSet = new Set(expired);
-    const ownerMarkers = names.filter((n) => {
-        const i = n.lastIndexOf('.owner-');
-        return i > 0 && expiredSet.has(n.slice(0, i));
-    });
-    await Promise.all([
-        ...expired.flatMap((jobId) =>
-            ['.json', '.done', '.exit', '.enforced', '.exit.cmd.sh', '.exit.cmd.ps1', '.stdout.log', '.stderr.log'].map((ext) =>
-                fsPromises.unlink(join(dir, jobId + ext)).catch(() => {}),
-            ),
-        ),
-        ...ownerMarkers.map((n) => fsPromises.unlink(join(dir, n)).catch(() => {})),
-    ]);
-}
-
-function getShellJobsDir() {
-    const dir = join(getPluginData(), 'shell-jobs');
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    sweepStaleShellJobs(dir);
-    return dir;
-}
-
-function shellJobDetailPath(jobId) { return join(getShellJobsDir(), `${jobId}.json`); }
-function shellJobStdoutPath(jobId) { return join(getShellJobsDir(), `${jobId}.stdout.log`); }
-function shellJobStderrPath(jobId) { return join(getShellJobsDir(), `${jobId}.stderr.log`); }
-function shellJobExitPath(jobId) { return join(getShellJobsDir(), `${jobId}.exit`); }
-function shellJobDonePath(jobId) { return join(getShellJobsDir(), `${jobId}.done`); }
-// Runtime proof that the posix wrapper's `timeout` branch actually ran: the
-// wrapper touches this marker immediately before exec'ing `timeout`, so its
-// existence is never optimistic (no spawn-time probe can guarantee the
-// wrapper's own env/cwd resolution). PS jobs don't need it — their wrapper
-// enforces unconditionally and records detail.timeoutEnforced:true.
-function shellJobEnforcedPath(jobId) { return join(getShellJobsDir(), `${jobId}.enforced`); }
-// Owner sidecar marker: a zero-byte file whose NAME encodes the owning CC host
-// (claude.exe) pid — `<jobId>.owner-<pid>`. It lets the statusline owner-filter
-// jobs from a SINGLE directory listing (no per-job JSON read) so the filter can
-// precede its per-tick scan cap — otherwise other sessions' newer jobs evict
-// this session's live jobs before filtering. Swept alongside the other
-// artefacts.
-function shellJobOwnerPath(jobId, pid) { return join(getShellJobsDir(), `${jobId}.owner-${pid}`); }
-
 const JOB_STATUS_PREVIEW_MAX_BYTES = 4096;
 const JOB_STATUS_PREVIEW_MAX_LINES = 20;
 const JOB_STATUS_PREVIEW_MAX_CHARS = 1200;
-
-// Resolve the CLI host pid that owns a freshly-spawned job. Standalone CLI
-// execution is process-owned: background tasks are scoped to this CLI lifetime,
-// and the pid stamp is only for statusline filtering / legacy sidecars.
-function resolveJobOwnerHostPid(clientHostPid) {
-    const explicit = Number(clientHostPid);
-    if (Number.isInteger(explicit) && explicit > 0) return explicit;
-    const envPid = Number(process.env.MIXDOG_OWNER_HOST_PID);
-    if (Number.isInteger(envPid) && envPid > 0) return envPid;
-    return null;
-}
-
-function writeShellJobDetail(detail) {
-    // Session scope stamp: every job record is tagged with the CC host pid
-    // that owns it (the claude.exe pid). This is the SAME physical pid the
-    // statusline shim passes as --client-host-pid, so the statusline can count
-    // only its own session's jobs by exact pid equality (no heuristic). The
-    // spawn sites set detail.ownerHostPid from the per-request threaded
-    // clientHostPid (resolveJobOwnerHostPid); this fallback only stamps the
-    // single-client env value when no spawn-site pid was set, and NEVER
-    // overwrites an existing stamp — so the field round-trips through disk on
-    // refresh/kill and a correct per-terminal stamp is preserved across rewrites.
-    if (detail && detail.ownerHostPid == null) {
-        const hostPid = Number(process.env.MIXDOG_OWNER_HOST_PID);
-        if (Number.isInteger(hostPid) && hostPid > 0) detail.ownerHostPid = hostPid;
-    }
-    writeFileSync(shellJobDetailPath(detail.jobId), JSON.stringify(detail, null, 2), 'utf-8');
-    // Owner sidecar: encode the resolved owner pid in the marker filename so the
-    // statusline can owner-filter from the directory listing alone (before its
-    // scan cap). Idempotent zero-byte write — safe to repeat on refresh/kill
-    // rewrites. Skipped when no owner is known (legacy/unattributed jobs).
-    if (detail && Number.isInteger(detail.ownerHostPid) && detail.ownerHostPid > 0) {
-        try { writeFileSync(shellJobOwnerPath(detail.jobId, detail.ownerHostPid), '', 'utf-8'); }
-        catch { /* best-effort marker */ }
-    }
-}
-
-function readShellJobDetail(jobId) {
-    try {
-        const p = shellJobDetailPath(jobId);
-        if (!existsSync(p)) return null;
-        return JSON.parse(readFileSync(p, 'utf-8'));
-    } catch {
-        return null;
-    }
-}
-
-export function buildJobNotFoundMessage(jobId) {
-    return `Error: task not found: ${jobId}`;
-}
-
-function isPidAlive(pid) {
-    if (!Number.isFinite(pid) || pid <= 0) return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-function killProcessTree(pid, signal = 'SIGTERM') {
-    if (!Number.isFinite(pid) || pid <= 0) return false;
-    try {
-        if (process.platform === 'win32') {
-            spawn('taskkill', ['/pid', String(pid), '/t', '/f'], { windowsHide: true, stdio: 'ignore' });
-        } else {
-            try { process.kill(-pid, signal); }
-            catch { process.kill(pid, signal); }
-            // SIGKILL escalation: a background child that ignores SIGTERM must
-            // not survive (foreground treeKill / persistent _killProcessTree
-            // already do this). After a 3s grace, force-kill the group/pid.
-            // unref so this backstop never holds the host process open.
-            if (signal === 'SIGTERM') {
-                const t = setTimeout(() => {
-                    try { process.kill(-pid, 'SIGKILL'); }
-                    catch { try { process.kill(pid, 'SIGKILL'); } catch { /* already gone */ } }
-                }, 3000);
-                if (t.unref) t.unref();
-            }
-        }
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-// Module-level tracking of live background-job pids so CLI shutdown can reap
-// owned children. Async jobs are intentionally CLI-owned; no restart replay or
-// daemon handoff is attempted.
-const _liveJobPids = new Set();
-const _liveJobIdsByPid = new Map();
-let _shellJobsExitHookInstalled = false;
-function _registerLiveJobPid(pid, jobId = null) {
-    if (Number.isFinite(pid) && pid > 0) {
-        _liveJobPids.add(pid);
-        if (jobId) _liveJobIdsByPid.set(pid, jobId);
-    }
-}
-function _unregisterLiveJobPid(pid) {
-    if (Number.isFinite(pid) && pid > 0) {
-        _liveJobPids.delete(pid);
-        _liveJobIdsByPid.delete(pid);
-    }
-}
-function _killLiveJobPid(pid, { sync = false } = {}) {
-    try {
-        if (process.platform === 'win32') {
-            if (sync) {
-                spawnSync('taskkill.exe', ['/pid', String(pid), '/t', '/f'], {
-                    windowsHide: true,
-                    stdio: 'ignore',
-                    timeout: 1500,
-                });
-            } else {
-                spawn('taskkill', ['/pid', String(pid), '/t', '/f'], { windowsHide: true, stdio: 'ignore' });
-            }
-        } else {
-            try { process.kill(-pid, 'SIGKILL'); }
-            catch { try { process.kill(pid, 'SIGKILL'); } catch { /* ignore */ } }
-        }
-        return true;
-    } catch {
-        return false;
-    }
-}
-function _sweepLiveJobsSync() {
-    for (const pid of _liveJobPids) {
-        _killLiveJobPid(pid, { sync: true });
-    }
-    _liveJobPids.clear();
-    _liveJobIdsByPid.clear();
-}
-function _ensureProcessListenerHeadroom(events, extra = 1) {
-    try {
-        if (typeof process.getMaxListeners !== 'function' || typeof process.setMaxListeners !== 'function') return;
-        const current = process.getMaxListeners();
-        if (current === 0) return;
-        let needed = current;
-        for (const event of events) needed = Math.max(needed, process.listenerCount(event) + extra);
-        if (needed > current) process.setMaxListeners(needed);
-    } catch { /* ignore */ }
-}
-function _installShellJobsExitHook() {
-    if (_shellJobsExitHookInstalled) return;
-    _shellJobsExitHookInstalled = true;
-    _ensureProcessListenerHeadroom(['exit', 'SIGTERM', 'SIGINT', 'SIGHUP'], 1);
-    try { process.on('exit', _sweepLiveJobsSync); } catch { /* ignore */ }
-    try { process.on('SIGTERM', _sweepLiveJobsSync); } catch { /* ignore */ }
-    try { process.on('SIGINT', _sweepLiveJobsSync); } catch { /* ignore */ }
-    try { process.on('SIGHUP', _sweepLiveJobsSync); } catch { /* ignore */ }
-}
-
 function shellQuoteSingle(s) {
     return `'${String(s).replace(/'/g, `'\"'\"'`)}'`;
 }

package/src/runtime/agent/orchestrator/tools/builtin.mjs

@@ -35,8 +35,6 @@ import {
     executeGlobTool,
     executeGrepTool,
 } from './builtin/search-tool.mjs';
-import { executeDiagnosticsTool } from './builtin/diagnostics-tool.mjs';
-import { executeOpenConfigTool } from './builtin/open-config-tool.mjs';
 import {
     configureReadRangeIndexTelemetry,
     flushReadRangeIndexesSync,
@@ -491,10 +489,6 @@ export async function executeBuiltinTool(name, args, cwd, options = {}) {
             return executeTaskTool(args, options);
         case 'read':
             return executeReadTool(args, workDir, readStateScope, executeChildBuiltinTool, options, _readToolHelpers);
-        case 'diagnostics':
-            return executeDiagnosticsTool(args, workDir, options);
-        case 'open_config':
-            return executeOpenConfigTool();
         case 'grep':
             return executeGrepTool(args, workDir, executeChildBuiltinTool, readStateScope, options);
         case 'glob':

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

@@ -38,6 +38,7 @@ import {
 } from './search.mjs';
 
 const CODE_GRAPH_BATCHABLE_MODES = new Set(['symbol', 'find_symbol', 'symbol_search', 'callers', 'callees', 'references']);
+const CODE_GRAPH_FILE_BATCHABLE_MODES = new Set(['imports', 'dependents', 'related', 'impact', 'symbols', 'overview']);
 
 function _collectGraphSymbolList(args) {
   const split = (s) => String(s || '').split(/[,\s]+/).map((t) => t.trim()).filter(Boolean);
@@ -48,6 +49,23 @@ function _collectGraphSymbolList(args) {
   ])];
 }
 
+const CODE_GRAPH_FILE_BATCH_CAP = 20;
+
+function _collectGraphFileList(args) {
+  const split = (s) => String(s || '').split(/,+/).map((t) => t.trim()).filter(Boolean);
+  const list = [...new Set([
+    ...(Array.isArray(args?.files) ? args.files.map((f) => String(f || '').trim()).filter(Boolean) : []),
+    ...(typeof args?.files === 'string' ? split(args.files) : []),
+    ...(typeof args?.file === 'string' && args.file.trim() ? [args.file.trim()] : []),
+  ])];
+  if (list.length > CODE_GRAPH_FILE_BATCH_CAP) {
+    const capped = list.slice(0, CODE_GRAPH_FILE_BATCH_CAP);
+    capped._capped = true;
+    return capped;
+  }
+  return list;
+}
+
 async function codeGraph(args, cwd, signal = null, options = {}) {
   let mode = String(args?.mode || '').trim();
   if (!mode) throw new Error('code_graph: "mode" is required');
@@ -208,11 +226,27 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
   }
 
   if (mode === 'symbol_search') {
-    const keyword = String(args?.symbol || '').trim();
-    if (!keyword) throw new Error('code_graph symbol_search: "symbol" is required.');
     const language = String(args?.language || '').trim() || null;
     const limit = Math.max(1, Math.min(100, Number(args?.limit || 30)));
-    return _searchSymbolsByKeyword(graph, keyword, cwd, { language, limit });
+    const symbolsList = Array.isArray(args?.symbols)
+      ? args.symbols.map((s) => String(s || '').trim()).filter(Boolean)
+      : [];
+    const keyword = String(args?.symbol || '').trim();
+    const keywords = symbolsList.length ? symbolsList : (keyword ? [keyword] : []);
+    if (!keywords.length) throw new Error('code_graph symbol_search: "symbol" (or "symbols[]") is required.');
+    if (keywords.length === 1) {
+      return _searchSymbolsByKeyword(graph, keywords[0], cwd, { language, limit });
+    }
+    // Batch: merge results across symbols, dedupe identical result blocks.
+    const seen = new Set();
+    const sections = [];
+    for (const kw of keywords) {
+      const result = _searchSymbolsByKeyword(graph, kw, cwd, { language, limit });
+      if (seen.has(result)) continue;
+      seen.add(result);
+      sections.push(`# symbol_search: ${kw}\n${result}`);
+    }
+    return sections.join('\n\n');
   }
 
   if (mode === 'references') {
@@ -468,6 +502,26 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
             return dispatchOne({ ...args, symbol: symbolList[0], symbols: undefined });
           }
         }
+        if (CODE_GRAPH_FILE_BATCHABLE_MODES.has(batchMode)) {
+          const fileList = _collectGraphFileList(args);
+          if (fileList.length > 1) {
+            const capped = fileList._capped;
+            return (async () => {
+              const sections = [];
+              for (const f of fileList) {
+                let body;
+                try { body = await dispatchOne({ ...args, file: f, files: undefined }); }
+                catch (e) { body = `Error: ${e?.message || String(e)}`; }
+                sections.push(`# ${batchMode} ${f}\n${body}`);
+              }
+              if (capped) sections.push(`Note: file list capped at ${CODE_GRAPH_FILE_BATCH_CAP} entries.`);
+              return sections.join('\n\n');
+            })();
+          }
+          if (fileList.length === 1 && args?.file !== fileList[0]) {
+            return dispatchOne({ ...args, file: fileList[0], files: undefined });
+          }
+        }
         return dispatchOne(args);
       }
       default: throw new Error(`Unknown code-graph tool: ${name}`);

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/search.mjs

@@ -19,6 +19,16 @@ import {
 } from './symbol-index.mjs';
 import { CODE_GRAPH_MAX_FILES } from './constants.mjs';
 import { _inferSpanEndByIndent } from './span.mjs';
+import {
+  _toByteColumn,
+  _byteColToCharCol,
+  _nearestEnclosingSymbol,
+} from './text-columns.mjs';
+import {
+  _keywordSymbolSortKey,
+  _tokenizeKeyword,
+  _keywordMatchesSymbolName,
+} from './keyword-match.mjs';
 
 export function _extractCallees(graph, declHit, _cwd, { cap = 200, callerSymbol = null, language = null } = {}) {
   if (!declHit || !_CALLEES_BRACE_LANGS.has(declHit.lang)) return [];
@@ -535,85 +545,6 @@ function _resolveCalleeDeclaration(graph, name, { language = null, preferRel = n
   return _pickCalleeDeclHit(_findSymbolHits(graph, name, { language }), preferRel);
 }
 
-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];
-}
-
-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;
-}
-
-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);
-}
-
 function _nativeSymbolHit(node, sym) {
   const line = Number(sym?.line ?? sym?.startLine);
   if (!Number.isFinite(line) || line < 1) return null;
@@ -1009,49 +940,6 @@ function _referenceKind(line, symbol, lang = null) {
   return 'reference';
 }
 
-function _toByteColumn(lineText, charCol) {
-  if (!Number.isFinite(charCol) || charCol < 1) return charCol;
-  const prefix = String(lineText || '').slice(0, charCol - 1);
-  return Buffer.byteLength(prefix, 'utf8') + 1;
-}
-
-function _byteColToCharCol(lineText, byteCol) {
-  if (!Number.isFinite(byteCol) || byteCol < 1) return 1;
-  const s = String(lineText || '');
-  let bytes = 0;
-  let k = 0;
-  while (k < s.length && bytes < byteCol - 1) {
-    const cp = s.codePointAt(k);
-    bytes += Buffer.byteLength(String.fromCodePoint(cp), 'utf8');
-    k += cp > 0xFFFF ? 2 : 1;
-  }
-  return k + 1;
-}
-
-function _nearestEnclosingSymbol(node, sourceText, lineNumber, col = null) {
-  const FUNCTION_LIKE = new Set([
-    'function', 'method', 'arrow', 'class', 'generator', 'fn', 'async-function',
-    'constructor', 'record', 'local-function',
-  ]);
-  const symbols = Array.isArray(node?.symbols) ? node.symbols : [];
-  const inRange = (item) => {
-    if (item.line > lineNumber || Number(item.endLine) < lineNumber) return false;
-    if (col != null) {
-      const sl = Number(item.startLine);
-      const sc = Number(item.startCol);
-      const ec = Number(item.endCol);
-      if (Number.isFinite(sl) && sl === lineNumber && Number.isFinite(sc) && col < sc) return false;
-      if (Number(item.endLine) === lineNumber && Number.isFinite(ec) && col > ec) return false;
-    }
-    return true;
-  };
-  const candidates = symbols
-    .filter(inRange)
-    .sort((a, b) => (b.line - a.line) || ((Number(b.startCol) || 0) - (Number(a.startCol) || 0)));
-  const fn = candidates.find((item) => FUNCTION_LIKE.has(String(item.kind || '').toLowerCase()));
-  return fn || candidates[0] || null;
-}
-
 function _collectCallerEntries(graph, symbol, referenceText) {
   const entries = _parseReferenceEntries(referenceText);
   const detailed = [];