@esankhan3/code-search-mcp 0.0.2 → 0.1.0

package/dist/core/indexer.js

@@ -1,552 +0,0 @@
-import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSync } from "node:fs";
-import { execSync } from "node:child_process";
-import { join, basename } from "node:path";
-import { chunkRepo, chunkChangedFiles } from "./chunker.js";
-import { buildAstGraph, generateGraphReport, incrementalGraphUpdate } from "./ast-graph-builder.js";
-import { getAllChanges, getChangedFilesList, getDeletedFilesList } from "./git-diff.js";
-import { createEmbeddingProvider } from "./embedder.js";
-import { VectorStore } from "./vector-store.js";
-import { ProjectGraphBuilder } from "./project-graph-builder.js";
-import { detectCrossRepoEdges } from "./cross-repo-detector.js";
-import { detectWorkspace } from "./workspace-detector.js";
-import { HybridRetriever } from "./retriever.js";
-import { loadKnowledgeConfig, getKnowledgeBasePath, DEFAULT_CONFIG } from "./config.js";
-import { profileProject, loadAllProfiles } from "./repo-profiler.js";
-import { inferServiceMesh } from "./service-mesh-inferrer.js";
-import { deduplicateByStructure } from "./structural-hasher.js";
-import { createQueryRouter } from "./query-router.js";
-function getRepoSha(repoPath) {
-  try {
-    return execSync("git rev-parse HEAD", { cwd: repoPath, stdio: "pipe", encoding: "utf-8", timeout: 5e3 }).trim();
-  } catch {
-    return null;
-  }
-}
-function readRepoIndexMeta(basePath, repoName) {
-  const metaPath = join(basePath, repoName, "index_meta.json");
-  if (!existsSync(metaPath)) return null;
-  try {
-    return JSON.parse(readFileSync(metaPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function writeRepoIndexMeta(basePath, repoName, meta) {
-  const dir = join(basePath, repoName);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "index_meta.json"), JSON.stringify(meta, null, 2), "utf-8");
-}
-class KnowledgeIndexer {
-  // ---------------------------------------------------------------------------
-  // BUILD KB — fast, static, no embedding. Profiles + chunks + graphs + edges.
-  // ---------------------------------------------------------------------------
-  async buildKB(project, repos, config, opts) {
-    const log = opts?.onProgress ?? (() => {
-    });
-    const report = opts?.onDetailedProgress ?? (() => {
-    });
-    const startTime = Date.now();
-    const basePath = getKnowledgeBasePath(project);
-    mkdirSync(basePath, { recursive: true });
-    const reposToIndex = [];
-    const skippedRepos = [];
-    for (const repo of repos) {
-      if (opts?.force) {
-        reposToIndex.push(repo);
-        continue;
-      }
-      const currentSha = getRepoSha(repo.path);
-      const meta = readRepoIndexMeta(basePath, repo.name);
-      if (meta && currentSha && meta.lastIndexedSha === currentSha) {
-        skippedRepos.push(repo.name);
-        log(`Skipping ${repo.name} \u2014 unchanged (${currentSha.slice(0, 7)})`);
-      } else {
-        reposToIndex.push(repo);
-      }
-    }
-    if (reposToIndex.length === 0) {
-      log("All repos up to date \u2014 nothing to build.");
-      report({ phase: "done", message: "All repos up to date", percent: 100, etaSeconds: 0, skippedRepos });
-      return { project, repos: [], totalChunks: 0, totalTokens: 0, crossRepoEdges: 0, durationMs: 0, chunksPath: join(basePath, "chunks.json") };
-    }
-    const { isLlmAvailable } = await import("./claude-runner.js");
-    if (isLlmAvailable()) {
-      report({ phase: "profiling", message: `Profiling ${repos.length} repos with LLM...`, percent: 3, etaSeconds: -1, reposTotal: repos.length, reposProcessed: 0 });
-      log(`Profiling ${repos.length} repos with LLM...`);
-      try {
-        const profiles = await profileProject(project, repos, {
-          force: opts?.force,
-          onProgress: (m) => {
-            log(m);
-            report({ phase: "profiling", message: m, percent: 5, etaSeconds: -1 });
-          }
-        });
-        log(`Profiled ${profiles.length} repos`);
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        log(`Warning: Repo profiling skipped: ${errMsg}`);
-        report({ phase: "profiling", message: `Profiling skipped: ${errMsg.slice(0, 100)}`, percent: 8, etaSeconds: -1 });
-      }
-    } else {
-      log("LLM profiling disabled (CODE_SEARCH_LLM_MODE=none) \u2014 skipping");
-      report({ phase: "profiling", message: "Skipped (LLM disabled)", percent: 8, etaSeconds: -1 });
-    }
-    report({ phase: "chunking", message: `Chunking ${reposToIndex.length} repos...`, percent: 10, etaSeconds: -1, reposTotal: repos.length, reposProcessed: skippedRepos.length, skippedRepos });
-    log(`Chunking ${reposToIndex.length} repos (${skippedRepos.length} skipped \u2014 unchanged)...`);
-    const allChunks = [];
-    const repoStats = [];
-    const repoChunkResults = /* @__PURE__ */ new Map();
-    const repoDiffs = /* @__PURE__ */ new Map();
-    for (const repo of reposToIndex) {
-      const meta = opts?.force ? null : readRepoIndexMeta(basePath, repo.name);
-      const diff = opts?.force ? null : meta?.lastIndexedSha ? getAllChanges(repo.path, meta.lastIndexedSha) : null;
-      const useIncremental = diff && !diff.fallbackToFull && diff.added.length + diff.modified.length + diff.deleted.length > 0;
-      let result;
-      if (useIncremental) {
-        const changedCount = diff.added.length + diff.modified.length;
-        const deletedCount = diff.deleted.length;
-        log(`  ${repo.name}: git diff \u2192 ${changedCount} changed, ${deletedCount} deleted (incremental)`);
-        result = await chunkChangedFiles(repo.path, repo.name, project, config.chunking, diff);
-        repoDiffs.set(repo.name, diff);
-      } else {
-        result = await chunkRepo(repo.path, repo.name, project, config.chunking, meta?.files ?? void 0);
-      }
-      allChunks.push(...result.chunks);
-      repoChunkResults.set(repo.name, result);
-      const totalChunkCount = Object.values(result.fileIndex).reduce((sum, f) => sum + f.chunkCount, 0);
-      repoStats.push({ name: repo.name, chunkCount: totalChunkCount, language: repo.language });
-    }
-    for (const name of skippedRepos) {
-      const meta = readRepoIndexMeta(basePath, name);
-      repoStats.push({ name, chunkCount: meta?.chunkCount ?? 0, language: "" });
-    }
-    log(`Chunked ${allChunks.length} chunks from ${reposToIndex.length} repos`);
-    report({ phase: "dedup", message: "Deduplicating chunks by structure...", percent: 25, etaSeconds: -1 });
-    const dedupResult = deduplicateByStructure(allChunks);
-    const uniqueChunks = dedupResult.unique;
-    if (dedupResult.savings.chunks > 0) {
-      log(`Structural dedup: ${dedupResult.savings.chunks} duplicates removed`);
-    }
-    const workspaceMaps = /* @__PURE__ */ new Map();
-    for (const repo of repos) {
-      try {
-        const wsMap = detectWorkspace(repo.path);
-        if (wsMap.packages.length > 0) {
-          workspaceMaps.set(repo.name, wsMap);
-          log(`Detected workspace in ${repo.name}: ${wsMap.packages.length} packages`);
-        }
-      } catch (err) {
-        log(`Warning: Workspace detection failed for ${repo.name}: ${err}`);
-      }
-    }
-    report({ phase: "graphing", message: "Building AST graphs...", percent: 40, etaSeconds: -1 });
-    const graphBuilder = new ProjectGraphBuilder();
-    await graphBuilder.init();
-    for (const repo of repos) {
-      try {
-        const repoKbDir = join(basePath, repo.name);
-        mkdirSync(repoKbDir, { recursive: true });
-        const existingGraphPath = join(repoKbDir, "graph.json");
-        const diff = repoDiffs.get(repo.name);
-        let graph;
-        if (diff && !diff.fallbackToFull && existsSync(existingGraphPath)) {
-          const existingGraph = JSON.parse(readFileSync(existingGraphPath, "utf-8"));
-          graph = await incrementalGraphUpdate(
-            existingGraph,
-            getChangedFilesList(diff),
-            getDeletedFilesList(diff),
-            repo.path,
-            { workspaceMap: workspaceMaps.get(repo.name) }
-          );
-          log(`Updated AST graph for ${repo.name} incrementally (${diff.added.length + diff.modified.length} files changed)`);
-        } else {
-          graph = await buildAstGraph(repo.path, { workspaceMap: workspaceMaps.get(repo.name) });
-          log(`Built AST graph for ${repo.name} (${graph.nodes.length} nodes, ${graph.links.length} edges)`);
-        }
-        graphBuilder.addRepoGraph(repo.name, graph);
-        writeFileSync(join(repoKbDir, "graph.json"), JSON.stringify(graph));
-        writeFileSync(join(repoKbDir, "GRAPH_REPORT.md"), generateGraphReport(repo.name, graph));
-      } catch (err) {
-        log(`Warning: AST graph build failed for ${repo.name}: ${err}`);
-      }
-    }
-    report({ phase: "graphing", message: "Detecting cross-repo edges...", percent: 70, etaSeconds: -1 });
-    let crossRepoEdgeCount = 0;
-    const hasWorkspaces = workspaceMaps.size > 0;
-    if (repos.length > 1 || hasWorkspaces) {
-      const crossEdges = await detectCrossRepoEdges(repos, workspaceMaps);
-      graphBuilder.addCrossRepoEdges(crossEdges);
-      crossRepoEdgeCount = crossEdges.length;
-      log(`Detected ${crossEdges.length} cross-repo edges`);
-    }
-    if (isLlmAvailable()) {
-      report({ phase: "service-mesh", message: "Inferring service mesh from profiles...", percent: 80, etaSeconds: -1 });
-      try {
-        const profiles = loadAllProfiles(project);
-        if (profiles.length > 0) {
-          log(`Inferring service mesh from ${profiles.length} profiles...`);
-          const meshEdges = await inferServiceMesh(profiles, {
-            onProgress: (m) => {
-              log(m);
-              report({ phase: "service-mesh", message: m, percent: 82, etaSeconds: -1 });
-            }
-          });
-          if (meshEdges.length > 0) {
-            graphBuilder.addCrossRepoEdges(meshEdges);
-            crossRepoEdgeCount += meshEdges.length;
-            log(`Service mesh: ${meshEdges.length} edges inferred`);
-          }
-        } else {
-          log("No profiles found \u2014 skipping service mesh inference");
-        }
-      } catch (err) {
-        log(`Warning: Service mesh inference failed (non-fatal): ${err}`);
-      }
-    } else {
-      log("LLM service mesh inference disabled \u2014 skipping");
-      report({ phase: "service-mesh", message: "Skipped (LLM disabled)", percent: 85, etaSeconds: -1 });
-    }
-    report({ phase: "graphing", message: "Detecting communities...", percent: 90, etaSeconds: -1 });
-    graphBuilder.detectCommunities();
-    const graphOutputPath = join(basePath, "system_graph_v2.json");
-    writeFileSync(graphOutputPath, JSON.stringify(graphBuilder.exportJson(), null, 2));
-    log(`Saved project graph to ${graphOutputPath}`);
-    const chunksPath = join(basePath, "chunks.json");
-    writeFileSync(chunksPath, JSON.stringify(uniqueChunks));
-    log(`Saved ${uniqueChunks.length} chunks to ${chunksPath}`);
-    const allDeletedFiles = [];
-    for (const repo of reposToIndex) {
-      const result = repoChunkResults.get(repo.name);
-      if (result?.deletedFiles) {
-        for (const f of result.deletedFiles) {
-          allDeletedFiles.push({ repoName: repo.name, filePath: f });
-        }
-      }
-    }
-    const deletedPath = join(basePath, "deleted_files.json");
-    writeFileSync(deletedPath, JSON.stringify(allDeletedFiles));
-    for (const repo of reposToIndex) {
-      const sha = getRepoSha(repo.path);
-      const result = repoChunkResults.get(repo.name);
-      const totalChunkCount = result ? Object.values(result.fileIndex).reduce((sum, f) => sum + f.chunkCount, 0) : 0;
-      if (sha) {
-        writeRepoIndexMeta(basePath, repo.name, {
-          lastIndexedSha: sha,
-          lastIndexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          chunkCount: totalChunkCount,
-          embeddingProvider: "pending",
-          files: result?.fileIndex
-        });
-      }
-    }
-    const durationMs = Date.now() - startTime;
-    report({ phase: "done", message: `KB built: ${uniqueChunks.length} chunks, ${crossRepoEdgeCount} edges in ${formatEta(Math.ceil(durationMs / 1e3))}`, percent: 100, etaSeconds: 0, skippedRepos });
-    return {
-      project,
-      repos: repoStats,
-      totalChunks: uniqueChunks.length,
-      totalTokens: uniqueChunks.reduce((sum, c) => sum + c.tokens, 0),
-      crossRepoEdges: crossRepoEdgeCount,
-      durationMs,
-      chunksPath
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // EMBED — incremental: only embeds new/changed chunks, preserves existing.
-  // ---------------------------------------------------------------------------
-  async embedChunks(project, config, opts) {
-    const log = opts?.onProgress ?? (() => {
-    });
-    const report = opts?.onDetailedProgress ?? (() => {
-    });
-    const startTime = Date.now();
-    const basePath = getKnowledgeBasePath(project);
-    const chunksPath = join(basePath, "chunks.json");
-    if (!existsSync(chunksPath)) {
-      throw new Error(`No chunks found \u2014 run Build KB first. Expected: ${chunksPath}`);
-    }
-    const chunks = JSON.parse(readFileSync(chunksPath, "utf-8"));
-    log(`Loaded ${chunks.length} chunks from ${chunksPath}`);
-    const dbPath = join(basePath, "lancedb");
-    const vectorStore = new VectorStore(dbPath);
-    await vectorStore.init();
-    const existingIds = /* @__PURE__ */ new Set();
-    try {
-      const stats = await vectorStore.getStats();
-      if (stats && stats.rowCount > 0) {
-        const existingChunks = await vectorStore.getChunkIds(project);
-        for (const id of existingChunks) existingIds.add(id);
-      }
-    } catch {
-    }
-    const newChunks = chunks.filter((c) => !existingIds.has(c.id));
-    const deletedFiles = this.getDeletedFiles(basePath);
-    if (newChunks.length === 0 && deletedFiles.length === 0) {
-      log("All chunks already embedded \u2014 nothing to do.");
-      report({ phase: "done", message: "All chunks already embedded", percent: 100, etaSeconds: 0 });
-      const repoNames2 = [...new Set(chunks.map((c) => c.repoName))];
-      return {
-        project,
-        repos: repoNames2.map((n) => ({ name: n, chunkCount: chunks.filter((c) => c.repoName === n).length, language: "" })),
-        totalChunks: chunks.length,
-        totalTokens: chunks.reduce((sum, c) => sum + c.tokens, 0),
-        embeddingProvider: "cached",
-        embeddingDimensions: 0,
-        crossRepoEdges: 0,
-        lastIndexed: (/* @__PURE__ */ new Date()).toISOString(),
-        indexDurationMs: Date.now() - startTime
-      };
-    }
-    if (deletedFiles.length > 0) {
-      const byRepo = /* @__PURE__ */ new Map();
-      for (const d of deletedFiles) {
-        const list = byRepo.get(d.repoName) ?? [];
-        list.push(d.filePath);
-        byRepo.set(d.repoName, list);
-      }
-      for (const [repoName, filePaths] of byRepo) {
-        log(`Removing chunks for ${filePaths.length} deleted files from ${repoName}...`);
-        await vectorStore.deleteFileChunks(project, repoName, filePaths);
-      }
-    }
-    const embedder = createEmbeddingProvider(config.embedding);
-    const isOllama = embedder.name === "ollama";
-    const batchSize = isOllama ? 10 : 50;
-    const batchDelay = isOllama ? 50 : 100;
-    log(`Embedding ${newChunks.length} new chunks with ${embedder.name} (${chunks.length - newChunks.length} cached, batch size: ${batchSize})...`);
-    const texts = newChunks.map((c) => c.contextualizedContent);
-    const embeddings = [];
-    const totalBatches = Math.ceil(texts.length / batchSize);
-    let batchesDone = 0;
-    const embedStartTime = Date.now();
-    for (let i = 0; i < texts.length; i += batchSize) {
-      const batch = texts.slice(i, i + batchSize);
-      const batchEmbeddings = await embedder.embed(batch);
-      embeddings.push(...batchEmbeddings);
-      batchesDone++;
-      const elapsed = Date.now() - embedStartTime;
-      const msPerBatch = elapsed / batchesDone;
-      const remainingBatches = totalBatches - batchesDone;
-      const etaSeconds = Math.ceil(msPerBatch * remainingBatches / 1e3);
-      const percent = Math.round(5 + batchesDone / totalBatches * 85);
-      const processed = Math.min(i + batchSize, texts.length);
-      report({
-        phase: "embedding",
-        message: `Embedding: ${processed}/${texts.length} new (~${etaSeconds}s remaining)`,
-        percent,
-        etaSeconds,
-        chunksTotal: texts.length,
-        chunksProcessed: processed
-      });
-      if (batchesDone % 10 === 0 || batchesDone === totalBatches) {
-        log(`  Embedded ${processed}/${texts.length} (ETA: ${formatEta(etaSeconds)})`);
-      }
-      if (i + batchSize < texts.length && batchDelay > 0) {
-        await new Promise((resolve) => setTimeout(resolve, batchDelay));
-      }
-    }
-    const embeddedChunks = newChunks.map((chunk, i) => ({ ...chunk, embedding: embeddings[i] }));
-    report({ phase: "storing", message: "Saving new chunks to vector database...", percent: 92, etaSeconds: -1 });
-    if (embeddedChunks.length > 0) {
-      await vectorStore.addChunks(embeddedChunks);
-    }
-    log(`Stored ${embeddedChunks.length} new chunks in LanceDB (${deletedIds.length} removed)`);
-    const repoNames = [...new Set(chunks.map((c) => c.repoName))];
-    for (const repoName of repoNames) {
-      const metaPath = join(basePath, repoName, "index_meta.json");
-      if (existsSync(metaPath)) {
-        try {
-          const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-          meta.embeddingProvider = embedder.name;
-          meta.lastIndexedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
-        } catch {
-        }
-      }
-    }
-    const durationMs = Date.now() - startTime;
-    report({ phase: "done", message: `Embedded ${newChunks.length} new chunks (${deletedIds.length} removed) in ${formatEta(Math.ceil(durationMs / 1e3))}`, percent: 100, etaSeconds: 0 });
-    return {
-      project,
-      repos: repoNames.map((n) => ({ name: n, chunkCount: chunks.filter((c) => c.repoName === n).length, language: "" })),
-      totalChunks: chunks.length,
-      totalTokens: chunks.reduce((sum, c) => sum + c.tokens, 0),
-      embeddingProvider: embedder.name,
-      embeddingDimensions: embedder.dimensions,
-      crossRepoEdges: 0,
-      lastIndexed: (/* @__PURE__ */ new Date()).toISOString(),
-      indexDurationMs: durationMs
-    };
-  }
-  /** Read the deleted files list saved by buildKB */
-  getDeletedFiles(basePath) {
-    const deletedPath = join(basePath, "deleted_files.json");
-    if (!existsSync(deletedPath)) return [];
-    try {
-      return JSON.parse(readFileSync(deletedPath, "utf-8"));
-    } catch {
-      return [];
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // FULL INDEX — convenience: buildKB + embedChunks in one call
-  // ---------------------------------------------------------------------------
-  async indexProject(project, repos, config, opts) {
-    await this.buildKB(project, repos, config, opts);
-    return this.embedChunks(project, config, opts);
-  }
-  /** Load index statistics for a project */
-  async getStats(project) {
-    const basePath = getKnowledgeBasePath(project);
-    const dbPath = join(basePath, "lancedb");
-    const store = new VectorStore(dbPath);
-    await store.init();
-    const stats = await store.getStats();
-    let provider = "unknown";
-    let lastIndexed = "";
-    const repos = [];
-    try {
-      const { readdirSync: readdirSync2 } = await import("node:fs");
-      for (const entry of readdirSync2(basePath)) {
-        const meta = readRepoIndexMeta(basePath, entry);
-        if (meta) {
-          repos.push({ name: entry, chunkCount: meta.chunkCount, language: "" });
-          if (meta.embeddingProvider !== "unknown") provider = meta.embeddingProvider;
-          if (meta.lastIndexedAt > lastIndexed) lastIndexed = meta.lastIndexedAt;
-        }
-      }
-    } catch {
-    }
-    return {
-      project,
-      repos,
-      totalChunks: stats?.rowCount ?? 0,
-      totalTokens: 0,
-      embeddingProvider: provider,
-      embeddingDimensions: 0,
-      crossRepoEdges: 0,
-      lastIndexed,
-      indexDurationMs: 0
-    };
-  }
-}
-const SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", ".next", "build", "__pycache__", ".venv", "vendor", "target"]);
-function discoverRepos(directoryPath) {
-  if (!existsSync(directoryPath)) return [];
-  const repos = [];
-  if (existsSync(join(directoryPath, ".git"))) {
-    repos.push({
-      name: basename(directoryPath),
-      path: directoryPath,
-      language: detectLanguage(directoryPath)
-    });
-    return repos;
-  }
-  try {
-    for (const entry of readdirSync(directoryPath)) {
-      if (entry.startsWith(".") || SKIP_DIRS.has(entry)) continue;
-      const fullPath = join(directoryPath, entry);
-      try {
-        if (!statSync(fullPath).isDirectory()) continue;
-      } catch {
-        continue;
-      }
-      if (!existsSync(join(fullPath, ".git"))) continue;
-      repos.push({
-        name: entry,
-        path: fullPath,
-        language: detectLanguage(fullPath)
-      });
-    }
-  } catch {
-  }
-  return repos;
-}
-function detectLanguage(repoPath) {
-  if (existsSync(join(repoPath, "go.mod"))) return "go";
-  if (existsSync(join(repoPath, "Cargo.toml"))) return "rust";
-  if (existsSync(join(repoPath, "pom.xml")) || existsSync(join(repoPath, "build.gradle"))) return "java";
-  if (existsSync(join(repoPath, "composer.json"))) return "php";
-  if (existsSync(join(repoPath, "pyproject.toml")) || existsSync(join(repoPath, "setup.py"))) return "python";
-  if (existsSync(join(repoPath, "package.json"))) {
-    if (existsSync(join(repoPath, "tsconfig.json"))) return "typescript";
-    return "javascript";
-  }
-  return "unknown";
-}
-async function buildKBFromPath(projectName, directoryPath, opts) {
-  const log = opts?.onProgress ?? (() => {
-  });
-  log(`Scanning ${directoryPath} for repos...`);
-  const repos = discoverRepos(directoryPath);
-  if (repos.length === 0) throw new Error(`No git repos found in ${directoryPath}`);
-  log(`Discovered ${repos.length} repos`);
-  const indexer = new KnowledgeIndexer();
-  return indexer.buildKB(projectName, repos, DEFAULT_CONFIG, opts);
-}
-async function embedFromPath(projectName, opts) {
-  const indexer = new KnowledgeIndexer();
-  return indexer.embedChunks(projectName, DEFAULT_CONFIG, opts);
-}
-async function indexFromPath(projectName, directoryPath, opts) {
-  const log = opts?.onProgress ?? (() => {
-  });
-  log(`Scanning ${directoryPath} for repos...`);
-  const repos = discoverRepos(directoryPath);
-  if (repos.length === 0) throw new Error(`No git repos found in ${directoryPath}`);
-  log(`Discovered ${repos.length} repos`);
-  const indexer = new KnowledgeIndexer();
-  return indexer.indexProject(projectName, repos, DEFAULT_CONFIG, opts);
-}
-function formatEta(seconds) {
-  if (seconds < 0) return "...";
-  if (seconds < 60) return `${seconds}s`;
-  const mins = Math.floor(seconds / 60);
-  const secs = seconds % 60;
-  return `${mins}m ${secs}s`;
-}
-async function getRetriever(project) {
-  const config = loadKnowledgeConfig(project);
-  const basePath = getKnowledgeBasePath(project);
-  const dbPath = join(basePath, "lancedb");
-  const vectorStore = new VectorStore(dbPath);
-  await vectorStore.init();
-  let graph = null;
-  const graphPath = join(basePath, "system_graph_v2.json");
-  if (existsSync(graphPath)) {
-    try {
-      const graphData = JSON.parse(readFileSync(graphPath, "utf-8"));
-      graph = new ProjectGraphBuilder();
-      await graph.importJson(graphData);
-    } catch {
-    }
-  }
-  const embedder = createEmbeddingProvider(config.embedding);
-  let reranker = null;
-  try {
-    const { createReranker } = await import("./reranker.js");
-    reranker = createReranker(config.retrieval.reranker);
-  } catch {
-  }
-  let queryRouter = null;
-  try {
-    queryRouter = await createQueryRouter(project, embedder);
-    if (queryRouter) {
-      console.log(`[knowledge] Query router ready (${queryRouter.repoCount} repo profiles)`);
-    }
-  } catch {
-  }
-  return new HybridRetriever(vectorStore, embedder, graph, {
-    maxChunks: config.retrieval.maxChunks,
-    maxTokens: config.retrieval.maxTokens,
-    hybridWeights: config.retrieval.hybridWeights
-  }, reranker, queryRouter);
-}
-export {
-  KnowledgeIndexer,
-  buildKBFromPath,
-  discoverRepos,
-  embedFromPath,
-  getRetriever,
-  indexFromPath
-};