@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-NRFVWJHP.js

@@ -0,0 +1,575 @@
+import {
+  chunkSourceFile,
+  isChunkable,
+  languageForFile,
+  summarizeChunk
+} from "./chunk-I7AW4237.js";
+import {
+  connectEmbedDaemon,
+  embedBatchViaClient
+} from "./chunk-L24HYX62.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-TNTFEWU5.js";
+
+// src/lib/code-context-index.ts
+import crypto from "crypto";
+import path from "path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { spawnSync } from "child_process";
+var VECTOR_STORE_VERSION = 1;
+var EMBED_BATCH_SIZE = 64;
+function vectorStorePath(projectRoot) {
+  const rootHash = hashText(projectRoot).slice(0, 16);
+  return path.join(indexDir(), `${rootHash}.vectors.json`);
+}
+function loadVectorStore(projectRoot) {
+  const file = vectorStorePath(projectRoot);
+  if (!existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (parsed.version !== VECTOR_STORE_VERSION) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveVectorStore(projectRoot, store) {
+  writeFileSync(vectorStorePath(projectRoot), JSON.stringify(store));
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+async function embedSymbols(index) {
+  const rootHash = hashText(index.projectRoot).slice(0, 16);
+  const existing = loadVectorStore(index.projectRoot);
+  const store = {
+    version: VECTOR_STORE_VERSION,
+    projectRootHash: rootHash,
+    vectors: {}
+  };
+  const allSymbols = [];
+  for (const file of Object.values(index.files)) {
+    for (const symbol of file.symbols) {
+      if (existing?.vectors[symbol.id]) {
+        store.vectors[symbol.id] = existing.vectors[symbol.id];
+      } else {
+        allSymbols.push({ id: symbol.id, text: symbol.summary || `${symbol.kind} ${symbol.name} in ${symbol.filePath}` });
+      }
+    }
+  }
+  if (allSymbols.length === 0) {
+    saveVectorStore(index.projectRoot, store);
+    return store;
+  }
+  const connected = await connectEmbedDaemon().catch(() => false);
+  if (!connected) {
+    saveVectorStore(index.projectRoot, store);
+    return store;
+  }
+  for (let i = 0; i < allSymbols.length; i += EMBED_BATCH_SIZE) {
+    const batch = allSymbols.slice(i, i + EMBED_BATCH_SIZE);
+    const texts = batch.map((s) => s.text);
+    try {
+      const vectors = await embedBatchViaClient(texts, "low");
+      if (vectors && vectors.length === batch.length) {
+        for (let j = 0; j < batch.length; j++) {
+          store.vectors[batch[j].id] = vectors[j];
+        }
+      }
+    } catch {
+    }
+  }
+  saveVectorStore(index.projectRoot, store);
+  return store;
+}
+var INDEX_VERSION = 2;
+var DEFAULT_MAX_FILES = 5e3;
+var IGNORE_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".worktrees", ".next", "build", "target", "vendor"]);
+function normalizeProjectRoot(projectRoot) {
+  return path.resolve(projectRoot || process.cwd());
+}
+function hashText(text) {
+  return crypto.createHash("sha256").update(text).digest("hex");
+}
+function indexDir() {
+  const dir = path.join(EXE_AI_DIR, "code-context");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getCodeContextIndexPath(projectRoot) {
+  const root = normalizeProjectRoot(projectRoot);
+  const rootHash = hashText(root).slice(0, 16);
+  return path.join(indexDir(), `${rootHash}.json`);
+}
+function currentBranch(projectRoot) {
+  const result = spawnSync("git", ["branch", "--show-current"], { cwd: projectRoot, encoding: "utf8", timeout: 2e3 });
+  const branch = result.status === 0 ? result.stdout.trim() : "";
+  return branch || "detached-or-unknown";
+}
+function shouldIgnore(relPath) {
+  const parts = relPath.split(/[\\/]/);
+  return parts.some((part) => IGNORE_SEGMENTS.has(part));
+}
+function listRecursive(projectRoot, dir = projectRoot, out = []) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const abs = path.join(dir, entry.name);
+    const rel = path.relative(projectRoot, abs).replaceAll(path.sep, "/");
+    if (shouldIgnore(rel)) continue;
+    if (entry.isDirectory()) listRecursive(projectRoot, abs, out);
+    else if (entry.isFile()) out.push(rel);
+  }
+  return out;
+}
+function listCodeFiles(projectRoot, maxFiles) {
+  const git = spawnSync("git", ["ls-files"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 * 16 });
+  let files = [];
+  if (git.status === 0 && git.stdout.trim()) {
+    files = git.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  } else {
+    const rg = spawnSync("rg", ["--files"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 * 16 });
+    files = rg.status === 0 && rg.stdout.trim() ? rg.stdout.split("\n").map((s) => s.trim()).filter(Boolean) : listRecursive(projectRoot);
+  }
+  return files.map((file) => file.replaceAll(path.sep, "/")).filter((file) => isChunkable(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
+}
+function parseImportPaths(importText) {
+  const paths = [];
+  const patterns = [/from\s+["']([^"']+)["']/g, /^import\s+["']([^"']+)["']/gm, /require\(["']([^"']+)["']\)/g, /use\s+([A-Za-z0-9_:]+)::/g, /#include\s+[<"]([^>"]+)[>"]/g];
+  for (const regex of patterns) {
+    let match;
+    while ((match = regex.exec(importText)) !== null) if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+  return paths;
+}
+function resolveImport(fromFile, importPath, allFiles) {
+  if (!importPath.startsWith(".")) return null;
+  const base = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile.replaceAll(path.sep, "/")), importPath));
+  const withoutKnownExt = base.replace(/\.(?:[a-z0-9]+)$/i, "");
+  const candidates = [base];
+  for (const ext of ["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "cs", "cpp", "c", "rb", "php", "swift", "kt", "scala", "sql", "md", "json", "yaml", "yml"]) {
+    candidates.push(`${withoutKnownExt}.${ext}`, `${base}.${ext}`);
+  }
+  for (const indexName of ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"]) candidates.push(path.posix.join(base, indexName));
+  return candidates.find((candidate) => allFiles.has(candidate)) ?? null;
+}
+function symbolId(filePath, chunk) {
+  return hashText(`${filePath}:${chunk.kind}:${chunk.name}:${chunk.startLine}:${chunk.endLine}`).slice(0, 24);
+}
+function loadIndex(projectRoot) {
+  const file = getCodeContextIndexPath(projectRoot);
+  if (!existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (parsed.version !== INDEX_VERSION || parsed.projectRoot !== projectRoot) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveIndex(index) {
+  writeFileSync(getCodeContextIndexPath(index.projectRoot), JSON.stringify(index, null, 2));
+}
+function buildFileRecord(projectRoot, relPath, allFiles, previous) {
+  const absPath = path.join(projectRoot, relPath);
+  let stat;
+  try {
+    stat = statSync(absPath);
+  } catch {
+    return { record: null, reused: false };
+  }
+  if (!stat.isFile()) return { record: null, reused: false };
+  const language = languageForFile(relPath);
+  if (!language || !isChunkable(relPath)) return { record: null, reused: false };
+  const source = readFileSync(absPath, "utf8");
+  const hash = hashText(source);
+  if (previous && previous.hash === hash && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size && previous.language === language) {
+    return { record: previous, reused: true };
+  }
+  const chunks = chunkSourceFile(source, relPath);
+  const imports = chunks.filter((chunk) => chunk.kind === "import").flatMap((chunk) => parseImportPaths(chunk.text));
+  const resolvedImports = imports.map((importPath) => resolveImport(relPath, importPath, allFiles)).filter((file) => Boolean(file));
+  const symbols = chunks.filter((chunk) => chunk.name !== "(unknown)").map((chunk) => ({
+    id: symbolId(relPath, chunk),
+    name: chunk.name,
+    kind: chunk.kind,
+    filePath: relPath,
+    language,
+    startLine: chunk.startLine,
+    endLine: chunk.endLine,
+    summary: summarizeChunk(chunk, relPath),
+    text: chunk.text.slice(0, 8e3),
+    comment: chunk.comment
+  }));
+  return { record: { path: relPath, absPath, language, hash, mtimeMs: stat.mtimeMs, size: stat.size, imports, resolvedImports, symbols }, reused: false };
+}
+function buildCodeContextIndex(options = {}) {
+  const projectRoot = normalizeProjectRoot(options.projectRoot);
+  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+  const branch = currentBranch(projectRoot);
+  const previous = options.force ? null : loadIndex(projectRoot);
+  const files = listCodeFiles(projectRoot, maxFiles);
+  const allFiles = new Set(files.map((file) => file.replaceAll(path.sep, "/")));
+  const fileRecords = {};
+  let rebuiltFiles = 0;
+  let reusedFiles = 0;
+  let skippedFiles = 0;
+  for (const rel of files) {
+    const normalized = rel.replaceAll(path.sep, "/");
+    const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
+    if (record) {
+      fileRecords[normalized] = record;
+      if (reused) reusedFiles++;
+      else rebuiltFiles++;
+    } else skippedFiles++;
+  }
+  const languageBreakdown = {};
+  for (const file of Object.values(fileRecords)) languageBreakdown[file.language] = (languageBreakdown[file.language] ?? 0) + 1;
+  const index = {
+    version: INDEX_VERSION,
+    projectRoot,
+    rootHash: hashText(projectRoot).slice(0, 16),
+    branch,
+    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: { filesSeen: files.length, filesIndexed: Object.keys(fileRecords).length, rebuiltFiles, reusedFiles, skippedFiles, languageBreakdown },
+    files: fileRecords
+  };
+  saveIndex(index);
+  return index;
+}
+function loadOrBuildCodeContextIndex(options = {}) {
+  const projectRoot = normalizeProjectRoot(options.projectRoot);
+  if (!options.force) {
+    const loaded = loadIndex(projectRoot);
+    if (loaded) {
+      const currentFiles = listCodeFiles(projectRoot, options.maxFiles ?? DEFAULT_MAX_FILES);
+      const unchanged = currentFiles.every((rel) => {
+        const normalized = rel.replaceAll(path.sep, "/");
+        const existing = loaded.files[normalized];
+        if (!existing) return false;
+        try {
+          const stat = statSync(path.join(projectRoot, normalized));
+          return stat.mtimeMs === existing.mtimeMs && stat.size === existing.size;
+        } catch {
+          return false;
+        }
+      });
+      if (unchanged && Object.keys(loaded.files).length === currentFiles.length) return loaded;
+    }
+  }
+  return buildCodeContextIndex(options);
+}
+function normalizeLanguage(language) {
+  return language.toLowerCase().replace(/^c\+\+$/, "cpp").replace(/^c#$/, "csharp").replace(/^js$/, "javascript").replace(/^ts$/, "typescript");
+}
+function tokenize(query) {
+  const raw = query.toLowerCase().replace(/([a-z])([A-Z])/g, "$1 $2").split(/[^a-z0-9_.$/-]+/).map((s) => s.trim()).filter((s) => s.length >= 2);
+  const expanded = /* @__PURE__ */ new Set();
+  for (const term of raw) {
+    expanded.add(term);
+    for (const part of term.split(/[_.$/-]+/)) if (part.length >= 2) expanded.add(part);
+    const dashed = term.replace(/[_.$/]+/g, "-");
+    if (dashed.length >= 2) expanded.add(dashed);
+    if (!term.includes("-")) expanded.add(`${term}s`);
+    if (term.endsWith("s") && term.length > 3) expanded.add(term.slice(0, -1));
+  }
+  return [...expanded];
+}
+function ngrams(terms) {
+  const grams = [...terms];
+  for (let i = 0; i < terms.length - 1; i++) grams.push(`${terms[i]} ${terms[i + 1]}`);
+  return grams;
+}
+function globToRegex(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    const next = pattern[i + 1];
+    if (ch === "*" && next === "*") {
+      out += ".*";
+      i++;
+      continue;
+    }
+    if (ch === "*") {
+      out += "[^/]*";
+      continue;
+    }
+    if (".+^${}()|[]\\".includes(ch)) out += `\\${ch}`;
+    else out += ch;
+  }
+  return new RegExp(`^${out}$`);
+}
+function matchesPath(filePath, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  const normalized = filePath.replaceAll(path.sep, "/");
+  return patterns.some((pattern) => {
+    const p = pattern.replaceAll(path.sep, "/").replace(/^\.\//, "");
+    return normalized === p || normalized.startsWith(`${p}/`) || normalized.endsWith(p) || globToRegex(p).test(normalized);
+  });
+}
+function scoreSymbol(symbol, terms) {
+  const grams = ngrams(terms);
+  const haystacks = {
+    name: symbol.name.toLowerCase(),
+    path: symbol.filePath.toLowerCase(),
+    language: symbol.language.toLowerCase(),
+    summary: symbol.summary.toLowerCase(),
+    text: symbol.text.toLowerCase()
+  };
+  let score = 0;
+  const matches = [];
+  for (const term of terms) {
+    if (haystacks.name === term) {
+      score += 100;
+      matches.push(`name=${term}`);
+      continue;
+    }
+    if (haystacks.name.includes(term)) {
+      score += 45;
+      matches.push(`name~${term}`);
+    }
+    if (haystacks.path.includes(term)) {
+      score += 18;
+      matches.push(`path~${term}`);
+    }
+    if (haystacks.language === term) {
+      score += 18;
+      matches.push(`language=${term}`);
+    }
+    if (haystacks.summary.includes(term)) {
+      score += 16;
+      matches.push(`summary~${term}`);
+    }
+    if (haystacks.text.includes(term)) {
+      score += 5;
+      matches.push(`text~${term}`);
+    }
+  }
+  for (const gram of grams.filter((g) => g.includes(" "))) {
+    if (haystacks.text.includes(gram) || haystacks.summary.includes(gram)) {
+      score += 20;
+      matches.push(`phrase~${gram}`);
+    }
+  }
+  const uniqueMatches = new Set(matches.map((m) => m.replace(/^[^=~]+[=~]/, ""))).size;
+  score += uniqueMatches * 3;
+  return { score, matches };
+}
+function filteredFiles(index, options = {}) {
+  const languages = options.languages?.map(normalizeLanguage).filter(Boolean);
+  return Object.values(index.files).filter((file) => {
+    if (languages && languages.length > 0 && !languages.includes(normalizeLanguage(file.language))) return false;
+    return matchesPath(file.path, options.paths);
+  });
+}
+function lexicalSearch(query, options = {}) {
+  const terms = tokenize(query);
+  if (terms.length === 0) return [];
+  const index = loadOrBuildCodeContextIndex({ projectRoot: options.projectRoot, force: options.force || options.refreshIndex, maxFiles: options.maxFiles });
+  const results = [];
+  for (const file of filteredFiles(index, options)) {
+    for (const symbol of file.symbols) {
+      const scored = scoreSymbol(symbol, terms);
+      if (scored.score > 0) {
+        results.push({
+          symbol,
+          score: scored.score,
+          matches: scored.matches,
+          filePath: symbol.filePath,
+          language: symbol.language,
+          content: symbol.text,
+          startLine: symbol.startLine,
+          endLine: symbol.endLine
+        });
+      }
+    }
+  }
+  const offset = Math.max(0, options.offset ?? 0);
+  const limit = options.limit ?? 20;
+  return results.sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath)).slice(offset, offset + limit);
+}
+function searchCodeContext(query, options = {}) {
+  return lexicalSearch(query, options);
+}
+var RRF_K = 60;
+async function searchCodeContextSemantic(query, options = {}) {
+  const terms = tokenize(query);
+  if (terms.length === 0) return [];
+  const index = loadOrBuildCodeContextIndex({ projectRoot: options.projectRoot, force: options.force || options.refreshIndex, maxFiles: options.maxFiles });
+  const projectRoot = normalizeProjectRoot(options.projectRoot);
+  const vectorStore = loadVectorStore(projectRoot);
+  if (!vectorStore || Object.keys(vectorStore.vectors).length === 0) {
+    return lexicalSearch(query, options);
+  }
+  let queryVector = null;
+  try {
+    const connected = await connectEmbedDaemon().catch(() => false);
+    if (connected) {
+      const result = await embedBatchViaClient([query], "high");
+      if (result && result.length === 1) queryVector = result[0];
+    }
+  } catch {
+  }
+  if (!queryVector) return lexicalSearch(query, options);
+  const files = filteredFiles(index, options);
+  const candidates = [];
+  for (const file of files) {
+    for (const symbol of file.symbols) {
+      const lexical = scoreSymbol(symbol, terms);
+      const vec = vectorStore.vectors[symbol.id];
+      const vectorScore = vec ? cosineSimilarity(queryVector, vec) : 0;
+      if (lexical.score > 0 || vectorScore > 0.3) {
+        candidates.push({
+          symbol,
+          lexicalScore: lexical.score,
+          vectorScore,
+          matches: lexical.matches
+        });
+      }
+    }
+  }
+  const byLexical = [...candidates].sort((a, b) => b.lexicalScore - a.lexicalScore);
+  const byVector = [...candidates].sort((a, b) => b.vectorScore - a.vectorScore);
+  const lexicalRank = /* @__PURE__ */ new Map();
+  const vectorRank = /* @__PURE__ */ new Map();
+  byLexical.forEach((c, i) => lexicalRank.set(c.symbol.id, i + 1));
+  byVector.forEach((c, i) => vectorRank.set(c.symbol.id, i + 1));
+  const VECTOR_WEIGHT = 0.6;
+  const LEXICAL_WEIGHT = 0.4;
+  const fused = candidates.map((c) => {
+    const lRank = lexicalRank.get(c.symbol.id) ?? candidates.length + 1;
+    const vRank = vectorRank.get(c.symbol.id) ?? candidates.length + 1;
+    const rrfScore = VECTOR_WEIGHT * (1 / (RRF_K + vRank)) + LEXICAL_WEIGHT * (1 / (RRF_K + lRank));
+    return {
+      symbol: c.symbol,
+      score: rrfScore,
+      matches: c.vectorScore > 0.3 ? [...c.matches, `semantic=${c.vectorScore.toFixed(3)}`] : c.matches,
+      filePath: c.symbol.filePath,
+      language: c.symbol.language,
+      content: c.symbol.text,
+      startLine: c.symbol.startLine,
+      endLine: c.symbol.endLine
+    };
+  });
+  const offset = Math.max(0, options.offset ?? 0);
+  const limit = options.limit ?? 20;
+  return fused.sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath)).slice(offset, offset + limit);
+}
+async function buildCodeContextIndexWithEmbeddings(options = {}) {
+  const index = buildCodeContextIndex(options);
+  const existingStore = loadVectorStore(index.projectRoot);
+  const existingCount = existingStore ? Object.keys(existingStore.vectors).length : 0;
+  const store = await embedSymbols(index);
+  const vectorCount = Object.keys(store.vectors).length;
+  const newEmbeddings = vectorCount - Math.min(existingCount, vectorCount);
+  return { index, vectorCount, newEmbeddings };
+}
+function dependentsMap(index) {
+  const map = /* @__PURE__ */ new Map();
+  for (const file of Object.values(index.files)) {
+    for (const dep of file.resolvedImports) {
+      if (!map.has(dep)) map.set(dep, /* @__PURE__ */ new Set());
+      map.get(dep).add(file.path);
+    }
+  }
+  return map;
+}
+function findSymbols(index, symbolName, limit = 20) {
+  const q = symbolName.toLowerCase();
+  const exact = [];
+  const fuzzy = [];
+  for (const file of Object.values(index.files)) {
+    for (const symbol of file.symbols) {
+      if (symbol.name.toLowerCase() === q) exact.push(symbol);
+      else if (symbol.name.toLowerCase().includes(q) || symbol.summary.toLowerCase().includes(q)) fuzzy.push(symbol);
+    }
+  }
+  return [...exact, ...fuzzy].slice(0, limit);
+}
+function traceCodeSymbol(symbolName, options = {}) {
+  const index = loadOrBuildCodeContextIndex(options);
+  const matches = findSymbols(index, symbolName, options.limit ?? 20);
+  const dependents = dependentsMap(index);
+  return { query: symbolName, matches, definitions: matches.map((symbol) => {
+    const file = index.files[symbol.filePath];
+    return { symbol, imports: file.resolvedImports, dependents: [...dependents.get(symbol.filePath) ?? /* @__PURE__ */ new Set()].sort(), relatedSymbols: file.symbols.filter((s) => s.id !== symbol.id).slice(0, 20) };
+  }) };
+}
+function resolveTargetFile(index, input) {
+  if (input.filePath) {
+    const normalized = input.filePath.replaceAll(path.sep, "/").replace(/^\.\//, "");
+    if (index.files[normalized]) return { filePath: normalized, target: normalized };
+    const suffix = Object.keys(index.files).find((file) => file.endsWith(normalized));
+    if (suffix) return { filePath: suffix, target: input.filePath };
+  }
+  if (input.symbol) {
+    const match = findSymbols(index, input.symbol, 1)[0];
+    if (match) return { filePath: match.filePath, target: input.symbol };
+  }
+  return null;
+}
+function analyzeBlastRadius(input) {
+  const index = loadOrBuildCodeContextIndex({ projectRoot: input.projectRoot, force: input.force });
+  const target = resolveTargetFile(index, { filePath: input.filePath, symbol: input.symbol });
+  if (!target) return null;
+  const dependents = dependentsMap(index);
+  const maxDepth = input.depth ?? 2;
+  const impacted = /* @__PURE__ */ new Map();
+  const queue = [{ filePath: target.filePath, distance: 0 }];
+  impacted.set(target.filePath, { distance: 0, reason: "target" });
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (item.distance >= maxDepth) continue;
+    for (const dep of dependents.get(item.filePath) ?? []) {
+      if (!impacted.has(dep)) {
+        impacted.set(dep, { distance: item.distance + 1, reason: `imports ${item.filePath}` });
+        queue.push({ filePath: dep, distance: item.distance + 1 });
+      }
+    }
+  }
+  const targetBase = path.basename(target.filePath).replace(/\.[^.]+$/, "").toLowerCase();
+  const symbolLower = input.symbol?.toLowerCase();
+  const tests = Object.keys(index.files).filter((file) => {
+    const lower = file.toLowerCase();
+    return (lower.includes("test") || lower.includes("spec")) && (lower.includes(targetBase) || (symbolLower ? index.files[file].symbols.some((s) => s.text.toLowerCase().includes(symbolLower)) : false));
+  });
+  for (const test of tests) if (!impacted.has(test)) impacted.set(test, { distance: 1, reason: "related test/spec" });
+  const impactedFiles = [...impacted.entries()].map(([filePath, value]) => ({ filePath, distance: value.distance, reason: value.reason })).sort((a, b) => a.distance - b.distance || a.filePath.localeCompare(b.filePath));
+  const nonTestImpacted = impactedFiles.filter((f) => !f.filePath.match(/(test|spec)\./i)).length;
+  return { target: target.target, targetFile: target.filePath, impactedFiles, tests, symbolsInTarget: index.files[target.filePath]?.symbols ?? [], riskLevel: nonTestImpacted >= 8 ? "high" : nonTestImpacted >= 4 ? "medium" : "low" };
+}
+function getCodeContextStats(options = {}) {
+  const index = loadOrBuildCodeContextIndex(options);
+  return {
+    projectRoot: index.projectRoot,
+    branch: index.branch,
+    indexedAt: index.indexedAt,
+    indexAgeMs: Math.max(0, Date.now() - Date.parse(index.indexedAt)),
+    files: Object.keys(index.files).length,
+    symbols: Object.values(index.files).reduce((sum, file) => sum + file.symbols.length, 0),
+    imports: Object.values(index.files).reduce((sum, file) => sum + file.resolvedImports.length, 0),
+    languageBreakdown: index.stats.languageBreakdown,
+    rebuiltFiles: index.stats.rebuiltFiles,
+    reusedFiles: index.stats.reusedFiles,
+    skippedFiles: index.stats.skippedFiles,
+    indexPath: getCodeContextIndexPath(index.projectRoot)
+  };
+}
+
+export {
+  getCodeContextIndexPath,
+  buildCodeContextIndex,
+  loadOrBuildCodeContextIndex,
+  searchCodeContext,
+  searchCodeContextSemantic,
+  buildCodeContextIndexWithEmbeddings,
+  traceCodeSymbol,
+  analyzeBlastRadius,
+  getCodeContextStats
+};