@liendev/lien 0.34.0 → 0.36.0

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -29,6 +32,70 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/utils/banner.ts
+import figlet from "figlet";
+import chalk from "chalk";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function wrapInBox(text, footer, padding = 1) {
+  const lines = text.split("\n").filter((line) => line.trim().length > 0);
+  const maxLength = Math.max(...lines.map((line) => line.length));
+  const horizontalBorder = "\u2500".repeat(maxLength + padding * 2);
+  const top = `\u250C${horizontalBorder}\u2510`;
+  const bottom = `\u2514${horizontalBorder}\u2518`;
+  const separator = `\u251C${horizontalBorder}\u2524`;
+  const paddedLines = lines.map((line) => {
+    const padRight = " ".repeat(maxLength - line.length + padding);
+    const padLeft = " ".repeat(padding);
+    return `\u2502${padLeft}${line}${padRight}\u2502`;
+  });
+  const totalPad = maxLength - footer.length;
+  const leftPad = Math.floor(totalPad / 2);
+  const rightPad = totalPad - leftPad;
+  const centeredFooter = " ".repeat(leftPad) + footer + " ".repeat(rightPad);
+  const paddedFooter = `\u2502${" ".repeat(padding)}${centeredFooter}${" ".repeat(padding)}\u2502`;
+  return [top, ...paddedLines, separator, paddedFooter, bottom].join("\n");
+}
+function showBanner() {
+  const banner = figlet.textSync("LIEN", {
+    font: "ANSI Shadow",
+    horizontalLayout: "fitted",
+    verticalLayout: "fitted"
+  });
+  const footer = `${PACKAGE_NAME} - v${VERSION}`;
+  const boxedBanner = wrapInBox(banner.trim(), footer);
+  console.error(chalk.cyan(boxedBanner));
+  console.error();
+}
+function showCompactBanner() {
+  const banner = figlet.textSync("LIEN", {
+    font: "ANSI Shadow",
+    horizontalLayout: "fitted",
+    verticalLayout: "fitted"
+  });
+  const footer = `${PACKAGE_NAME} - v${VERSION}`;
+  const boxedBanner = wrapInBox(banner.trim(), footer);
+  console.log(chalk.cyan(boxedBanner));
+  console.log();
+}
+var __filename, __dirname, require2, packageJson, PACKAGE_NAME, VERSION;
+var init_banner = __esm({
+  "src/utils/banner.ts"() {
+    "use strict";
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    require2 = createRequire(import.meta.url);
+    try {
+      packageJson = require2(join(__dirname, "../package.json"));
+    } catch {
+      packageJson = require2(join(__dirname, "../../package.json"));
+    }
+    PACKAGE_NAME = packageJson.name;
+    VERSION = packageJson.version;
+  }
+});
+
 // ../../node_modules/collect.js/dist/methods/symbol.iterator.js
 var require_symbol_iterator = __commonJS({
   "../../node_modules/collect.js/dist/methods/symbol.iterator.js"(exports, module) {
@@ -3595,115 +3662,65 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname3, join as join3 } from "path";
 
 // src/cli/init.ts
+init_banner();
 import fs from "fs/promises";
 import path from "path";
 import chalk2 from "chalk";
-
-// src/utils/banner.ts
-import figlet from "figlet";
-import chalk from "chalk";
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var require2 = createRequire(import.meta.url);
-var packageJson;
-try {
-  packageJson = require2(join(__dirname, "../package.json"));
-} catch {
-  packageJson = require2(join(__dirname, "../../package.json"));
-}
-var PACKAGE_NAME = packageJson.name;
-var VERSION = packageJson.version;
-function wrapInBox(text, footer, padding = 1) {
-  const lines = text.split("\n").filter((line) => line.trim().length > 0);
-  const maxLength = Math.max(...lines.map((line) => line.length));
-  const horizontalBorder = "\u2500".repeat(maxLength + padding * 2);
-  const top = `\u250C${horizontalBorder}\u2510`;
-  const bottom = `\u2514${horizontalBorder}\u2518`;
-  const separator = `\u251C${horizontalBorder}\u2524`;
-  const paddedLines = lines.map((line) => {
-    const padRight = " ".repeat(maxLength - line.length + padding);
-    const padLeft = " ".repeat(padding);
-    return `\u2502${padLeft}${line}${padRight}\u2502`;
-  });
-  const totalPad = maxLength - footer.length;
-  const leftPad = Math.floor(totalPad / 2);
-  const rightPad = totalPad - leftPad;
-  const centeredFooter = " ".repeat(leftPad) + footer + " ".repeat(rightPad);
-  const paddedFooter = `\u2502${" ".repeat(padding)}${centeredFooter}${" ".repeat(padding)}\u2502`;
-  return [top, ...paddedLines, separator, paddedFooter, bottom].join("\n");
-}
-function showBanner() {
-  const banner = figlet.textSync("LIEN", {
-    font: "ANSI Shadow",
-    horizontalLayout: "fitted",
-    verticalLayout: "fitted"
-  });
-  const footer = `${PACKAGE_NAME} - v${VERSION}`;
-  const boxedBanner = wrapInBox(banner.trim(), footer);
-  console.error(chalk.cyan(boxedBanner));
-  console.error();
-}
-function showCompactBanner() {
-  const banner = figlet.textSync("LIEN", {
-    font: "ANSI Shadow",
-    horizontalLayout: "fitted",
-    verticalLayout: "fitted"
-  });
-  const footer = `${PACKAGE_NAME} - v${VERSION}`;
-  const boxedBanner = wrapInBox(banner.trim(), footer);
-  console.log(chalk.cyan(boxedBanner));
-  console.log();
-}
-
-// src/cli/init.ts
+var MCP_CONFIG = {
+  command: "lien",
+  args: ["serve"]
+};
 async function initCommand(options = {}) {
   showCompactBanner();
-  console.log(chalk2.bold("\nLien Initialization\n"));
-  console.log(chalk2.green("\u2713 No per-project configuration needed!"));
-  console.log(chalk2.dim("\nLien now uses:"));
-  console.log(chalk2.dim("  \u2022 Auto-detected frameworks"));
-  console.log(chalk2.dim("  \u2022 Sensible defaults for all settings"));
-  console.log(chalk2.dim("  \u2022 Global config (optional) at ~/.lien/config.json"));
-  console.log(chalk2.bold("\nNext steps:"));
-  console.log(chalk2.dim("  1. Run"), chalk2.bold("lien index"), chalk2.dim("to index your codebase"));
-  console.log(chalk2.dim("  2. Run"), chalk2.bold("lien serve"), chalk2.dim("to start the MCP server"));
-  console.log(chalk2.bold("\nGlobal Configuration (optional):"));
-  console.log(chalk2.dim("  To use Qdrant backend, create ~/.lien/config.json:"));
-  console.log(chalk2.dim("  {"));
-  console.log(chalk2.dim('    "backend": "qdrant",'));
-  console.log(chalk2.dim('    "qdrant": {'));
-  console.log(chalk2.dim('      "url": "http://localhost:6333",'));
-  console.log(chalk2.dim('      "apiKey": "optional-api-key"'));
-  console.log(chalk2.dim("    }"));
-  console.log(chalk2.dim("  }"));
-  console.log(chalk2.dim("\n  Or use environment variables:"));
-  console.log(chalk2.dim("    LIEN_BACKEND=qdrant"));
-  console.log(chalk2.dim("    LIEN_QDRANT_URL=http://localhost:6333"));
-  console.log(chalk2.dim("    LIEN_QDRANT_API_KEY=your-key"));
   const rootDir = options.path || process.cwd();
-  const configPath = path.join(rootDir, ".lien.config.json");
+  const cursorDir = path.join(rootDir, ".cursor");
+  const mcpConfigPath = path.join(cursorDir, "mcp.json");
+  let existingConfig = null;
+  try {
+    const raw = await fs.readFile(mcpConfigPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      existingConfig = parsed;
+    }
+  } catch {
+  }
+  if (existingConfig?.mcpServers?.lien) {
+    console.log(chalk2.green("\n\u2713 Already configured \u2014 .cursor/mcp.json contains lien entry"));
+  } else if (existingConfig) {
+    const servers = existingConfig.mcpServers;
+    const safeServers = servers && typeof servers === "object" && !Array.isArray(servers) ? servers : {};
+    safeServers.lien = MCP_CONFIG;
+    existingConfig.mcpServers = safeServers;
+    await fs.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2) + "\n");
+    console.log(chalk2.green("\n\u2713 Added lien to existing .cursor/mcp.json"));
+  } else {
+    await fs.mkdir(cursorDir, { recursive: true });
+    const config = { mcpServers: { lien: MCP_CONFIG } };
+    await fs.writeFile(mcpConfigPath, JSON.stringify(config, null, 2) + "\n");
+    console.log(chalk2.green("\n\u2713 Created .cursor/mcp.json"));
+  }
+  console.log(chalk2.dim("  Restart Cursor to activate.\n"));
+  const legacyConfigPath = path.join(rootDir, ".lien.config.json");
   try {
-    await fs.access(configPath);
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  Note: .lien.config.json found but no longer used"));
+    await fs.access(legacyConfigPath);
+    console.log(chalk2.yellow("\u26A0\uFE0F  Note: .lien.config.json found but no longer used"));
     console.log(chalk2.dim("  You can safely delete it."));
   } catch {
   }
 }
 
 // src/cli/status.ts
+init_banner();
 import chalk3 from "chalk";
 import fs2 from "fs/promises";
 import path2 from "path";
 import os from "os";
-import crypto from "crypto";
 import {
   isGitRepo,
   getCurrentBranch,
   getCurrentCommit,
   readVersionFile,
+  extractRepoId,
   DEFAULT_CONCURRENCY,
   DEFAULT_EMBEDDING_BATCH_SIZE,
   DEFAULT_CHUNK_SIZE,
@@ -3712,12 +3729,14 @@ import {
 } from "@liendev/core";
 async function statusCommand() {
   const rootDir = process.cwd();
-  const projectName = path2.basename(rootDir);
-  const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
-  const indexPath = path2.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
+  const repoId = extractRepoId(rootDir);
+  const indexPath = path2.join(os.homedir(), ".lien", "indices", repoId);
   showCompactBanner();
   console.log(chalk3.bold("Status\n"));
-  console.log(chalk3.dim("Configuration:"), chalk3.green("\u2713 Using defaults (no per-project config needed)"));
+  console.log(
+    chalk3.dim("Configuration:"),
+    chalk3.green("\u2713 Using defaults (no per-project config needed)")
+  );
   try {
     const stats = await fs2.stat(indexPath);
     console.log(chalk3.dim("Index location:"), indexPath);
@@ -3725,7 +3744,7 @@ async function statusCommand() {
     try {
       const files = await fs2.readdir(indexPath, { recursive: true });
       console.log(chalk3.dim("Index files:"), files.length);
-    } catch (e) {
+    } catch {
     }
     console.log(chalk3.dim("Last modified:"), stats.mtime.toLocaleString());
     try {
@@ -3736,9 +3755,13 @@ async function statusCommand() {
       }
     } catch {
     }
-  } catch (error) {
+  } catch {
     console.log(chalk3.dim("Index status:"), chalk3.yellow("\u2717 Not indexed"));
-    console.log(chalk3.yellow("\nRun"), chalk3.bold("lien index"), chalk3.yellow("to index your codebase"));
+    console.log(
+      chalk3.yellow("\nRun"),
+      chalk3.bold("lien index"),
+      chalk3.yellow("to index your codebase")
+    );
   }
   console.log(chalk3.bold("\nFeatures:"));
   const isRepo = await isGitRepo(rootDir);
@@ -3775,8 +3798,9 @@ async function statusCommand() {
 }
 
 // src/cli/index-cmd.ts
-import chalk4 from "chalk";
-import ora from "ora";
+init_banner();
+import chalk5 from "chalk";
+import ora2 from "ora";
 import { indexCodebase } from "@liendev/core";
 
 // src/utils/loading-messages.ts
@@ -3855,17 +3879,28 @@ function getModelLoadingMessage() {
   return message;
 }
 
+// src/cli/utils.ts
+import ora from "ora";
+import chalk4 from "chalk";
+import { isLienError, getErrorMessage, getErrorStack } from "@liendev/core";
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+
 // src/cli/index-cmd.ts
 async function clearExistingIndex() {
   const { VectorDB: VectorDB2 } = await import("@liendev/core");
   const { ManifestManager: ManifestManager2 } = await import("@liendev/core");
-  console.log(chalk4.yellow("Clearing existing index and manifest..."));
+  console.log(chalk5.yellow("Clearing existing index and manifest..."));
   const vectorDB = new VectorDB2(process.cwd());
   await vectorDB.initialize();
   await vectorDB.clear();
   const manifest = new ManifestManager2(vectorDB.dbPath);
   await manifest.clear();
-  console.log(chalk4.green("\u2713 Index and manifest cleared\n"));
+  console.log(chalk5.green("\u2713 Index and manifest cleared\n"));
 }
 function createProgressTracker() {
   return {
@@ -3932,19 +3967,24 @@ function createProgressCallback(spinner, tracker) {
       if (progress.filesTotal && progress.filesProcessed !== void 0) {
         message = `${message} (${progress.filesProcessed}/${progress.filesTotal})`;
       }
-      spinner.succeed(chalk4.green(message));
+      spinner.succeed(chalk5.green(message));
     } else {
       updateSpinner(spinner, tracker);
     }
   };
 }
-function displayFinalResult(spinner, tracker, result) {
-  if (!tracker.completedViaProgress) {
-    if (result.filesIndexed === 0) {
-      spinner.succeed(chalk4.green("Index is up to date - no changes detected"));
-    } else {
-      spinner.succeed(chalk4.green(`Indexed ${result.filesIndexed} files, ${result.chunksCreated} chunks`));
-    }
+function displayFinalResult(spinner, tracker, result, durationMs) {
+  const timing = formatDuration(durationMs);
+  if (tracker.completedViaProgress) {
+    console.log(chalk5.dim(`  Completed in ${timing}`));
+  } else if (result.filesIndexed === 0) {
+    spinner.succeed(chalk5.green(`Index is up to date - no changes detected in ${timing}`));
+  } else {
+    spinner.succeed(
+      chalk5.green(
+        `Indexed ${result.filesIndexed} files, ${result.chunksCreated} chunks in ${timing}`
+      )
+    );
   }
 }
 async function indexCommand(options) {
@@ -3953,7 +3993,7 @@ async function indexCommand(options) {
     if (options.force) {
       await clearExistingIndex();
     }
-    const spinner = ora({
+    const spinner = ora2({
       text: "Starting indexing...",
       interval: 30
       // Faster refresh rate for smoother progress
@@ -3968,23 +4008,20 @@ async function indexCommand(options) {
     });
     stopMessageRotation(tracker);
     if (!result.success && result.error) {
-      spinner.fail(chalk4.red("Indexing failed"));
-      console.error(chalk4.red("\n" + result.error));
+      spinner.fail(chalk5.red("Indexing failed"));
+      console.error(chalk5.red("\n" + result.error));
       process.exit(1);
     }
-    displayFinalResult(spinner, tracker, result);
-    if (options.watch) {
-      console.log(chalk4.yellow("\n\u26A0\uFE0F  Watch mode not yet implemented"));
-    }
+    displayFinalResult(spinner, tracker, result, result.durationMs);
   } catch (error) {
-    console.error(chalk4.red("Error during indexing:"), error);
+    console.error(chalk5.red("Error during indexing:"), error);
     process.exit(1);
   }
 }
 
 // src/cli/serve.ts
-import chalk5 from "chalk";
-import fs3 from "fs/promises";
+import chalk6 from "chalk";
+import fs5 from "fs/promises";
 import path4 from "path";
 
 // src/mcp/server.ts
@@ -3992,26 +4029,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 {
-  LocalEmbeddings,
-  GitStateTracker,
-  indexMultipleFiles,
-  indexSingleFile,
-  ManifestManager,
-  isGitAvailable,
-  isGitRepo as isGitRepo2,
-  VERSION_CHECK_INTERVAL_MS,
-  DEFAULT_GIT_POLL_INTERVAL_MS as DEFAULT_GIT_POLL_INTERVAL_MS2,
-  createVectorDB,
-  computeContentHash,
-  normalizeToRelativePath
-} from "@liendev/core";
+import { dirname as dirname2, join as join2 } from "path";
+import { WorkerEmbeddings, VERSION_CHECK_INTERVAL_MS, 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 +4056,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 +4065,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 +4083,7 @@ var FileWatcher = class {
   getDefaultPatterns() {
     return {
       include: ["**/*"],
-      exclude: [
-        "**/node_modules/**",
-        "**/vendor/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.git/**"
-      ]
+      exclude: [...ALWAYS_IGNORE_PATTERNS]
     };
   }
   /**
@@ -4134,17 +4134,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);
       })
@@ -4152,7 +4152,7 @@ var FileWatcher = class {
   }
   /**
    * Starts watching files for changes.
-   * 
+   *
    * @param handler - Callback function called when files change
    */
   async start(handler) {
@@ -4168,43 +4168,61 @@ var FileWatcher = class {
   /**
    * Enable watching .git directory for git operations.
    * Call this after start() to enable event-driven git detection.
-   * 
+   *
    * @param onGitChange - Callback invoked when git operations detected
    */
   watchGit(onGitChange) {
     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);
     }
     this.gitChangeTimer = setTimeout(async () => {
       try {
         await this.gitChangeHandler?.();
-      } catch (error) {
+      } catch {
       }
       this.gitChangeTimer = null;
     }, this.GIT_DEBOUNCE_MS);
@@ -4213,13 +4231,12 @@ var FileWatcher = class {
    * Handles a file change event with smart batching.
    * Collects rapid changes across multiple files and processes them together.
    * Forces flush after MAX_BATCH_WAIT_MS even if changes keep arriving.
-   * 
+   *
    * If a batch is currently being processed by an async handler, waits for completion
    * 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) {
@@ -4310,7 +4327,7 @@ var FileWatcher = class {
       } else {
         this.handleBatchComplete();
       }
-    } catch (error) {
+    } catch {
       this.handleBatchComplete();
     }
   }
@@ -4358,7 +4375,7 @@ var FileWatcher = class {
         modified,
         deleted
       });
-    } catch (error) {
+    } catch {
     }
   }
   /**
@@ -4368,6 +4385,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 +4400,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);
@@ -4413,10 +4437,7 @@ var FileWatcher = class {
 };
 
 // src/mcp/server-config.ts
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
 // src/mcp/utils/zod-to-json-schema.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -4909,8 +4930,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 +5047,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() {
@@ -8481,25 +8502,23 @@ var SemanticSearchSchema = external_exports.object({
     "Number of results to return.\n\nDefault: 5\nIncrease to 10-15 for broad exploration."
   ),
   crossRepo: external_exports.boolean().default(false).describe(
-    "If true, search across all repos in the organization (requires Qdrant backend).\n\nDefault: false (single-repo search)\nWhen enabled, results are grouped by repository."
+    "If true, search across all repos in the organization (requires a cross-repo-capable backend, currently Qdrant).\n\nDefault: false (single-repo search)\nWhen enabled, results are grouped by repository."
   ),
-  repoIds: external_exports.array(external_exports.string()).optional().describe(
+  repoIds: external_exports.array(external_exports.string().max(255)).optional().describe(
     "Optional: Filter to specific repos when crossRepo=true.\n\nIf provided, only searches within the specified repositories.\nIf omitted and crossRepo=true, searches all repos in the organization."
   )
 });
 
 // src/mcp/schemas/similarity.schema.ts
 var FindSimilarSchema = external_exports.object({
-  code: external_exports.string().min(24, "Code snippet must be at least 24 characters").describe(
+  code: external_exports.string().min(24, "Code snippet must be at least 24 characters").max(5e4, "Code snippet too long (max 50000 characters)").describe(
     "Code snippet to find similar implementations for.\n\nProvide a representative code sample that demonstrates the pattern you want to find similar examples of in the codebase."
   ),
-  limit: external_exports.number().int().min(1, "Limit must be at least 1").max(20, "Limit cannot exceed 20").default(5).describe(
-    "Number of similar code blocks to return.\n\nDefault: 5"
-  ),
-  language: external_exports.string().min(1, "Language filter cannot be empty").optional().describe(
+  limit: external_exports.number().int().min(1, "Limit must be at least 1").max(20, "Limit cannot exceed 20").default(5).describe("Number of similar code blocks to return.\n\nDefault: 5"),
+  language: external_exports.string().min(1, "Language filter cannot be empty").max(50).optional().describe(
     "Filter by programming language.\n\nExamples: 'typescript', 'python', 'javascript', 'php'\n\nIf omitted, searches all languages."
   ),
-  pathHint: external_exports.string().min(1, "Path hint cannot be empty").optional().describe(
+  pathHint: external_exports.string().min(1, "Path hint cannot be empty").max(500).optional().describe(
     "Filter by file path substring.\n\nOnly returns results where the file path contains this string (case-insensitive).\n\nExamples: 'src/api', 'components', 'utils'"
   )
 });
@@ -8507,8 +8526,8 @@ var FindSimilarSchema = external_exports.object({
 // src/mcp/schemas/file.schema.ts
 var GetFilesContextSchema = external_exports.object({
   filepaths: external_exports.union([
-    external_exports.string().min(1, "Filepath cannot be empty"),
-    external_exports.array(external_exports.string().min(1, "Filepath cannot be empty")).min(1, "Array must contain at least one filepath").max(50, "Maximum 50 files per request")
+    external_exports.string().min(1, "Filepath cannot be empty").max(1e3),
+    external_exports.array(external_exports.string().min(1, "Filepath cannot be empty").max(1e3)).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."
   ),
@@ -8519,10 +8538,10 @@ var GetFilesContextSchema = external_exports.object({
 
 // src/mcp/schemas/symbols.schema.ts
 var ListFunctionsSchema = external_exports.object({
-  pattern: external_exports.string().optional().describe(
+  pattern: external_exports.string().max(200).optional().describe(
     "Regex pattern to match symbol names.\n\nExamples:\n  - '.*Controller.*' to find all Controllers\n  - 'handle.*' to find handlers\n  - '.*Service$' to find Services\n\nIf omitted, returns all symbols."
   ),
-  language: external_exports.string().optional().describe(
+  language: external_exports.string().max(50).optional().describe(
     "Filter by programming language.\n\nExamples: 'typescript', 'python', 'javascript', 'php'\n\nIf omitted, searches all languages."
   ),
   symbolType: external_exports.enum(["function", "method", "class", "interface"]).optional().describe("Filter by symbol type. If omitted, returns all types."),
@@ -8536,23 +8555,23 @@ var ListFunctionsSchema = external_exports.object({
 
 // src/mcp/schemas/dependents.schema.ts
 var GetDependentsSchema = external_exports.object({
-  filepath: external_exports.string().min(1, "Filepath cannot be empty").describe(
+  filepath: external_exports.string().min(1, "Filepath cannot be empty").max(1e3).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)."
   ),
-  symbol: external_exports.string().min(1, "Symbol cannot be an empty string").optional().describe(
+  symbol: external_exports.string().min(1, "Symbol cannot be an empty string").max(500).optional().describe(
     "Optional: specific exported symbol to find usages of.\n\nWhen provided, returns call sites instead of just importing files.\n\nExample: 'validateEmail' to find where validateEmail() is called.\n\nResponse includes 'usages' array showing which functions call this symbol."
   ),
   depth: external_exports.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"
   ),
   crossRepo: external_exports.boolean().default(false).describe(
-    "If true, find dependents across all repos in the organization (requires Qdrant backend).\n\nDefault: false (single-repo search)\nWhen enabled, results are grouped by repository."
+    "If true, find dependents across all repos in the organization (requires a cross-repo-capable backend, currently Qdrant).\n\nDefault: false (single-repo search)\nWhen enabled, results are grouped by repository."
   )
 });
 
 // src/mcp/schemas/complexity.schema.ts
 var GetComplexitySchema = external_exports.object({
-  files: external_exports.array(external_exports.string().min(1, "Filepath cannot be empty")).optional().describe(
+  files: external_exports.array(external_exports.string().min(1, "Filepath cannot be empty").max(1e3)).optional().describe(
     "Specific files to analyze. If omitted, analyzes entire codebase.\n\nExample: ['src/auth.ts', 'src/api/user.ts']"
   ),
   top: external_exports.number().int().min(1, "Top must be at least 1").max(50, "Top cannot exceed 50").default(10).describe(
@@ -8562,9 +8581,9 @@ var GetComplexitySchema = external_exports.object({
     "Only return functions above this complexity threshold.\n\nNote: Violations are first identified using the threshold from lien.config.json (default: 15). This parameter filters those violations to show only items above the specified value. Setting threshold below the config threshold will not show additional functions."
   ),
   crossRepo: external_exports.boolean().default(false).describe(
-    "If true, analyze complexity across all repos in the organization (requires Qdrant backend).\n\nDefault: false (single-repo analysis)\nWhen enabled, results are aggregated by repository."
+    "If true, analyze complexity across all repos in the organization (requires a cross-repo-capable backend, currently Qdrant).\n\nDefault: false (single-repo analysis)\nWhen enabled, results are aggregated by repository."
   ),
-  repoIds: external_exports.array(external_exports.string()).optional().describe(
+  repoIds: external_exports.array(external_exports.string().max(255)).optional().describe(
     "Optional: Filter to specific repos when crossRepo=true.\n\nIf provided, only analyzes the specified repositories.\nIf omitted and crossRepo=true, analyzes all repos in the organization."
   )
 });
@@ -8744,30 +8763,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 +8818,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
     }
   };
 }
@@ -8822,10 +8848,12 @@ function wrapToolHandler(schema, handler) {
 ${truncation.message}` : truncation.message;
       }
       return {
-        content: [{
-          type: "text",
-          text: JSON.stringify(result, null, 2)
-        }]
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
       };
     } catch (error) {
       return formatErrorResponse(error);
@@ -8836,42 +8864,57 @@ function formatErrorResponse(error) {
   if (error instanceof ZodError) {
     return {
       isError: true,
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          error: "Invalid parameters",
-          code: LienErrorCode.INVALID_INPUT,
-          details: error.errors.map((e) => ({
-            field: e.path.join("."),
-            message: e.message
-          }))
-        }, null, 2)
-      }]
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              error: "Invalid parameters",
+              code: LienErrorCode.INVALID_INPUT,
+              details: error.errors.map((e) => ({
+                field: e.path.join("."),
+                message: e.message
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
     };
   }
   if (error instanceof LienError) {
     return {
       isError: true,
-      content: [{
-        type: "text",
-        text: JSON.stringify(error.toJSON(), null, 2)
-      }]
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(error.toJSON(), null, 2)
+        }
+      ]
     };
   }
   console.error("Unexpected error in tool handler:", error);
   return {
     isError: true,
-    content: [{
-      type: "text",
-      text: JSON.stringify({
-        error: error instanceof Error ? error.message : "Unknown error",
-        code: LienErrorCode.INTERNAL_ERROR
-      }, null, 2)
-    }]
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            error: error instanceof Error ? error.message : "Unknown error",
+            code: LienErrorCode.INTERNAL_ERROR
+          },
+          null,
+          2
+        )
+      }
+    ]
   };
 }
 
 // src/mcp/utils/metadata-shaper.ts
+import { normalizeToRelativePath } from "@liendev/core";
 var FIELD_ALLOWLISTS = {
   semantic_search: /* @__PURE__ */ new Set([
     "language",
@@ -8923,7 +8966,12 @@ var FIELD_ALLOWLISTS = {
 function deduplicateResults(results) {
   const seen = /* @__PURE__ */ new Set();
   return results.filter((r) => {
-    const key = JSON.stringify([r.metadata.repoId ?? "", r.metadata.file, r.metadata.startLine, r.metadata.endLine]);
+    const key = JSON.stringify([
+      r.metadata.repoId ?? "",
+      r.metadata.file ? normalizeToRelativePath(r.metadata.file) : "",
+      r.metadata.startLine,
+      r.metadata.endLine
+    ]);
     if (seen.has(key)) return false;
     seen.add(key);
     return true;
@@ -8980,7 +9028,6 @@ function shapeResults(results, tool) {
 }
 
 // src/mcp/handlers/semantic-search.ts
-import { QdrantDB } from "@liendev/core";
 function groupResultsByRepo(results) {
   const grouped = {};
   for (const result of results) {
@@ -8994,13 +9041,18 @@ function groupResultsByRepo(results) {
 }
 async function executeSearch(vectorDB, queryEmbedding, params, log) {
   const { query, limit, crossRepo, repoIds } = params;
-  if (crossRepo && vectorDB instanceof QdrantDB) {
+  if (crossRepo && vectorDB.supportsCrossRepo) {
     const results2 = await vectorDB.searchCrossRepo(queryEmbedding, limit, { repoIds });
-    log(`Found ${results2.length} results across ${Object.keys(groupResultsByRepo(results2)).length} repos`);
+    log(
+      `Found ${results2.length} results across ${Object.keys(groupResultsByRepo(results2)).length} repos`
+    );
     return { results: results2, crossRepoFallback: false };
   }
   if (crossRepo) {
-    log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo search.", "warning");
+    log(
+      "Warning: crossRepo=true requires a cross-repo-capable backend. Falling back to single-repo search.",
+      "warning"
+    );
   }
   const results = await vectorDB.search(queryEmbedding, limit, query);
   log(`Found ${results.length} results`);
@@ -9009,7 +9061,9 @@ async function executeSearch(vectorDB, queryEmbedding, params, log) {
 function processResults(rawResults, crossRepoFallback, log) {
   const notes = [];
   if (crossRepoFallback) {
-    notes.push("Cross-repo search requires Qdrant backend. Fell back to single-repo search.");
+    notes.push(
+      "Cross-repo search requires a cross-repo-capable backend. Fell back to single-repo search."
+    );
   }
   const results = deduplicateResults(rawResults);
   if (results.length > 0 && results.every((r) => r.relevance === "not_relevant")) {
@@ -9021,33 +9075,32 @@ function processResults(rawResults, crossRepoFallback, log) {
 }
 async function handleSemanticSearch(args, ctx) {
   const { vectorDB, embeddings, log, checkAndReconnect, getIndexMetadata } = ctx;
-  return await wrapToolHandler(
-    SemanticSearchSchema,
-    async (validatedArgs) => {
-      const { crossRepo, repoIds, query, limit } = validatedArgs;
-      log(`Searching for: "${query}"${crossRepo ? " (cross-repo)" : ""}`);
-      await checkAndReconnect();
-      const queryEmbedding = await embeddings.embed(query);
-      const { results: rawResults, crossRepoFallback } = await executeSearch(
-        vectorDB,
-        queryEmbedding,
-        { query, limit: limit ?? 5, crossRepo, repoIds },
-        log
+  return await wrapToolHandler(SemanticSearchSchema, async (validatedArgs) => {
+    const { crossRepo, repoIds, query, limit } = validatedArgs;
+    log(`Searching for: "${query}"${crossRepo ? " (cross-repo)" : ""}`);
+    await checkAndReconnect();
+    const queryEmbedding = await embeddings.embed(query);
+    const { results: rawResults, crossRepoFallback } = await executeSearch(
+      vectorDB,
+      queryEmbedding,
+      { query, limit: limit ?? 5, crossRepo, repoIds },
+      log
+    );
+    const { results, notes } = processResults(rawResults, crossRepoFallback, log);
+    log(`Returning ${results.length} results`);
+    const shaped = shapeResults(results, "semantic_search");
+    if (shaped.length === 0) {
+      notes.push(
+        '0 results. Try rephrasing as a full question (e.g. "How does X work?"), or use grep for exact string matches. If the codebase was recently updated, run "lien reindex".'
       );
-      const { results, notes } = processResults(rawResults, crossRepoFallback, log);
-      log(`Returning ${results.length} results`);
-      const shaped = shapeResults(results, "semantic_search");
-      if (shaped.length === 0) {
-        notes.push('0 results. Try rephrasing as a full question (e.g. "How does X work?"), or use grep for exact string matches. If the codebase was recently updated, run "lien reindex".');
-      }
-      return {
-        indexInfo: getIndexMetadata(),
-        results: shaped,
-        ...crossRepo && vectorDB instanceof QdrantDB && { groupedByRepo: groupResultsByRepo(shaped) },
-        ...notes.length > 0 && { note: notes.join(" ") }
-      };
     }
-  )(args);
+    return {
+      indexInfo: getIndexMetadata(),
+      results: shaped,
+      ...crossRepo && vectorDB.supportsCrossRepo && { groupedByRepo: groupResultsByRepo(shaped) },
+      ...notes.length > 0 && { note: notes.join(" ") }
+    };
+  })(args);
 }
 
 // src/mcp/handlers/find-similar.ts
@@ -9066,139 +9119,52 @@ function pruneIrrelevantResults(results) {
 }
 async function handleFindSimilar(args, ctx) {
   const { vectorDB, embeddings, log, checkAndReconnect, getIndexMetadata } = ctx;
-  return await wrapToolHandler(
-    FindSimilarSchema,
-    async (validatedArgs) => {
-      log(`Finding similar code...`);
-      await checkAndReconnect();
-      const codeEmbedding = await embeddings.embed(validatedArgs.code);
-      const limit = validatedArgs.limit ?? 5;
-      const extraLimit = limit + 10;
-      let results = await vectorDB.search(codeEmbedding, extraLimit, validatedArgs.code);
-      results = deduplicateResults(results);
-      const inputCode = validatedArgs.code.trim();
-      results = results.filter((r) => {
-        if (r.score >= 0.1) return true;
-        return r.content.trim() !== inputCode;
-      });
-      const filtersApplied = { prunedLowRelevance: 0 };
-      if (validatedArgs.language) {
-        filtersApplied.language = validatedArgs.language;
-        results = applyLanguageFilter(results, validatedArgs.language);
-      }
-      if (validatedArgs.pathHint) {
-        filtersApplied.pathHint = validatedArgs.pathHint;
-        results = applyPathHintFilter(results, validatedArgs.pathHint);
-      }
-      const { filtered, prunedCount } = pruneIrrelevantResults(results);
-      filtersApplied.prunedLowRelevance = prunedCount;
-      const finalResults = filtered.slice(0, limit);
-      log(`Found ${finalResults.length} similar chunks`);
-      const hasFilters = filtersApplied.language || filtersApplied.pathHint || filtersApplied.prunedLowRelevance > 0;
-      return {
-        indexInfo: getIndexMetadata(),
-        results: shapeResults(finalResults, "find_similar"),
-        ...hasFilters && { filtersApplied },
-        ...finalResults.length === 0 && { note: "0 results. Ensure the code snippet is at least 24 characters and representative of the pattern. Try grep for exact string matches." }
-      };
-    }
-  )(args);
-}
-
-// 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)$/, "");
-  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;
-  }
-  if (matchesPHPNamespace(normalizedImport, normalizedTarget)) {
-    return true;
-  }
-  if (matchesPythonModule(normalizedImport, normalizedTarget)) {
-    return true;
-  }
-  return false;
-}
-function matchesDirectPythonModule(moduleAsPath, targetWithoutPy) {
-  return targetWithoutPy === moduleAsPath || targetWithoutPy === moduleAsPath + "/__init__" || targetWithoutPy.replace(/\/__init__$/, "") === moduleAsPath;
-}
-function matchesParentPythonPackage(moduleAsPath, targetWithoutPy) {
-  return targetWithoutPy.startsWith(moduleAsPath + "/");
-}
-function matchesSuffixPythonModule(moduleAsPath, targetWithoutPy) {
-  return targetWithoutPy.endsWith("/" + moduleAsPath) || targetWithoutPy.endsWith("/" + moduleAsPath + "/__init__");
-}
-function matchesWithSourcePrefix(moduleAsPath, targetWithoutPy) {
-  const moduleIndex = targetWithoutPy.indexOf(moduleAsPath);
-  if (moduleIndex < 0) return false;
-  const prefix = targetWithoutPy.substring(0, moduleIndex);
-  const prefixSlashes = (prefix.match(/\//g) || []).length;
-  return prefixSlashes <= 1 && (prefix === "" || prefix.endsWith("/"));
-}
-function matchesPythonModule(importPath, targetPath) {
-  if (!importPath.includes(".")) {
-    return false;
-  }
-  const moduleAsPath = importPath.replace(/\./g, "/");
-  const targetWithoutPy = targetPath.replace(/\.py$/, "");
-  return matchesDirectPythonModule(moduleAsPath, targetWithoutPy) || matchesParentPythonPackage(moduleAsPath, targetWithoutPy) || matchesSuffixPythonModule(moduleAsPath, targetWithoutPy) || matchesWithSourcePrefix(moduleAsPath, targetWithoutPy);
-}
-function matchesPHPNamespace(importPath, targetPath) {
-  const importComponents = importPath.split("/").filter(Boolean);
-  const targetComponents = targetPath.split("/").filter(Boolean);
-  if (importComponents.length === 0 || targetComponents.length === 0) {
-    return false;
-  }
-  let matched = 0;
-  for (let i = 1; i <= importComponents.length && i <= targetComponents.length; i++) {
-    const impComp = importComponents[importComponents.length - i].toLowerCase();
-    const targetComp = targetComponents[targetComponents.length - i].toLowerCase();
-    if (impComp === targetComp) {
-      matched++;
-    } else {
-      break;
-    }
-  }
-  return matched === importComponents.length;
-}
-function getCanonicalPath(filepath, workspaceRoot) {
-  let canonical = filepath.replace(/\\/g, "/");
-  if (canonical.startsWith(workspaceRoot + "/")) {
-    canonical = canonical.substring(workspaceRoot.length + 1);
-  }
-  return canonical;
-}
-function isTestFile(filepath) {
-  return /\.(test|spec)\.[^/]+$/.test(filepath) || /(^|[/\\])(test|tests|__tests__)[/\\]/.test(filepath);
+  return await wrapToolHandler(FindSimilarSchema, async (validatedArgs) => {
+    log(`Finding similar code...`);
+    await checkAndReconnect();
+    const codeEmbedding = await embeddings.embed(validatedArgs.code);
+    const limit = validatedArgs.limit ?? 5;
+    const extraLimit = limit + 10;
+    let results = await vectorDB.search(codeEmbedding, extraLimit, validatedArgs.code);
+    results = deduplicateResults(results);
+    const inputCode = validatedArgs.code.trim();
+    results = results.filter((r) => {
+      if (r.score >= 0.1) return true;
+      return r.content.trim() !== inputCode;
+    });
+    const filtersApplied = { prunedLowRelevance: 0 };
+    if (validatedArgs.language) {
+      filtersApplied.language = validatedArgs.language;
+      results = applyLanguageFilter(results, validatedArgs.language);
+    }
+    if (validatedArgs.pathHint) {
+      filtersApplied.pathHint = validatedArgs.pathHint;
+      results = applyPathHintFilter(results, validatedArgs.pathHint);
+    }
+    const { filtered, prunedCount } = pruneIrrelevantResults(results);
+    filtersApplied.prunedLowRelevance = prunedCount;
+    const finalResults = filtered.slice(0, limit);
+    log(`Found ${finalResults.length} similar chunks`);
+    const hasFilters = filtersApplied.language || filtersApplied.pathHint || filtersApplied.prunedLowRelevance > 0;
+    return {
+      indexInfo: getIndexMetadata(),
+      results: shapeResults(finalResults, "find_similar"),
+      ...hasFilters && { filtersApplied },
+      ...finalResults.length === 0 && {
+        note: "0 results. Ensure the code snippet is at least 24 characters and representative of the pattern. Try grep for exact string matches."
+      }
+    };
+  })(args);
 }
 
 // src/mcp/handlers/get-files-context.ts
-import { MAX_CHUNKS_PER_FILE } from "@liendev/core";
+import {
+  normalizePath,
+  matchesFile,
+  getCanonicalPath,
+  isTestFile,
+  MAX_CHUNKS_PER_FILE
+} from "@liendev/core";
 var SCAN_LIMIT = 1e4;
 async function searchFileChunks(filepaths, ctx) {
   const { vectorDB, workspaceRoot } = ctx;
@@ -9228,10 +9194,7 @@ async function findRelatedChunks(filepaths, fileChunksMap, ctx) {
       (embedding, i) => vectorDB.search(embedding, 5, filesWithChunks[i].chunks[0].content)
     )
   );
-  const relatedChunksMap = Array.from(
-    { length: filepaths.length },
-    () => []
-  );
+  const relatedChunksMap = Array.from({ length: filepaths.length }, () => []);
   filesWithChunks.forEach(({ filepath, index }, i) => {
     const related = relatedSearches[i];
     const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
@@ -9246,10 +9209,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 };
@@ -9281,10 +9244,7 @@ function deduplicateChunks(fileChunks, relatedChunks) {
 function buildFilesData(filepaths, fileChunksMap, relatedChunksMap, testAssociationsMap) {
   const filesData = {};
   filepaths.forEach((filepath, i) => {
-    const dedupedChunks = deduplicateChunks(
-      fileChunksMap[i],
-      relatedChunksMap[i] || []
-    );
+    const dedupedChunks = deduplicateChunks(fileChunksMap[i], relatedChunksMap[i] || []);
     filesData[filepath] = {
       chunks: dedupedChunks,
       testAssociations: testAssociationsMap[i]
@@ -9321,61 +9281,48 @@ function buildMultiFileResponse(filesData, indexInfo, note) {
 }
 async function handleGetFilesContext(args, ctx) {
   const { vectorDB, embeddings, log, checkAndReconnect, getIndexMetadata } = ctx;
-  return await wrapToolHandler(
-    GetFilesContextSchema,
-    async (validatedArgs) => {
-      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 workspaceRoot = process.cwd().replace(/\\/g, "/");
-      const handlerCtx = {
-        vectorDB,
-        embeddings,
-        log,
-        workspaceRoot
-      };
-      const fileChunksMap = await searchFileChunks(filepaths, handlerCtx);
-      let relatedChunksMap = [];
-      if (validatedArgs.includeRelated !== false) {
-        relatedChunksMap = await findRelatedChunks(
-          filepaths,
-          fileChunksMap,
-          handlerCtx
-        );
-      }
-      const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
-      const hitScanLimit = allChunks.length === SCAN_LIMIT;
-      if (hitScanLimit) {
-        log(
-          `Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`,
-          "warning"
-        );
-      }
-      const testAssociationsMap = findTestAssociations(
-        filepaths,
-        allChunks,
-        handlerCtx
-      );
-      const filesData = buildFilesData(
-        filepaths,
-        fileChunksMap,
-        relatedChunksMap,
-        testAssociationsMap
-      );
-      const totalChunks = Object.values(filesData).reduce(
-        (sum, f) => sum + f.chunks.length,
-        0
+  return await wrapToolHandler(GetFilesContextSchema, async (validatedArgs) => {
+    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 workspaceRoot = process.cwd().replace(/\\/g, "/");
+    const handlerCtx = {
+      vectorDB,
+      embeddings,
+      log,
+      workspaceRoot
+    };
+    const fileChunksMap = await searchFileChunks(filepaths, handlerCtx);
+    let relatedChunksMap = [];
+    if (validatedArgs.includeRelated !== false) {
+      relatedChunksMap = await findRelatedChunks(filepaths, fileChunksMap, handlerCtx);
+    }
+    const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
+    const hitScanLimit = allChunks.length === SCAN_LIMIT;
+    if (hitScanLimit) {
+      log(
+        `Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`,
+        "warning"
       );
-      log(`Found ${totalChunks} total chunks`);
-      const note = buildScanLimitNote(hitScanLimit);
-      const indexInfo = getIndexMetadata();
-      return isSingleFile ? buildSingleFileResponse(filepaths[0], filesData, indexInfo, note) : buildMultiFileResponse(filesData, indexInfo, note);
     }
-  )(args);
+    const testAssociationsMap = findTestAssociations(filepaths, allChunks, handlerCtx);
+    const filesData = buildFilesData(
+      filepaths,
+      fileChunksMap,
+      relatedChunksMap,
+      testAssociationsMap
+    );
+    const totalChunks = Object.values(filesData).reduce((sum, f) => sum + f.chunks.length, 0);
+    log(`Found ${totalChunks} total chunks`);
+    const note = buildScanLimitNote(hitScanLimit);
+    const indexInfo = getIndexMetadata();
+    return isSingleFile ? buildSingleFileResponse(filepaths[0], filesData, indexInfo, note) : buildMultiFileResponse(filesData, indexInfo, note);
+  })(args);
 }
 
 // src/mcp/handlers/list-functions.ts
+import { safeRegex } from "@liendev/core";
 async function performContentScan(vectorDB, args, fetchLimit, log) {
   log("Falling back to content scan...");
   let results = await vectorDB.scanWithFilter({
@@ -9384,11 +9331,15 @@ async function performContentScan(vectorDB, args, fetchLimit, log) {
     limit: fetchLimit
   });
   if (args.pattern) {
-    const regex = new RegExp(args.pattern, "i");
-    results = results.filter((r) => {
-      const symbolName = r.metadata?.symbolName;
-      return symbolName && regex.test(symbolName);
-    });
+    const regex = safeRegex(args.pattern);
+    if (regex) {
+      results = results.filter((r) => {
+        const symbolName = r.metadata?.symbolName;
+        return symbolName && regex.test(symbolName);
+      });
+    } else {
+      results = results.filter((r) => !!r.metadata?.symbolName);
+    }
   }
   return {
     results,
@@ -9425,44 +9376,51 @@ function paginateResults(results, offset, limit) {
 }
 async function handleListFunctions(args, ctx) {
   const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
-  return await wrapToolHandler(
-    ListFunctionsSchema,
-    async (validatedArgs) => {
-      log("Listing functions with symbol metadata...");
-      await checkAndReconnect();
-      const limit = validatedArgs.limit ?? 50;
-      const offset = validatedArgs.offset ?? 0;
-      const fetchLimit = limit + offset + 1;
-      const queryResult = await queryWithFallback(vectorDB, validatedArgs, fetchLimit, log);
-      const { paginatedResults, hasMore, nextOffset } = paginateResults(queryResult.results, offset, limit);
-      log(`Found ${paginatedResults.length} matches using ${queryResult.method} method`);
-      const notes = [];
-      if (queryResult.results.length === 0) {
-        notes.push('0 results. Try a broader regex pattern (e.g. ".*") or omit the symbolType filter. Use semantic_search for behavior-based queries.');
-      } else if (paginatedResults.length === 0 && offset > 0) {
-        notes.push("No results for this page. The offset is beyond the available results; try reducing or resetting the offset to 0.");
-      }
-      if (queryResult.method === "content") {
-        notes.push('Using content search. Run "lien reindex" to enable faster symbol-based queries.');
-      }
-      return {
-        indexInfo: getIndexMetadata(),
-        method: queryResult.method,
-        hasMore,
-        ...nextOffset !== void 0 ? { nextOffset } : {},
-        results: shapeResults(paginatedResults, "list_functions"),
-        ...notes.length > 0 && { note: notes.join(" ") }
-      };
+  return await wrapToolHandler(ListFunctionsSchema, async (validatedArgs) => {
+    log("Listing functions with symbol metadata...");
+    await checkAndReconnect();
+    const limit = validatedArgs.limit ?? 50;
+    const offset = validatedArgs.offset ?? 0;
+    const fetchLimit = limit + offset + 1;
+    const queryResult = await queryWithFallback(vectorDB, validatedArgs, fetchLimit, log);
+    const { paginatedResults, hasMore, nextOffset } = paginateResults(
+      queryResult.results,
+      offset,
+      limit
+    );
+    log(`Found ${paginatedResults.length} matches using ${queryResult.method} method`);
+    const notes = [];
+    if (queryResult.results.length === 0) {
+      notes.push(
+        '0 results. Try a broader regex pattern (e.g. ".*") or omit the symbolType filter. Use semantic_search for behavior-based queries.'
+      );
+    } else if (paginatedResults.length === 0 && offset > 0) {
+      notes.push(
+        "No results for this page. The offset is beyond the available results; try reducing or resetting the offset to 0."
+      );
     }
-  )(args);
+    if (queryResult.method === "content") {
+      notes.push('Using content search. Run "lien reindex" to enable faster symbol-based queries.');
+    }
+    return {
+      indexInfo: getIndexMetadata(),
+      method: queryResult.method,
+      hasMore,
+      ...nextOffset !== void 0 ? { nextOffset } : {},
+      results: shapeResults(paginatedResults, "list_functions"),
+      ...notes.length > 0 && { note: notes.join(" ") }
+    };
+  })(args);
 }
 
-// src/mcp/handlers/get-dependents.ts
-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,
+  normalizePath as normalizePath2,
+  matchesFile as matchesFile2,
+  getCanonicalPath as getCanonicalPath2,
+  isTestFile as isTestFile2
+} from "@liendev/core";
 var COMPLEXITY_THRESHOLDS = {
   HIGH_COMPLEXITY_DEPENDENT: 10,
   // Individual file is complex
@@ -9479,81 +9437,283 @@ var COMPLEXITY_THRESHOLDS = {
   MEDIUM_MAX: 15
   // Occasional branching
 };
-async function scanChunks(vectorDB, crossRepo, log) {
-  let allChunks;
-  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");
+var scanCache = null;
+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 (matchesFile2(normalizePathCached(importPath), normalizedTarget)) {
+      for (const sym of syms) symbols.add(sym);
     }
-    allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT2 });
   }
-  const hitLimit = allChunks.length === SCAN_LIMIT2;
-  if (hitLimit) {
-    log(`Scanned ${SCAN_LIMIT2} chunks (limit reached). Results may be incomplete.`, "warning");
+}
+function collectRawImportSentinel(chunk, normalizedTarget, normalizePathCached, symbols) {
+  const imports = chunk.metadata.imports || [];
+  for (const imp of imports) {
+    if (matchesFile2(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 (matchesFile2(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) => matchesFile2(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, seenRanges) {
+  const canonical = normalizePathCached(chunk.metadata.file);
+  if (!fileMap.has(canonical)) {
+    fileMap.set(canonical, []);
+    seenRanges.set(canonical, /* @__PURE__ */ new Set());
+  }
+  const rangeKey = `${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+  const seen = seenRanges.get(canonical);
+  if (seen.has(rangeKey)) return;
+  seen.add(rangeKey);
+  fileMap.get(canonical).push(chunk);
+}
+async function scanChunksPaginated(vectorDB, crossRepo, log, normalizePathCached) {
+  const importIndex = /* @__PURE__ */ new Map();
+  const allChunksByFile = /* @__PURE__ */ new Map();
+  const seenRanges = /* @__PURE__ */ new Map();
+  let totalChunks = 0;
+  if (crossRepo && vectorDB.supportsCrossRepo) {
+    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, seenRanges);
+    }
+    return { importIndex, allChunksByFile, totalChunks, hitLimit };
+  }
+  if (crossRepo) {
+    log(
+      "Warning: crossRepo=true requires a cross-repo-capable 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, seenRanges);
+    }
   }
-  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, normalizePath2(path7, workspaceRoot));
     }
-    return cache.get(path6);
+    return cache.get(path7);
   };
 }
 function groupChunksByFile(chunks) {
   const workspaceRoot = process.cwd().replace(/\\/g, "/");
   const chunksByFile = /* @__PURE__ */ new Map();
   for (const chunk of chunks) {
-    const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+    const canonical = getCanonicalPath2(chunk.metadata.file, workspaceRoot);
     const existing = chunksByFile.get(canonical) || [];
     existing.push(chunk);
     chunksByFile.set(canonical, existing);
   }
   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,
-    isTestFile: isTestFile(fp)
+    isTestFile: isTestFile2(fp)
   }));
   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");
   }
 }
-async function findDependents(vectorDB, filepath, crossRepo, log, symbol) {
-  const { allChunks, hitLimit } = await scanChunks(vectorDB, crossRepo, log);
-  log(`Scanning ${allChunks.length} chunks for imports...`);
+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 getOrScanChunks(vectorDB, crossRepo, log, normalizePathCached, indexVersion) {
+  if (indexVersion !== void 0 && scanCache !== null && scanCache.indexVersion === indexVersion && scanCache.crossRepo === crossRepo) {
+    log(`Using cached import index (${scanCache.totalChunks} chunks, version ${indexVersion})`);
+    return scanCache;
+  }
+  const scanResult = await scanChunksPaginated(vectorDB, crossRepo, log, normalizePathCached);
+  if (indexVersion !== void 0) {
+    scanCache = { indexVersion, crossRepo, ...scanResult };
+  }
+  log(`Scanned ${scanResult.totalChunks} chunks for imports...`);
+  return scanResult;
+}
+function resolveTransitiveDependents(allChunksByFile, normalizedTarget, normalizePathCached, importIndex, chunksByFile, log) {
+  const reExporters = buildReExportGraph(allChunksByFile, normalizedTarget, normalizePathCached);
+  if (reExporters.length > 0) {
+    mergeTransitiveDependents(
+      reExporters,
+      importIndex,
+      normalizedTarget,
+      normalizePathCached,
+      allChunksByFile,
+      chunksByFile,
+      log
+    );
+  }
+  return reExporters;
+}
+async function findDependents(vectorDB, filepath, crossRepo, log, symbol, indexVersion) {
   const normalizePathCached = createPathNormalizer();
   const normalizedTarget = normalizePathCached(filepath);
-  const importIndex = buildImportIndex(allChunks, normalizePathCached);
+  const { importIndex, allChunksByFile, hitLimit } = await getOrScanChunks(
+    vectorDB,
+    crossRepo,
+    log,
+    normalizePathCached,
+    indexVersion
+  );
   const dependentChunks = findDependentChunks(importIndex, normalizedTarget);
   const chunksByFile = groupChunksByFile(dependentChunks);
+  const reExporters = resolveTransitiveDependents(
+    allChunksByFile,
+    normalizedTarget,
+    normalizePathCached,
+    importIndex,
+    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 +9721,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 +9734,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();
@@ -9612,7 +9750,7 @@ function findDependentChunks(importIndex, normalizedTarget) {
     }
   }
   for (const [normalizedImport, chunks] of importIndex.entries()) {
-    if (normalizedImport !== normalizedTarget && matchesFile(normalizedImport, normalizedTarget)) {
+    if (normalizedImport !== normalizedTarget && matchesFile2(normalizedImport, normalizedTarget)) {
       for (const chunk of chunks) {
         addChunk(chunk);
       }
@@ -9651,7 +9789,11 @@ function calculateOverallComplexityMetrics(fileComplexities) {
   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 }));
+  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
+  }));
   const complexityRiskBoost = calculateComplexityRiskBoost(totalAvg, globalMax);
   return {
     averageComplexity: Math.round(totalAvg * 10) / 10,
@@ -9713,37 +9855,24 @@ 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);
     dependents.push({
       filepath,
-      isTestFile: isTestFile(filepath),
+      isTestFile: isTestFile2(filepath),
       usages: usages.length > 0 ? usages : void 0
     });
     totalUsageCount += usages.length;
   }
   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) {
@@ -9790,12 +9919,14 @@ function extractSnippet(lines, callLine, startLine, symbolName) {
 
 // src/mcp/handlers/get-dependents.ts
 function checkCrossRepoFallback(crossRepo, vectorDB) {
-  return Boolean(crossRepo && !(vectorDB instanceof QdrantDB3));
+  return Boolean(crossRepo && !vectorDB.supportsCrossRepo);
 }
 function buildNotes(crossRepoFallback, hitLimit) {
   const notes = [];
   if (crossRepoFallback) {
-    notes.push("Cross-repo search requires Qdrant backend. Fell back to single-repo search.");
+    notes.push(
+      "Cross-repo search requires a cross-repo-capable backend. Fell back to single-repo search."
+    );
   }
   if (hitLimit) {
     notes.push("Scanned 10,000 chunks (limit reached). Results may be incomplete.");
@@ -9815,9 +9946,7 @@ function logRiskAssessment(analysis, riskLevel, symbol, log) {
       );
     }
   } else {
-    log(
-      `Found ${analysis.dependents.length} dependents ${prodTest} - risk: ${riskLevel}`
-    );
+    log(`Found ${analysis.dependents.length} dependents ${prodTest} - risk: ${riskLevel}`);
   }
 }
 function buildDependentsResponse(analysis, args, riskLevel, indexInfo, notes, crossRepo, vectorDB) {
@@ -9841,46 +9970,51 @@ function buildDependentsResponse(analysis, args, riskLevel, indexInfo, notes, cr
   if (notes.length > 0) {
     response.note = notes.join(" ");
   }
-  if (crossRepo && vectorDB instanceof QdrantDB3) {
+  if (crossRepo && vectorDB.supportsCrossRepo) {
     response.groupedByRepo = groupDependentsByRepo(analysis.dependents, analysis.allChunks);
   }
   return response;
 }
 async function handleGetDependents(args, ctx) {
   const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
-  return await wrapToolHandler(
-    GetDependentsSchema,
-    async (validatedArgs) => {
-      const { crossRepo, filepath, symbol } = validatedArgs;
-      const symbolSuffix = symbol ? ` (symbol: ${symbol})` : "";
-      const crossRepoSuffix = crossRepo ? " (cross-repo)" : "";
-      log(`Finding dependents of: ${filepath}${symbolSuffix}${crossRepoSuffix}`);
-      await checkAndReconnect();
-      const analysis = await findDependents(vectorDB, filepath, crossRepo ?? false, log, symbol);
-      const riskLevel = calculateRiskLevel(
-        analysis.dependents.length,
-        analysis.complexityMetrics.complexityRiskBoost,
-        analysis.productionDependentCount
-      );
-      logRiskAssessment(analysis, riskLevel, symbol, log);
-      const crossRepoFallback = checkCrossRepoFallback(crossRepo, vectorDB);
-      const notes = buildNotes(crossRepoFallback, analysis.hitLimit);
-      return buildDependentsResponse(
-        analysis,
-        validatedArgs,
-        riskLevel,
-        getIndexMetadata(),
-        notes,
-        crossRepo,
-        vectorDB
-      );
-    }
-  )(args);
+  return await wrapToolHandler(GetDependentsSchema, async (validatedArgs) => {
+    const { crossRepo, filepath, symbol } = validatedArgs;
+    const symbolSuffix = symbol ? ` (symbol: ${symbol})` : "";
+    const crossRepoSuffix = crossRepo ? " (cross-repo)" : "";
+    log(`Finding dependents of: ${filepath}${symbolSuffix}${crossRepoSuffix}`);
+    await checkAndReconnect();
+    const indexInfo = getIndexMetadata();
+    const analysis = await findDependents(
+      vectorDB,
+      filepath,
+      crossRepo ?? false,
+      log,
+      symbol,
+      indexInfo.indexVersion
+    );
+    const riskLevel = calculateRiskLevel(
+      analysis.dependents.length,
+      analysis.complexityMetrics.complexityRiskBoost,
+      analysis.productionDependentCount
+    );
+    logRiskAssessment(analysis, riskLevel, symbol, log);
+    const crossRepoFallback = checkCrossRepoFallback(crossRepo, vectorDB);
+    const notes = buildNotes(crossRepoFallback, analysis.hitLimit);
+    return buildDependentsResponse(
+      analysis,
+      validatedArgs,
+      riskLevel,
+      indexInfo,
+      notes,
+      crossRepo,
+      vectorDB
+    );
+  })(args);
 }
 
 // src/mcp/handlers/get-complexity.ts
 var import_collect = __toESM(require_dist(), 1);
-import { ComplexityAnalyzer, QdrantDB as QdrantDB4 } from "@liendev/core";
+import { ComplexityAnalyzer } from "@liendev/core";
 function transformViolation(v, fileData) {
   return {
     filepath: v.filepath,
@@ -9919,7 +10053,7 @@ async function fetchCrossRepoChunks(vectorDB, crossRepo, repoIds, log) {
   if (!crossRepo) {
     return { chunks: [], fallback: false };
   }
-  if (vectorDB instanceof QdrantDB4) {
+  if (vectorDB.supportsCrossRepo) {
     const chunks = await vectorDB.scanCrossRepo({ limit: 1e5, repoIds });
     log(`Scanned ${chunks.length} chunks across repos`);
     return { chunks, fallback: false };
@@ -9928,7 +10062,11 @@ async function fetchCrossRepoChunks(vectorDB, crossRepo, repoIds, log) {
 }
 function processViolations(report, threshold, top) {
   const allViolations = (0, import_collect.default)(Object.entries(report.files)).flatMap(
-    ([, fileData]) => fileData.violations.map((v) => transformViolation(v, fileData))
+    ([
+      ,
+      /* filepath unused */
+      fileData
+    ]) => fileData.violations.map((v) => transformViolation(v, fileData))
   ).sortByDesc("complexity").all();
   const violations = threshold !== void 0 ? allViolations.filter((v) => v.complexity >= threshold) : allViolations;
   const severityCounts = (0, import_collect.default)(violations).countBy("severity").all();
@@ -9942,61 +10080,61 @@ function processViolations(report, threshold, top) {
   };
 }
 function buildCrossRepoFallbackNote(fallback) {
-  return fallback ? "Cross-repo analysis requires Qdrant backend. Fell back to single-repo analysis." : void 0;
+  return fallback ? "Cross-repo analysis requires a cross-repo-capable backend. Fell back to single-repo analysis." : void 0;
 }
 async function handleGetComplexity(args, ctx) {
   const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
-  return await wrapToolHandler(
-    GetComplexitySchema,
-    async (validatedArgs) => {
-      const { crossRepo, repoIds, files, top, threshold } = validatedArgs;
-      log(`Analyzing complexity${crossRepo ? " (cross-repo)" : ""}...`);
-      await checkAndReconnect();
-      const { chunks: allChunks, fallback } = await fetchCrossRepoChunks(
-        vectorDB,
-        crossRepo,
-        repoIds,
-        log
-      );
-      const analyzer = new ComplexityAnalyzer(vectorDB);
-      const report = await analyzer.analyze(files, crossRepo && !fallback, repoIds);
-      log(`Analyzed ${report.summary.filesAnalyzed} files`);
-      const { violations, topViolations, bySeverity } = processViolations(
-        report,
-        threshold,
-        top ?? 10
+  return await wrapToolHandler(GetComplexitySchema, async (validatedArgs) => {
+    const { crossRepo, repoIds, files, top, threshold } = validatedArgs;
+    log(`Analyzing complexity${crossRepo ? " (cross-repo)" : ""}...`);
+    await checkAndReconnect();
+    const { chunks: allChunks, fallback } = await fetchCrossRepoChunks(
+      vectorDB,
+      crossRepo,
+      repoIds,
+      log
+    );
+    const analyzer = new ComplexityAnalyzer(vectorDB);
+    const report = await analyzer.analyze(files, crossRepo && !fallback, repoIds);
+    log(`Analyzed ${report.summary.filesAnalyzed} files`);
+    const { violations, topViolations, bySeverity } = processViolations(
+      report,
+      threshold,
+      top ?? 10
+    );
+    const note = buildCrossRepoFallbackNote(fallback);
+    if (note) {
+      log(
+        "Warning: crossRepo=true requires a cross-repo-capable backend. Falling back to single-repo analysis.",
+        "warning"
       );
-      const note = buildCrossRepoFallbackNote(fallback);
-      if (note) {
-        log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo analysis.", "warning");
-      }
-      return {
-        indexInfo: getIndexMetadata(),
-        summary: {
-          filesAnalyzed: report.summary.filesAnalyzed,
-          avgComplexity: report.summary.avgComplexity,
-          maxComplexity: report.summary.maxComplexity,
-          violationCount: violations.length,
-          bySeverity
-        },
-        violations: topViolations,
-        ...crossRepo && !fallback && allChunks.length > 0 && {
-          groupedByRepo: groupViolationsByRepo(topViolations, allChunks)
-        },
-        ...note && { note }
-      };
     }
-  )(args);
+    return {
+      indexInfo: getIndexMetadata(),
+      summary: {
+        filesAnalyzed: report.summary.filesAnalyzed,
+        avgComplexity: report.summary.avgComplexity,
+        maxComplexity: report.summary.maxComplexity,
+        violationCount: violations.length,
+        bySeverity
+      },
+      violations: topViolations,
+      ...crossRepo && !fallback && allChunks.length > 0 && {
+        groupedByRepo: groupViolationsByRepo(topViolations, allChunks)
+      },
+      ...note && { note }
+    };
+  })(args);
 }
 
 // src/mcp/handlers/index.ts
 var toolHandlers = {
-  "semantic_search": handleSemanticSearch,
-  "find_similar": handleFindSimilar,
-  "get_files_context": handleGetFilesContext,
-  "list_functions": handleListFunctions,
-  "get_dependents": handleGetDependents,
-  "get_complexity": handleGetComplexity
+  semantic_search: handleSemanticSearch,
+  find_similar: handleFindSimilar,
+  get_files_context: handleGetFilesContext,
+  list_functions: handleListFunctions,
+  get_dependents: handleGetDependents,
+  get_complexity: handleGetComplexity
 };
 
 // src/mcp/server-config.ts
@@ -10084,7 +10222,7 @@ function mergePendingFiles(pendingFiles, newFiles) {
   }
 }
 function createReindexStateManager() {
-  let state = {
+  const state = {
     inProgress: false,
     pendingFiles: [],
     lastReindexTimestamp: null,
@@ -10108,12 +10246,12 @@ function createReindexStateManager() {
     },
     /**
      * Start a new reindex operation.
-     * 
+     *
      * **Important**: Silently ignores empty or null file arrays without incrementing
      * activeOperations. This is intentional - if there's no work to do, no operation
      * is started. Callers should check for empty arrays before calling if they need
      * to track "attempted" operations.
-     * 
+     *
      * @param files - Array of file paths to reindex. Empty/null arrays are ignored.
      */
     startReindex: (files) => {
@@ -10127,10 +10265,10 @@ function createReindexStateManager() {
     },
     /**
      * Mark a reindex operation as complete.
-     * 
+     *
      * Logs a warning if called without a matching startReindex.
      * Only clears state when all concurrent operations finish.
-     * 
+     *
      * @param durationMs - Duration of the reindex operation in milliseconds
      */
     completeReindex: (durationMs) => {
@@ -10149,7 +10287,7 @@ function createReindexStateManager() {
     },
     /**
      * Mark a reindex operation as failed.
-     * 
+     *
      * Logs a warning if called without a matching startReindex.
      * Only clears state when all concurrent operations finish/fail.
      */
@@ -10167,13 +10305,13 @@ function createReindexStateManager() {
     },
     /**
      * Manually reset state if it's stuck.
-     * 
+     *
      * **WARNING**: Only use this if you're certain operations have crashed without cleanup.
      * This will forcibly clear the inProgress flag and reset activeOperations counter.
-     * 
+     *
      * Use this when getState() health check detects stuck state and you've verified
      * no legitimate operations are running.
-     * 
+     *
      * @returns true if state was reset, false if state was already clean
      */
     resetIfStuck: () => {
@@ -10192,60 +10330,292 @@ 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, "../../..");
+// 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 as normalizeToRelativePath2,
+  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;
+  }
 }
-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");
+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 {
+      await vectorDB.deleteByFile(filepath);
+      await manifest.removeFile(filepath);
+      log(`\u2713 Removed ${filepath} from index`);
+    } catch (error) {
+      log(`Failed to remove ${filepath}: ${error}`, "warning");
+      failures.push(filepath);
+    }
   }
-  if (typeof vectorDB.initialize !== "function") {
-    throw new Error(`Invalid vectorDB instance: ${vectorDB.constructor?.name || "unknown"}. Expected VectorDBInterface but got: ${JSON.stringify(Object.keys(vectorDB))}`);
+  if (failures.length > 0) {
+    throw new Error(`Failed to delete ${failures.length} file(s): ${failures.join(", ")}`);
   }
-  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 canSkipReindex(filepath, rootDir, vectorDB, log) {
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  const normalizedPath = normalizeToRelativePath2(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 { indexCodebase: indexCodebase2 } = await import("@liendev/core");
-      await indexCodebase2({ rootDir, verbose: true });
-      log("\u2705 Initial indexing complete!");
+      if (await canSkipReindex(filepath, rootDir, vectorDB, log)) return;
     } catch (error) {
-      log(`\u26A0\uFE0F  Initial indexing failed: ${error}`, "warning");
-      log("You can manually run: lien index", "warning");
+      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 stats = await fs3.stat(filepath);
+      return { shouldReindex: false, newMtime: stats.mtimeMs };
+    } catch {
+      return { shouldReindex: true };
     }
   }
+  return { shouldReindex: true };
+}
+async function checkFilesAgainstManifest(files, rootDir, manifestFiles, log) {
+  const results = [];
+  for (const filepath of files) {
+    const normalizedPath = normalizeToRelativePath2(filepath, rootDir);
+    const existingEntry = manifestFiles[normalizedPath];
+    const { shouldReindex, newMtime } = await shouldReindexFile(filepath, existingEntry, log);
+    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 results) {
+      if (!result.shouldReindex && result.newMtime !== void 0) {
+        const entry = data.files[result.normalizedPath];
+        if (entry) {
+          entry.lastModified = result.newMtime;
+        }
+      }
+    }
+    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, rootDir, vectorDB, log) {
+  const addedFiles = event.added || [];
+  const modifiedFiles = event.modified || [];
+  const deletedFiles = event.deleted || [];
+  let modifiedFilesToReindex = [];
+  try {
+    modifiedFilesToReindex = await filterModifiedFilesByHash(modifiedFiles, rootDir, vectorDB, log);
+  } catch (error) {
+    log(`Hash-based filtering failed, will reindex all modified files: ${error}`, "warning");
+    modifiedFilesToReindex = modifiedFiles;
+  }
+  const filesToIndex = [...addedFiles, ...modifiedFilesToReindex];
+  return { filesToIndex, deletedFiles };
+}
+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, rootDir })
+    );
+  }
+  if (deletedFiles.length > 0) {
+    operations.push(handleBatchDeletions(deletedFiles, vectorDB, log));
+  }
+  await Promise.all(operations);
+}
+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;
+  }
+  const startTime = Date.now();
+  reindexStateManager.startReindex(allFiles);
+  try {
+    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`
+    );
+  } catch (error) {
+    reindexStateManager.failReindex();
+    log(`Batch reindex failed: ${error}`, "warning");
+  }
+}
+async function handleUnlinkEvent(filepath, vectorDB, log, reindexStateManager) {
+  const startTime = Date.now();
+  reindexStateManager.startReindex([filepath]);
+  try {
+    await handleFileDeletion(filepath, vectorDB, log);
+    const duration = Date.now() - startTime;
+    reindexStateManager.completeReindex(duration);
+  } catch (error) {
+    reindexStateManager.failReindex();
+    log(`Failed to process deletion for ${filepath}: ${error}`, "warning");
+  }
+}
+function isFileIgnored(filepath, rootDir, isIgnored) {
+  return isIgnored(normalizeToRelativePath2(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") {
+      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 {
+      if (isFileIgnored(event.filepath, rootDir, ignoreFilter)) return;
+      await checkAndReconnect();
+      await handleSingleFileChange(
+        event.filepath,
+        type,
+        rootDir,
+        vectorDB,
+        embeddings,
+        log,
+        reindexStateManager
+      );
+    }
+  };
 }
-async function handleGitStartup(gitTracker, 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(changedFiles);
-    log(`\u{1F33F} Git changes detected: ${changedFiles.length} files changed`);
+    reindexStateManager.startReindex(filteredFiles);
+    log(`\u{1F33F} Git changes detected: ${filteredFiles.length} files changed`);
     try {
-      const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, { verbose: false });
+      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`);
@@ -10257,8 +10627,12 @@ async function handleGitStartup(gitTracker, vectorDB, embeddings, _verbose, log,
     log("\u2713 Index is up to date with git state");
   }
 }
-function createGitPollInterval(gitTracker, vectorDB, embeddings, _verbose, log, reindexStateManager) {
+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) {
@@ -10270,11 +10644,22 @@ function createGitPollInterval(gitTracker, vectorDB, embeddings, _verbose, log,
           );
           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(changedFiles);
-        log(`\u{1F33F} Git change detected: ${changedFiles.length} files changed`);
+        reindexStateManager.startReindex(filteredFiles);
+        log(`\u{1F33F} Git change detected: ${filteredFiles.length} files changed`);
         try {
-          const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, { verbose: false });
+          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`);
@@ -10285,48 +10670,99 @@ function createGitPollInterval(gitTracker, vectorDB, embeddings, _verbose, log,
       }
     } catch (error) {
       log(`Git detection check failed: ${error}`, "warning");
+    } finally {
+      pollInProgress = false;
     }
   }, DEFAULT_GIT_POLL_INTERVAL_MS2);
 }
-function createGitChangeHandler(gitTracker, vectorDB, embeddings, _verbose, log, reindexStateManager) {
+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 () => {
-    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) {
+    if (shouldSkipGitReindex(
+      gitReindexInProgress,
+      lastGitReindexTime,
+      GIT_REINDEX_COOLDOWN_MS,
+      reindexStateManager,
+      log
+    )) {
       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`);
+      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) {
-      reindexStateManager.failReindex();
-      log(`Git reindex failed: ${error}`, "warning");
+      log(`Git change handler failed: ${error}`, "warning");
     } finally {
       gitReindexInProgress = false;
     }
   };
 }
-async function setupGitDetection(rootDir, vectorDB, embeddings, verbose, log, reindexStateManager, fileWatcher) {
+async function setupGitDetection(rootDir, vectorDB, embeddings, log, reindexStateManager, fileWatcher, checkAndReconnect) {
   const gitAvailable = await isGitAvailable();
   const isRepo = await isGitRepo2(rootDir);
   if (!gitAvailable) {
@@ -10340,18 +10776,27 @@ async function setupGitDetection(rootDir, vectorDB, embeddings, verbose, log, re
   log("\u2713 Detected git repository");
   const gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
   try {
-    await handleGitStartup(gitTracker, vectorDB, embeddings, verbose, log, reindexStateManager);
+    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,
-      verbose,
       log,
-      reindexStateManager
+      reindexStateManager,
+      checkAndReconnect
     );
     fileWatcher.watchGit(gitChangeHandler);
     log("\u2713 Git detection enabled (event-driven via file watcher)");
@@ -10359,185 +10804,98 @@ async function setupGitDetection(rootDir, vectorDB, embeddings, verbose, log, re
   }
   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);
+  const gitPollInterval = createGitPollInterval(
+    rootDir,
+    gitTracker,
+    vectorDB,
+    embeddings,
+    log,
+    reindexStateManager,
+    checkAndReconnect
+  );
   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);
+async function filterGitChangedFiles(changedFiles, rootDir, ignoreFilter) {
+  const results = [];
+  for (const filepath of changedFiles) {
+    if (!isFileIgnored(filepath, rootDir, ignoreFilter)) {
+      results.push(filepath);
+      continue;
+    }
     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;
-        }
-      }
+      await fs4.access(filepath);
     } catch (error) {
-      log(`Content hash check failed, will reindex: ${error}`, "warning");
+      if (error.code === "ENOENT") {
+        results.push(filepath);
+      }
     }
   }
-  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");
-  }
+  return results;
 }
-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");
+
+// src/mcp/cleanup.ts
+function setupCleanupHandlers(server, versionCheckInterval, gitPollInterval, fileWatcher, log) {
+  let cleaningUp = false;
+  return async () => {
+    if (cleaningUp) return;
+    cleaningUp = true;
     try {
-      const fs5 = await import("fs/promises");
-      const stats = await fs5.stat(filepath);
-      return { shouldReindex: false, newMtime: stats.mtimeMs };
-    } catch {
-      return { shouldReindex: true };
-    }
-  }
-  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) {
-    const normalizedPath = normalizeToRelativePath(filepath, rootDir);
-    const existingEntry = manifestData.files[normalizedPath];
-    const { shouldReindex, newMtime } = await shouldReindexFile(filepath, existingEntry, log);
-    checkResults.push({
-      filepath,
-      normalizedPath,
-      shouldReindex,
-      newMtime
-    });
-  }
-  await manifest.transaction(async (data) => {
-    for (const result of checkResults) {
-      if (!result.shouldReindex && result.newMtime) {
-        const entry = data.files[result.normalizedPath];
-        if (entry) {
-          entry.lastModified = result.newMtime;
-        }
-      }
+      log("Shutting down MCP server...");
+      await server.close();
+      clearInterval(versionCheckInterval);
+      if (gitPollInterval) clearInterval(gitPollInterval);
+      if (fileWatcher) await fileWatcher.stop();
+    } finally {
+      process.exit(0);
     }
-    return null;
-  });
-  return checkResults.filter((r) => r.shouldReindex).map((r) => r.filepath);
+  };
 }
-async function prepareFilesForReindexing(event, vectorDB, log) {
-  const addedFiles = event.added || [];
-  const modifiedFiles = event.modified || [];
-  const deletedFiles = event.deleted || [];
-  let modifiedFilesToReindex = [];
-  try {
-    modifiedFilesToReindex = await filterModifiedFilesByHash(modifiedFiles, vectorDB, log);
-  } catch (error) {
-    log(`Hash-based filtering failed, will reindex all modified files: ${error}`, "warning");
-    modifiedFilesToReindex = modifiedFiles;
-  }
-  const filesToIndex = [...addedFiles, ...modifiedFilesToReindex];
-  return { filesToIndex, deletedFiles };
+
+// 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 executeReindexOperations(filesToIndex, deletedFiles, 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 }));
+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 (deletedFiles.length > 0) {
-    operations.push(
-      Promise.all(
-        deletedFiles.map((deleted) => handleFileDeletion(deleted, vectorDB, log))
-      )
+  if (typeof vectorDB.initialize !== "function") {
+    throw new Error(
+      `Invalid vectorDB instance: ${vectorDB.constructor?.name || "unknown"}. Expected VectorDBInterface but got: ${JSON.stringify(Object.keys(vectorDB))}`
     );
   }
-  await Promise.all(operations);
-}
-async function handleBatchEvent(event, vectorDB, embeddings, _verbose, log, reindexStateManager) {
-  const { filesToIndex, deletedFiles } = await prepareFilesForReindexing(event, vectorDB, log);
-  const allFiles = [...filesToIndex, ...deletedFiles];
-  if (allFiles.length === 0) {
-    return;
-  }
-  const startTime = Date.now();
-  reindexStateManager.startReindex(allFiles);
-  try {
-    await executeReindexOperations(filesToIndex, deletedFiles, 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`);
-  } catch (error) {
-    reindexStateManager.failReindex();
-    log(`Batch reindex failed: ${error}`, "warning");
-  }
-}
-async function handleUnlinkEvent(filepath, vectorDB, log, reindexStateManager) {
-  const startTime = Date.now();
-  reindexStateManager.startReindex([filepath]);
-  try {
-    await handleFileDeletion(filepath, vectorDB, log);
-    const duration = Date.now() - startTime;
-    reindexStateManager.completeReindex(duration);
-  } catch (error) {
-    reindexStateManager.failReindex();
-    log(`Failed to process deletion for ${filepath}: ${error}`, "warning");
-  }
+  log("Loading embedding model...");
+  await embeddings.initialize();
+  log("Loading vector database...");
+  await vectorDB.initialize();
+  log("Embeddings and vector DB ready");
+  return { embeddings, vectorDB };
 }
-function createFileChangeHandler(vectorDB, embeddings, verbose, log, reindexStateManager) {
-  return async (event) => {
-    const { type } = event;
-    if (type === "batch") {
-      await handleBatchEvent(event, vectorDB, embeddings, verbose, log, reindexStateManager);
-    } else if (type === "unlink") {
-      await handleUnlinkEvent(event.filepath, vectorDB, log, reindexStateManager);
-    } else {
-      await handleSingleFileChange(event.filepath, type, vectorDB, embeddings, verbose, log, reindexStateManager);
+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, verbose, log, reindexStateManager) {
+async function setupFileWatching(watch, rootDir, vectorDB, embeddings, log, reindexStateManager, checkAndReconnect) {
   const fileWatchingEnabled = watch !== void 0 ? watch : true;
   if (!fileWatchingEnabled) {
     return null;
@@ -10545,7 +10903,14 @@ 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 +10921,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 +10976,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 +10993,35 @@ 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);
@@ -10672,7 +11044,11 @@ async function startMCPServer(options) {
   const server = createMCPServer();
   const log = createMCPLog(server, verbose);
   const reindexStateManager = createReindexStateManager();
-  const { interval: versionCheckInterval, checkAndReconnect, getIndexMetadata } = setupVersionChecking(vectorDB, log, reindexStateManager);
+  const {
+    interval: versionCheckInterval,
+    checkAndReconnect,
+    getIndexMetadata
+  } = setupVersionChecking(vectorDB, log, reindexStateManager);
   const toolContext = {
     vectorDB,
     embeddings,
@@ -10682,41 +11058,45 @@ 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
+init_banner();
 async function serveCommand(options) {
   const rootDir = options.root ? path4.resolve(options.root) : process.cwd();
   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}`));
+          console.error(chalk6.red(`Error: --root path is not a directory: ${rootDir}`));
           process.exit(1);
         }
       } catch (error) {
         if (error.code === "ENOENT") {
-          console.error(chalk5.red(`Error: --root directory does not exist: ${rootDir}`));
+          console.error(chalk6.red(`Error: --root directory does not exist: ${rootDir}`));
         } else if (error.code === "EACCES") {
-          console.error(chalk5.red(`Error: --root directory is not accessible: ${rootDir}`));
+          console.error(chalk6.red(`Error: --root directory is not accessible: ${rootDir}`));
         } else {
-          console.error(chalk5.red(`Error: Failed to access --root directory: ${rootDir}`));
-          console.error(chalk5.dim(error.message));
+          console.error(chalk6.red(`Error: Failed to access --root directory: ${rootDir}`));
+          console.error(chalk6.dim(error.message));
         }
         process.exit(1);
       }
     }
     showBanner();
-    console.error(chalk5.bold("Starting MCP server...\n"));
+    console.error(chalk6.bold("Starting MCP server...\n"));
     if (options.root) {
-      console.error(chalk5.dim(`Serving from: ${rootDir}
+      console.error(chalk6.dim(`Serving from: ${rootDir}
 `));
     }
     if (options.watch) {
-      console.error(chalk5.yellow("\u26A0\uFE0F  --watch flag is deprecated (file watching is now default)"));
-      console.error(chalk5.dim("    Use --no-watch to disable file watching\n"));
+      console.error(chalk6.yellow("\u26A0\uFE0F  --watch flag is deprecated (file watching is now default)"));
+      console.error(chalk6.dim("    Use --no-watch to disable file watching\n"));
     }
     const watch = options.noWatch ? false : options.watch ? true : void 0;
     await startMCPServer({
@@ -10725,14 +11105,14 @@ async function serveCommand(options) {
       watch
     });
   } catch (error) {
-    console.error(chalk5.red("Failed to start MCP server:"), error);
+    console.error(chalk6.red("Failed to start MCP server:"), error);
     process.exit(1);
   }
 }
 
 // src/cli/complexity.ts
-import chalk6 from "chalk";
-import fs4 from "fs";
+import chalk7 from "chalk";
+import fs6 from "fs";
 import path5 from "path";
 import { VectorDB } from "@liendev/core";
 import { ComplexityAnalyzer as ComplexityAnalyzer2 } from "@liendev/core";
@@ -10741,13 +11121,17 @@ var VALID_FAIL_ON = ["error", "warning"];
 var VALID_FORMATS = ["text", "json", "sarif"];
 function validateFailOn(failOn) {
   if (failOn && !VALID_FAIL_ON.includes(failOn)) {
-    console.error(chalk6.red(`Error: Invalid --fail-on value "${failOn}". Must be either 'error' or 'warning'`));
+    console.error(
+      chalk7.red(`Error: Invalid --fail-on value "${failOn}". Must be either 'error' or 'warning'`)
+    );
     process.exit(1);
   }
 }
 function validateFormat(format) {
   if (!VALID_FORMATS.includes(format)) {
-    console.error(chalk6.red(`Error: Invalid --format value "${format}". Must be one of: text, json, sarif`));
+    console.error(
+      chalk7.red(`Error: Invalid --format value "${format}". Must be one of: text, json, sarif`)
+    );
     process.exit(1);
   }
 }
@@ -10755,11 +11139,11 @@ 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:`));
-    missingFiles.forEach((file) => console.error(chalk6.red(`  - ${file}`)));
+    console.error(chalk7.red(`Error: File${missingFiles.length > 1 ? "s" : ""} not found:`));
+    missingFiles.forEach((file) => console.error(chalk7.red(`  - ${file}`)));
     process.exit(1);
   }
 }
@@ -10767,8 +11151,12 @@ async function ensureIndexExists(vectorDB) {
   try {
     await vectorDB.scanWithFilter({ limit: 1 });
   } catch {
-    console.error(chalk6.red("Error: Index not found"));
-    console.log(chalk6.yellow("\nRun"), chalk6.bold("lien index"), chalk6.yellow("to index your codebase first"));
+    console.error(chalk7.red("Error: Index not found"));
+    console.log(
+      chalk7.yellow("\nRun"),
+      chalk7.bold("lien index"),
+      chalk7.yellow("to index your codebase first")
+    );
     process.exit(1);
   }
 }
@@ -10778,10 +11166,6 @@ async function complexityCommand(options) {
     validateFailOn(options.failOn);
     validateFormat(options.format);
     validateFilesExist(options.files, rootDir);
-    if (options.threshold || options.cyclomaticThreshold || options.cognitiveThreshold) {
-      console.warn(chalk6.yellow("Warning: Threshold overrides via CLI flags are not supported."));
-      console.warn(chalk6.yellow("Use the MCP tool with threshold parameter for custom thresholds."));
-    }
     const vectorDB = new VectorDB(rootDir);
     await vectorDB.initialize();
     await ensureIndexExists(vectorDB);
@@ -10793,11 +11177,102 @@ async function complexityCommand(options) {
       if (hasViolations) process.exit(1);
     }
   } catch (error) {
-    console.error(chalk6.red("Error analyzing complexity:"), error);
+    console.error(chalk7.red("Error analyzing complexity:"), error);
     process.exit(1);
   }
 }
 
+// src/cli/config.ts
+import chalk8 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(chalk8.red(`Unknown config key: "${key}"`));
+    console.log(chalk8.dim("Valid keys:"), Object.keys(ALLOWED_KEYS).join(", "));
+    process.exit(1);
+  }
+  if (allowed.values.length > 0 && !allowed.values.includes(value)) {
+    console.error(chalk8.red(`Invalid value "${value}" for ${key}`));
+    console.log(chalk8.dim("Valid values:"), allowed.values.join(", "));
+    process.exit(1);
+  }
+  if (key === "qdrant.apiKey") {
+    const existing = await loadGlobalConfig();
+    if (!existing.qdrant?.url) {
+      console.error(chalk8.red("Set qdrant.url first before setting qdrant.apiKey"));
+      process.exit(1);
+    }
+  }
+  const partial = buildPartialConfig(key, value);
+  await mergeGlobalConfig(partial);
+  console.log(chalk8.green(`Set ${key} = ${value}`));
+  console.log(chalk8.dim(`Config: ${CONFIG_PATH}`));
+}
+async function configGetCommand(key) {
+  if (!ALLOWED_KEYS[key]) {
+    console.error(chalk8.red(`Unknown config key: "${key}"`));
+    console.log(chalk8.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(chalk8.dim(`${key}: (not set)`));
+  } else {
+    console.log(`${key}: ${value}`);
+  }
+}
+async function configListCommand() {
+  const config = await loadGlobalConfig();
+  console.log(chalk8.bold("Global Configuration"));
+  console.log(chalk8.dim(`File: ${CONFIG_PATH}
+`));
+  for (const [key, meta] of Object.entries(ALLOWED_KEYS)) {
+    const value = getConfigValue(config, key);
+    const display = value ?? chalk8.dim("(not set)");
+    console.log(`  ${chalk8.cyan(key)}: ${display}  ${chalk8.dim(`\u2014 ${meta.description}`)}`);
+  }
+}
+
 // src/cli/index.ts
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname3(__filename3);
@@ -10811,10 +11286,18 @@ try {
 var program = new Command();
 program.name("lien").description("Local semantic code search for AI assistants via MCP").version(packageJson3.version);
 program.command("init").description("Initialize Lien in the current directory").option("-u, --upgrade", "Upgrade existing config with new options").option("-y, --yes", "Skip interactive prompts and use defaults").option("-p, --path <path>", "Path to initialize (defaults to current directory)").action(initCommand);
-program.command("index").description("Index the codebase for semantic search").option("-f, --force", "Force full reindex (skip incremental)").option("-w, --watch", "Watch for changes and re-index automatically").option("-v, --verbose", "Show detailed logging during indexing").action(indexCommand);
-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("index").description("Index the codebase for semantic search").option("-f, --force", "Force full reindex (skip incremental)").option("-v, --verbose", "Show detailed logging during indexing").action(indexCommand);
+program.command("serve").description(
+  "Start the MCP server (works with Cursor, Claude Code, Windsurf, and any MCP client)"
+).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);
+program.command("complexity").description("Analyze code complexity").option("--files <paths...>", "Specific files to analyze").option("--format <type>", "Output format: text, json, sarif", "text").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);
+program.addHelpText("beforeAll", `Quick start: run 'lien serve' in your project directory
+`);
 
 // src/index.ts
 program.parse();