@liendev/lien 0.34.0 → 0.35.0

package/dist/index.js

@@ -3984,7 +3984,7 @@ async function indexCommand(options) {
 
 // src/cli/serve.ts
 import chalk5 from "chalk";
-import fs3 from "fs/promises";
+import fs5 from "fs/promises";
 import path4 from "path";
 
 // src/mcp/server.ts
@@ -3992,26 +3992,17 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join2, resolve } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import {
-  LocalEmbeddings,
-  GitStateTracker,
-  indexMultipleFiles,
-  indexSingleFile,
-  ManifestManager,
-  isGitAvailable,
-  isGitRepo as isGitRepo2,
+  WorkerEmbeddings,
   VERSION_CHECK_INTERVAL_MS,
-  DEFAULT_GIT_POLL_INTERVAL_MS as DEFAULT_GIT_POLL_INTERVAL_MS2,
-  createVectorDB,
-  computeContentHash,
-  normalizeToRelativePath
+  createVectorDB
 } from "@liendev/core";
 
 // src/watcher/index.ts
 import chokidar from "chokidar";
 import path3 from "path";
-import { detectAllFrameworks, getFrameworkDetector } from "@liendev/core";
+import { detectEcosystems, getEcosystemExcludePatterns, ALWAYS_IGNORE_PATTERNS } from "@liendev/core";
 var FileWatcher = class {
   watcher = null;
   rootDir;
@@ -4028,6 +4019,7 @@ var FileWatcher = class {
   firstChangeTimestamp = null;
   // Track when batch started
   // Git watching state
+  gitWatcher = null;
   gitChangeTimer = null;
   gitChangeHandler = null;
   GIT_DEBOUNCE_MS = 1e3;
@@ -4036,38 +4028,15 @@ var FileWatcher = class {
     this.rootDir = rootDir;
   }
   /**
-   * Detect watch patterns from frameworks or use defaults.
+   * Detect watch patterns from ecosystem presets or use defaults.
    */
   async getWatchPatterns() {
     try {
-      const detectedFrameworks = await detectAllFrameworks(this.rootDir);
-      if (detectedFrameworks.length > 0) {
-        const frameworks = await Promise.all(
-          detectedFrameworks.map(async (detection) => {
-            const detector = getFrameworkDetector(detection.name);
-            if (!detector) {
-              return null;
-            }
-            const config = await detector.generateConfig(this.rootDir, detection.path);
-            return {
-              name: detection.name,
-              path: detection.path,
-              enabled: true,
-              config
-            };
-          })
-        );
-        const validFrameworks = frameworks.filter((f) => f !== null);
-        const includePatterns = validFrameworks.flatMap((f) => f.config.include);
-        const excludePatterns = validFrameworks.flatMap((f) => f.config.exclude);
-        if (includePatterns.length === 0) {
-          return this.getDefaultPatterns();
-        }
-        return { include: includePatterns, exclude: excludePatterns };
-      } else {
-        return this.getDefaultPatterns();
-      }
-    } catch (error) {
+      const ecosystems = await detectEcosystems(this.rootDir);
+      const ecosystemExcludes = getEcosystemExcludePatterns(ecosystems);
+      const mergedExcludes = [.../* @__PURE__ */ new Set([...ALWAYS_IGNORE_PATTERNS, ...ecosystemExcludes])];
+      return { include: ["**/*"], exclude: mergedExcludes };
+    } catch {
       return this.getDefaultPatterns();
     }
   }
@@ -4077,13 +4046,7 @@ var FileWatcher = class {
   getDefaultPatterns() {
     return {
       include: ["**/*"],
-      exclude: [
-        "**/node_modules/**",
-        "**/vendor/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.git/**"
-      ]
+      exclude: [...ALWAYS_IGNORE_PATTERNS]
     };
   }
   /**
@@ -4134,17 +4097,17 @@ var FileWatcher = class {
     }
     let readyFired = false;
     await Promise.race([
-      new Promise((resolve2) => {
+      new Promise((resolve) => {
         const readyHandler = () => {
           readyFired = true;
-          resolve2();
+          resolve();
         };
         this.watcher.once("ready", readyHandler);
       }),
-      new Promise((resolve2) => {
+      new Promise((resolve) => {
         setTimeout(() => {
           if (!readyFired) {
-            resolve2();
+            resolve();
           }
         }, 1e3);
       })
@@ -4175,29 +4138,47 @@ var FileWatcher = class {
     if (!this.watcher) {
       throw new Error("Cannot watch git - watcher not started");
     }
+    if (this.gitWatcher) {
+      void this.gitWatcher.close().catch(() => {
+      });
+      this.gitWatcher = null;
+    }
     this.gitChangeHandler = onGitChange;
-    this.watcher.add([
-      path3.join(this.rootDir, ".git/HEAD"),
-      path3.join(this.rootDir, ".git/index"),
-      path3.join(this.rootDir, ".git/refs/**"),
-      path3.join(this.rootDir, ".git/MERGE_HEAD"),
-      path3.join(this.rootDir, ".git/REBASE_HEAD"),
-      path3.join(this.rootDir, ".git/CHERRY_PICK_HEAD"),
-      path3.join(this.rootDir, ".git/logs/refs/stash")
-      // git stash operations
-    ]);
+    const gitPaths = [
+      "HEAD",
+      "index",
+      "refs/**",
+      "MERGE_HEAD",
+      "REBASE_HEAD",
+      "CHERRY_PICK_HEAD",
+      "logs/refs/stash"
+    ].map((p) => path3.join(this.rootDir, ".git", p).replace(/\\/g, "/"));
+    this.gitWatcher = chokidar.watch(gitPaths, {
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.gitWatcher.on("add", () => this.handleGitChange()).on("change", () => this.handleGitChange()).on("unlink", () => this.handleGitChange()).on("error", (error) => {
+      try {
+        const message = "[FileWatcher] Git watcher error: " + (error instanceof Error ? error.stack || error.message : String(error)) + "\n";
+        process.stderr.write(message);
+      } catch {
+      }
+    });
   }
   /**
    * Check if a filepath is a git-related change
    */
   isGitChange(filepath) {
     const normalized = filepath.replace(/\\/g, "/");
-    return normalized.includes(".git/");
+    return normalized.startsWith(".git/") || normalized.includes("/.git/");
   }
   /**
    * Handle git-related file changes with debouncing
    */
   handleGitChange() {
+    if (!this.gitChangeHandler) {
+      return;
+    }
     if (this.gitChangeTimer) {
       clearTimeout(this.gitChangeTimer);
     }
@@ -4218,8 +4199,7 @@ var FileWatcher = class {
    * before starting a new batch to prevent race conditions.
    */
   handleChange(type, filepath) {
-    if (this.gitChangeHandler && this.isGitChange(filepath)) {
-      this.handleGitChange();
+    if (this.isGitChange(filepath)) {
       return;
     }
     if (!this.onChangeHandler) {
@@ -4368,6 +4348,13 @@ var FileWatcher = class {
     if (!this.watcher) {
       return;
     }
+    if (this.gitWatcher) {
+      try {
+        await this.gitWatcher.close();
+      } catch {
+      }
+      this.gitWatcher = null;
+    }
     const handler = this.onChangeHandler;
     this.onChangeHandler = null;
     this.gitChangeHandler = null;
@@ -4376,7 +4363,7 @@ var FileWatcher = class {
       this.gitChangeTimer = null;
     }
     while (this.batchInProgress) {
-      await new Promise((resolve2) => setTimeout(resolve2, 50));
+      await new Promise((resolve) => setTimeout(resolve, 50));
     }
     if (this.batchTimer) {
       clearTimeout(this.batchTimer);
@@ -4909,8 +4896,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path6, errorMaps, issueData } = params;
-  const fullPath = [...path6, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5026,11 +5013,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path6, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path6;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -8744,30 +8731,33 @@ function applyResponseBudget(result, maxChars = MAX_RESPONSE_CHARS) {
   if (arrays.length === 0) {
     return { result };
   }
-  for (const arr of arrays) {
-    for (const item of arr) {
-      item.content = truncateContent(item.content, 10);
-    }
+  const originalItemCount = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  truncateArrays(arrays, 10);
+  if (measureSize(cloned) <= maxChars) {
+    return buildResult(cloned, originalChars, 1, arrays, originalItemCount);
   }
+  dropArrayItems(arrays, cloned, maxChars);
   if (measureSize(cloned) <= maxChars) {
-    return buildResult(cloned, originalChars, 1);
+    return buildResult(cloned, originalChars, 2, arrays, originalItemCount);
   }
-  let currentSize = measureSize(cloned);
+  truncateArrays(arrays, 3);
+  return buildResult(cloned, originalChars, 3, arrays, originalItemCount);
+}
+function truncateArrays(arrays, maxLines) {
   for (const arr of arrays) {
-    while (arr.length > 1 && currentSize > maxChars) {
-      arr.pop();
-      currentSize = measureSize(cloned);
+    for (const item of arr) {
+      item.content = truncateContent(item.content, maxLines);
     }
   }
-  if (currentSize <= maxChars) {
-    return buildResult(cloned, originalChars, 2);
-  }
+}
+function dropArrayItems(arrays, root, maxChars) {
+  let currentSize = measureSize(root);
   for (const arr of arrays) {
-    for (const item of arr) {
-      item.content = truncateContent(item.content, 3);
+    while (arr.length > 1 && currentSize > maxChars) {
+      arr.pop();
+      currentSize = measureSize(root);
     }
   }
-  return buildResult(cloned, originalChars, 3);
 }
 function truncateContent(content, maxLines) {
   const lines = content.split("\n");
@@ -8796,15 +8786,19 @@ function walk(node, found) {
     walk(value, found);
   }
 }
-function buildResult(cloned, originalChars, phase) {
+function buildResult(cloned, originalChars, phase, arrays, originalItemCount) {
   const finalChars = measureSize(cloned);
+  const finalItemCount = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const message = finalItemCount < originalItemCount ? `Showing ${finalItemCount} of ${originalItemCount} results (truncated). Use narrower filters or smaller limit for complete results.` : `Showing all ${finalItemCount} results (content trimmed to fit). Use narrower filters or smaller limit for complete results.`;
   return {
     result: cloned,
     truncation: {
       originalChars,
       finalChars,
+      originalItemCount,
+      finalItemCount,
       phase,
-      message: `Response truncated from ${originalChars} to ${finalChars} chars (phase ${phase}/3). Use narrower filters or smaller limit for complete results.`
+      message
     }
   };
 }
@@ -9106,9 +9100,21 @@ async function handleFindSimilar(args, ctx) {
 }
 
 // src/mcp/utils/path-matching.ts
-function normalizePath(path6, workspaceRoot) {
-  let normalized = path6.replace(/['"]/g, "").trim().replace(/\\/g, "/");
-  normalized = normalized.replace(/\.(ts|tsx|js|jsx|php|py)$/, "");
+import { getSupportedExtensions } from "@liendev/core";
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var extensionRegex = null;
+function getExtensionRegex() {
+  if (!extensionRegex) {
+    const extPattern = getSupportedExtensions().map(escapeRegex).join("|");
+    extensionRegex = new RegExp(`\\.(${extPattern})$`);
+  }
+  return extensionRegex;
+}
+function normalizePath(path7, workspaceRoot) {
+  let normalized = path7.replace(/['"]/g, "").trim().replace(/\\/g, "/");
+  normalized = normalized.replace(getExtensionRegex(), "");
   if (normalized.startsWith(workspaceRoot + "/")) {
     normalized = normalized.substring(workspaceRoot.length + 1);
   }
@@ -9246,10 +9252,10 @@ async function findRelatedChunks(filepaths, fileChunksMap, ctx) {
 }
 function createPathCache(workspaceRoot) {
   const cache = /* @__PURE__ */ new Map();
-  const normalize = (path6) => {
-    if (cache.has(path6)) return cache.get(path6);
-    const normalized = normalizePath(path6, workspaceRoot);
-    cache.set(path6, normalized);
+  const normalize = (path7) => {
+    if (cache.has(path7)) return cache.get(path7);
+    const normalized = normalizePath(path7, workspaceRoot);
+    cache.set(path7, normalized);
     return normalized;
   };
   return { normalize, cache };
@@ -9462,7 +9468,9 @@ import { QdrantDB as QdrantDB3 } from "@liendev/core";
 
 // src/mcp/handlers/dependency-analyzer.ts
 import { QdrantDB as QdrantDB2 } from "@liendev/core";
-var SCAN_LIMIT2 = 1e4;
+import {
+  findTransitiveDependents
+} from "@liendev/core";
 var COMPLEXITY_THRESHOLDS = {
   HIGH_COMPLEXITY_DEPENDENT: 10,
   // Individual file is complex
@@ -9479,30 +9487,144 @@ var COMPLEXITY_THRESHOLDS = {
   MEDIUM_MAX: 15
   // Occasional branching
 };
-async function scanChunks(vectorDB, crossRepo, log) {
-  let allChunks;
+function collectNamedSymbolsFromChunk(chunk, normalizedTarget, normalizePathCached, symbols) {
+  const importedSymbols = chunk.metadata.importedSymbols;
+  if (!importedSymbols || typeof importedSymbols !== "object") return;
+  for (const [importPath, syms] of Object.entries(importedSymbols)) {
+    if (matchesFile(normalizePathCached(importPath), normalizedTarget)) {
+      for (const sym of syms) symbols.add(sym);
+    }
+  }
+}
+function collectRawImportSentinel(chunk, normalizedTarget, normalizePathCached, symbols) {
+  const imports = chunk.metadata.imports || [];
+  for (const imp of imports) {
+    if (matchesFile(normalizePathCached(imp), normalizedTarget)) symbols.add("*");
+  }
+}
+function collectSymbolsFromChunk(chunk, normalizedTarget, normalizePathCached, symbols) {
+  collectNamedSymbolsFromChunk(chunk, normalizedTarget, normalizePathCached, symbols);
+  collectRawImportSentinel(chunk, normalizedTarget, normalizePathCached, symbols);
+}
+function collectImportedSymbolsFromTarget(chunks, normalizedTarget, normalizePathCached) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const chunk of chunks) {
+    collectSymbolsFromChunk(chunk, normalizedTarget, normalizePathCached, symbols);
+  }
+  return symbols;
+}
+function collectExportsFromChunks(chunks) {
+  const allExports = /* @__PURE__ */ new Set();
+  for (const chunk of chunks) {
+    for (const exp of chunk.metadata.exports || []) allExports.add(exp);
+  }
+  return allExports;
+}
+function findReExportedSymbols(importsFromTarget, allExports) {
+  if (importsFromTarget.has("*")) return [...allExports];
+  for (const sym of importsFromTarget) {
+    if (sym.startsWith("* as ")) return [...allExports];
+  }
+  const reExported = [];
+  for (const sym of importsFromTarget) {
+    if (allExports.has(sym)) reExported.push(sym);
+  }
+  return reExported;
+}
+function buildReExportGraph(allChunksByFile, normalizedTarget, normalizePathCached) {
+  const reExporters = [];
+  for (const [filepath, chunks] of allChunksByFile.entries()) {
+    if (matchesFile(filepath, normalizedTarget)) continue;
+    const importsFromTarget = collectImportedSymbolsFromTarget(chunks, normalizedTarget, normalizePathCached);
+    const allExports = collectExportsFromChunks(chunks);
+    if (importsFromTarget.size === 0 || allExports.size === 0) continue;
+    const reExportedSymbols = findReExportedSymbols(importsFromTarget, allExports);
+    if (reExportedSymbols.length > 0) {
+      reExporters.push({ filepath, reExportedSymbols });
+    }
+  }
+  return reExporters;
+}
+function fileImportsSymbolFromAny(chunks, targetSymbol, targetPaths, normalizePathCached) {
+  return chunks.some((chunk) => {
+    const importedSymbols = chunk.metadata.importedSymbols;
+    if (!importedSymbols) return false;
+    for (const [importPath, symbols] of Object.entries(importedSymbols)) {
+      const normalizedImport = normalizePathCached(importPath);
+      const matchesAny = targetPaths.some((tp) => matchesFile(normalizedImport, tp));
+      if (matchesAny) {
+        if (symbols.includes(targetSymbol)) return true;
+        if (symbols.some((s) => s.startsWith("* as "))) return true;
+      }
+    }
+    return false;
+  });
+}
+function addChunkToImportIndex(chunk, normalizePathCached, importIndex) {
+  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 importedSymbols = chunk.metadata.importedSymbols;
+  if (importedSymbols && typeof importedSymbols === "object") {
+    for (const modulePath of Object.keys(importedSymbols)) {
+      const normalizedImport = normalizePathCached(modulePath);
+      if (!importIndex.has(normalizedImport)) {
+        importIndex.set(normalizedImport, []);
+      }
+      importIndex.get(normalizedImport).push(chunk);
+    }
+  }
+}
+function addChunkToFileMap(chunk, normalizePathCached, fileMap) {
+  const canonical = normalizePathCached(chunk.metadata.file);
+  if (!fileMap.has(canonical)) {
+    fileMap.set(canonical, []);
+  }
+  fileMap.get(canonical).push(chunk);
+}
+async function scanChunksPaginated(vectorDB, crossRepo, log, normalizePathCached) {
+  const importIndex = /* @__PURE__ */ new Map();
+  const allChunksByFile = /* @__PURE__ */ new Map();
+  let totalChunks = 0;
   if (crossRepo && vectorDB instanceof QdrantDB2) {
-    allChunks = await vectorDB.scanCrossRepo({ limit: SCAN_LIMIT2 });
-  } else {
-    if (crossRepo) {
-      log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo search.", "warning");
+    const CROSS_REPO_LIMIT = 1e5;
+    const allChunks = await vectorDB.scanCrossRepo({ limit: CROSS_REPO_LIMIT });
+    totalChunks = allChunks.length;
+    const hitLimit = totalChunks >= CROSS_REPO_LIMIT;
+    if (hitLimit) {
+      log(`Warning: cross-repo scan hit ${CROSS_REPO_LIMIT} chunk limit. Results may be incomplete.`, "warning");
+    }
+    for (const chunk of allChunks) {
+      addChunkToImportIndex(chunk, normalizePathCached, importIndex);
+      addChunkToFileMap(chunk, normalizePathCached, allChunksByFile);
     }
-    allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT2 });
+    return { importIndex, allChunksByFile, totalChunks, hitLimit };
   }
-  const hitLimit = allChunks.length === SCAN_LIMIT2;
-  if (hitLimit) {
-    log(`Scanned ${SCAN_LIMIT2} chunks (limit reached). Results may be incomplete.`, "warning");
+  if (crossRepo) {
+    log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo paginated scan.", "warning");
+  }
+  for await (const page of vectorDB.scanPaginated({ pageSize: 1e3 })) {
+    totalChunks += page.length;
+    for (const chunk of page) {
+      addChunkToImportIndex(chunk, normalizePathCached, importIndex);
+      addChunkToFileMap(chunk, normalizePathCached, allChunksByFile);
+    }
   }
-  return { allChunks, hitLimit };
+  return { importIndex, allChunksByFile, totalChunks, hitLimit: false };
 }
 function createPathNormalizer() {
   const workspaceRoot = process.cwd().replace(/\\/g, "/");
   const cache = /* @__PURE__ */ new Map();
-  return (path6) => {
-    if (!cache.has(path6)) {
-      cache.set(path6, normalizePath(path6, workspaceRoot));
+  return (path7) => {
+    if (!cache.has(path7)) {
+      cache.set(path7, normalizePath(path7, workspaceRoot));
     }
-    return cache.get(path6);
+    return cache.get(path7);
   };
 }
 function groupChunksByFile(chunks) {
@@ -9516,10 +9638,10 @@ function groupChunksByFile(chunks) {
   }
   return chunksByFile;
 }
-function buildDependentsList(chunksByFile, symbol, normalizedTarget, normalizePathCached, allChunks, filepath, log) {
+function buildDependentsList(chunksByFile, symbol, normalizedTarget, normalizePathCached, targetFileChunks, filepath, log, reExporterPaths = []) {
   if (symbol) {
-    validateSymbolExport(allChunks, normalizedTarget, normalizePathCached, symbol, filepath, log);
-    return findSymbolUsages(chunksByFile, symbol, normalizedTarget, normalizePathCached);
+    validateSymbolExport(targetFileChunks, symbol, filepath, log);
+    return findSymbolUsages(chunksByFile, symbol, normalizedTarget, normalizePathCached, reExporterPaths);
   }
   const dependents = Array.from(chunksByFile.keys()).map((fp) => ({
     filepath: fp,
@@ -9527,33 +9649,69 @@ function buildDependentsList(chunksByFile, symbol, normalizedTarget, normalizePa
   }));
   return { dependents, totalUsageCount: void 0 };
 }
-function validateSymbolExport(allChunks, normalizedTarget, normalizePathCached, symbol, filepath, log) {
-  const targetFileExportsSymbol = allChunks.some((chunk) => {
-    const chunkFile = normalizePathCached(chunk.metadata.file);
-    return matchesFile(chunkFile, normalizedTarget) && chunk.metadata.exports?.includes(symbol);
-  });
-  if (!targetFileExportsSymbol) {
+function validateSymbolExport(targetFileChunks, symbol, filepath, log) {
+  const exportsSymbol = targetFileChunks.some(
+    (chunk) => chunk.metadata.exports?.includes(symbol)
+  );
+  if (!exportsSymbol) {
     log(`Warning: Symbol "${symbol}" not found in exports of ${filepath}`, "warning");
   }
 }
+function mergeChunksByFile(target, source) {
+  for (const [fp, chunks] of source.entries()) {
+    const existing = target.get(fp);
+    if (existing) {
+      existing.push(...chunks);
+    } else {
+      target.set(fp, chunks);
+    }
+  }
+}
+function mergeTransitiveDependents(reExporters, importIndex, normalizedTarget, normalizePathCached, allChunksByFile, chunksByFile, log) {
+  const existingFiles = new Set(chunksByFile.keys());
+  const transitiveChunks = findTransitiveDependents(
+    reExporters.map((r) => r.filepath),
+    importIndex,
+    normalizedTarget,
+    normalizePathCached,
+    allChunksByFile,
+    existingFiles
+  );
+  if (transitiveChunks.length > 0) {
+    const transitiveByFile = groupChunksByFile(transitiveChunks);
+    mergeChunksByFile(chunksByFile, transitiveByFile);
+    log(`Found ${transitiveByFile.size} additional dependents via re-export chains`);
+  }
+}
 async function findDependents(vectorDB, filepath, crossRepo, log, symbol) {
-  const { allChunks, hitLimit } = await scanChunks(vectorDB, crossRepo, log);
-  log(`Scanning ${allChunks.length} chunks for imports...`);
   const normalizePathCached = createPathNormalizer();
   const normalizedTarget = normalizePathCached(filepath);
-  const importIndex = buildImportIndex(allChunks, normalizePathCached);
+  const { importIndex, allChunksByFile, totalChunks, hitLimit } = await scanChunksPaginated(
+    vectorDB,
+    crossRepo,
+    log,
+    normalizePathCached
+  );
+  log(`Scanned ${totalChunks} chunks for imports...`);
   const dependentChunks = findDependentChunks(importIndex, normalizedTarget);
   const chunksByFile = groupChunksByFile(dependentChunks);
+  const reExporters = buildReExportGraph(allChunksByFile, normalizedTarget, normalizePathCached);
+  if (reExporters.length > 0) {
+    mergeTransitiveDependents(reExporters, importIndex, normalizedTarget, normalizePathCached, allChunksByFile, chunksByFile, log);
+  }
   const fileComplexities = calculateFileComplexities(chunksByFile);
   const complexityMetrics = calculateOverallComplexityMetrics(fileComplexities);
+  const targetFileChunks = symbol ? allChunksByFile.get(normalizedTarget) ?? [] : [];
+  const reExporterPaths = reExporters.map((re) => re.filepath);
   const { dependents, totalUsageCount } = buildDependentsList(
     chunksByFile,
     symbol,
     normalizedTarget,
     normalizePathCached,
-    allChunks,
+    targetFileChunks,
     filepath,
-    log
+    log,
+    reExporterPaths
   );
   dependents.sort((a, b) => {
     if (a.isTestFile === b.isTestFile) return 0;
@@ -9561,6 +9719,7 @@ async function findDependents(vectorDB, filepath, crossRepo, log, symbol) {
   });
   const testDependentCount = dependents.filter((f) => f.isTestFile).length;
   const productionDependentCount = dependents.length - testDependentCount;
+  const allChunks = crossRepo ? Array.from(allChunksByFile.values()).flat() : [];
   return {
     dependents,
     productionDependentCount,
@@ -9573,29 +9732,6 @@ async function findDependents(vectorDB, filepath, crossRepo, log, symbol) {
     totalUsageCount
   };
 }
-function buildImportIndex(allChunks, normalizePathCached) {
-  const importIndex = /* @__PURE__ */ new Map();
-  const addToIndex = (importPath, chunk) => {
-    const normalizedImport = normalizePathCached(importPath);
-    if (!importIndex.has(normalizedImport)) {
-      importIndex.set(normalizedImport, []);
-    }
-    importIndex.get(normalizedImport).push(chunk);
-  };
-  for (const chunk of allChunks) {
-    const imports = chunk.metadata.imports || [];
-    for (const imp of imports) {
-      addToIndex(imp, chunk);
-    }
-    const importedSymbols = chunk.metadata.importedSymbols;
-    if (importedSymbols && typeof importedSymbols === "object") {
-      for (const modulePath of Object.keys(importedSymbols)) {
-        addToIndex(modulePath, chunk);
-      }
-    }
-  }
-  return importIndex;
-}
 function findDependentChunks(importIndex, normalizedTarget) {
   const dependentChunks = [];
   const seenChunkIds = /* @__PURE__ */ new Set();
@@ -9713,11 +9849,12 @@ function groupDependentsByRepo(dependents, chunks) {
   }
   return grouped;
 }
-function findSymbolUsages(chunksByFile, targetSymbol, normalizedTarget, normalizePathCached) {
+function findSymbolUsages(chunksByFile, targetSymbol, normalizedTarget, normalizePathCached, reExporterPaths = []) {
   const dependents = [];
   let totalUsageCount = 0;
+  const allTargetPaths = [normalizedTarget, ...reExporterPaths];
   for (const [filepath, chunks] of chunksByFile.entries()) {
-    if (!fileImportsSymbol(chunks, targetSymbol, normalizedTarget, normalizePathCached)) {
+    if (!fileImportsSymbolFromAny(chunks, targetSymbol, allTargetPaths, normalizePathCached)) {
       continue;
     }
     const usages = extractSymbolUsagesFromChunks(chunks, targetSymbol);
@@ -9730,20 +9867,6 @@ function findSymbolUsages(chunksByFile, targetSymbol, normalizedTarget, normaliz
   }
   return { dependents, totalUsageCount };
 }
-function fileImportsSymbol(chunks, targetSymbol, normalizedTarget, normalizePathCached) {
-  return chunks.some((chunk) => {
-    const importedSymbols = chunk.metadata.importedSymbols;
-    if (!importedSymbols) return false;
-    for (const [importPath, symbols] of Object.entries(importedSymbols)) {
-      const normalizedImport = normalizePathCached(importPath);
-      if (matchesFile(normalizedImport, normalizedTarget)) {
-        if (symbols.includes(targetSymbol)) return true;
-        if (symbols.some((s) => s.startsWith("* as "))) return true;
-      }
-    }
-    return false;
-  });
-}
 function extractSymbolUsagesFromChunks(chunks, targetSymbol) {
   const usages = [];
   for (const chunk of chunks) {
@@ -10192,238 +10315,106 @@ function createReindexStateManager() {
   };
 }
 
-// src/mcp/server.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname2(__filename2);
-var require3 = createRequire2(import.meta.url);
-var packageJson2;
-try {
-  packageJson2 = require3(join2(__dirname2, "../package.json"));
-} catch {
-  packageJson2 = require3(join2(__dirname2, "../../package.json"));
-}
-function getRootDirFromDbPath(dbPath) {
-  return resolve(dbPath, "../../..");
-}
-async function initializeDatabase(rootDir, log) {
-  const embeddings = new LocalEmbeddings();
-  log("Creating vector database...");
-  const vectorDB = await createVectorDB(rootDir);
-  if (!vectorDB) {
-    throw new Error("createVectorDB returned undefined or null");
-  }
-  if (typeof vectorDB.initialize !== "function") {
-    throw new Error(`Invalid vectorDB instance: ${vectorDB.constructor?.name || "unknown"}. Expected VectorDBInterface but got: ${JSON.stringify(Object.keys(vectorDB))}`);
+// src/mcp/git-detection.ts
+import fs4 from "fs/promises";
+import {
+  GitStateTracker,
+  indexMultipleFiles as indexMultipleFiles2,
+  isGitAvailable,
+  isGitRepo as isGitRepo2,
+  DEFAULT_GIT_POLL_INTERVAL_MS as DEFAULT_GIT_POLL_INTERVAL_MS2,
+  createGitignoreFilter as createGitignoreFilter2
+} from "@liendev/core";
+
+// src/mcp/file-change-handler.ts
+import fs3 from "fs/promises";
+import {
+  indexMultipleFiles,
+  indexSingleFile,
+  ManifestManager,
+  computeContentHash,
+  normalizeToRelativePath,
+  createGitignoreFilter
+} from "@liendev/core";
+async function handleFileDeletion(filepath, vectorDB, log) {
+  log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  try {
+    await vectorDB.deleteByFile(filepath);
+    await manifest.removeFile(filepath);
+    log(`\u2713 Removed ${filepath} from index`);
+  } catch (error) {
+    log(`Failed to remove ${filepath}: ${error}`, "warning");
+    throw error;
   }
-  log("Loading embedding model...");
-  await embeddings.initialize();
-  log("Loading vector database...");
-  await vectorDB.initialize();
-  log("Embeddings and vector DB ready");
-  return { embeddings, vectorDB };
 }
-async function handleAutoIndexing(vectorDB, rootDir, log) {
-  const hasIndex = await vectorDB.hasData();
-  if (!hasIndex) {
-    log("\u{1F4E6} No index found - running initial indexing...");
-    log("\u23F1\uFE0F  This may take 5-20 minutes depending on project size");
+async function handleBatchDeletions(deletedFiles, vectorDB, log) {
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  const failures = [];
+  for (const filepath of deletedFiles) {
+    log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
     try {
-      const { indexCodebase: indexCodebase2 } = await import("@liendev/core");
-      await indexCodebase2({ rootDir, verbose: true });
-      log("\u2705 Initial indexing complete!");
+      await vectorDB.deleteByFile(filepath);
+      await manifest.removeFile(filepath);
+      log(`\u2713 Removed ${filepath} from index`);
     } catch (error) {
-      log(`\u26A0\uFE0F  Initial indexing failed: ${error}`, "warning");
-      log("You can manually run: lien index", "warning");
+      log(`Failed to remove ${filepath}: ${error}`, "warning");
+      failures.push(filepath);
     }
   }
+  if (failures.length > 0) {
+    throw new Error(`Failed to delete ${failures.length} file(s): ${failures.join(", ")}`);
+  }
 }
-async function handleGitStartup(gitTracker, vectorDB, embeddings, _verbose, log, reindexStateManager) {
-  log("Checking for git changes...");
-  const changedFiles = await gitTracker.initialize();
-  if (changedFiles && changedFiles.length > 0) {
-    const startTime = Date.now();
-    reindexStateManager.startReindex(changedFiles);
-    log(`\u{1F33F} Git changes detected: ${changedFiles.length} files changed`);
+async function canSkipReindex(filepath, rootDir, vectorDB, log) {
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  const normalizedPath = normalizeToRelativePath(filepath, rootDir);
+  const manifestData = await manifest.load();
+  const existingEntry = manifestData?.files[normalizedPath];
+  const { shouldReindex, newMtime } = await shouldReindexFile(filepath, existingEntry, log);
+  if (!shouldReindex && newMtime !== void 0 && existingEntry) {
+    const skipped = await manifest.transaction(async (data) => {
+      const entry = data.files[normalizedPath];
+      if (entry) {
+        entry.lastModified = newMtime;
+        return true;
+      }
+      return false;
+    });
+    return !!skipped;
+  }
+  return false;
+}
+async function handleSingleFileChange(filepath, type, rootDir, vectorDB, embeddings, log, reindexStateManager) {
+  const action = type === "add" ? "added" : "changed";
+  if (type === "change") {
     try {
-      const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, { verbose: false });
-      const duration = Date.now() - startTime;
-      reindexStateManager.completeReindex(duration);
-      log(`\u2713 Reindexed ${count} files in ${duration}ms`);
+      if (await canSkipReindex(filepath, rootDir, vectorDB, log)) return;
     } catch (error) {
-      reindexStateManager.failReindex();
-      throw error;
+      log(`Content hash check failed, will reindex: ${error}`, "warning");
     }
-  } else {
-    log("\u2713 Index is up to date with git state");
+  }
+  const startTime = Date.now();
+  reindexStateManager.startReindex([filepath]);
+  log(`\u{1F4DD} File ${action}: ${filepath}`);
+  try {
+    await indexSingleFile(filepath, vectorDB, embeddings, { verbose: false, rootDir });
+    const duration = Date.now() - startTime;
+    reindexStateManager.completeReindex(duration);
+  } catch (error) {
+    reindexStateManager.failReindex();
+    log(`Failed to reindex ${filepath}: ${error}`, "warning");
   }
 }
-function createGitPollInterval(gitTracker, vectorDB, embeddings, _verbose, log, reindexStateManager) {
-  return setInterval(async () => {
+async function shouldReindexFile(filepath, existingEntry, log) {
+  if (!existingEntry?.contentHash) {
+    return { shouldReindex: true };
+  }
+  const currentHash = await computeContentHash(filepath);
+  if (currentHash && currentHash === existingEntry.contentHash) {
+    log(`\u23ED\uFE0F  File mtime changed but content unchanged: ${filepath}`, "debug");
     try {
-      const changedFiles = await gitTracker.detectChanges();
-      if (changedFiles && changedFiles.length > 0) {
-        const currentState = reindexStateManager.getState();
-        if (currentState.inProgress) {
-          log(
-            `Background reindex already in progress (${currentState.pendingFiles.length} files pending), skipping git poll cycle`,
-            "debug"
-          );
-          return;
-        }
-        const startTime = Date.now();
-        reindexStateManager.startReindex(changedFiles);
-        log(`\u{1F33F} Git change detected: ${changedFiles.length} files changed`);
-        try {
-          const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, { verbose: false });
-          const duration = Date.now() - startTime;
-          reindexStateManager.completeReindex(duration);
-          log(`\u2713 Background reindex complete: ${count} files in ${duration}ms`);
-        } catch (error) {
-          reindexStateManager.failReindex();
-          log(`Git background reindex failed: ${error}`, "warning");
-        }
-      }
-    } catch (error) {
-      log(`Git detection check failed: ${error}`, "warning");
-    }
-  }, DEFAULT_GIT_POLL_INTERVAL_MS2);
-}
-function createGitChangeHandler(gitTracker, vectorDB, embeddings, _verbose, log, reindexStateManager) {
-  let gitReindexInProgress = false;
-  let lastGitReindexTime = 0;
-  const GIT_REINDEX_COOLDOWN_MS = 5e3;
-  return async () => {
-    const { inProgress: globalInProgress } = reindexStateManager.getState();
-    if (gitReindexInProgress || globalInProgress) {
-      log("Git reindex already in progress, skipping", "debug");
-      return;
-    }
-    const timeSinceLastReindex = Date.now() - lastGitReindexTime;
-    if (timeSinceLastReindex < GIT_REINDEX_COOLDOWN_MS) {
-      log(`Git change ignored (cooldown: ${GIT_REINDEX_COOLDOWN_MS - timeSinceLastReindex}ms remaining)`, "debug");
-      return;
-    }
-    log("\u{1F33F} Git change detected (event-driven)");
-    const changedFiles = await gitTracker.detectChanges();
-    if (!changedFiles || changedFiles.length === 0) {
-      return;
-    }
-    gitReindexInProgress = true;
-    const startTime = Date.now();
-    reindexStateManager.startReindex(changedFiles);
-    log(`Reindexing ${changedFiles.length} files from git change`);
-    try {
-      const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, { verbose: false });
-      const duration = Date.now() - startTime;
-      reindexStateManager.completeReindex(duration);
-      log(`\u2713 Reindexed ${count} files in ${duration}ms`);
-      lastGitReindexTime = Date.now();
-    } catch (error) {
-      reindexStateManager.failReindex();
-      log(`Git reindex failed: ${error}`, "warning");
-    } finally {
-      gitReindexInProgress = false;
-    }
-  };
-}
-async function setupGitDetection(rootDir, vectorDB, embeddings, verbose, log, reindexStateManager, fileWatcher) {
-  const gitAvailable = await isGitAvailable();
-  const isRepo = await isGitRepo2(rootDir);
-  if (!gitAvailable) {
-    log("Git not available - git detection disabled");
-    return { gitTracker: null, gitPollInterval: null };
-  }
-  if (!isRepo) {
-    log("Not a git repository - git detection disabled");
-    return { gitTracker: null, gitPollInterval: null };
-  }
-  log("\u2713 Detected git repository");
-  const gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
-  try {
-    await handleGitStartup(gitTracker, vectorDB, embeddings, verbose, log, reindexStateManager);
-  } catch (error) {
-    log(`Failed to check git state on startup: ${error}`, "warning");
-  }
-  if (fileWatcher) {
-    const gitChangeHandler = createGitChangeHandler(
-      gitTracker,
-      vectorDB,
-      embeddings,
-      verbose,
-      log,
-      reindexStateManager
-    );
-    fileWatcher.watchGit(gitChangeHandler);
-    log("\u2713 Git detection enabled (event-driven via file watcher)");
-    return { gitTracker, gitPollInterval: null };
-  }
-  const pollIntervalSeconds = DEFAULT_GIT_POLL_INTERVAL_MS2 / 1e3;
-  log(`\u2713 Git detection enabled (polling fallback every ${pollIntervalSeconds}s)`);
-  const gitPollInterval = createGitPollInterval(gitTracker, vectorDB, embeddings, verbose, log, reindexStateManager);
-  return { gitTracker, gitPollInterval };
-}
-async function handleFileDeletion(filepath, vectorDB, log) {
-  log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
-  const manifest = new ManifestManager(vectorDB.dbPath);
-  try {
-    await vectorDB.deleteByFile(filepath);
-    await manifest.removeFile(filepath);
-    log(`\u2713 Removed ${filepath} from index`);
-  } catch (error) {
-    log(`Failed to remove ${filepath}: ${error}`, "warning");
-    throw error;
-  }
-}
-async function handleSingleFileChange(filepath, type, vectorDB, embeddings, _verbose, log, reindexStateManager) {
-  const action = type === "add" ? "added" : "changed";
-  const rootDir = getRootDirFromDbPath(vectorDB.dbPath);
-  if (type === "change") {
-    const manifest = new ManifestManager(vectorDB.dbPath);
-    const normalizedPath = normalizeToRelativePath(filepath, rootDir);
-    try {
-      const existingEntry = await manifest.transaction(async (manifestData) => {
-        return manifestData.files[normalizedPath];
-      });
-      const { shouldReindex, newMtime } = await shouldReindexFile(filepath, existingEntry, log);
-      if (!shouldReindex && newMtime && existingEntry) {
-        const skipReindex = await manifest.transaction(async (manifestData) => {
-          const entry = manifestData.files[normalizedPath];
-          if (entry) {
-            entry.lastModified = newMtime;
-            return true;
-          }
-          return false;
-        });
-        if (skipReindex) {
-          return;
-        }
-      }
-    } catch (error) {
-      log(`Content hash check failed, will reindex: ${error}`, "warning");
-    }
-  }
-  const startTime = Date.now();
-  reindexStateManager.startReindex([filepath]);
-  log(`\u{1F4DD} File ${action}: ${filepath}`);
-  try {
-    await indexSingleFile(filepath, vectorDB, embeddings, { verbose: false, rootDir });
-    const duration = Date.now() - startTime;
-    reindexStateManager.completeReindex(duration);
-  } catch (error) {
-    reindexStateManager.failReindex();
-    log(`Failed to reindex ${filepath}: ${error}`, "warning");
-  }
-}
-async function shouldReindexFile(filepath, existingEntry, log) {
-  if (!existingEntry?.contentHash) {
-    return { shouldReindex: true };
-  }
-  const currentHash = await computeContentHash(filepath);
-  if (currentHash && currentHash === existingEntry.contentHash) {
-    log(`\u23ED\uFE0F  File mtime changed but content unchanged: ${filepath}`, "debug");
-    try {
-      const fs5 = await import("fs/promises");
-      const stats = await fs5.stat(filepath);
+      const stats = await fs3.stat(filepath);
       return { shouldReindex: false, newMtime: stats.mtimeMs };
     } catch {
       return { shouldReindex: true };
@@ -10431,31 +10422,22 @@ async function shouldReindexFile(filepath, existingEntry, log) {
   }
   return { shouldReindex: true };
 }
-async function filterModifiedFilesByHash(modifiedFiles, vectorDB, log) {
-  if (modifiedFiles.length === 0) {
-    return [];
-  }
-  const manifest = new ManifestManager(vectorDB.dbPath);
-  const rootDir = getRootDirFromDbPath(vectorDB.dbPath);
-  const manifestData = await manifest.transaction(async (data) => data);
-  if (!manifestData) {
-    return modifiedFiles;
-  }
-  const checkResults = [];
-  for (const filepath of modifiedFiles) {
+async function checkFilesAgainstManifest(files, rootDir, manifestFiles, log) {
+  const results = [];
+  for (const filepath of files) {
     const normalizedPath = normalizeToRelativePath(filepath, rootDir);
-    const existingEntry = manifestData.files[normalizedPath];
+    const existingEntry = manifestFiles[normalizedPath];
     const { shouldReindex, newMtime } = await shouldReindexFile(filepath, existingEntry, log);
-    checkResults.push({
-      filepath,
-      normalizedPath,
-      shouldReindex,
-      newMtime
-    });
+    results.push({ filepath, normalizedPath, shouldReindex, newMtime });
   }
+  return results;
+}
+async function updateUnchangedMtimes(manifest, results) {
+  const hasUpdates = results.some((r) => !r.shouldReindex && r.newMtime !== void 0);
+  if (!hasUpdates) return;
   await manifest.transaction(async (data) => {
-    for (const result of checkResults) {
-      if (!result.shouldReindex && result.newMtime) {
+    for (const result of results) {
+      if (!result.shouldReindex && result.newMtime !== void 0) {
         const entry = data.files[result.normalizedPath];
         if (entry) {
           entry.lastModified = result.newMtime;
@@ -10464,15 +10446,23 @@ async function filterModifiedFilesByHash(modifiedFiles, vectorDB, log) {
     }
     return null;
   });
+}
+async function filterModifiedFilesByHash(modifiedFiles, rootDir, vectorDB, log) {
+  if (modifiedFiles.length === 0) return [];
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  const manifestData = await manifest.load();
+  if (!manifestData) return modifiedFiles;
+  const checkResults = await checkFilesAgainstManifest(modifiedFiles, rootDir, manifestData.files, log);
+  await updateUnchangedMtimes(manifest, checkResults);
   return checkResults.filter((r) => r.shouldReindex).map((r) => r.filepath);
 }
-async function prepareFilesForReindexing(event, vectorDB, log) {
+async function prepareFilesForReindexing(event, rootDir, vectorDB, log) {
   const addedFiles = event.added || [];
   const modifiedFiles = event.modified || [];
   const deletedFiles = event.deleted || [];
   let modifiedFilesToReindex = [];
   try {
-    modifiedFilesToReindex = await filterModifiedFilesByHash(modifiedFiles, vectorDB, log);
+    modifiedFilesToReindex = await filterModifiedFilesByHash(modifiedFiles, rootDir, vectorDB, log);
   } catch (error) {
     log(`Hash-based filtering failed, will reindex all modified files: ${error}`, "warning");
     modifiedFilesToReindex = modifiedFiles;
@@ -10480,23 +10470,19 @@ async function prepareFilesForReindexing(event, vectorDB, log) {
   const filesToIndex = [...addedFiles, ...modifiedFilesToReindex];
   return { filesToIndex, deletedFiles };
 }
-async function executeReindexOperations(filesToIndex, deletedFiles, vectorDB, embeddings, log) {
+async function executeReindexOperations(filesToIndex, deletedFiles, rootDir, vectorDB, embeddings, log) {
   const operations = [];
   if (filesToIndex.length > 0) {
     log(`\u{1F4C1} ${filesToIndex.length} file(s) changed, reindexing...`);
-    operations.push(indexMultipleFiles(filesToIndex, vectorDB, embeddings, { verbose: false }));
+    operations.push(indexMultipleFiles(filesToIndex, vectorDB, embeddings, { verbose: false, rootDir }));
   }
   if (deletedFiles.length > 0) {
-    operations.push(
-      Promise.all(
-        deletedFiles.map((deleted) => handleFileDeletion(deleted, vectorDB, log))
-      )
-    );
+    operations.push(handleBatchDeletions(deletedFiles, vectorDB, log));
   }
   await Promise.all(operations);
 }
-async function handleBatchEvent(event, vectorDB, embeddings, _verbose, log, reindexStateManager) {
-  const { filesToIndex, deletedFiles } = await prepareFilesForReindexing(event, vectorDB, log);
+async function handleBatchEvent(event, rootDir, vectorDB, embeddings, log, reindexStateManager) {
+  const { filesToIndex, deletedFiles } = await prepareFilesForReindexing(event, rootDir, vectorDB, log);
   const allFiles = [...filesToIndex, ...deletedFiles];
   if (allFiles.length === 0) {
     return;
@@ -10504,7 +10490,7 @@ async function handleBatchEvent(event, vectorDB, embeddings, _verbose, log, rein
   const startTime = Date.now();
   reindexStateManager.startReindex(allFiles);
   try {
-    await executeReindexOperations(filesToIndex, deletedFiles, vectorDB, embeddings, log);
+    await executeReindexOperations(filesToIndex, deletedFiles, rootDir, vectorDB, embeddings, log);
     const duration = Date.now() - startTime;
     reindexStateManager.completeReindex(duration);
     log(`\u2713 Processed ${filesToIndex.length} file(s) + ${deletedFiles.length} deletion(s) in ${duration}ms`);
@@ -10525,19 +10511,316 @@ async function handleUnlinkEvent(filepath, vectorDB, log, reindexStateManager) {
     log(`Failed to process deletion for ${filepath}: ${error}`, "warning");
   }
 }
-function createFileChangeHandler(vectorDB, embeddings, verbose, log, reindexStateManager) {
+function isFileIgnored(filepath, rootDir, isIgnored) {
+  return isIgnored(normalizeToRelativePath(filepath, rootDir));
+}
+function filterFileChangeEvent(event, ignoreFilter, rootDir) {
+  return {
+    ...event,
+    added: (event.added || []).filter((f) => !isFileIgnored(f, rootDir, ignoreFilter)),
+    modified: (event.modified || []).filter((f) => !isFileIgnored(f, rootDir, ignoreFilter)),
+    deleted: event.deleted || []
+  };
+}
+function isGitignoreFile(filepath) {
+  const name = filepath.split(/[/\\]/).pop() ?? filepath;
+  return name === ".gitignore";
+}
+function hasGitignoreChange(event) {
+  if (event.type === "batch") {
+    const allFiles = [...event.added || [], ...event.modified || [], ...event.deleted || []];
+    return allFiles.some(isGitignoreFile);
+  }
+  return event.filepath ? isGitignoreFile(event.filepath) : false;
+}
+function createFileChangeHandler(rootDir, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect) {
+  let ignoreFilter = null;
   return async (event) => {
+    if (hasGitignoreChange(event)) {
+      ignoreFilter = null;
+    }
+    if (!ignoreFilter) {
+      ignoreFilter = await createGitignoreFilter(rootDir);
+    }
     const { type } = event;
     if (type === "batch") {
-      await handleBatchEvent(event, vectorDB, embeddings, verbose, log, reindexStateManager);
+      const filtered = filterFileChangeEvent(event, ignoreFilter, rootDir);
+      const totalToProcess = filtered.added.length + filtered.modified.length + filtered.deleted.length;
+      if (totalToProcess === 0) return;
+      await checkAndReconnect();
+      await handleBatchEvent(filtered, rootDir, vectorDB, embeddings, log, reindexStateManager);
     } else if (type === "unlink") {
+      await checkAndReconnect();
       await handleUnlinkEvent(event.filepath, vectorDB, log, reindexStateManager);
     } else {
-      await handleSingleFileChange(event.filepath, type, vectorDB, embeddings, verbose, log, reindexStateManager);
+      if (isFileIgnored(event.filepath, rootDir, ignoreFilter)) return;
+      await checkAndReconnect();
+      await handleSingleFileChange(event.filepath, type, rootDir, vectorDB, embeddings, log, reindexStateManager);
     }
   };
 }
-async function setupFileWatching(watch, rootDir, vectorDB, embeddings, verbose, log, reindexStateManager) {
+
+// src/mcp/git-detection.ts
+async function handleGitStartup(rootDir, gitTracker, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect) {
+  log("Checking for git changes...");
+  const changedFiles = await gitTracker.initialize();
+  if (changedFiles && changedFiles.length > 0) {
+    const isIgnored = await createGitignoreFilter2(rootDir);
+    const filteredFiles = await filterGitChangedFiles(changedFiles, rootDir, isIgnored);
+    if (filteredFiles.length === 0) {
+      log("\u2713 Index is up to date with git state");
+      return;
+    }
+    const startTime = Date.now();
+    reindexStateManager.startReindex(filteredFiles);
+    log(`\u{1F33F} Git changes detected: ${filteredFiles.length} files changed`);
+    try {
+      await checkAndReconnect();
+      const count = await indexMultipleFiles2(filteredFiles, vectorDB, embeddings, { verbose: false });
+      const duration = Date.now() - startTime;
+      reindexStateManager.completeReindex(duration);
+      log(`\u2713 Reindexed ${count} files in ${duration}ms`);
+    } catch (error) {
+      reindexStateManager.failReindex();
+      throw error;
+    }
+  } else {
+    log("\u2713 Index is up to date with git state");
+  }
+}
+function createGitPollInterval(rootDir, gitTracker, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect) {
+  let isIgnored = null;
+  let pollInProgress = false;
+  return setInterval(async () => {
+    if (pollInProgress) return;
+    pollInProgress = true;
+    try {
+      const changedFiles = await gitTracker.detectChanges();
+      if (changedFiles && changedFiles.length > 0) {
+        const currentState = reindexStateManager.getState();
+        if (currentState.inProgress) {
+          log(
+            `Background reindex already in progress (${currentState.pendingFiles.length} files pending), skipping git poll cycle`,
+            "debug"
+          );
+          return;
+        }
+        if (changedFiles.some(isGitignoreFile)) {
+          isIgnored = null;
+        }
+        if (!isIgnored) {
+          isIgnored = await createGitignoreFilter2(rootDir);
+        }
+        const filteredFiles = await filterGitChangedFiles(changedFiles, rootDir, isIgnored);
+        if (filteredFiles.length === 0) return;
+        const startTime = Date.now();
+        reindexStateManager.startReindex(filteredFiles);
+        log(`\u{1F33F} Git change detected: ${filteredFiles.length} files changed`);
+        try {
+          await checkAndReconnect();
+          const count = await indexMultipleFiles2(filteredFiles, vectorDB, embeddings, { verbose: false });
+          const duration = Date.now() - startTime;
+          reindexStateManager.completeReindex(duration);
+          log(`\u2713 Background reindex complete: ${count} files in ${duration}ms`);
+        } catch (error) {
+          reindexStateManager.failReindex();
+          log(`Git background reindex failed: ${error}`, "warning");
+        }
+      }
+    } catch (error) {
+      log(`Git detection check failed: ${error}`, "warning");
+    } finally {
+      pollInProgress = false;
+    }
+  }, DEFAULT_GIT_POLL_INTERVAL_MS2);
+}
+function shouldSkipGitReindex(gitReindexInProgress, lastGitReindexTime, cooldownMs, reindexStateManager, log) {
+  const { inProgress: globalInProgress } = reindexStateManager.getState();
+  if (gitReindexInProgress || globalInProgress) {
+    log("Git reindex already in progress, skipping", "debug");
+    return true;
+  }
+  const timeSinceLastReindex = Date.now() - lastGitReindexTime;
+  if (timeSinceLastReindex < cooldownMs) {
+    log(`Git change ignored (cooldown: ${cooldownMs - timeSinceLastReindex}ms remaining)`, "debug");
+    return true;
+  }
+  return false;
+}
+async function detectAndFilterGitChanges(gitTracker, rootDir, getIgnoreFilter, setIgnoreFilter, log) {
+  log("\u{1F33F} Git change detected (event-driven)");
+  const changedFiles = await gitTracker.detectChanges();
+  if (!changedFiles || changedFiles.length === 0) return null;
+  if (changedFiles.some(isGitignoreFile)) {
+    setIgnoreFilter(null);
+  }
+  let filter = getIgnoreFilter();
+  if (!filter) {
+    filter = await createGitignoreFilter2(rootDir);
+    setIgnoreFilter(filter);
+  }
+  const filteredFiles = await filterGitChangedFiles(changedFiles, rootDir, filter);
+  return filteredFiles.length > 0 ? filteredFiles : null;
+}
+async function executeGitReindex(filteredFiles, vectorDB, embeddings, reindexStateManager, checkAndReconnect, log) {
+  const startTime = Date.now();
+  reindexStateManager.startReindex(filteredFiles);
+  log(`Reindexing ${filteredFiles.length} files from git change`);
+  try {
+    await checkAndReconnect();
+    const count = await indexMultipleFiles2(filteredFiles, vectorDB, embeddings, { verbose: false });
+    const duration = Date.now() - startTime;
+    reindexStateManager.completeReindex(duration);
+    log(`\u2713 Reindexed ${count} files in ${duration}ms`);
+  } catch (error) {
+    reindexStateManager.failReindex();
+    log(`Git reindex failed: ${error}`, "warning");
+    throw error;
+  }
+}
+function createGitChangeHandler(rootDir, gitTracker, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect) {
+  let isIgnored = null;
+  let gitReindexInProgress = false;
+  let lastGitReindexTime = 0;
+  const GIT_REINDEX_COOLDOWN_MS = 5e3;
+  return async () => {
+    if (shouldSkipGitReindex(gitReindexInProgress, lastGitReindexTime, GIT_REINDEX_COOLDOWN_MS, reindexStateManager, log)) {
+      return;
+    }
+    gitReindexInProgress = true;
+    try {
+      const filteredFiles = await detectAndFilterGitChanges(
+        gitTracker,
+        rootDir,
+        () => isIgnored,
+        (f) => {
+          isIgnored = f;
+        },
+        log
+      );
+      if (!filteredFiles) return;
+      await executeGitReindex(filteredFiles, vectorDB, embeddings, reindexStateManager, checkAndReconnect, log);
+      lastGitReindexTime = Date.now();
+    } catch (error) {
+      log(`Git change handler failed: ${error}`, "warning");
+    } finally {
+      gitReindexInProgress = false;
+    }
+  };
+}
+async function setupGitDetection(rootDir, vectorDB, embeddings, log, reindexStateManager, fileWatcher, checkAndReconnect) {
+  const gitAvailable = await isGitAvailable();
+  const isRepo = await isGitRepo2(rootDir);
+  if (!gitAvailable) {
+    log("Git not available - git detection disabled");
+    return { gitTracker: null, gitPollInterval: null };
+  }
+  if (!isRepo) {
+    log("Not a git repository - git detection disabled");
+    return { gitTracker: null, gitPollInterval: null };
+  }
+  log("\u2713 Detected git repository");
+  const gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
+  try {
+    await handleGitStartup(rootDir, gitTracker, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect);
+  } catch (error) {
+    log(`Failed to check git state on startup: ${error}`, "warning");
+  }
+  if (fileWatcher) {
+    const gitChangeHandler = createGitChangeHandler(
+      rootDir,
+      gitTracker,
+      vectorDB,
+      embeddings,
+      log,
+      reindexStateManager,
+      checkAndReconnect
+    );
+    fileWatcher.watchGit(gitChangeHandler);
+    log("\u2713 Git detection enabled (event-driven via file watcher)");
+    return { gitTracker, gitPollInterval: null };
+  }
+  const pollIntervalSeconds = DEFAULT_GIT_POLL_INTERVAL_MS2 / 1e3;
+  log(`\u2713 Git detection enabled (polling fallback every ${pollIntervalSeconds}s)`);
+  const gitPollInterval = createGitPollInterval(rootDir, gitTracker, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect);
+  return { gitTracker, gitPollInterval };
+}
+async function filterGitChangedFiles(changedFiles, rootDir, ignoreFilter) {
+  const results = [];
+  for (const filepath of changedFiles) {
+    if (!isFileIgnored(filepath, rootDir, ignoreFilter)) {
+      results.push(filepath);
+      continue;
+    }
+    try {
+      await fs4.access(filepath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        results.push(filepath);
+      }
+    }
+  }
+  return results;
+}
+
+// src/mcp/cleanup.ts
+function setupCleanupHandlers(server, versionCheckInterval, gitPollInterval, fileWatcher, log) {
+  return async () => {
+    try {
+      log("Shutting down MCP server...");
+      await server.close();
+      clearInterval(versionCheckInterval);
+      if (gitPollInterval) clearInterval(gitPollInterval);
+      if (fileWatcher) await fileWatcher.stop();
+    } finally {
+      process.exit(0);
+    }
+  };
+}
+
+// src/mcp/server.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var require3 = createRequire2(import.meta.url);
+var packageJson2;
+try {
+  packageJson2 = require3(join2(__dirname2, "../package.json"));
+} catch {
+  packageJson2 = require3(join2(__dirname2, "../../package.json"));
+}
+async function initializeDatabase(rootDir, log) {
+  const embeddings = new WorkerEmbeddings();
+  log("Creating vector database...");
+  const vectorDB = await createVectorDB(rootDir);
+  if (!vectorDB) {
+    throw new Error("createVectorDB returned undefined or null");
+  }
+  if (typeof vectorDB.initialize !== "function") {
+    throw new Error(`Invalid vectorDB instance: ${vectorDB.constructor?.name || "unknown"}. Expected VectorDBInterface but got: ${JSON.stringify(Object.keys(vectorDB))}`);
+  }
+  log("Loading embedding model...");
+  await embeddings.initialize();
+  log("Loading vector database...");
+  await vectorDB.initialize();
+  log("Embeddings and vector DB ready");
+  return { embeddings, vectorDB };
+}
+async function handleAutoIndexing(vectorDB, rootDir, log) {
+  const hasIndex = await vectorDB.hasData();
+  if (!hasIndex) {
+    log("\u{1F4E6} No index found - running initial indexing...");
+    log("\u23F1\uFE0F  This may take 5-20 minutes depending on project size");
+    try {
+      const { indexCodebase: indexCodebase2 } = await import("@liendev/core");
+      await indexCodebase2({ rootDir, verbose: true });
+      log("\u2705 Initial indexing complete!");
+    } catch (error) {
+      log(`\u26A0\uFE0F  Initial indexing failed: ${error}`, "warning");
+      log("You can manually run: lien index", "warning");
+    }
+  }
+}
+async function setupFileWatching(watch, rootDir, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect) {
   const fileWatchingEnabled = watch !== void 0 ? watch : true;
   if (!fileWatchingEnabled) {
     return null;
@@ -10545,7 +10828,7 @@ async function setupFileWatching(watch, rootDir, vectorDB, embeddings, verbose,
   log("\u{1F440} Starting file watcher...");
   const fileWatcher = new FileWatcher(rootDir);
   try {
-    const handler = createFileChangeHandler(vectorDB, embeddings, verbose, log, reindexStateManager);
+    const handler = createFileChangeHandler(rootDir, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect);
     await fileWatcher.start(handler);
     log(`\u2713 File watching enabled (watching ${fileWatcher.getWatchedFiles().length} files)`);
     return fileWatcher;
@@ -10556,23 +10839,11 @@ async function setupFileWatching(watch, rootDir, vectorDB, embeddings, verbose,
 }
 function setupTransport(log) {
   const transport = new StdioServerTransport();
-  transport.onclose = () => {
-    log("Transport closed");
-  };
   transport.onerror = (error) => {
-    log(`Transport error: ${error}`);
+    log(`Transport error: ${error}`, "warning");
   };
   return transport;
 }
-function setupCleanupHandlers(versionCheckInterval, gitPollInterval, fileWatcher, log) {
-  return async () => {
-    log("Shutting down MCP server...");
-    clearInterval(versionCheckInterval);
-    if (gitPollInterval) clearInterval(gitPollInterval);
-    if (fileWatcher) await fileWatcher.stop();
-    process.exit(0);
-  };
-}
 function setupVersionChecking(vectorDB, log, reindexStateManager) {
   const checkAndReconnect = async () => {
     try {
@@ -10623,9 +10894,6 @@ function createMCPLog(server, verbose) {
 async function initializeComponents(rootDir, earlyLog) {
   try {
     const result = await initializeDatabase(rootDir, earlyLog);
-    if (!result.vectorDB || typeof result.vectorDB.initialize !== "function") {
-      throw new Error(`Invalid vectorDB instance: ${result.vectorDB?.constructor?.name || "undefined"}. Missing initialize method.`);
-    }
     return result;
   } catch (error) {
     console.error(`Failed to initialize: ${error}`);
@@ -10643,13 +10911,13 @@ function createMCPServer() {
   );
 }
 async function setupAndConnectServer(server, toolContext, log, versionCheckInterval, reindexStateManager, options) {
-  const { rootDir, verbose, watch } = options;
+  const { rootDir, watch } = options;
   const { vectorDB, embeddings } = toolContext;
   registerMCPHandlers(server, toolContext, log);
   await handleAutoIndexing(vectorDB, rootDir, log);
-  const fileWatcher = await setupFileWatching(watch, rootDir, vectorDB, embeddings, verbose, log, reindexStateManager);
-  const { gitPollInterval } = await setupGitDetection(rootDir, vectorDB, embeddings, verbose, log, reindexStateManager, fileWatcher);
-  const cleanup = setupCleanupHandlers(versionCheckInterval, gitPollInterval, fileWatcher, log);
+  const fileWatcher = await setupFileWatching(watch, rootDir, vectorDB, embeddings, log, reindexStateManager, toolContext.checkAndReconnect);
+  const { gitPollInterval } = await setupGitDetection(rootDir, vectorDB, embeddings, log, reindexStateManager, fileWatcher, toolContext.checkAndReconnect);
+  const cleanup = setupCleanupHandlers(server, versionCheckInterval, gitPollInterval, fileWatcher, log);
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   const transport = setupTransport(log);
@@ -10682,7 +10950,7 @@ async function startMCPServer(options) {
     getIndexMetadata,
     getReindexState: () => reindexStateManager.getState()
   };
-  await setupAndConnectServer(server, toolContext, log, versionCheckInterval, reindexStateManager, { rootDir, verbose, watch });
+  await setupAndConnectServer(server, toolContext, log, versionCheckInterval, reindexStateManager, { rootDir, watch });
 }
 
 // src/cli/serve.ts
@@ -10691,7 +10959,7 @@ async function serveCommand(options) {
   try {
     if (options.root) {
       try {
-        const stats = await fs3.stat(rootDir);
+        const stats = await fs5.stat(rootDir);
         if (!stats.isDirectory()) {
           console.error(chalk5.red(`Error: --root path is not a directory: ${rootDir}`));
           process.exit(1);
@@ -10732,7 +11000,7 @@ async function serveCommand(options) {
 
 // src/cli/complexity.ts
 import chalk6 from "chalk";
-import fs4 from "fs";
+import fs6 from "fs";
 import path5 from "path";
 import { VectorDB } from "@liendev/core";
 import { ComplexityAnalyzer as ComplexityAnalyzer2 } from "@liendev/core";
@@ -10755,7 +11023,7 @@ function validateFilesExist(files, rootDir) {
   if (!files || files.length === 0) return;
   const missingFiles = files.filter((file) => {
     const fullPath = path5.isAbsolute(file) ? file : path5.join(rootDir, file);
-    return !fs4.existsSync(fullPath);
+    return !fs6.existsSync(fullPath);
   });
   if (missingFiles.length > 0) {
     console.error(chalk6.red(`Error: File${missingFiles.length > 1 ? "s" : ""} not found:`));
@@ -10798,6 +11066,100 @@ async function complexityCommand(options) {
   }
 }
 
+// src/cli/config.ts
+import chalk7 from "chalk";
+import path6 from "path";
+import os2 from "os";
+import {
+  loadGlobalConfig,
+  mergeGlobalConfig
+} from "@liendev/core";
+var CONFIG_PATH = path6.join(os2.homedir(), ".lien", "config.json");
+var ALLOWED_KEYS = {
+  "backend": {
+    values: ["lancedb", "qdrant"],
+    description: "Vector database backend"
+  },
+  "qdrant.url": {
+    values: [],
+    description: "Qdrant server URL"
+  },
+  "qdrant.apiKey": {
+    values: [],
+    description: "Qdrant API key"
+  }
+};
+function getConfigValue(config, key) {
+  const parts = key.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current == null ? void 0 : String(current);
+}
+function buildPartialConfig(key, value) {
+  switch (key) {
+    case "backend":
+      return { backend: value };
+    case "qdrant.url":
+      return { qdrant: { url: value } };
+    case "qdrant.apiKey":
+      return { qdrant: { url: "", apiKey: value } };
+    default:
+      return {};
+  }
+}
+async function configSetCommand(key, value) {
+  const allowed = ALLOWED_KEYS[key];
+  if (!allowed) {
+    console.error(chalk7.red(`Unknown config key: "${key}"`));
+    console.log(chalk7.dim("Valid keys:"), Object.keys(ALLOWED_KEYS).join(", "));
+    process.exit(1);
+  }
+  if (allowed.values.length > 0 && !allowed.values.includes(value)) {
+    console.error(chalk7.red(`Invalid value "${value}" for ${key}`));
+    console.log(chalk7.dim("Valid values:"), allowed.values.join(", "));
+    process.exit(1);
+  }
+  if (key === "qdrant.apiKey") {
+    const existing = await loadGlobalConfig();
+    if (!existing.qdrant?.url) {
+      console.error(chalk7.red("Set qdrant.url first before setting qdrant.apiKey"));
+      process.exit(1);
+    }
+  }
+  const partial = buildPartialConfig(key, value);
+  await mergeGlobalConfig(partial);
+  console.log(chalk7.green(`Set ${key} = ${value}`));
+  console.log(chalk7.dim(`Config: ${CONFIG_PATH}`));
+}
+async function configGetCommand(key) {
+  if (!ALLOWED_KEYS[key]) {
+    console.error(chalk7.red(`Unknown config key: "${key}"`));
+    console.log(chalk7.dim("Valid keys:"), Object.keys(ALLOWED_KEYS).join(", "));
+    process.exit(1);
+  }
+  const config = await loadGlobalConfig();
+  const value = getConfigValue(config, key);
+  if (value === void 0) {
+    console.log(chalk7.dim(`${key}: (not set)`));
+  } else {
+    console.log(`${key}: ${value}`);
+  }
+}
+async function configListCommand() {
+  const config = await loadGlobalConfig();
+  console.log(chalk7.bold("Global Configuration"));
+  console.log(chalk7.dim(`File: ${CONFIG_PATH}
+`));
+  for (const [key, meta] of Object.entries(ALLOWED_KEYS)) {
+    const value = getConfigValue(config, key);
+    const display = value ?? chalk7.dim("(not set)");
+    console.log(`  ${chalk7.cyan(key)}: ${display}  ${chalk7.dim(`\u2014 ${meta.description}`)}`);
+  }
+}
+
 // src/cli/index.ts
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname3(__filename3);
@@ -10815,6 +11177,10 @@ program.command("index").description("Index the codebase for semantic search").o
 program.command("serve").description("Start the MCP server for Cursor integration").option("-p, --port <port>", "Port number (for future use)", "7133").option("--no-watch", "Disable file watching for this session").option("-w, --watch", "[DEPRECATED] File watching is now enabled by default").option("-r, --root <path>", "Root directory to serve (defaults to current directory)").action(serveCommand);
 program.command("status").description("Show indexing status and statistics").action(statusCommand);
 program.command("complexity").description("Analyze code complexity").option("--files <paths...>", "Specific files to analyze").option("--format <type>", "Output format: text, json, sarif", "text").option("--threshold <n>", "Override both complexity thresholds (cyclomatic & cognitive)").option("--cyclomatic-threshold <n>", "Override cyclomatic complexity threshold only").option("--cognitive-threshold <n>", "Override cognitive complexity threshold only").option("--fail-on <severity>", "Exit 1 if violations: error, warning").action(complexityCommand);
+var configCmd = program.command("config").description("Manage global configuration (~/.lien/config.json)");
+configCmd.command("set <key> <value>").description("Set a global config value").action(configSetCommand);
+configCmd.command("get <key>").description("Get a config value").action(configGetCommand);
+configCmd.command("list").description("Show all current config").action(configListCommand);
 
 // src/index.ts
 program.parse();