dsh-code-index 0.6.1 → 0.7.0

package/dist/index.js

@@ -1533,8 +1533,8 @@ function resolveCallTargetsFor(fileSet, file, call, symbolsByName, symbolsByFile
   if (!qualified) {
     const locals = named.filter((s) => s.file === file.path && lexicallyVisible(s, call));
     if (locals.length > 0) {
-      const unique = locals.length === 1;
-      const owned = unique && isStructuralOwner(call, locals[0]);
+      const unique2 = locals.length === 1;
+      const owned = unique2 && isStructuralOwner(call, locals[0]);
       const provenance = owned && call.fromId !== null ? "structural-owner" : "local-unique";
       return toEdges(locals, call, file.path, provenance, owned ? "exact" : "name-only", maxCandidates);
     }
@@ -1618,10 +1618,10 @@ function resolveCallTargetsFor(fileSet, file, call, symbolsByName, symbolsByFile
   return [];
 }
 function toEdges(candidates, call, filePath, provenance, resolution, maxCandidates) {
-  const unique = dedupeSymbols(candidates);
-  const count = unique.length;
+  const unique2 = dedupeSymbols(candidates);
+  const count = unique2.length;
   const cap = maxCandidates > 0 ? Math.floor(maxCandidates) : 0;
-  return unique.slice(0, cap).map((target) => ({
+  return unique2.slice(0, cap).map((target) => ({
     sourceId: call.fromId,
     targetId: target.id,
     callSite: { file: filePath, line: call.line },
@@ -1701,7 +1701,7 @@ function isSubsequence(query, name2) {
   }
   return false;
 }
-function searchSymbols(index, filter, limit = 50) {
+function searchSymbols(index, filter, limit = 50, refs = callerCounts(index)) {
   const q = (filter.query ?? "").trim();
   const filePat = filter.file?.trim().toLowerCase();
   const hits = [];
@@ -1715,7 +1715,6 @@ function searchSymbols(index, filter, limit = 50) {
       hits.push({ ...sym, score });
     }
   }
-  const refs = callerCounts(index);
   hits.sort((a, b) => {
     const ab = Number(b.exported) - Number(a.exported) || b.score - a.score || (refs.get(b.name) ?? 0) - (refs.get(a.name) ?? 0) || a.name.localeCompare(b.name) || a.file.localeCompare(b.file);
     return ab;
@@ -2715,6 +2714,409 @@ function renderChangeContext(result, maxChars = 12e3) {
   return out;
 }
 
+// src/context.ts
+var TEST_PATH_RE2 = /(^|\/)(tests?|__tests__)(\/|$)|\.(?:spec|test)\.[cm]?[jt]sx?$|(^|\/)(?:test_[^/]+\.py|[^/]+_test\.(?:py|go))$/i;
+var FILE_TOKEN_RE = /[A-Za-z0-9_./\\-]+\.[A-Za-z0-9]+/g;
+var CODE_TOKEN_RE = /[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)?/g;
+var STOP_WORDS = /* @__PURE__ */ new Set(
+  [
+    "a",
+    "an",
+    "and",
+    "are",
+    "be",
+    "by",
+    "does",
+    "for",
+    "from",
+    "how",
+    "in",
+    "is",
+    "it",
+    "my",
+    "of",
+    "on",
+    "or",
+    "the",
+    "this",
+    "to",
+    "what",
+    "where",
+    "why",
+    "with"
+  ]
+);
+var CHANGE_RE = /\b(fix|bug|broken|breaks?|change|changed|current|working\s+tree|regression|impact|modified|duplicate|fails?|failure)\b/i;
+var TEST_RE3 = /\b(test|tests|spec|specs|failing|assert|coverage)\b/i;
+var ARCH_RE = /\b(architecture|architectural|flow|loading|authentication|authorization|plugin|startup|overview|pipeline|lifecycle|design|works?)\b/i;
+var EXPLORE_RE = /\b(where|implement|add|feature|introduce|entry\s+point|similar|explore|understand|locate)\b/i;
+function unique(values, key) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    const id = key(value);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(value);
+  }
+  return out;
+}
+function clamp2(value, min, max, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function wordBoundary(name2) {
+  return new RegExp(`(^|[^A-Za-z0-9_$])${name2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?=$|[^A-Za-z0-9_$])`);
+}
+function symbolLabel2(symbol) {
+  return `${symbol.kind} ${symbol.signature || symbol.name} \u2014 ${symbol.file}:${symbol.line}`;
+}
+function isTestFile(file) {
+  return TEST_PATH_RE2.test(file);
+}
+function fileMentionMatches(file, mentions) {
+  const lower = file.toLowerCase();
+  return mentions.some((mention) => {
+    const normalized = mention.replace(/\\/g, "/").toLowerCase();
+    return lower === normalized || lower.endsWith(`/${normalized}`) || lower.includes(normalized);
+  });
+}
+function routeTask(task, index) {
+  const text = task.trim();
+  const mentionedFiles = unique(text.match(FILE_TOKEN_RE) ?? [], (value) => value.toLowerCase()).map((value) => value.replace(/\\/g, "/")).filter((value) => !index || index.files.some((file) => fileMentionMatches(file.path, [value])));
+  const exactSymbolNames = index ? unique(
+    index.files.flatMap((file) => file.symbols.map((symbol) => symbol.name)),
+    (name2) => name2
+  ).filter((name2) => wordBoundary(name2).test(text)).sort((a, b) => b.length - a.length || a.localeCompare(b)) : [];
+  const codeTokens = unique(
+    (text.match(CODE_TOKEN_RE) ?? []).map((token) => token.replace(/^[^A-Za-z_$]+|[^A-Za-z0-9_$]+$/g, "")).filter((token) => token.length >= 3 && !STOP_WORDS.has(token.toLowerCase())),
+    (token) => token.toLowerCase()
+  );
+  const queries = unique(
+    [...exactSymbolNames, ...codeTokens.filter((token) => !exactSymbolNames.includes(token))],
+    (value) => value.toLowerCase()
+  ).slice(0, 12);
+  const kind = TEST_RE3.test(text) || mentionedFiles.some(isTestFile) ? "test" : CHANGE_RE.test(text) ? "change" : exactSymbolNames.length > 0 ? "symbol" : EXPLORE_RE.test(text) ? "exploration" : ARCH_RE.test(text) ? "architecture" : "ambiguous";
+  const includeChangeContext = kind === "change" || kind === "test";
+  const includeRelationships = kind === "change" || kind === "test" || kind === "symbol";
+  const sources = /* @__PURE__ */ new Set();
+  if (kind === "change" || kind === "test") sources.add("change context");
+  if (kind === "architecture" || kind === "exploration" || kind === "ambiguous") {
+    sources.add("repo map");
+  }
+  if (queries.length > 0) sources.add("ranked search");
+  if (includeRelationships) sources.add("call graph");
+  if (mentionedFiles.length > 0) sources.add("file relevance");
+  if (sources.size === 0) sources.add("repo map");
+  return {
+    kind,
+    queries,
+    mentionedFiles,
+    exactSymbolNames,
+    sources: [...sources],
+    includeChangeContext,
+    includeRelationships
+  };
+}
+function routeScore(route, hit) {
+  let score = hit.score * 30;
+  if (route.exactSymbolNames.includes(hit.name)) score += 100;
+  if (fileMentionMatches(hit.file, route.mentionedFiles)) score += 30;
+  if (isTestFile(hit.file) && route.kind !== "test") score -= 10;
+  return score;
+}
+function gatherPrimarySymbols(index, route, maxSymbols, changedIds, changedFiles, refs) {
+  const hits = [];
+  for (const query of route.queries) {
+    hits.push(...searchSymbols(index, { query }, Math.max(maxSymbols * 3, 20), refs));
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const exact = route.exactSymbolNames.includes(hit.name);
+    let score = routeScore(route, hit);
+    if (changedIds.has(hit.id)) score += 80;
+    else if (changedFiles.has(hit.file)) score += 55;
+    if (route.kind === "test" && isTestFile(hit.file)) score += 35;
+    const candidate = { symbol: hit, score, provenance: exact ? "exact" : "lexical" };
+    const previous = byId.get(hit.id);
+    if (!previous || candidate.score > previous.score) byId.set(hit.id, candidate);
+  }
+  if (route.includeChangeContext) {
+    for (const file of index.files) {
+      if (!changedFiles.has(file.path)) continue;
+      for (const symbol of file.symbols) {
+        if (byId.has(symbol.id)) continue;
+        byId.set(symbol.id, {
+          symbol,
+          score: 70,
+          provenance: "lexical"
+        });
+      }
+    }
+  }
+  return [...byId.values()].sort(
+    (a, b) => b.score - a.score || Number(b.provenance === "exact") - Number(a.provenance === "exact") || a.symbol.file.localeCompare(b.symbol.file) || a.symbol.line - b.symbol.line || a.symbol.id.localeCompare(b.symbol.id)
+  ).slice(0, maxSymbols);
+}
+function edgeText(graph, edge, direction) {
+  const source = edge.sourceId ? graph.symbolsById.get(edge.sourceId) : void 0;
+  const target = graph.symbolsById.get(edge.targetId);
+  const sourceText = source ? `${source.name} (${source.file}:${source.line})` : "module";
+  const targetText = target ? `${target.name} (${target.file}:${target.line})` : edge.name;
+  const arrow = direction === "caller" ? `${sourceText} \u2192 ${targetText}` : `${sourceText} \u2192 ${targetText}`;
+  return `${arrow} at ${edge.callSite.file}:${edge.callSite.line} [${edge.resolution}; ${edge.provenance}]`;
+}
+function collectRelationships(graph, primary) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (edge, direction, priority) => {
+    const key = `${edge.sourceId ?? "module"}:${edge.targetId}:${edge.callSite.file}:${edge.callSite.line}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    rows.push({
+      key,
+      text: edgeText(graph, edge, direction),
+      resolution: edge.resolution,
+      priority
+    });
+  };
+  for (const candidate of primary) {
+    for (const edge of graph.incoming.get(candidate.symbol.id) ?? []) add(edge, "caller", 100);
+    for (const edge of graph.outgoing.get(candidate.symbol.id) ?? []) add(edge, "callee", 90);
+  }
+  return rows.sort(
+    (a, b) => b.priority - a.priority || a.resolution.localeCompare(b.resolution) || a.text.localeCompare(b.text)
+  );
+}
+function addFile(files, path9, score, reason) {
+  const previous = files.get(path9);
+  if (!previous || score > previous.score) files.set(path9, { path: path9, score, reason });
+}
+function gatherFiles(index, route, primary, change, maxFiles) {
+  const files = /* @__PURE__ */ new Map();
+  for (const file of index.files) {
+    const base = Math.min(scoreFile(file), 8);
+    if (route.kind === "architecture" || route.kind === "exploration" || route.kind === "ambiguous") {
+      addFile(files, file.path, base, "structural importance");
+    }
+    if (fileMentionMatches(file.path, route.mentionedFiles)) addFile(files, file.path, 120, "task-mentioned file");
+  }
+  for (const candidate of primary) {
+    addFile(files, candidate.symbol.file, candidate.score + 45, "primary symbol");
+  }
+  if (change) {
+    for (const changed of change.changed) addFile(files, changed.symbol.file, 115, "current change");
+    for (const dependent of change.importDependents) addFile(files, dependent.file, 65, "import dependent");
+    for (const test of change.tests) addFile(files, test.file, 75, "likely affected test");
+    for (const pathRow of change.paths) {
+      addFile(files, pathRow.entry.file, 60, "entry path");
+      addFile(files, pathRow.changed.file, 90, "changed path");
+    }
+  }
+  for (const entry of rankRepoMap(index, { topFiles: maxFiles * 2, symbolsPerFile: 8 })) {
+    addFile(files, entry.path, Math.min(35, entry.score + 10), "repo map");
+  }
+  return [...files.values()].sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).slice(0, maxFiles);
+}
+function confidenceOf(primary, relationships, change) {
+  const out = { exact: 0, "import-scoped": 0, "name-only": 0 };
+  for (const symbol of primary) if (symbol.provenance === "exact") out.exact++;
+  for (const relation of relationships) out[relation.resolution]++;
+  if (change) {
+    for (const row of [...change.directCallers, ...change.impact]) out[row.resolution]++;
+    for (const dependent of change.importDependents) out[dependent.resolution]++;
+    for (const test of change.tests) out[test.resolution]++;
+  }
+  return out;
+}
+function renderRows(result, budgetChars) {
+  const lines = [
+    `Task context \u2014 ${result.route.kind}`,
+    `Task: ${result.task}`,
+    `Sources: ${result.route.sources.join(", ")}`,
+    "",
+    "Primary symbols:"
+  ];
+  if (result.primarySymbols.length === 0) lines.push("- (none found)");
+  const optional = [];
+  for (const candidate2 of result.primarySymbols) {
+    optional.push({
+      priority: 1e3 + candidate2.score,
+      key: `symbol:${candidate2.symbol.id}`,
+      section: "primary",
+      line: `- [${candidate2.provenance}] ${symbolLabel2(candidate2.symbol)}`
+    });
+  }
+  optional.push({ priority: 700, key: "files-header", section: "files", line: "\nRelevant files:" });
+  for (const file of result.relevantFiles) {
+    optional.push({ priority: 500 + file.score, key: `file:${file.path}`, section: "files", line: `- ${file.path} (${file.reason})` });
+  }
+  optional.push({ priority: 400, key: "relationships-header", section: "relationships", line: "\nRelationships:" });
+  for (const relation of result.relationships) {
+    optional.push({ priority: relation.priority, key: `relation:${relation.key}`, section: "relationships", line: `- ${relation.text}` });
+  }
+  if (result.changeContext) {
+    optional.push({ priority: 850, key: "changes-header", section: "changes", line: "\nCurrent changes:" });
+    for (const changed of result.changeContext.changed) {
+      optional.push({
+        priority: 840,
+        key: `changed:${changed.side}:${changed.symbol.id}`,
+        section: "changes",
+        line: `- ${changed.change} ${symbolLabel2(changed.symbol)} [${changed.resolution}]`
+      });
+    }
+    if (result.changeContext.unmapped.length > 0) {
+      optional.push({
+        priority: 830,
+        key: "changes-unmapped",
+        section: "changes",
+        line: `- unmapped: ${result.changeContext.unmapped.map((entry) => entry.file).join(", ")}`
+      });
+    }
+  }
+  if (result.tests.length > 0) {
+    optional.push({ priority: 350, key: "tests-header", section: "tests", line: "\nLikely affected tests:" });
+    for (const test of result.tests) optional.push({ priority: 340, key: `test:${test}`, section: "tests", line: `- ${test}` });
+  }
+  if (result.warnings.length > 0) {
+    optional.push({ priority: 200, key: "warnings-header", section: "warnings", line: "\nWarnings:" });
+    for (const warning of result.warnings) optional.push({ priority: 190, key: `warning:${warning}`, section: "warnings", line: `- ${warning}` });
+  }
+  const ordered = optional.map((item, index) => ({ ...item, index })).sort((a, b) => b.priority - a.priority || a.index - b.index || a.key.localeCompare(b.key));
+  const footerReserve = 100;
+  let truncated = false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of ordered) {
+    if (seen.has(item.key)) continue;
+    const next = lines.join("\n") + `
+${item.line}`;
+    if (next.length + footerReserve > budgetChars) {
+      truncated = true;
+      continue;
+    }
+    seen.add(item.key);
+    lines.push(item.line);
+  }
+  lines.push(
+    "",
+    `Confidence: exact ${result.confidence.exact}; import-scoped ${result.confidence["import-scoped"]}; name-only ${result.confidence["name-only"]}`
+  );
+  const body = lines.join("\n");
+  const withFooter = (bodyText, wasTruncated) => {
+    let usedChars = bodyText.length + 1;
+    for (let iteration = 0; iteration < 10; iteration++) {
+      const footer2 = `Budget: ${usedChars} / ${budgetChars} chars${wasTruncated ? " (trimmed low-priority context)" : ""}`;
+      const text2 = `${bodyText}
+${footer2}`;
+      const nextUsedChars = text2.length;
+      if (nextUsedChars === usedChars) return { text: text2, usedChars: nextUsedChars };
+      usedChars = nextUsedChars;
+    }
+    const footer = `Budget: ${usedChars} / ${budgetChars} chars${wasTruncated ? " (trimmed low-priority context)" : ""}`;
+    const text = `${bodyText}
+${footer}`;
+    return { text, usedChars: text.length };
+  };
+  const complete = withFooter(body, truncated);
+  if (complete.usedChars <= budgetChars) {
+    return { text: complete.text, usedChars: complete.usedChars, truncated };
+  }
+  truncated = true;
+  const candidate = (prefixLength) => {
+    const prefix = `${body.slice(0, prefixLength).trimEnd()}\u2026`;
+    return withFooter(prefix, true);
+  };
+  let low = 0;
+  let high = body.length;
+  let best = candidate(0);
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const current = candidate(middle);
+    if (current.usedChars <= budgetChars) {
+      best = current;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return { text: best.text, usedChars: best.usedChars, truncated };
+}
+async function buildTaskContext(index, task, options = {}) {
+  const budgetChars = clamp2(options.budgetChars, 300, 2e4, 5e3);
+  const maxFiles = clamp2(options.maxFiles, 1, 50, 12);
+  const maxSymbols = clamp2(options.maxSymbols, 1, 50, 10);
+  const route = routeTask(task, index);
+  let changeContext = null;
+  const warnings = [];
+  if (route.includeChangeContext) {
+    try {
+      changeContext = await buildChangeContext(index, {
+        kind: "git",
+        root: index.root,
+        baseRef: "HEAD"
+      });
+      warnings.push(...changeContext.warnings);
+    } catch (error) {
+      warnings.push(`change context unavailable: ${error.message ?? String(error)}`);
+    }
+  }
+  const changedIds = new Set((changeContext?.changed ?? []).map((entry) => entry.symbol.id));
+  const changedFiles = new Set((changeContext?.changed ?? []).map((entry) => entry.symbol.file));
+  const primarySymbols = gatherPrimarySymbols(
+    index,
+    route,
+    maxSymbols,
+    changedIds,
+    changedFiles,
+    callerCounts(index)
+  );
+  const graph = route.includeRelationships ? buildReferenceGraph(index) : null;
+  const relationships = graph ? collectRelationships(graph, primarySymbols) : [];
+  if (changeContext) {
+    const existing = new Set(relationships.map((row) => row.key));
+    for (const row of changeContext.directCallers) {
+      const key = `change:${row.symbol.id}:${row.via.callSite.file}:${row.via.callSite.line}`;
+      if (existing.has(key)) continue;
+      existing.add(key);
+      relationships.push({
+        key,
+        text: `${row.symbol.name} (${row.symbol.file}:${row.symbol.line}) \u2192 changed symbol at ${row.via.callSite.file}:${row.via.callSite.line} [${row.resolution}; ${row.via.reason}]`,
+        resolution: row.resolution,
+        priority: 110
+      });
+    }
+    relationships.sort((a, b) => b.priority - a.priority || a.text.localeCompare(b.text));
+  }
+  const relevantFiles = gatherFiles(index, route, primarySymbols, changeContext, maxFiles);
+  const tests = unique(changeContext?.tests.map((test) => test.file) ?? [], (file) => file);
+  const confidence = confidenceOf(primarySymbols, relationships, changeContext);
+  const partial = {
+    root: index.root,
+    task,
+    route,
+    primarySymbols,
+    relevantFiles,
+    relationships,
+    changeContext,
+    tests,
+    confidence,
+    warnings
+  };
+  const rendered = renderRows(partial, budgetChars);
+  return {
+    ...partial,
+    budget: {
+      usedChars: rendered.usedChars,
+      budgetChars,
+      truncated: rendered.truncated
+    }
+  };
+}
+function renderTaskContext(result) {
+  const rendered = renderRows(result, result.budget.budgetChars);
+  return rendered.text;
+}
+
 // src/tools.ts
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import path8 from "path";
@@ -2726,7 +3128,8 @@ var DEFAULTS = {
   mapMaxChars: 3200,
   mapTtlMs: 6e4,
   autoInject: true,
-  codeHealth: false
+  codeHealth: false,
+  toolSurface: "full"
 };
 var state = { current: { ...DEFAULTS } };
 function applyConfig(partial) {
@@ -2744,6 +3147,9 @@ function applyConfig(partial) {
   if (!Number.isFinite(state.current.mapTtlMs) || state.current.mapTtlMs < 1e3) {
     state.current.mapTtlMs = DEFAULTS.mapTtlMs;
   }
+  if (state.current.toolSurface !== "full" && state.current.toolSurface !== "compact") {
+    state.current.toolSurface = DEFAULTS.toolSurface;
+  }
 }
 function getConfig() {
   return state.current;
@@ -3155,6 +3561,60 @@ var tools = [
       }
     }
   }),
+  defineTool({
+    name: "code_context",
+    description: "Return the smallest useful structural context for a code task. Pass the task in plain language; the deterministic router combines ranked symbols, relevant files, call/import relationships, repository structure, current Git changes, affected tests, provenance, and a hard character budget. Existing specialized tools remain available for focused follow-up queries.",
+    parameters: {
+      task: {
+        type: "string",
+        required: true,
+        description: "The code task or question the agent is currently trying to complete."
+      },
+      budgetChars: {
+        type: "number",
+        description: "Hard output budget in characters (default 5000)."
+      },
+      maxFiles: {
+        type: "number",
+        description: "Maximum relevant files to include (default 12)."
+      },
+      maxSymbols: {
+        type: "number",
+        description: "Maximum primary symbols to include (default 10)."
+      },
+      repoRoot: {
+        type: "string",
+        description: "Optional absolute repo path; defaults to the session workspace root."
+      }
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }]
+    },
+    presentCall: (args) => ({
+      card: "generic",
+      title: "Task context",
+      kind: "search",
+      rawInput: { task: args.task, budgetChars: args.budgetChars }
+    }),
+    async execute(args, exec) {
+      try {
+        if (typeof args.task !== "string" || args.task.trim().length === 0) {
+          throw new Error("task must be a non-empty string");
+        }
+        const root = await resolveRoot(args.repoRoot, exec);
+        const index = await getIndex(root);
+        const result = await buildTaskContext(index, args.task, {
+          budgetChars: args.budgetChars,
+          maxFiles: args.maxFiles,
+          maxSymbols: args.maxSymbols
+        });
+        return renderTaskContext(result);
+      } catch (error) {
+        return `code_context: ${error.message ?? String(error)}`;
+      }
+    }
+  }),
   defineTool({
     name: "code_health",
     description: "Report structural health from the import graph: circular dependencies (import cycles) and orphan modules (symbol-bearing files that nothing imports and that import nothing, excluding entry points and tests).",
@@ -3204,7 +3664,8 @@ var settingsSchema = Schema.object({
   mapMaxChars: Schema.number().default(3200),
   mapTtlMs: Schema.number().default(6e4),
   autoInject: Schema.boolean().default(true),
-  codeHealth: Schema.boolean().default(false)
+  codeHealth: Schema.boolean().default(false),
+  toolSurface: Schema.string().default("full")
 });
 function registerSettings(getService, pluginConfig, onResolved) {
   const service = getService("settings");
@@ -3236,7 +3697,8 @@ function apply(ctx, pluginConfig) {
         );
       });
     }
-    for (const tool of tools) {
+    const visibleTools = getConfig().toolSurface === "compact" ? tools.filter((tool) => ["code_index", "code_context", "code_health"].includes(tool.name)) : tools;
+    for (const tool of visibleTools) {
       if (tool.name === "code_health" && !getConfig().codeHealth) continue;
       disposers.push(ctx.tools.register(tool));
       console.log(`[dsh-code-index] registered tool: ${tool.name}`);
@@ -3306,6 +3768,7 @@ export {
   buildIndexWithCache,
   buildModuleGraph,
   buildSymbolTable,
+  buildTaskContext,
   callerCounts,
   changeContextInputFromArgs,
   defaultCachePath,
@@ -3326,6 +3789,8 @@ export {
   renderChangeContext,
   renderHit,
   renderRepoMap,
+  renderTaskContext,
+  routeTask,
   saveIndex,
   scanRepo,
   scoreFile,