@liendev/lien 0.15.1 → 0.17.0

package/dist/index.js

@@ -2524,26 +2524,73 @@ var init_relevance = __esm({
 });
 
 // src/vectordb/intent-classifier.ts
+function getSortedRules() {
+  if (cachedSortedRules === null) {
+    cachedSortedRules = [...INTENT_RULES].sort((a, b) => b.priority - a.priority);
+  }
+  return cachedSortedRules;
+}
 function classifyQueryIntent(query) {
   const lower = query.toLowerCase().trim();
-  if (lower.match(/where\s+(is|are|does|can\s+i\s+find)/) || lower.match(/find\s+the\s+/) || lower.match(/locate\s+/)) {
-    return "location" /* LOCATION */;
-  }
-  if (lower.match(/how\s+does\s+.*\s+work/) || lower.match(/what\s+(is|are|does)/) || lower.match(/explain\s+/) || lower.match(/understand\s+/) || lower.match(/\b(process|workflow|architecture)\b/)) {
-    return "conceptual" /* CONCEPTUAL */;
-  }
-  if (lower.match(/how\s+(is|are)\s+.*\s+(implemented|built|coded)/) || lower.match(/implementation\s+of/) || lower.match(/source\s+code\s+for/)) {
-    return "implementation" /* IMPLEMENTATION */;
+  const sortedRules = getSortedRules();
+  for (const rule of sortedRules) {
+    if (rule.patterns.some((pattern) => pattern.test(lower))) {
+      return rule.intent;
+    }
   }
   return "implementation" /* IMPLEMENTATION */;
 }
+var INTENT_RULES, INITIAL_RULE_COUNT, cachedSortedRules;
 var init_intent_classifier = __esm({
   "src/vectordb/intent-classifier.ts"() {
     "use strict";
+    INTENT_RULES = [
+      // LOCATION intent (highest priority - most specific)
+      {
+        intent: "location" /* LOCATION */,
+        priority: 3,
+        patterns: [
+          /where\s+(is|are|does|can\s+i\s+find)/,
+          /find\s+the\s+/,
+          /locate\s+/
+        ]
+      },
+      // CONCEPTUAL intent (medium priority)
+      {
+        intent: "conceptual" /* CONCEPTUAL */,
+        priority: 2,
+        patterns: [
+          /how\s+does\s+.*\s+work/,
+          /what\s+(is|are|does)/,
+          /explain\s+/,
+          /understand\s+/,
+          /\b(process|workflow|architecture)\b/
+        ]
+      },
+      // IMPLEMENTATION intent (low priority - catches "how is X implemented")
+      {
+        intent: "implementation" /* IMPLEMENTATION */,
+        priority: 1,
+        patterns: [
+          /how\s+(is|are)\s+.*\s+(implemented|built|coded)/,
+          /implementation\s+of/,
+          /source\s+code\s+for/
+        ]
+      }
+    ];
+    INITIAL_RULE_COUNT = INTENT_RULES.length;
+    cachedSortedRules = null;
   }
 });
 
-// src/vectordb/query.ts
+// src/vectordb/boosting/types.ts
+var init_types2 = __esm({
+  "src/vectordb/boosting/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/vectordb/boosting/strategies.ts
 import path13 from "path";
 function isDocumentationFile(filepath) {
   const lower = filepath.toLowerCase();
@@ -2581,106 +2628,162 @@ function isUtilityFile(filepath) {
   }
   return false;
 }
-function boostPathRelevance(query, filepath, baseScore) {
-  const queryTokens = query.toLowerCase().split(/\s+/);
-  const pathSegments = filepath.toLowerCase().split("/");
-  let boostFactor = 1;
-  for (const token of queryTokens) {
-    if (token.length <= 2) continue;
-    if (pathSegments.some((seg) => seg.includes(token))) {
-      boostFactor *= 0.9;
-    }
-  }
-  return baseScore * boostFactor;
-}
-function boostFilenameRelevance(query, filepath, baseScore) {
-  const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
-  const queryTokens = query.toLowerCase().split(/\s+/);
-  let boostFactor = 1;
-  for (const token of queryTokens) {
-    if (token.length <= 2) continue;
-    if (filename === token) {
-      boostFactor *= 0.7;
-    } else if (filename.includes(token)) {
-      boostFactor *= 0.8;
-    }
-  }
-  return baseScore * boostFactor;
-}
-function boostForLocationIntent(query, filepath, baseScore) {
-  let score = baseScore;
-  const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
-  const queryTokens = query.toLowerCase().split(/\s+/);
-  for (const token of queryTokens) {
-    if (token.length <= 2) continue;
-    if (filename === token) {
-      score *= 0.6;
-    } else if (filename.includes(token)) {
-      score *= 0.7;
-    }
-  }
-  score = boostPathRelevance(query, filepath, score);
-  if (isTestFile(filepath)) {
-    score *= 1.1;
-  }
-  return score;
-}
-function boostForConceptualIntent(query, filepath, baseScore) {
-  let score = baseScore;
-  if (isDocumentationFile(filepath)) {
-    score *= 0.65;
-    const lower = filepath.toLowerCase();
-    if (lower.includes("architecture") || lower.includes("workflow") || lower.includes("flow")) {
-      score *= 0.9;
-    }
-  }
-  if (isUtilityFile(filepath)) {
-    score *= 1.05;
-  }
-  const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
-  const queryTokens = query.toLowerCase().split(/\s+/);
-  for (const token of queryTokens) {
-    if (token.length <= 2) continue;
-    if (filename.includes(token)) {
-      score *= 0.9;
-    }
+var PathBoostingStrategy, FilenameBoostingStrategy, FileTypeBoostingStrategy;
+var init_strategies = __esm({
+  "src/vectordb/boosting/strategies.ts"() {
+    "use strict";
+    init_intent_classifier();
+    PathBoostingStrategy = class {
+      name = "path-matching";
+      apply(query, filepath, baseScore) {
+        const queryTokens = query.toLowerCase().split(/\s+/);
+        const pathSegments = filepath.toLowerCase().split("/");
+        let boostFactor = 1;
+        for (const token of queryTokens) {
+          if (token.length <= 2) continue;
+          if (pathSegments.some((seg) => seg.includes(token))) {
+            boostFactor *= 0.9;
+          }
+        }
+        return baseScore * boostFactor;
+      }
+    };
+    FilenameBoostingStrategy = class {
+      name = "filename-matching";
+      apply(query, filepath, baseScore) {
+        const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
+        const queryTokens = query.toLowerCase().split(/\s+/);
+        let boostFactor = 1;
+        for (const token of queryTokens) {
+          if (token.length <= 2) continue;
+          if (filename === token) {
+            boostFactor *= 0.7;
+          } else if (filename.includes(token)) {
+            boostFactor *= 0.8;
+          }
+        }
+        return baseScore * boostFactor;
+      }
+    };
+    FileTypeBoostingStrategy = class {
+      constructor(intent) {
+        this.intent = intent;
+      }
+      name = "file-type";
+      apply(query, filepath, baseScore) {
+        switch (this.intent) {
+          case "location" /* LOCATION */:
+            return this.applyLocationBoosting(query, filepath, baseScore);
+          case "conceptual" /* CONCEPTUAL */:
+            return this.applyConceptualBoosting(query, filepath, baseScore);
+          case "implementation" /* IMPLEMENTATION */:
+            return this.applyImplementationBoosting(query, filepath, baseScore);
+          default:
+            return baseScore;
+        }
+      }
+      applyLocationBoosting(_query, filepath, score) {
+        if (isTestFile(filepath)) {
+          score *= 1.1;
+        }
+        return score;
+      }
+      applyConceptualBoosting(_query, filepath, score) {
+        if (isDocumentationFile(filepath)) {
+          score *= 0.65;
+          const lower = filepath.toLowerCase();
+          if (lower.includes("architecture") || lower.includes("workflow") || lower.includes("flow")) {
+            score *= 0.9;
+          }
+        }
+        if (isUtilityFile(filepath)) {
+          score *= 0.95;
+        }
+        return score;
+      }
+      applyImplementationBoosting(_query, filepath, score) {
+        if (isTestFile(filepath)) {
+          score *= 1.1;
+        }
+        return score;
+      }
+    };
   }
-  const pathSegments = filepath.toLowerCase().split(path13.sep);
-  for (const token of queryTokens) {
-    if (token.length <= 2) continue;
-    for (const segment of pathSegments) {
-      if (segment.includes(token)) {
-        score *= 0.95;
-        break;
+});
+
+// src/vectordb/boosting/composer.ts
+var BoostingComposer;
+var init_composer = __esm({
+  "src/vectordb/boosting/composer.ts"() {
+    "use strict";
+    BoostingComposer = class {
+      strategies = [];
+      /**
+       * Add a boosting strategy to the pipeline.
+       * Strategies are applied in the order they are added.
+       * 
+       * @param strategy - The strategy to add
+       * @returns This composer for chaining
+       */
+      addStrategy(strategy) {
+        this.strategies.push(strategy);
+        return this;
       }
-    }
+      /**
+       * Apply all strategies to a base score.
+       * 
+       * @param query - The search query
+       * @param filepath - The file path being scored
+       * @param baseScore - The initial score from vector similarity
+       * @returns The final boosted score after all strategies
+       */
+      apply(query, filepath, baseScore) {
+        let score = baseScore;
+        for (const strategy of this.strategies) {
+          score = strategy.apply(query, filepath, score);
+        }
+        return score;
+      }
+      /**
+       * Get the names of all strategies in this composer.
+       * Useful for debugging and logging.
+       */
+      getStrategyNames() {
+        return this.strategies.map((s) => s.name);
+      }
+      /**
+       * Get the number of strategies in this composer.
+       */
+      getStrategyCount() {
+        return this.strategies.length;
+      }
+      /**
+       * Clear all strategies from this composer.
+       */
+      clear() {
+        this.strategies = [];
+      }
+    };
   }
-  return score;
-}
-function boostForImplementationIntent(query, filepath, baseScore) {
-  let score = baseScore;
-  score = boostFilenameRelevance(query, filepath, score);
-  score = boostPathRelevance(query, filepath, score);
-  if (isTestFile(filepath)) {
-    score *= 0.9;
+});
+
+// src/vectordb/boosting/index.ts
+var init_boosting = __esm({
+  "src/vectordb/boosting/index.ts"() {
+    "use strict";
+    init_types2();
+    init_strategies();
+    init_composer();
   }
-  return score;
-}
+});
+
+// src/vectordb/query.ts
 function applyRelevanceBoosting(query, filepath, baseScore) {
   if (!query) {
     return baseScore;
   }
   const intent = classifyQueryIntent(query);
-  switch (intent) {
-    case "location" /* LOCATION */:
-      return boostForLocationIntent(query, filepath, baseScore);
-    case "conceptual" /* CONCEPTUAL */:
-      return boostForConceptualIntent(query, filepath, baseScore);
-    case "implementation" /* IMPLEMENTATION */:
-      return boostForImplementationIntent(query, filepath, baseScore);
-    default:
-      return boostForImplementationIntent(query, filepath, baseScore);
-  }
+  return BOOSTING_COMPOSERS[intent].apply(query, filepath, baseScore);
 }
 function dbRecordToSearchResult(r, query) {
   const baseScore = r._distance ?? 0;
@@ -2862,6 +2965,7 @@ async function querySymbols(table, options) {
     throw wrapError(error, "Failed to query symbols");
   }
 }
+var PATH_STRATEGY, FILENAME_STRATEGY, FILE_TYPE_STRATEGIES, BOOSTING_COMPOSERS;
 var init_query = __esm({
   "src/vectordb/query.ts"() {
     "use strict";
@@ -2869,6 +2973,19 @@ var init_query = __esm({
     init_errors();
     init_relevance();
     init_intent_classifier();
+    init_boosting();
+    PATH_STRATEGY = new PathBoostingStrategy();
+    FILENAME_STRATEGY = new FilenameBoostingStrategy();
+    FILE_TYPE_STRATEGIES = {
+      ["location" /* LOCATION */]: new FileTypeBoostingStrategy("location" /* LOCATION */),
+      ["conceptual" /* CONCEPTUAL */]: new FileTypeBoostingStrategy("conceptual" /* CONCEPTUAL */),
+      ["implementation" /* IMPLEMENTATION */]: new FileTypeBoostingStrategy("implementation" /* IMPLEMENTATION */)
+    };
+    BOOSTING_COMPOSERS = {
+      ["location" /* LOCATION */]: new BoostingComposer().addStrategy(PATH_STRATEGY).addStrategy(FILENAME_STRATEGY).addStrategy(FILE_TYPE_STRATEGIES["location" /* LOCATION */]),
+      ["conceptual" /* CONCEPTUAL */]: new BoostingComposer().addStrategy(PATH_STRATEGY).addStrategy(FILENAME_STRATEGY).addStrategy(FILE_TYPE_STRATEGIES["conceptual" /* CONCEPTUAL */]),
+      ["implementation" /* IMPLEMENTATION */]: new BoostingComposer().addStrategy(PATH_STRATEGY).addStrategy(FILENAME_STRATEGY).addStrategy(FILE_TYPE_STRATEGIES["implementation" /* IMPLEMENTATION */])
+    };
   }
 });
 
@@ -3793,6 +3910,22 @@ var init_change_detector = __esm({
   }
 });
 
+// src/utils/result.ts
+function Ok(value) {
+  return { ok: true, value };
+}
+function Err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok;
+}
+var init_result = __esm({
+  "src/utils/result.ts"() {
+    "use strict";
+  }
+});
+
 // src/indexer/incremental.ts
 import fs16 from "fs/promises";
 async function processFileContent(filepath, content, embeddings, config, verbose) {
@@ -3874,36 +4007,29 @@ async function indexSingleFile(filepath, vectorDB, embeddings, config, options =
     console.error(`[Lien] \u26A0\uFE0F  Failed to index ${filepath}: ${error}`);
   }
 }
+async function processSingleFileForIndexing(filepath, embeddings, config, verbose) {
+  try {
+    const stats = await fs16.stat(filepath);
+    const content = await fs16.readFile(filepath, "utf-8");
+    const result = await processFileContent(filepath, content, embeddings, config, verbose);
+    return Ok({
+      filepath,
+      result,
+      mtime: stats.mtimeMs
+    });
+  } catch (error) {
+    return Err(`Failed to process ${filepath}: ${error}`);
+  }
+}
 async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, options = {}) {
   const { verbose } = options;
   let processedCount = 0;
   const manifestEntries = [];
   for (const filepath of filepaths) {
-    let content;
-    let fileMtime;
-    try {
-      const stats = await fs16.stat(filepath);
-      fileMtime = stats.mtimeMs;
-      content = await fs16.readFile(filepath, "utf-8");
-    } catch (error) {
-      if (verbose) {
-        console.error(`[Lien] File not readable: ${filepath}`);
-      }
-      try {
-        await vectorDB.deleteByFile(filepath);
-        const manifest = new ManifestManager(vectorDB.dbPath);
-        await manifest.removeFile(filepath);
-      } catch (error2) {
-        if (verbose) {
-          console.error(`[Lien] Note: ${filepath} not in index`);
-        }
-      }
-      processedCount++;
-      continue;
-    }
-    try {
-      const result = await processFileContent(filepath, content, embeddings, config, verbose || false);
-      if (result === null) {
+    const result = await processSingleFileForIndexing(filepath, embeddings, config, verbose || false);
+    if (isOk(result)) {
+      const { result: processResult, mtime } = result.value;
+      if (processResult === null) {
         try {
           await vectorDB.deleteByFile(filepath);
         } catch (error) {
@@ -3911,7 +4037,7 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
         const manifest = new ManifestManager(vectorDB.dbPath);
         await manifest.updateFile(filepath, {
           filepath,
-          lastModified: fileMtime,
+          lastModified: mtime,
           chunkCount: 0
         });
         processedCount++;
@@ -3922,21 +4048,33 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
       } catch (error) {
       }
       await vectorDB.insertBatch(
-        result.vectors,
-        result.chunks.map((c) => c.metadata),
-        result.texts
+        processResult.vectors,
+        processResult.chunks.map((c) => c.metadata),
+        processResult.texts
       );
       manifestEntries.push({
         filepath,
-        chunkCount: result.chunkCount,
-        mtime: fileMtime
+        chunkCount: processResult.chunkCount,
+        mtime
       });
       if (verbose) {
-        console.error(`[Lien] \u2713 Updated ${filepath} (${result.chunkCount} chunks)`);
+        console.error(`[Lien] \u2713 Updated ${filepath} (${processResult.chunkCount} chunks)`);
+      }
+      processedCount++;
+    } else {
+      if (verbose) {
+        console.error(`[Lien] ${result.error}`);
+      }
+      try {
+        await vectorDB.deleteByFile(filepath);
+        const manifest = new ManifestManager(vectorDB.dbPath);
+        await manifest.removeFile(filepath);
+      } catch (error) {
+        if (verbose) {
+          console.error(`[Lien] Note: ${filepath} not in index`);
+        }
       }
       processedCount++;
-    } catch (error) {
-      console.error(`[Lien] \u26A0\uFE0F  Failed to index ${filepath}: ${error}`);
     }
   }
   if (manifestEntries.length > 0) {
@@ -3959,6 +4097,7 @@ var init_incremental = __esm({
     init_schema();
     init_manifest();
     init_constants();
+    init_result();
   }
 });
 
@@ -4044,6 +4183,99 @@ var init_loading_messages = __esm({
   }
 });
 
+// src/indexer/progress-tracker.ts
+var IndexingProgressTracker;
+var init_progress_tracker = __esm({
+  "src/indexer/progress-tracker.ts"() {
+    "use strict";
+    init_loading_messages();
+    IndexingProgressTracker = class _IndexingProgressTracker {
+      processedFiles = 0;
+      totalFiles;
+      wittyMessage;
+      spinner;
+      updateInterval;
+      // Configuration constants
+      static SPINNER_UPDATE_INTERVAL_MS = 200;
+      // How often to update spinner
+      static MESSAGE_ROTATION_INTERVAL_MS = 8e3;
+      // How often to rotate message
+      constructor(totalFiles, spinner) {
+        this.totalFiles = totalFiles;
+        this.spinner = spinner;
+        this.wittyMessage = getIndexingMessage();
+      }
+      /**
+       * Start the progress tracker.
+       * Sets up periodic updates for spinner and message rotation.
+       * 
+       * Safe to call multiple times - will not create duplicate intervals.
+       */
+      start() {
+        if (this.updateInterval) {
+          return;
+        }
+        const MESSAGE_ROTATION_TICKS = Math.floor(
+          _IndexingProgressTracker.MESSAGE_ROTATION_INTERVAL_MS / _IndexingProgressTracker.SPINNER_UPDATE_INTERVAL_MS
+        );
+        let spinnerTick = 0;
+        this.updateInterval = setInterval(() => {
+          spinnerTick++;
+          if (spinnerTick >= MESSAGE_ROTATION_TICKS) {
+            this.wittyMessage = getIndexingMessage();
+            spinnerTick = 0;
+          }
+          this.spinner.text = `${this.processedFiles}/${this.totalFiles} files | ${this.wittyMessage}`;
+        }, _IndexingProgressTracker.SPINNER_UPDATE_INTERVAL_MS);
+      }
+      /**
+       * Increment the count of processed files.
+       * 
+       * Safe for async operations in Node.js's single-threaded event loop.
+       * Note: Not thread-safe for true concurrent operations (e.g., worker threads).
+       */
+      incrementFiles() {
+        this.processedFiles++;
+      }
+      /**
+       * Set a custom message (e.g., for special operations like embedding generation).
+       * The message will be displayed until the next automatic rotation.
+       */
+      setMessage(message) {
+        this.wittyMessage = message;
+      }
+      /**
+       * Stop the progress tracker and clean up intervals.
+       * Must be called when indexing completes or fails.
+       */
+      stop() {
+        if (this.updateInterval) {
+          clearInterval(this.updateInterval);
+          this.updateInterval = void 0;
+        }
+      }
+      /**
+       * Get the current count of processed files.
+       */
+      getProcessedCount() {
+        return this.processedFiles;
+      }
+      /**
+       * Get the total number of files to process.
+       */
+      getTotalFiles() {
+        return this.totalFiles;
+      }
+      /**
+       * Get the current message being displayed.
+       */
+      getCurrentMessage() {
+        return this.wittyMessage;
+      }
+    };
+  }
+});
+
 // src/indexer/index.ts
 var indexer_exports = {};
 __export(indexer_exports, {
@@ -4053,162 +4285,171 @@ import fs17 from "fs/promises";
 import ora from "ora";
 import chalk5 from "chalk";
 import pLimit from "p-limit";
-async function indexCodebase(options = {}) {
-  const rootDir = options.rootDir ?? process.cwd();
-  const spinner = ora("Starting indexing process...").start();
-  let updateInterval;
+async function updateGitState(rootDir, vectorDB, manifest) {
+  const { isGitAvailable: isGitAvailable2, isGitRepo: isGitRepo2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+  const { GitStateTracker: GitStateTracker2 } = await Promise.resolve().then(() => (init_tracker(), tracker_exports));
+  const gitAvailable = await isGitAvailable2();
+  const isRepo = await isGitRepo2(rootDir);
+  if (!gitAvailable || !isRepo) {
+    return;
+  }
+  const gitTracker = new GitStateTracker2(rootDir, vectorDB.dbPath);
+  await gitTracker.initialize();
+  const gitState = gitTracker.getState();
+  if (gitState) {
+    await manifest.updateGitState(gitState);
+  }
+}
+async function handleDeletions(deletedFiles, vectorDB, manifest, spinner) {
+  if (deletedFiles.length === 0) {
+    return;
+  }
+  spinner.start(`Removing ${deletedFiles.length} deleted files...`);
+  let removedCount = 0;
+  for (const filepath of deletedFiles) {
+    try {
+      await vectorDB.deleteByFile(filepath);
+      await manifest.removeFile(filepath);
+      removedCount++;
+    } catch (err) {
+      spinner.warn(
+        `Failed to remove file "${filepath}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  spinner.succeed(`Removed ${removedCount}/${deletedFiles.length} deleted files`);
+}
+async function handleUpdates(addedFiles, modifiedFiles, vectorDB, embeddings, config, options, spinner) {
+  const filesToIndex = [...addedFiles, ...modifiedFiles];
+  if (filesToIndex.length === 0) {
+    return;
+  }
+  spinner.start(`Reindexing ${filesToIndex.length} changed files...`);
+  const count = await indexMultipleFiles(
+    filesToIndex,
+    vectorDB,
+    embeddings,
+    config,
+    { verbose: options.verbose }
+  );
+  await writeVersionFile(vectorDB.dbPath);
+  spinner.succeed(
+    `Incremental reindex complete: ${count}/${filesToIndex.length} files indexed successfully`
+  );
+}
+async function tryIncrementalIndex(rootDir, vectorDB, config, options, spinner) {
+  spinner.text = "Checking for changes...";
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  const savedManifest = await manifest.load();
+  if (!savedManifest) {
+    return false;
+  }
+  const changes = await detectChanges(rootDir, vectorDB, config);
+  if (changes.reason === "full") {
+    spinner.text = "Full reindex required...";
+    return false;
+  }
+  const totalChanges = changes.added.length + changes.modified.length;
+  const totalDeleted = changes.deleted.length;
+  if (totalChanges === 0 && totalDeleted === 0) {
+    spinner.succeed("No changes detected - index is up to date!");
+    return true;
+  }
+  spinner.succeed(
+    `Detected changes: ${totalChanges} files to index, ${totalDeleted} to remove (${changes.reason} detection)`
+  );
+  spinner.start(getModelLoadingMessage());
+  const embeddings = new LocalEmbeddings();
+  await embeddings.initialize();
+  spinner.succeed("Embedding model loaded");
+  await handleDeletions(changes.deleted, vectorDB, manifest, spinner);
+  await handleUpdates(changes.added, changes.modified, vectorDB, embeddings, config, options, spinner);
+  await updateGitState(rootDir, vectorDB, manifest);
+  console.log(chalk5.dim("\nNext step: Run"), chalk5.bold("lien serve"), chalk5.dim("to start the MCP server"));
+  return true;
+}
+async function performFullIndex(rootDir, vectorDB, config, options, spinner) {
+  spinner.text = "Scanning codebase...";
+  let files;
+  if (isModernConfig(config) && config.frameworks.length > 0) {
+    files = await scanCodebaseWithFrameworks(rootDir, config);
+  } else if (isLegacyConfig(config)) {
+    files = await scanCodebase({
+      rootDir,
+      includePatterns: config.indexing.include,
+      excludePatterns: config.indexing.exclude
+    });
+  } else {
+    files = await scanCodebase({
+      rootDir,
+      includePatterns: [],
+      excludePatterns: []
+    });
+  }
+  if (files.length === 0) {
+    spinner.fail("No files found to index");
+    return;
+  }
+  spinner.text = `Found ${files.length} files`;
+  spinner.text = getModelLoadingMessage();
+  const embeddings = new LocalEmbeddings();
+  await embeddings.initialize();
+  spinner.succeed("Embedding model loaded");
+  const concurrency = isModernConfig(config) ? config.core.concurrency : 4;
+  const embeddingBatchSize = isModernConfig(config) ? config.core.embeddingBatchSize : 50;
+  const vectorDBBatchSize = 100;
+  spinner.start(`Processing files with ${concurrency}x concurrency...`);
+  const startTime = Date.now();
+  let processedChunks = 0;
+  const chunkAccumulator = [];
+  const limit = pLimit(concurrency);
+  const indexedFileEntries = [];
+  const progressTracker = new IndexingProgressTracker(files.length, spinner);
+  progressTracker.start();
   try {
-    spinner.text = "Loading configuration...";
-    const config = await configService.load(rootDir);
-    spinner.text = "Initializing vector database...";
-    const vectorDB = new VectorDB(rootDir);
-    await vectorDB.initialize();
-    if (!options.force) {
-      spinner.text = "Checking for changes...";
-      const manifest2 = new ManifestManager(vectorDB.dbPath);
-      const savedManifest = await manifest2.load();
-      if (savedManifest) {
-        const changes = await detectChanges(rootDir, vectorDB, config);
-        if (changes.reason !== "full") {
-          const totalChanges = changes.added.length + changes.modified.length;
-          const totalDeleted = changes.deleted.length;
-          if (totalChanges === 0 && totalDeleted === 0) {
-            spinner.succeed("No changes detected - index is up to date!");
-            return;
-          }
-          spinner.succeed(
-            `Detected changes: ${totalChanges} files to index, ${totalDeleted} to remove (${changes.reason} detection)`
-          );
-          spinner.start(getModelLoadingMessage());
-          const embeddings2 = new LocalEmbeddings();
-          await embeddings2.initialize();
-          spinner.succeed("Embedding model loaded");
-          if (totalDeleted > 0) {
-            spinner.start(`Removing ${totalDeleted} deleted files...`);
-            let removedCount = 0;
-            for (const filepath of changes.deleted) {
-              try {
-                await vectorDB.deleteByFile(filepath);
-                await manifest2.removeFile(filepath);
-                removedCount++;
-              } catch (err) {
-                spinner.warn(`Failed to remove file "${filepath}": ${err instanceof Error ? err.message : String(err)}`);
-              }
-            }
-            spinner.succeed(`Removed ${removedCount}/${totalDeleted} deleted files`);
-          }
-          if (totalChanges > 0) {
-            spinner.start(`Reindexing ${totalChanges} changed files...`);
-            const filesToIndex = [...changes.added, ...changes.modified];
-            const count = await indexMultipleFiles(
-              filesToIndex,
-              vectorDB,
-              embeddings2,
-              config,
-              { verbose: options.verbose }
-            );
-            await writeVersionFile(vectorDB.dbPath);
-            spinner.succeed(
-              `Incremental reindex complete: ${count}/${totalChanges} files indexed successfully`
-            );
-          }
-          const { isGitAvailable: isGitAvailable3, isGitRepo: isGitRepo3 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
-          const { GitStateTracker: GitStateTracker3 } = await Promise.resolve().then(() => (init_tracker(), tracker_exports));
-          const gitAvailable2 = await isGitAvailable3();
-          const isRepo2 = await isGitRepo3(rootDir);
-          if (gitAvailable2 && isRepo2) {
-            const gitTracker = new GitStateTracker3(rootDir, vectorDB.dbPath);
-            await gitTracker.initialize();
-            const gitState = gitTracker.getState();
-            if (gitState) {
-              await manifest2.updateGitState(gitState);
-            }
-          }
-          console.log(chalk5.dim("\nNext step: Run"), chalk5.bold("lien serve"), chalk5.dim("to start the MCP server"));
-          return;
-        }
-        spinner.text = "Full reindex required...";
+    let addChunksLock = null;
+    let processingQueue = null;
+    const processAccumulatedChunks = async () => {
+      if (processingQueue) {
+        processingQueue = processingQueue.then(() => doProcessChunks());
+      } else {
+        processingQueue = doProcessChunks();
       }
-    } else {
-      spinner.text = "Force flag enabled, performing full reindex...";
-    }
-    spinner.text = "Scanning codebase...";
-    let files;
-    if (isModernConfig(config) && config.frameworks.length > 0) {
-      files = await scanCodebaseWithFrameworks(rootDir, config);
-    } else if (isLegacyConfig(config)) {
-      files = await scanCodebase({
-        rootDir,
-        includePatterns: config.indexing.include,
-        excludePatterns: config.indexing.exclude
-      });
-    } else {
-      files = await scanCodebase({
-        rootDir,
-        includePatterns: [],
-        excludePatterns: []
-      });
-    }
-    if (files.length === 0) {
-      spinner.fail("No files found to index");
-      return;
-    }
-    spinner.text = `Found ${files.length} files`;
-    spinner.text = getModelLoadingMessage();
-    const embeddings = new LocalEmbeddings();
-    await embeddings.initialize();
-    spinner.succeed("Embedding model loaded");
-    const concurrency = isModernConfig(config) ? config.core.concurrency : 4;
-    const embeddingBatchSize = isModernConfig(config) ? config.core.embeddingBatchSize : 50;
-    const vectorDBBatchSize = 100;
-    spinner.start(`Processing files with ${concurrency}x concurrency...`);
-    const startTime = Date.now();
-    let processedFiles = 0;
-    let processedChunks = 0;
-    const chunkAccumulator = [];
-    const limit = pLimit(concurrency);
-    const indexedFileEntries = [];
-    const progressState = {
-      processedFiles: 0,
-      totalFiles: files.length,
-      wittyMessage: getIndexingMessage()
+      return processingQueue;
     };
-    const SPINNER_UPDATE_INTERVAL_MS = 200;
-    const MESSAGE_ROTATION_INTERVAL_MS = 8e3;
-    const MESSAGE_ROTATION_TICKS = Math.floor(MESSAGE_ROTATION_INTERVAL_MS / SPINNER_UPDATE_INTERVAL_MS);
-    let spinnerTick = 0;
-    updateInterval = setInterval(() => {
-      spinnerTick++;
-      if (spinnerTick >= MESSAGE_ROTATION_TICKS) {
-        progressState.wittyMessage = getIndexingMessage();
-        spinnerTick = 0;
-      }
-      spinner.text = `${progressState.processedFiles}/${progressState.totalFiles} files | ${progressState.wittyMessage}`;
-    }, SPINNER_UPDATE_INTERVAL_MS);
-    const processAccumulatedChunks = async () => {
-      if (chunkAccumulator.length === 0) return;
-      const toProcess = chunkAccumulator.splice(0, chunkAccumulator.length);
-      for (let i = 0; i < toProcess.length; i += embeddingBatchSize) {
-        const batch = toProcess.slice(i, Math.min(i + embeddingBatchSize, toProcess.length));
-        progressState.wittyMessage = getEmbeddingMessage();
-        const texts = batch.map((item) => item.content);
-        const embeddingVectors = [];
-        for (let j = 0; j < texts.length; j += EMBEDDING_MICRO_BATCH_SIZE) {
-          const microBatch = texts.slice(j, Math.min(j + EMBEDDING_MICRO_BATCH_SIZE, texts.length));
-          const microResults = await embeddings.embedBatch(microBatch);
-          embeddingVectors.push(...microResults);
+    const doProcessChunks = async () => {
+      if (chunkAccumulator.length === 0) {
+        return;
+      }
+      const currentPromise = processingQueue;
+      try {
+        const toProcess = chunkAccumulator.splice(0, chunkAccumulator.length);
+        for (let i = 0; i < toProcess.length; i += embeddingBatchSize) {
+          const batch = toProcess.slice(i, Math.min(i + embeddingBatchSize, toProcess.length));
+          progressTracker.setMessage(getEmbeddingMessage());
+          const texts = batch.map((item) => item.content);
+          const embeddingVectors = [];
+          for (let j = 0; j < texts.length; j += EMBEDDING_MICRO_BATCH_SIZE) {
+            const microBatch = texts.slice(j, Math.min(j + EMBEDDING_MICRO_BATCH_SIZE, texts.length));
+            const microResults = await embeddings.embedBatch(microBatch);
+            embeddingVectors.push(...microResults);
+            await new Promise((resolve) => setImmediate(resolve));
+          }
+          processedChunks += batch.length;
+          progressTracker.setMessage(`Inserting ${batch.length} chunks into vector space...`);
+          await vectorDB.insertBatch(
+            embeddingVectors,
+            batch.map((item) => item.chunk.metadata),
+            texts
+          );
           await new Promise((resolve) => setImmediate(resolve));
         }
-        processedChunks += batch.length;
-        progressState.wittyMessage = `Inserting ${batch.length} chunks into vector space...`;
-        await vectorDB.insertBatch(
-          embeddingVectors,
-          batch.map((item) => item.chunk.metadata),
-          texts
-        );
-        await new Promise((resolve) => setImmediate(resolve));
+        progressTracker.setMessage(getIndexingMessage());
+      } finally {
+        if (processingQueue === currentPromise) {
+          processingQueue = null;
+        }
       }
-      progressState.wittyMessage = getIndexingMessage();
     };
     const filePromises = files.map(
       (file) => limit(async () => {
@@ -4226,73 +4467,91 @@ async function indexCodebase(options = {}) {
             astFallback
           });
           if (chunks.length === 0) {
-            processedFiles++;
-            progressState.processedFiles = processedFiles;
+            progressTracker.incrementFiles();
             return;
           }
-          for (const chunk of chunks) {
-            chunkAccumulator.push({
-              chunk,
-              content: chunk.content
+          {
+            if (addChunksLock) {
+              await addChunksLock;
+            }
+            let releaseAddLock;
+            addChunksLock = new Promise((resolve) => {
+              releaseAddLock = resolve;
             });
-          }
-          indexedFileEntries.push({
-            filepath: file,
-            chunkCount: chunks.length,
-            mtime: stats.mtimeMs
-          });
-          processedFiles++;
-          progressState.processedFiles = processedFiles;
-          if (chunkAccumulator.length >= vectorDBBatchSize) {
-            await processAccumulatedChunks();
+            try {
+              for (const chunk of chunks) {
+                chunkAccumulator.push({
+                  chunk,
+                  content: chunk.content
+                });
+              }
+              indexedFileEntries.push({
+                filepath: file,
+                chunkCount: chunks.length,
+                mtime: stats.mtimeMs
+              });
+              progressTracker.incrementFiles();
+              if (chunkAccumulator.length >= vectorDBBatchSize) {
+                await processAccumulatedChunks();
+              }
+            } finally {
+              releaseAddLock();
+              addChunksLock = null;
+            }
           }
         } catch (error) {
           if (options.verbose) {
             console.error(chalk5.yellow(`
 \u26A0\uFE0F  Skipping ${file}: ${error}`));
           }
-          processedFiles++;
-          progressState.processedFiles = processedFiles;
+          progressTracker.incrementFiles();
         }
       })
     );
     await Promise.all(filePromises);
-    progressState.wittyMessage = "Processing final chunks...";
+    progressTracker.setMessage("Processing final chunks...");
     await processAccumulatedChunks();
-    clearInterval(updateInterval);
-    spinner.start("Saving index manifest...");
-    const manifest = new ManifestManager(vectorDB.dbPath);
-    await manifest.updateFiles(
-      indexedFileEntries.map((entry) => ({
-        filepath: entry.filepath,
-        lastModified: entry.mtime,
-        // Use actual file mtime for accurate change detection
-        chunkCount: entry.chunkCount
-      }))
-    );
-    const { isGitAvailable: isGitAvailable2, isGitRepo: isGitRepo2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
-    const { GitStateTracker: GitStateTracker2 } = await Promise.resolve().then(() => (init_tracker(), tracker_exports));
-    const gitAvailable = await isGitAvailable2();
-    const isRepo = await isGitRepo2(rootDir);
-    if (gitAvailable && isRepo) {
-      const gitTracker = new GitStateTracker2(rootDir, vectorDB.dbPath);
-      await gitTracker.initialize();
-      const gitState = gitTracker.getState();
-      if (gitState) {
-        await manifest.updateGitState(gitState);
+  } finally {
+    progressTracker.stop();
+  }
+  spinner.start("Saving index manifest...");
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  await manifest.updateFiles(
+    indexedFileEntries.map((entry) => ({
+      filepath: entry.filepath,
+      // Use actual file mtime for accurate change detection
+      lastModified: entry.mtime,
+      chunkCount: entry.chunkCount
+    }))
+  );
+  await updateGitState(rootDir, vectorDB, manifest);
+  spinner.succeed("Manifest saved");
+  await writeVersionFile(vectorDB.dbPath);
+  const totalTime = ((Date.now() - startTime) / 1e3).toFixed(1);
+  spinner.succeed(
+    `Indexed ${progressTracker.getProcessedCount()} files (${processedChunks} chunks) in ${totalTime}s using ${concurrency}x concurrency`
+  );
+  console.log(chalk5.dim("\nNext step: Run"), chalk5.bold("lien serve"), chalk5.dim("to start the MCP server"));
+}
+async function indexCodebase(options = {}) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const spinner = ora("Starting indexing process...").start();
+  try {
+    spinner.text = "Loading configuration...";
+    const config = await configService.load(rootDir);
+    spinner.text = "Initializing vector database...";
+    const vectorDB = new VectorDB(rootDir);
+    await vectorDB.initialize();
+    if (!options.force) {
+      const completed = await tryIncrementalIndex(rootDir, vectorDB, config, options, spinner);
+      if (completed) {
+        return;
       }
+    } else {
+      spinner.text = "Force flag enabled, performing full reindex...";
     }
-    spinner.succeed("Manifest saved");
-    await writeVersionFile(vectorDB.dbPath);
-    const totalTime = ((Date.now() - startTime) / 1e3).toFixed(1);
-    spinner.succeed(
-      `Indexed ${processedFiles} files (${processedChunks} chunks) in ${totalTime}s using ${concurrency}x concurrency`
-    );
-    console.log(chalk5.dim("\nNext step: Run"), chalk5.bold("lien serve"), chalk5.dim("to start the MCP server"));
+    await performFullIndex(rootDir, vectorDB, config, options, spinner);
   } catch (error) {
-    if (updateInterval) {
-      clearInterval(updateInterval);
-    }
     spinner.fail(`Indexing failed: ${error}`);
     throw error;
   }
@@ -4312,6 +4571,7 @@ var init_indexer = __esm({
     init_incremental();
     init_loading_messages();
     init_constants();
+    init_progress_tracker();
   }
 });
 
@@ -5405,9 +5665,12 @@ var FindSimilarSchema = z2.object({
 
 // src/mcp/schemas/file.schema.ts
 import { z as z3 } from "zod";
-var GetFileContextSchema = z3.object({
-  filepath: z3.string().min(1, "Filepath cannot be empty").describe(
-    "Relative path to file from workspace root.\n\nExample: 'src/components/Button.tsx'"
+var GetFilesContextSchema = z3.object({
+  filepaths: z3.union([
+    z3.string().min(1, "Filepath cannot be empty"),
+    z3.array(z3.string().min(1, "Filepath cannot be empty")).min(1, "Array must contain at least one filepath").max(50, "Maximum 50 files per request")
+  ]).describe(
+    "Single filepath or array of filepaths (relative to workspace root).\n\nSingle file: 'src/components/Button.tsx'\nMultiple files: ['src/auth.ts', 'src/user.ts']\n\nMaximum 50 files per request for batch operations."
   ),
   includeRelated: z3.boolean().default(true).describe(
     "Include semantically related chunks from nearby code.\n\nDefault: true\n\nWhen enabled, also returns related code from other files that are semantically similar to the target file's contents."
@@ -5425,6 +5688,17 @@ var ListFunctionsSchema = z4.object({
   )
 });
 
+// src/mcp/schemas/dependents.schema.ts
+import { z as z5 } from "zod";
+var GetDependentsSchema = z5.object({
+  filepath: z5.string().min(1, "Filepath cannot be empty").describe(
+    "Path to file to find dependents for (relative to workspace root).\n\nExample: 'src/utils/validate.ts'\n\nReturns all files that import or depend on this file.\n\nNote: Scans up to 10,000 code chunks. For very large codebases,\nresults may be incomplete (a warning will be included if truncated)."
+  ),
+  depth: z5.number().int().min(1).max(1).default(1).describe(
+    "Depth of transitive dependencies. Only depth=1 (direct dependents) is currently supported.\n\n1 = Direct dependents only"
+  )
+});
+
 // src/mcp/tools.ts
 var tools = [
   toMCPToolSchema(
@@ -5451,16 +5725,48 @@ Results include a relevance category (highly_relevant, relevant, loosely_related
 Provide at least 10 characters of code to match against. Results include a relevance category for each match.`
   ),
   toMCPToolSchema(
-    GetFileContextSchema,
-    "get_file_context",
-    `Get full context for a file including related code and dependencies.
+    GetFilesContextSchema,
+    "get_files_context",
+    `Get context for one or more files including dependencies and test coverage.
+
+MANDATORY: Call this BEFORE editing any file. Accepts single path or array of paths.
+
+Single file:
+  get_files_context({ filepaths: "src/auth.ts" })
+  
+  Returns:
+  {
+    file: "src/auth.ts",
+    chunks: [...],
+    testAssociations: ["src/__tests__/auth.test.ts"]
+  }
+
+Multiple files (batch):
+  get_files_context({ filepaths: ["src/auth.ts", "src/user.ts"] })
+  
+  Returns:
+  {
+    files: {
+      "src/auth.ts": {
+        chunks: [...],
+        testAssociations: ["src/__tests__/auth.test.ts"]
+      },
+      "src/user.ts": {
+        chunks: [...],
+        testAssociations: ["src/__tests__/user.test.ts"]
+      }
+    }
+  }
 
-IMPORTANT: Call this BEFORE editing any file to understand:
-- What the file does
-- What depends on it
-- Related test files (via testAssociations)
+Returns for each file:
+- All chunks and related code
+- testAssociations: Array of test files that import this file (reverse dependency lookup)
+- Relevance scoring
 
-Results include a relevance category for each related chunk. Typical flow: semantic_search \u2192 find file \u2192 get_file_context \u2192 make changes.`
+ALWAYS check testAssociations before modifying source code.
+After changes, remind the user to run the associated tests.
+
+Batch calls are more efficient than multiple single-file calls.`
   ),
   toMCPToolSchema(
     ListFunctionsSchema,
@@ -5472,6 +5778,20 @@ Examples:
 - "Find service classes" \u2192 list_functions({ pattern: ".*Service$" })
 
 10x faster than semantic_search for structural/architectural queries. Use semantic_search instead when searching by what code DOES.`
+  ),
+  toMCPToolSchema(
+    GetDependentsSchema,
+    "get_dependents",
+    `Find all code that depends on a file (reverse dependency lookup). Use for impact analysis:
+- "What breaks if I change this?"
+- "Is this safe to delete?"
+- "What imports this module?"
+
+Returns:
+- List of files that import the target
+- Risk level (low/medium/high/critical) based on dependent count and complexity
+
+Example: get_dependents({ filepath: "src/utils/validate.ts" })`
   )
 ];
 
@@ -5671,6 +5991,50 @@ function wrapToolHandler(schema, handler) {
   };
 }
 
+// src/mcp/utils/path-matching.ts
+function normalizePath(path18, workspaceRoot) {
+  let normalized = path18.replace(/['"]/g, "").trim().replace(/\\/g, "/");
+  normalized = normalized.replace(/\.(ts|tsx|js|jsx)$/, "");
+  if (normalized.startsWith(workspaceRoot + "/")) {
+    normalized = normalized.substring(workspaceRoot.length + 1);
+  }
+  return normalized;
+}
+function matchesAtBoundary(str, pattern) {
+  const index = str.indexOf(pattern);
+  if (index === -1) return false;
+  const charBefore = index > 0 ? str[index - 1] : "/";
+  if (charBefore !== "/" && index !== 0) return false;
+  const endIndex = index + pattern.length;
+  if (endIndex === str.length) return true;
+  const charAfter = str[endIndex];
+  return charAfter === "/";
+}
+function matchesFile(normalizedImport, normalizedTarget) {
+  if (normalizedImport === normalizedTarget) return true;
+  if (matchesAtBoundary(normalizedImport, normalizedTarget)) {
+    return true;
+  }
+  if (matchesAtBoundary(normalizedTarget, normalizedImport)) {
+    return true;
+  }
+  const cleanedImport = normalizedImport.replace(/^(\.\.?\/)+/, "");
+  if (matchesAtBoundary(cleanedImport, normalizedTarget) || matchesAtBoundary(normalizedTarget, cleanedImport)) {
+    return true;
+  }
+  return false;
+}
+function getCanonicalPath(filepath, workspaceRoot) {
+  let canonical = filepath.replace(/\\/g, "/");
+  if (canonical.startsWith(workspaceRoot + "/")) {
+    canonical = canonical.substring(workspaceRoot.length + 1);
+  }
+  return canonical;
+}
+function isTestFile2(filepath) {
+  return /\.(test|spec)\.[^/]+$/.test(filepath) || /(^|[/\\])(test|tests|__tests__)[/\\]/.test(filepath);
+}
+
 // src/mcp/server.ts
 init_errors();
 var __filename4 = fileURLToPath4(import.meta.url);
@@ -5682,6 +6046,31 @@ try {
 } catch {
   packageJson3 = require4(join3(__dirname4, "../../package.json"));
 }
+var DEPENDENT_COUNT_THRESHOLDS = {
+  LOW: 5,
+  // Few dependents, safe to change
+  MEDIUM: 15,
+  // Moderate impact, review dependents
+  HIGH: 30
+  // High impact, careful planning needed
+};
+var COMPLEXITY_THRESHOLDS = {
+  HIGH_COMPLEXITY_DEPENDENT: 10,
+  // Individual file is complex
+  CRITICAL_AVG: 15,
+  // Average complexity indicates systemic complexity
+  CRITICAL_MAX: 25,
+  // Peak complexity indicates hotspot
+  HIGH_AVG: 10,
+  // Moderately complex on average
+  HIGH_MAX: 20,
+  // Some complex functions exist
+  MEDIUM_AVG: 6,
+  // Slightly above simple code
+  MEDIUM_MAX: 15
+  // Occasional branching
+};
+var SCAN_LIMIT = 1e4;
 async function startMCPServer(options) {
   const { rootDir, verbose, watch } = options;
   const log = (message) => {
@@ -5770,32 +6159,112 @@ async function startMCPServer(options) {
               };
             }
           )(args);
-        case "get_file_context":
+        case "get_files_context":
           return await wrapToolHandler(
-            GetFileContextSchema,
+            GetFilesContextSchema,
             async (validatedArgs) => {
-              log(`Getting context for: ${validatedArgs.filepath}`);
+              const filepaths = Array.isArray(validatedArgs.filepaths) ? validatedArgs.filepaths : [validatedArgs.filepaths];
+              const isSingleFile = !Array.isArray(validatedArgs.filepaths);
+              log(`Getting context for: ${filepaths.join(", ")}`);
               await checkAndReconnect();
-              const fileEmbedding = await embeddings.embed(validatedArgs.filepath);
-              const allResults = await vectorDB.search(fileEmbedding, 50, validatedArgs.filepath);
-              const fileChunks = allResults.filter(
-                (r) => r.metadata.file.includes(validatedArgs.filepath) || validatedArgs.filepath.includes(r.metadata.file)
+              const workspaceRoot = process.cwd().replace(/\\/g, "/");
+              const fileEmbeddings = await Promise.all(filepaths.map((fp) => embeddings.embed(fp)));
+              const allFileSearches = await Promise.all(
+                fileEmbeddings.map(
+                  (embedding, i) => vectorDB.search(embedding, 50, filepaths[i])
+                )
               );
-              let results = fileChunks;
-              if (validatedArgs.includeRelated && fileChunks.length > 0) {
-                const relatedEmbedding = await embeddings.embed(fileChunks[0].content);
-                const related = await vectorDB.search(relatedEmbedding, 5, fileChunks[0].content);
-                const relatedOtherFiles = related.filter(
-                  (r) => !r.metadata.file.includes(validatedArgs.filepath) && !validatedArgs.filepath.includes(r.metadata.file)
-                );
-                results = [...fileChunks, ...relatedOtherFiles];
+              const fileChunksMap = filepaths.map((filepath, i) => {
+                const allResults = allFileSearches[i];
+                const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
+                return allResults.filter((r) => {
+                  const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
+                  return chunkCanonical === targetCanonical;
+                });
+              });
+              let relatedChunksMap = [];
+              if (validatedArgs.includeRelated) {
+                const filesWithChunks = fileChunksMap.map((chunks, i) => ({ chunks, filepath: filepaths[i], index: i })).filter(({ chunks }) => chunks.length > 0);
+                if (filesWithChunks.length > 0) {
+                  const relatedEmbeddings = await Promise.all(
+                    filesWithChunks.map(({ chunks }) => embeddings.embed(chunks[0].content))
+                  );
+                  const relatedSearches = await Promise.all(
+                    relatedEmbeddings.map(
+                      (embedding, i) => vectorDB.search(embedding, 5, filesWithChunks[i].chunks[0].content)
+                    )
+                  );
+                  relatedChunksMap = Array.from({ length: filepaths.length }, () => []);
+                  filesWithChunks.forEach(({ filepath, index }, i) => {
+                    const related = relatedSearches[i];
+                    const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
+                    relatedChunksMap[index] = related.filter((r) => {
+                      const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
+                      return chunkCanonical !== targetCanonical;
+                    });
+                  });
+                }
               }
-              log(`Found ${results.length} chunks`);
-              return {
-                indexInfo: getIndexMetadata(),
-                file: validatedArgs.filepath,
-                chunks: results
+              const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
+              if (allChunks.length === SCAN_LIMIT) {
+                log(`WARNING: Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`);
+              }
+              const pathCache = /* @__PURE__ */ new Map();
+              const normalizePathCached = (path18) => {
+                if (pathCache.has(path18)) return pathCache.get(path18);
+                const normalized = normalizePath(path18, workspaceRoot);
+                pathCache.set(path18, normalized);
+                return normalized;
               };
+              const testAssociationsMap = filepaths.map((filepath) => {
+                const normalizedTarget = normalizePathCached(filepath);
+                const testFiles = /* @__PURE__ */ new Set();
+                for (const chunk of allChunks) {
+                  const chunkFile2 = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+                  if (!isTestFile2(chunkFile2)) continue;
+                  const imports = chunk.metadata.imports || [];
+                  for (const imp of imports) {
+                    const normalizedImport = normalizePathCached(imp);
+                    if (matchesFile(normalizedImport, normalizedTarget)) {
+                      testFiles.add(chunkFile2);
+                      break;
+                    }
+                  }
+                }
+                return Array.from(testFiles);
+              });
+              const filesData = {};
+              filepaths.forEach((filepath, i) => {
+                const fileChunks = fileChunksMap[i];
+                const relatedChunks = relatedChunksMap[i] || [];
+                const seenChunks = /* @__PURE__ */ new Set();
+                const dedupedChunks = [...fileChunks, ...relatedChunks].filter((chunk) => {
+                  const canonicalFile = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+                  const chunkId = `${canonicalFile}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+                  if (seenChunks.has(chunkId)) return false;
+                  seenChunks.add(chunkId);
+                  return true;
+                });
+                filesData[filepath] = {
+                  chunks: dedupedChunks,
+                  testAssociations: testAssociationsMap[i]
+                };
+              });
+              log(`Found ${Object.values(filesData).reduce((sum, f) => sum + f.chunks.length, 0)} total chunks`);
+              if (isSingleFile) {
+                const filepath = filepaths[0];
+                return {
+                  indexInfo: getIndexMetadata(),
+                  file: filepath,
+                  chunks: filesData[filepath].chunks,
+                  testAssociations: filesData[filepath].testAssociations
+                };
+              } else {
+                return {
+                  indexInfo: getIndexMetadata(),
+                  files: filesData
+                };
+              }
             }
           )(args);
         case "list_functions":
@@ -5839,6 +6308,144 @@ async function startMCPServer(options) {
               };
             }
           )(args);
+        case "get_dependents":
+          return await wrapToolHandler(
+            GetDependentsSchema,
+            async (validatedArgs) => {
+              log(`Finding dependents of: ${validatedArgs.filepath}`);
+              await checkAndReconnect();
+              const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
+              if (allChunks.length === SCAN_LIMIT) {
+                log(`WARNING: Scanned ${SCAN_LIMIT} chunks (limit reached). Results may be incomplete for large codebases.`);
+              }
+              log(`Scanning ${allChunks.length} chunks for imports...`);
+              const workspaceRoot = process.cwd().replace(/\\/g, "/");
+              const pathCache = /* @__PURE__ */ new Map();
+              const normalizePathCached = (path18) => {
+                if (pathCache.has(path18)) return pathCache.get(path18);
+                const normalized = normalizePath(path18, workspaceRoot);
+                pathCache.set(path18, normalized);
+                return normalized;
+              };
+              const importIndex = /* @__PURE__ */ new Map();
+              for (const chunk of allChunks) {
+                const imports = chunk.metadata.imports || [];
+                for (const imp of imports) {
+                  const normalizedImport = normalizePathCached(imp);
+                  if (!importIndex.has(normalizedImport)) {
+                    importIndex.set(normalizedImport, []);
+                  }
+                  importIndex.get(normalizedImport).push(chunk);
+                }
+              }
+              const normalizedTarget = normalizePathCached(validatedArgs.filepath);
+              const dependentChunks = [];
+              const seenChunkIds = /* @__PURE__ */ new Set();
+              if (importIndex.has(normalizedTarget)) {
+                for (const chunk of importIndex.get(normalizedTarget)) {
+                  const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+                  if (!seenChunkIds.has(chunkId)) {
+                    dependentChunks.push(chunk);
+                    seenChunkIds.add(chunkId);
+                  }
+                }
+              }
+              for (const [normalizedImport, chunks] of importIndex.entries()) {
+                if (normalizedImport !== normalizedTarget && matchesFile(normalizedImport, normalizedTarget)) {
+                  for (const chunk of chunks) {
+                    const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+                    if (!seenChunkIds.has(chunkId)) {
+                      dependentChunks.push(chunk);
+                      seenChunkIds.add(chunkId);
+                    }
+                  }
+                }
+              }
+              const chunksByFile = /* @__PURE__ */ new Map();
+              for (const chunk of dependentChunks) {
+                const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+                const existing = chunksByFile.get(canonical) || [];
+                existing.push(chunk);
+                chunksByFile.set(canonical, existing);
+              }
+              const fileComplexities = [];
+              for (const [filepath, chunks] of chunksByFile.entries()) {
+                const complexities = chunks.map((c) => c.metadata.complexity).filter((c) => typeof c === "number" && c > 0);
+                if (complexities.length > 0) {
+                  const sum = complexities.reduce((a, b) => a + b, 0);
+                  const avg = sum / complexities.length;
+                  const max = Math.max(...complexities);
+                  fileComplexities.push({
+                    filepath,
+                    avgComplexity: Math.round(avg * 10) / 10,
+                    // Round to 1 decimal
+                    maxComplexity: max,
+                    complexityScore: sum,
+                    chunksWithComplexity: complexities.length
+                  });
+                }
+              }
+              let complexityMetrics;
+              if (fileComplexities.length > 0) {
+                const allAvgs = fileComplexities.map((f) => f.avgComplexity);
+                const allMaxes = fileComplexities.map((f) => f.maxComplexity);
+                const totalAvg = allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length;
+                const globalMax = Math.max(...allMaxes);
+                const highComplexityDependents = fileComplexities.filter((f) => f.maxComplexity > COMPLEXITY_THRESHOLDS.HIGH_COMPLEXITY_DEPENDENT).sort((a, b) => b.maxComplexity - a.maxComplexity).slice(0, 5).map((f) => ({
+                  filepath: f.filepath,
+                  maxComplexity: f.maxComplexity,
+                  avgComplexity: f.avgComplexity
+                }));
+                let complexityRiskBoost = "low";
+                if (totalAvg > COMPLEXITY_THRESHOLDS.CRITICAL_AVG || globalMax > COMPLEXITY_THRESHOLDS.CRITICAL_MAX) {
+                  complexityRiskBoost = "critical";
+                } else if (totalAvg > COMPLEXITY_THRESHOLDS.HIGH_AVG || globalMax > COMPLEXITY_THRESHOLDS.HIGH_MAX) {
+                  complexityRiskBoost = "high";
+                } else if (totalAvg > COMPLEXITY_THRESHOLDS.MEDIUM_AVG || globalMax > COMPLEXITY_THRESHOLDS.MEDIUM_MAX) {
+                  complexityRiskBoost = "medium";
+                }
+                complexityMetrics = {
+                  averageComplexity: Math.round(totalAvg * 10) / 10,
+                  maxComplexity: globalMax,
+                  filesWithComplexityData: fileComplexities.length,
+                  highComplexityDependents,
+                  complexityRiskBoost
+                };
+              } else {
+                complexityMetrics = {
+                  averageComplexity: 0,
+                  maxComplexity: 0,
+                  filesWithComplexityData: 0,
+                  highComplexityDependents: [],
+                  complexityRiskBoost: "low"
+                };
+              }
+              const uniqueFiles = Array.from(chunksByFile.keys()).map((filepath) => ({
+                filepath,
+                isTestFile: isTestFile2(filepath)
+              }));
+              const count = uniqueFiles.length;
+              let riskLevel = count === 0 ? "low" : count <= DEPENDENT_COUNT_THRESHOLDS.LOW ? "low" : count <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM ? "medium" : count <= DEPENDENT_COUNT_THRESHOLDS.HIGH ? "high" : "critical";
+              const RISK_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
+              if (RISK_ORDER[complexityMetrics.complexityRiskBoost] > RISK_ORDER[riskLevel]) {
+                riskLevel = complexityMetrics.complexityRiskBoost;
+              }
+              log(`Found ${count} dependent files (risk: ${riskLevel}${complexityMetrics.filesWithComplexityData > 0 ? ", complexity-boosted" : ""})`);
+              let note;
+              if (allChunks.length === SCAN_LIMIT) {
+                note = `Warning: Scanned ${SCAN_LIMIT} chunks (limit reached). Results may be incomplete for large codebases. Some dependents might not be listed.`;
+              }
+              return {
+                indexInfo: getIndexMetadata(),
+                filepath: validatedArgs.filepath,
+                dependentCount: count,
+                riskLevel,
+                dependents: uniqueFiles,
+                complexityMetrics,
+                note
+              };
+            }
+          )(args);
         default:
           throw new LienError(
             `Unknown tool: ${name}`,