@liendev/lien 0.20.0 → 0.21.0

package/dist/index.js

@@ -3590,7 +3590,7 @@ var require_dist = __commonJS({
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { createRequire as createRequire4 } from "module";
+import { createRequire as createRequire3 } from "module";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { dirname as dirname3, join as join3 } from "path";
 
@@ -3598,15 +3598,8 @@ import { dirname as dirname3, join as join3 } from "path";
 import fs from "fs/promises";
 import path from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { createRequire as createRequire2 } from "module";
 import chalk2 from "chalk";
 import inquirer from "inquirer";
-import {
-  defaultConfig,
-  MigrationManager,
-  detectAllFrameworks,
-  getFrameworkDetector
-} from "@liendev/core";
 
 // src/utils/banner.ts
 import figlet from "figlet";
@@ -3670,151 +3663,39 @@ function showCompactBanner() {
 // src/cli/init.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = path.dirname(__filename2);
-var require3 = createRequire2(import.meta.url);
-var CLI_VERSION;
-try {
-  CLI_VERSION = require3("../package.json").version;
-} catch {
-  CLI_VERSION = require3("../../package.json").version;
-}
 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");
   try {
-    let configExists = false;
-    try {
-      await fs.access(configPath);
-      configExists = true;
-    } catch {
-    }
-    if (configExists && options.upgrade) {
-      const migrationManager = new MigrationManager(rootDir, CLI_VERSION);
-      await migrationManager.upgradeInteractive();
-      return;
-    }
-    if (configExists && !options.upgrade) {
-      console.log(chalk2.yellow("\u26A0\uFE0F  .lien.config.json already exists"));
-      console.log(chalk2.dim("Run"), chalk2.bold("lien init --upgrade"), chalk2.dim("to merge new config options"));
-      return;
-    }
-    if (!configExists) {
-      await createNewConfig(rootDir, options);
-    }
-  } catch (error) {
-    console.error(chalk2.red("Error creating config file:"), error);
-    process.exit(1);
-  }
-}
-function createGenericFramework() {
-  return {
-    name: "generic",
-    path: ".",
-    enabled: true,
-    config: {
-      include: ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
-      exclude: [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.git/**",
-        "**/coverage/**",
-        "**/.next/**",
-        "**/.nuxt/**",
-        "**/vendor/**"
-      ]
-    }
-  };
-}
-async function handleNoFrameworksDetected(options) {
-  console.log(chalk2.yellow("\n\u26A0\uFE0F  No frameworks detected"));
-  if (!options.yes) {
-    const { useGeneric } = await inquirer.prompt([{
-      type: "confirm",
-      name: "useGeneric",
-      message: "Create a generic config (index all supported file types)?",
-      default: true
-    }]);
-    if (!useGeneric) {
-      console.log(chalk2.dim("Aborted."));
-      return null;
-    }
-  } else {
-    console.log(chalk2.dim("Creating generic config (no frameworks detected)..."));
-  }
-  return [createGenericFramework()];
-}
-function displayDetectedFrameworks(detections) {
-  console.log(chalk2.green(`
-\u2713 Found ${detections.length} framework(s):
-`));
-  for (const det of detections) {
-    const pathDisplay = det.path === "." ? "root" : det.path;
-    console.log(chalk2.bold(`  ${det.name}`), chalk2.dim(`(${det.confidence} confidence)`));
-    console.log(chalk2.dim(`    Location: ${pathDisplay}`));
-    if (det.evidence.length > 0) {
-      det.evidence.forEach((e) => console.log(chalk2.dim(`    \u2022 ${e}`)));
-    }
-    console.log();
-  }
-}
-async function confirmFrameworkConfiguration(options) {
-  if (options.yes) return true;
-  const { confirm } = await inquirer.prompt([{
-    type: "confirm",
-    name: "confirm",
-    message: "Configure these frameworks?",
-    default: true
-  }]);
-  return confirm;
-}
-async function generateSingleFrameworkConfig(det, rootDir, options) {
-  const detector = getFrameworkDetector(det.name);
-  if (!detector) {
-    console.warn(chalk2.yellow(`\u26A0\uFE0F  No detector found for ${det.name}, skipping`));
-    return null;
-  }
-  const frameworkConfig = await detector.generateConfig(rootDir, det.path);
-  let finalConfig = frameworkConfig;
-  const pathDisplay = det.path === "." ? "root" : det.path;
-  if (!options.yes) {
-    const { customize } = await inquirer.prompt([{
-      type: "confirm",
-      name: "customize",
-      message: `Customize ${det.name} settings?`,
-      default: false
-    }]);
-    if (customize) {
-      const customized = await promptForCustomization(det.name, frameworkConfig);
-      finalConfig = { ...frameworkConfig, ...customized };
-    } else {
-      console.log(chalk2.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
-    }
-  } else {
-    console.log(chalk2.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
-  }
-  return {
-    name: det.name,
-    path: det.path,
-    enabled: true,
-    config: finalConfig
-  };
-}
-async function handleFrameworksDetected(detections, rootDir, options) {
-  displayDetectedFrameworks(detections);
-  if (!await confirmFrameworkConfiguration(options)) {
-    console.log(chalk2.dim("Aborted."));
-    return null;
-  }
-  const frameworks = [];
-  for (const det of detections) {
-    const framework = await generateSingleFrameworkConfig(det, rootDir, options);
-    if (framework) frameworks.push(framework);
-  }
-  if (frameworks.length === 0) {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  No framework configs could be generated"));
-    return null;
+    await fs.access(configPath);
+    console.log(chalk2.yellow("\n\u26A0\uFE0F  Note: .lien.config.json found but no longer used"));
+    console.log(chalk2.dim("  You can safely delete it."));
+  } catch {
   }
-  return frameworks;
+  await promptAndInstallCursorRules(rootDir, options);
 }
 async function getPathType(filepath) {
   try {
@@ -3938,51 +3819,6 @@ async function promptAndInstallCursorRules(rootDir, options) {
     console.log(chalk2.dim("You can manually copy CURSOR_RULES_TEMPLATE.md to .cursor/rules/lien.mdc"));
   }
 }
-async function writeConfigAndShowSuccess(rootDir, frameworks) {
-  const config = { ...defaultConfig, version: CLI_VERSION, frameworks };
-  const configPath = path.join(rootDir, ".lien.config.json");
-  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  console.log(chalk2.green("\n\u2713 Created .lien.config.json"));
-  console.log(chalk2.green(`\u2713 Configured ${frameworks.length} framework(s)`));
-  console.log(chalk2.dim("\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.dim("  3. Configure Cursor to use the MCP server (see README.md)"));
-}
-async function createNewConfig(rootDir, options) {
-  showCompactBanner();
-  console.log(chalk2.bold("Initializing Lien...\n"));
-  console.log(chalk2.dim("\u{1F50D} Detecting frameworks in"), chalk2.bold(rootDir));
-  const detections = await detectAllFrameworks(rootDir);
-  const frameworks = detections.length === 0 ? await handleNoFrameworksDetected(options) : await handleFrameworksDetected(detections, rootDir, options);
-  if (!frameworks) return;
-  await promptAndInstallCursorRules(rootDir, options);
-  await writeConfigAndShowSuccess(rootDir, frameworks);
-}
-async function promptForCustomization(frameworkName, config) {
-  console.log(chalk2.bold(`
-Customizing ${frameworkName} settings:`));
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "include",
-      message: "File patterns to include (comma-separated):",
-      default: config.include.join(", "),
-      filter: (input) => input.split(",").map((s) => s.trim())
-    },
-    {
-      type: "input",
-      name: "exclude",
-      message: "File patterns to exclude (comma-separated):",
-      default: config.exclude.join(", "),
-      filter: (input) => input.split(",").map((s) => s.trim())
-    }
-  ]);
-  return {
-    include: answers.include,
-    exclude: answers.exclude
-  };
-}
 
 // src/cli/status.ts
 import chalk3 from "chalk";
@@ -3991,12 +3827,16 @@ import path2 from "path";
 import os from "os";
 import crypto from "crypto";
 import {
-  configService,
   isGitRepo,
   getCurrentBranch,
   getCurrentCommit,
   readVersionFile,
-  isModernConfig
+  DEFAULT_CONCURRENCY,
+  DEFAULT_EMBEDDING_BATCH_SIZE,
+  DEFAULT_CHUNK_SIZE,
+  DEFAULT_CHUNK_OVERLAP,
+  DEFAULT_GIT_POLL_INTERVAL_MS,
+  DEFAULT_DEBOUNCE_MS
 } from "@liendev/core";
 async function statusCommand() {
   const rootDir = process.cwd();
@@ -4005,12 +3845,7 @@ async function statusCommand() {
   const indexPath = path2.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
   showCompactBanner();
   console.log(chalk3.bold("Status\n"));
-  const hasConfig = await configService.exists(rootDir);
-  console.log(chalk3.dim("Configuration:"), hasConfig ? chalk3.green("\u2713 Found") : chalk3.red("\u2717 Not initialized"));
-  if (!hasConfig) {
-    console.log(chalk3.yellow("\nRun"), chalk3.bold("lien init"), chalk3.yellow("to initialize"));
-    return;
-  }
+  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);
@@ -4033,51 +3868,38 @@ async function statusCommand() {
     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"));
   }
-  try {
-    const config = await configService.load(rootDir);
-    console.log(chalk3.bold("\nFeatures:"));
-    const isRepo = await isGitRepo(rootDir);
-    if (config.gitDetection.enabled && isRepo) {
-      console.log(chalk3.dim("Git detection:"), chalk3.green("\u2713 Enabled"));
-      console.log(chalk3.dim("  Poll interval:"), `${config.gitDetection.pollIntervalMs / 1e3}s`);
+  console.log(chalk3.bold("\nFeatures:"));
+  const isRepo = await isGitRepo(rootDir);
+  if (isRepo) {
+    console.log(chalk3.dim("Git detection:"), chalk3.green("\u2713 Enabled"));
+    console.log(chalk3.dim("  Poll interval:"), `${DEFAULT_GIT_POLL_INTERVAL_MS / 1e3}s`);
+    try {
+      const branch = await getCurrentBranch(rootDir);
+      const commit = await getCurrentCommit(rootDir);
+      console.log(chalk3.dim("  Current branch:"), branch);
+      console.log(chalk3.dim("  Current commit:"), commit.substring(0, 8));
+      const gitStateFile = path2.join(indexPath, ".git-state.json");
       try {
-        const branch = await getCurrentBranch(rootDir);
-        const commit = await getCurrentCommit(rootDir);
-        console.log(chalk3.dim("  Current branch:"), branch);
-        console.log(chalk3.dim("  Current commit:"), commit.substring(0, 8));
-        const gitStateFile = path2.join(indexPath, ".git-state.json");
-        try {
-          const gitStateContent = await fs2.readFile(gitStateFile, "utf-8");
-          const gitState = JSON.parse(gitStateContent);
-          if (gitState.branch !== branch || gitState.commit !== commit) {
-            console.log(chalk3.yellow("  \u26A0\uFE0F  Git state changed - will reindex on next serve"));
-          }
-        } catch {
+        const gitStateContent = await fs2.readFile(gitStateFile, "utf-8");
+        const gitState = JSON.parse(gitStateContent);
+        if (gitState.branch !== branch || gitState.commit !== commit) {
+          console.log(chalk3.yellow("  \u26A0\uFE0F  Git state changed - will reindex on next serve"));
         }
       } catch {
       }
-    } else if (config.gitDetection.enabled && !isRepo) {
-      console.log(chalk3.dim("Git detection:"), chalk3.yellow("Enabled (not a git repo)"));
-    } else {
-      console.log(chalk3.dim("Git detection:"), chalk3.gray("Disabled"));
-    }
-    if (config.fileWatching.enabled) {
-      console.log(chalk3.dim("File watching:"), chalk3.green("\u2713 Enabled"));
-      console.log(chalk3.dim("  Debounce:"), `${config.fileWatching.debounceMs}ms`);
-    } else {
-      console.log(chalk3.dim("File watching:"), chalk3.gray("Disabled"));
-      console.log(chalk3.dim("  Enable with:"), chalk3.bold("lien serve --watch"));
-    }
-    console.log(chalk3.bold("\nIndexing Settings:"));
-    if (isModernConfig(config)) {
-      console.log(chalk3.dim("Concurrency:"), config.core.concurrency);
-      console.log(chalk3.dim("Batch size:"), config.core.embeddingBatchSize);
-      console.log(chalk3.dim("Chunk size:"), config.core.chunkSize);
-      console.log(chalk3.dim("Chunk overlap:"), config.core.chunkOverlap);
+    } catch {
     }
-  } catch (error) {
-    console.log(chalk3.yellow("\nWarning: Could not load configuration"));
-  }
+  } else {
+    console.log(chalk3.dim("Git detection:"), chalk3.yellow("Not a git repo"));
+  }
+  console.log(chalk3.dim("File watching:"), chalk3.green("\u2713 Enabled (default)"));
+  console.log(chalk3.dim("  Debounce:"), `${DEFAULT_DEBOUNCE_MS}ms`);
+  console.log(chalk3.dim("  Disable with:"), chalk3.bold("lien serve --no-watch"));
+  console.log(chalk3.bold("\nIndexing Settings (defaults):"));
+  console.log(chalk3.dim("Concurrency:"), DEFAULT_CONCURRENCY);
+  console.log(chalk3.dim("Batch size:"), DEFAULT_EMBEDDING_BATCH_SIZE);
+  console.log(chalk3.dim("Chunk size:"), DEFAULT_CHUNK_SIZE);
+  console.log(chalk3.dim("Chunk overlap:"), DEFAULT_CHUNK_OVERLAP);
 }
 
 // src/cli/index-cmd.ts
@@ -4166,10 +3988,10 @@ async function indexCommand(options) {
   showCompactBanner();
   try {
     if (options.force) {
-      const { VectorDB: VectorDB3 } = await import("@liendev/core");
+      const { VectorDB: VectorDB2 } = await import("@liendev/core");
       const { ManifestManager: ManifestManager2 } = await import("@liendev/core");
       console.log(chalk4.yellow("Clearing existing index and manifest..."));
-      const vectorDB = new VectorDB3(process.cwd());
+      const vectorDB = new VectorDB2(process.cwd());
       await vectorDB.initialize();
       await vectorDB.clear();
       const manifest = new ManifestManager2(vectorDB.dbPath);
@@ -4271,13 +4093,234 @@ import path4 from "path";
 // src/mcp/server.ts
 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 fileURLToPath3 } from "url";
+import { dirname as dirname2, join as join2 } 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
+} from "@liendev/core";
+
+// src/watcher/index.ts
+import chokidar from "chokidar";
+import path3 from "path";
+import { detectAllFrameworks, getFrameworkDetector, DEFAULT_DEBOUNCE_MS as DEFAULT_DEBOUNCE_MS2 } from "@liendev/core";
+var FileWatcher = class {
+  watcher = null;
+  debounceTimers = /* @__PURE__ */ new Map();
+  rootDir;
+  onChangeHandler = null;
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  /**
+   * Detect watch patterns from frameworks 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) {
+      return this.getDefaultPatterns();
+    }
+  }
+  /**
+   * Get default watch patterns.
+   */
+  getDefaultPatterns() {
+    return {
+      include: ["**/*"],
+      exclude: [
+        "**/node_modules/**",
+        "**/vendor/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.git/**"
+      ]
+    };
+  }
+  /**
+   * Create chokidar watcher configuration.
+   */
+  createWatcherConfig(patterns) {
+    return {
+      cwd: this.rootDir,
+      ignored: patterns.exclude,
+      persistent: true,
+      ignoreInitial: true,
+      // Don't trigger for existing files
+      // Handle atomic saves from modern editors (VS Code, Sublime, etc.)
+      // Editors write to temp file then rename - without this, we get unlink+add instead of change
+      atomic: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 300,
+        // Reduced from 500ms for faster detection
+        pollInterval: 100
+      },
+      // Performance optimizations
+      usePolling: false,
+      interval: 100,
+      binaryInterval: 300
+    };
+  }
+  /**
+   * Register event handlers on the watcher.
+   */
+  registerEventHandlers() {
+    if (!this.watcher) {
+      return;
+    }
+    this.watcher.on("add", (filepath) => this.handleChange("add", filepath)).on("change", (filepath) => this.handleChange("change", filepath)).on("unlink", (filepath) => this.handleChange("unlink", filepath)).on("error", (error) => {
+      console.error(`[Lien] File watcher error: ${error}`);
+    });
+  }
+  /**
+   * Wait for watcher to be ready with timeout fallback.
+   */
+  async waitForReady() {
+    if (!this.watcher) {
+      return;
+    }
+    let readyFired = false;
+    await Promise.race([
+      new Promise((resolve) => {
+        const readyHandler = () => {
+          readyFired = true;
+          resolve();
+        };
+        this.watcher.once("ready", readyHandler);
+      }),
+      new Promise((resolve) => {
+        setTimeout(() => {
+          if (!readyFired) {
+            resolve();
+          }
+        }, 1e3);
+      })
+    ]);
+  }
+  /**
+   * Starts watching files for changes.
+   * 
+   * @param handler - Callback function called when files change
+   */
+  async start(handler) {
+    if (this.watcher) {
+      throw new Error("File watcher is already running");
+    }
+    this.onChangeHandler = handler;
+    const patterns = await this.getWatchPatterns();
+    this.watcher = chokidar.watch(patterns.include, this.createWatcherConfig(patterns));
+    this.registerEventHandlers();
+    await this.waitForReady();
+  }
+  /**
+   * Handles a file change event with debouncing.
+   * Debouncing prevents rapid reindexing when files are saved multiple times quickly.
+   */
+  handleChange(type, filepath) {
+    const existingTimer = this.debounceTimers.get(filepath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(filepath);
+      if (this.onChangeHandler) {
+        const absolutePath = path3.isAbsolute(filepath) ? filepath : path3.join(this.rootDir, filepath);
+        try {
+          const result = this.onChangeHandler({
+            type,
+            filepath: absolutePath
+          });
+          if (result instanceof Promise) {
+            result.catch((error) => {
+              console.error(`[Lien] Error handling file change: ${error}`);
+            });
+          }
+        } catch (error) {
+          console.error(`[Lien] Error handling file change: ${error}`);
+        }
+      }
+    }, DEFAULT_DEBOUNCE_MS2);
+    this.debounceTimers.set(filepath, timer);
+  }
+  /**
+   * Stops the file watcher and cleans up resources.
+   */
+  async stop() {
+    if (!this.watcher) {
+      return;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+    await this.watcher.close();
+    this.watcher = null;
+    this.onChangeHandler = null;
+  }
+  /**
+   * Gets the list of files currently being watched.
+   */
+  getWatchedFiles() {
+    if (!this.watcher) {
+      return [];
+    }
+    const watched = this.watcher.getWatched();
+    const files = [];
+    for (const [dir, filenames] of Object.entries(watched)) {
+      for (const filename of filenames) {
+        files.push(`${dir}/${filename}`);
+      }
+    }
+    return files;
+  }
+  /**
+   * Checks if the watcher is currently running.
+   */
+  isRunning() {
+    return this.watcher !== null;
+  }
+};
+
+// src/mcp/server-config.ts
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { createRequire as createRequire3 } from "module";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname2, join as join2 } from "path";
 
 // src/mcp/utils/zod-to-json-schema.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -8340,7 +8383,13 @@ var SemanticSearchSchema = external_exports.object({
   ),
   limit: external_exports.number().int().min(1, "Limit must be at least 1").max(50, "Limit cannot exceed 50").default(5).describe(
     "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."
+  ),
+  repoIds: external_exports.array(external_exports.string()).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
@@ -8383,6 +8432,9 @@ var GetDependentsSchema = external_exports.object({
   ),
   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."
   )
 });
 
@@ -8396,6 +8448,12 @@ var GetComplexitySchema = external_exports.object({
   ),
   threshold: external_exports.number().int().min(1, "Threshold must be at least 1").optional().describe(
     "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."
+  ),
+  repoIds: external_exports.array(external_exports.string()).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."
   )
 });
 
@@ -8575,20 +8633,46 @@ function wrapToolHandler(schema, handler) {
 }
 
 // src/mcp/handlers/semantic-search.ts
+import { QdrantDB } from "@liendev/core";
+function groupResultsByRepo(results) {
+  const grouped = {};
+  for (const result of results) {
+    const repoId = result.metadata.repoId || "unknown";
+    if (!grouped[repoId]) {
+      grouped[repoId] = [];
+    }
+    grouped[repoId].push(result);
+  }
+  return grouped;
+}
 async function handleSemanticSearch(args, ctx) {
   const { vectorDB, embeddings, log, checkAndReconnect, getIndexMetadata } = ctx;
   return await wrapToolHandler(
     SemanticSearchSchema,
     async (validatedArgs) => {
-      log(`Searching for: "${validatedArgs.query}"`);
+      const { crossRepo, repoIds, query, limit } = validatedArgs;
+      log(`Searching for: "${query}"${crossRepo ? " (cross-repo)" : ""}`);
       await checkAndReconnect();
-      const queryEmbedding = await embeddings.embed(validatedArgs.query);
-      const results = await vectorDB.search(queryEmbedding, validatedArgs.limit, validatedArgs.query);
-      log(`Found ${results.length} results`);
-      return {
+      const queryEmbedding = await embeddings.embed(query);
+      let results;
+      if (crossRepo && vectorDB instanceof QdrantDB) {
+        results = await vectorDB.searchCrossRepo(queryEmbedding, limit, repoIds);
+        log(`Found ${results.length} results across ${Object.keys(groupResultsByRepo(results)).length} repos`);
+      } else {
+        if (crossRepo) {
+          log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo search.");
+        }
+        results = await vectorDB.search(queryEmbedding, limit, query);
+        log(`Found ${results.length} results`);
+      }
+      const response = {
         indexInfo: getIndexMetadata(),
         results
       };
+      if (crossRepo && vectorDB instanceof QdrantDB) {
+        response.groupedByRepo = groupResultsByRepo(results);
+      }
+      return response;
     }
   )(args);
 }
@@ -8874,14 +8958,11 @@ async function handleListFunctions(args, ctx) {
 }
 
 // src/mcp/handlers/get-dependents.ts
-var DEPENDENT_COUNT_THRESHOLDS = {
-  LOW: 5,
-  // Few dependents, safe to change
-  MEDIUM: 15,
-  // Moderate impact, review dependents
-  HIGH: 30
-  // High impact, careful planning needed
-};
+import { QdrantDB as QdrantDB3 } from "@liendev/core";
+
+// src/mcp/handlers/dependency-analyzer.ts
+import { QdrantDB as QdrantDB2 } from "@liendev/core";
+var SCAN_LIMIT2 = 1e4;
 var COMPLEXITY_THRESHOLDS = {
   HIGH_COMPLEXITY_DEPENDENT: 10,
   // Individual file is complex
@@ -8898,8 +8979,52 @@ var COMPLEXITY_THRESHOLDS = {
   MEDIUM_MAX: 15
   // Occasional branching
 };
-var SCAN_LIMIT2 = 1e4;
-var RISK_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
+async function findDependents(vectorDB, filepath, 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");
+    }
+    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");
+  }
+  log(`Scanning ${allChunks.length} chunks for imports...`);
+  const workspaceRoot = process.cwd().replace(/\\/g, "/");
+  const pathCache = /* @__PURE__ */ new Map();
+  const normalizePathCached = (path6) => {
+    if (!pathCache.has(path6)) pathCache.set(path6, normalizePath(path6, workspaceRoot));
+    return pathCache.get(path6);
+  };
+  const importIndex = buildImportIndex(allChunks, normalizePathCached);
+  const normalizedTarget = normalizePathCached(filepath);
+  const dependentChunks = findDependentChunks(importIndex, normalizedTarget);
+  const chunksByFile = /* @__PURE__ */ new Map();
+  for (const chunk of dependentChunks) {
+    const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+    const existing = chunksByFile.get(canonical) || [];
+    existing.push(chunk);
+    chunksByFile.set(canonical, existing);
+  }
+  const fileComplexities = calculateFileComplexities(chunksByFile);
+  const complexityMetrics = calculateOverallComplexityMetrics(fileComplexities);
+  const uniqueFiles = Array.from(chunksByFile.keys()).map((filepath2) => ({
+    filepath: filepath2,
+    isTestFile: isTestFile(filepath2)
+  }));
+  return {
+    dependents: uniqueFiles,
+    chunksByFile,
+    fileComplexities,
+    complexityMetrics,
+    hitLimit,
+    allChunks
+  };
+}
 function buildImportIndex(allChunks, normalizePathCached) {
   const importIndex = /* @__PURE__ */ new Map();
   for (const chunk of allChunks) {
@@ -8992,65 +9117,82 @@ function calculateComplexityRiskBoost(avgComplexity, maxComplexity) {
   return "low";
 }
 function calculateRiskLevel(dependentCount, complexityRiskBoost) {
+  const DEPENDENT_COUNT_THRESHOLDS = {
+    LOW: 5,
+    MEDIUM: 15,
+    HIGH: 30
+  };
+  const RISK_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
   let riskLevel = dependentCount === 0 ? "low" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.LOW ? "low" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM ? "medium" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.HIGH ? "high" : "critical";
   if (RISK_ORDER[complexityRiskBoost] > RISK_ORDER[riskLevel]) {
     riskLevel = complexityRiskBoost;
   }
   return riskLevel;
 }
+function groupDependentsByRepo(dependents, chunks) {
+  const repoMap = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const repoId = chunk.metadata.repoId || "unknown";
+    const filepath = chunk.metadata.file;
+    if (!repoMap.has(repoId)) {
+      repoMap.set(repoId, /* @__PURE__ */ new Set());
+    }
+    repoMap.get(repoId).add(filepath);
+  }
+  const grouped = {};
+  for (const dependent of dependents) {
+    let foundRepo = "unknown";
+    for (const [repoId, files] of repoMap.entries()) {
+      if (files.has(dependent.filepath)) {
+        foundRepo = repoId;
+        break;
+      }
+    }
+    if (!grouped[foundRepo]) {
+      grouped[foundRepo] = [];
+    }
+    grouped[foundRepo].push(dependent);
+  }
+  return grouped;
+}
+
+// src/mcp/handlers/get-dependents.ts
 async function handleGetDependents(args, ctx) {
   const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
   return await wrapToolHandler(
     GetDependentsSchema,
     async (validatedArgs) => {
-      log(`Finding dependents of: ${validatedArgs.filepath}`);
+      const { crossRepo, filepath } = validatedArgs;
+      log(`Finding dependents of: ${filepath}${crossRepo ? " (cross-repo)" : ""}`);
       await checkAndReconnect();
-      const 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");
-      }
-      log(`Scanning ${allChunks.length} chunks for imports...`);
-      const workspaceRoot = process.cwd().replace(/\\/g, "/");
-      const pathCache = /* @__PURE__ */ new Map();
-      const normalizePathCached = (path6) => {
-        if (!pathCache.has(path6)) pathCache.set(path6, normalizePath(path6, workspaceRoot));
-        return pathCache.get(path6);
-      };
-      const importIndex = buildImportIndex(allChunks, normalizePathCached);
-      const normalizedTarget = normalizePathCached(validatedArgs.filepath);
-      const dependentChunks = findDependentChunks(importIndex, normalizedTarget);
-      const chunksByFile = /* @__PURE__ */ new Map();
-      for (const chunk of dependentChunks) {
-        const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
-        const existing = chunksByFile.get(canonical) || [];
-        existing.push(chunk);
-        chunksByFile.set(canonical, existing);
-      }
-      const fileComplexities = calculateFileComplexities(chunksByFile);
-      const complexityMetrics = calculateOverallComplexityMetrics(fileComplexities);
-      const uniqueFiles = Array.from(chunksByFile.keys()).map((filepath) => ({
-        filepath,
-        isTestFile: isTestFile(filepath)
-      }));
-      const riskLevel = calculateRiskLevel(uniqueFiles.length, complexityMetrics.complexityRiskBoost);
-      log(`Found ${uniqueFiles.length} dependent files (risk: ${riskLevel}${complexityMetrics.filesWithComplexityData > 0 ? ", complexity-boosted" : ""})`);
-      return {
+      const analysis = await findDependents(vectorDB, filepath, crossRepo ?? false, log);
+      const riskLevel = calculateRiskLevel(
+        analysis.dependents.length,
+        analysis.complexityMetrics.complexityRiskBoost
+      );
+      log(
+        `Found ${analysis.dependents.length} dependent files (risk: ${riskLevel}${analysis.complexityMetrics.filesWithComplexityData > 0 ? ", complexity-boosted" : ""})`
+      );
+      const response = {
         indexInfo: getIndexMetadata(),
         filepath: validatedArgs.filepath,
-        dependentCount: uniqueFiles.length,
+        dependentCount: analysis.dependents.length,
         riskLevel,
-        dependents: uniqueFiles,
-        complexityMetrics,
-        note: hitLimit ? `Warning: Scanned ${SCAN_LIMIT2} chunks (limit reached). Results may be incomplete.` : void 0
+        dependents: analysis.dependents,
+        complexityMetrics: analysis.complexityMetrics,
+        note: analysis.hitLimit ? `Warning: Scanned 10000 chunks (limit reached). Results may be incomplete.` : void 0
       };
+      if (crossRepo && vectorDB instanceof QdrantDB3) {
+        response.groupedByRepo = groupDependentsByRepo(analysis.dependents, analysis.allChunks);
+      }
+      return response;
     }
   )(args);
 }
 
 // src/mcp/handlers/get-complexity.ts
 var import_collect = __toESM(require_dist(), 1);
-import { ComplexityAnalyzer } from "@liendev/core";
+import { ComplexityAnalyzer, QdrantDB as QdrantDB4 } from "@liendev/core";
 function transformViolation(v, fileData) {
   return {
     filepath: v.filepath,
@@ -9069,23 +9211,48 @@ function transformViolation(v, fileData) {
     ...v.halsteadDetails && { halsteadDetails: v.halsteadDetails }
   };
 }
+function groupViolationsByRepo(violations, allChunks) {
+  const fileToRepo = /* @__PURE__ */ new Map();
+  for (const chunk of allChunks) {
+    const repoId = chunk.metadata.repoId || "unknown";
+    fileToRepo.set(chunk.metadata.file, repoId);
+  }
+  const grouped = {};
+  for (const violation of violations) {
+    const repoId = fileToRepo.get(violation.filepath) || "unknown";
+    if (!grouped[repoId]) {
+      grouped[repoId] = [];
+    }
+    grouped[repoId].push(violation);
+  }
+  return grouped;
+}
 async function handleGetComplexity(args, ctx) {
-  const { vectorDB, config, log, checkAndReconnect, getIndexMetadata } = ctx;
+  const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
   return await wrapToolHandler(
     GetComplexitySchema,
     async (validatedArgs) => {
-      log("Analyzing complexity...");
+      const { crossRepo, repoIds, files, top, threshold } = validatedArgs;
+      log(`Analyzing complexity${crossRepo ? " (cross-repo)" : ""}...`);
       await checkAndReconnect();
-      const analyzer = new ComplexityAnalyzer(vectorDB, config);
-      const report = await analyzer.analyze(validatedArgs.files);
+      let allChunks = [];
+      if (crossRepo && vectorDB instanceof QdrantDB4) {
+        allChunks = await vectorDB.scanCrossRepo({
+          limit: 1e5,
+          repoIds
+        });
+        log(`Scanned ${allChunks.length} chunks across repos`);
+      }
+      const analyzer = new ComplexityAnalyzer(vectorDB);
+      const report = await analyzer.analyze(files, crossRepo && vectorDB instanceof QdrantDB4 ? crossRepo : false, repoIds);
       log(`Analyzed ${report.summary.filesAnalyzed} files`);
       const allViolations = (0, import_collect.default)(Object.entries(report.files)).flatMap(
         ([, fileData]) => fileData.violations.map((v) => transformViolation(v, fileData))
       ).sortByDesc("complexity").all();
-      const violations = validatedArgs.threshold !== void 0 ? allViolations.filter((v) => v.complexity >= validatedArgs.threshold) : allViolations;
-      const topViolations = violations.slice(0, validatedArgs.top);
+      const violations = threshold !== void 0 ? allViolations.filter((v) => v.complexity >= threshold) : allViolations;
+      const topViolations = violations.slice(0, top);
       const bySeverity = (0, import_collect.default)(violations).countBy("severity").all();
-      return {
+      const response = {
         indexInfo: getIndexMetadata(),
         summary: {
           filesAnalyzed: report.summary.filesAnalyzed,
@@ -9099,6 +9266,12 @@ async function handleGetComplexity(args, ctx) {
         },
         violations: topViolations
       };
+      if (crossRepo && vectorDB instanceof QdrantDB4 && allChunks.length > 0) {
+        response.groupedByRepo = groupViolationsByRepo(topViolations, allChunks);
+      } else if (crossRepo) {
+        log("Warning: crossRepo=true requires Qdrant backend. Falling back to single-repo analysis.", "warning");
+      }
+      return response;
     }
   )(args);
 }
@@ -9113,168 +9286,91 @@ var toolHandlers = {
   "get_complexity": handleGetComplexity
 };
 
-// src/mcp/server.ts
-import {
-  VectorDB,
-  LocalEmbeddings,
-  GitStateTracker,
-  indexMultipleFiles,
-  indexSingleFile,
-  configService as configService2,
-  ManifestManager,
-  isGitAvailable,
-  isGitRepo as isGitRepo2,
-  VERSION_CHECK_INTERVAL_MS,
-  LienError as LienError2,
-  LienErrorCode as LienErrorCode2
-} from "@liendev/core";
-
-// src/watcher/index.ts
-import chokidar from "chokidar";
-import path3 from "path";
-import { isLegacyConfig, isModernConfig as isModernConfig2 } from "@liendev/core";
-var FileWatcher = class {
-  watcher = null;
-  debounceTimers = /* @__PURE__ */ new Map();
-  config;
-  rootDir;
-  onChangeHandler = null;
-  constructor(rootDir, config) {
-    this.rootDir = rootDir;
-    this.config = config;
-  }
-  /**
-   * Starts watching files for changes.
-   * 
-   * @param handler - Callback function called when files change
-   */
-  async start(handler) {
-    if (this.watcher) {
-      throw new Error("File watcher is already running");
-    }
-    this.onChangeHandler = handler;
-    let includePatterns;
-    let excludePatterns;
-    if (isLegacyConfig(this.config)) {
-      includePatterns = this.config.indexing.include;
-      excludePatterns = this.config.indexing.exclude;
-    } else if (isModernConfig2(this.config)) {
-      includePatterns = this.config.frameworks.flatMap((f) => f.config.include);
-      excludePatterns = this.config.frameworks.flatMap((f) => f.config.exclude);
-    } else {
-      includePatterns = ["**/*"];
-      excludePatterns = [];
-    }
-    this.watcher = chokidar.watch(includePatterns, {
-      cwd: this.rootDir,
-      ignored: excludePatterns,
-      persistent: true,
-      ignoreInitial: true,
-      // Don't trigger for existing files
-      // Handle atomic saves from modern editors (VS Code, Sublime, etc.)
-      // Editors write to temp file then rename - without this, we get unlink+add instead of change
-      atomic: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 300,
-        // Reduced from 500ms for faster detection
-        pollInterval: 100
-      },
-      // Performance optimizations
-      usePolling: false,
-      interval: 100,
-      binaryInterval: 300
-    });
-    this.watcher.on("add", (filepath) => this.handleChange("add", filepath)).on("change", (filepath) => this.handleChange("change", filepath)).on("unlink", (filepath) => this.handleChange("unlink", filepath)).on("error", (error) => {
-      console.error(`[Lien] File watcher error: ${error}`);
-    });
-    await new Promise((resolve) => {
-      this.watcher.on("ready", () => {
-        resolve();
-      });
-    });
-  }
-  /**
-   * Handles a file change event with debouncing.
-   * Debouncing prevents rapid reindexing when files are saved multiple times quickly.
-   */
-  handleChange(type, filepath) {
-    const existingTimer = this.debounceTimers.get(filepath);
-    if (existingTimer) {
-      clearTimeout(existingTimer);
-    }
-    const timer = setTimeout(() => {
-      this.debounceTimers.delete(filepath);
-      if (this.onChangeHandler) {
-        const absolutePath = path3.isAbsolute(filepath) ? filepath : path3.join(this.rootDir, filepath);
-        try {
-          const result = this.onChangeHandler({
-            type,
-            filepath: absolutePath
-          });
-          if (result instanceof Promise) {
-            result.catch((error) => {
-              console.error(`[Lien] Error handling file change: ${error}`);
-            });
-          }
-        } catch (error) {
-          console.error(`[Lien] Error handling file change: ${error}`);
-        }
-      }
-    }, this.config.fileWatching.debounceMs);
-    this.debounceTimers.set(filepath, timer);
-  }
-  /**
-   * Stops the file watcher and cleans up resources.
-   */
-  async stop() {
-    if (!this.watcher) {
-      return;
-    }
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
+// src/mcp/server-config.ts
+import { LienError as LienError2, LienErrorCode as LienErrorCode2 } from "@liendev/core";
+function createMCPServerConfig(name, version) {
+  return {
+    name,
+    version,
+    capabilities: {
+      tools: {},
+      logging: {}
     }
-    this.debounceTimers.clear();
-    await this.watcher.close();
-    this.watcher = null;
-    this.onChangeHandler = null;
-  }
-  /**
-   * Gets the list of files currently being watched.
-   */
-  getWatchedFiles() {
-    if (!this.watcher) {
-      return [];
+  };
+}
+function registerMCPHandlers(server, toolContext, log) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    log(`Handling tool call: ${name}`);
+    const handler = toolHandlers[name];
+    if (!handler) {
+      const error = new LienError2(
+        `Unknown tool: ${name}`,
+        LienErrorCode2.INVALID_INPUT,
+        { requestedTool: name, availableTools: tools.map((t) => t.name) },
+        "medium",
+        false,
+        false
+      );
+      return {
+        isError: true,
+        content: [{ type: "text", text: JSON.stringify(error.toJSON(), null, 2) }]
+      };
     }
-    const watched = this.watcher.getWatched();
-    const files = [];
-    for (const [dir, filenames] of Object.entries(watched)) {
-      for (const filename of filenames) {
-        files.push(`${dir}/${filename}`);
+    try {
+      return await handler(args, toolContext);
+    } catch (error) {
+      if (error instanceof LienError2) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: JSON.stringify(error.toJSON(), null, 2) }]
+        };
       }
+      console.error(`Unexpected error handling tool call ${name}:`, error);
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                error: error instanceof Error ? error.message : "Unknown error",
+                code: LienErrorCode2.INTERNAL_ERROR,
+                tool: name
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
     }
-    return files;
-  }
-  /**
-   * Checks if the watcher is currently running.
-   */
-  isRunning() {
-    return this.watcher !== null;
-  }
-};
+  });
+}
 
 // src/mcp/server.ts
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname2(__filename3);
-var require4 = createRequire3(import.meta.url);
+var require3 = createRequire2(import.meta.url);
 var packageJson2;
 try {
-  packageJson2 = require4(join2(__dirname3, "../package.json"));
+  packageJson2 = require3(join2(__dirname3, "../package.json"));
 } catch {
-  packageJson2 = require4(join2(__dirname3, "../../package.json"));
+  packageJson2 = require3(join2(__dirname3, "../../package.json"));
 }
 async function initializeDatabase(rootDir, log) {
   const embeddings = new LocalEmbeddings();
-  const vectorDB = new VectorDB(rootDir);
+  log("Creating vector database...");
+  const vectorDB = await createVectorDB(rootDir);
+  if (!vectorDB) {
+    throw new Error("createVectorDB returned undefined or null");
+  }
+  if (typeof vectorDB.initialize !== "function") {
+    throw new Error(`Invalid vectorDB instance: ${vectorDB.constructor?.name || "unknown"}. Expected VectorDBInterface but got: ${JSON.stringify(Object.keys(vectorDB))}`);
+  }
   log("Loading embedding model...");
   await embeddings.initialize();
   log("Loading vector database...");
@@ -9282,9 +9378,9 @@ async function initializeDatabase(rootDir, log) {
   log("Embeddings and vector DB ready");
   return { embeddings, vectorDB };
 }
-async function handleAutoIndexing(vectorDB, config, rootDir, log) {
+async function handleAutoIndexing(vectorDB, rootDir, log) {
   const hasIndex = await vectorDB.hasData();
-  if (!hasIndex && config.mcp.autoIndexOnFirstRun) {
+  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 {
@@ -9295,16 +9391,9 @@ async function handleAutoIndexing(vectorDB, config, rootDir, log) {
       log(`\u26A0\uFE0F  Initial indexing failed: ${error}`, "warning");
       log("You can manually run: lien index", "warning");
     }
-  } else if (!hasIndex) {
-    log("\u26A0\uFE0F  No index found. Auto-indexing is disabled in config.", "warning");
-    log('Run "lien index" to index your codebase.', "warning");
   }
 }
-async function setupGitDetection(config, rootDir, vectorDB, embeddings, verbose, log) {
-  if (!config.gitDetection.enabled) {
-    log("Git detection disabled by configuration");
-    return { gitTracker: null, gitPollInterval: null };
-  }
+async function setupGitDetection(rootDir, vectorDB, embeddings, verbose, log) {
   const gitAvailable = await isGitAvailable();
   const isRepo = await isGitRepo2(rootDir);
   if (!gitAvailable) {
@@ -9322,7 +9411,7 @@ async function setupGitDetection(config, rootDir, vectorDB, embeddings, verbose,
     const changedFiles = await gitTracker.initialize();
     if (changedFiles && changedFiles.length > 0) {
       log(`\u{1F33F} Git changes detected: ${changedFiles.length} files changed`);
-      const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, config, { verbose });
+      const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, { verbose });
       log(`\u2713 Reindexed ${count} files`);
     } else {
       log("\u2713 Index is up to date with git state");
@@ -9330,25 +9419,28 @@ async function setupGitDetection(config, rootDir, vectorDB, embeddings, verbose,
   } catch (error) {
     log(`Failed to check git state on startup: ${error}`, "warning");
   }
-  log(`\u2713 Git detection enabled (checking every ${config.gitDetection.pollIntervalMs / 1e3}s)`);
+  const pollIntervalSeconds = DEFAULT_GIT_POLL_INTERVAL_MS2 / 1e3;
+  log(`\u2713 Git detection enabled (checking every ${pollIntervalSeconds}s)`);
   const gitPollInterval = setInterval(async () => {
     try {
       const changedFiles = await gitTracker.detectChanges();
       if (changedFiles && changedFiles.length > 0) {
         log(`\u{1F33F} Git change detected: ${changedFiles.length} files changed`);
-        indexMultipleFiles(changedFiles, vectorDB, embeddings, config, { verbose }).then((count) => log(`\u2713 Background reindex complete: ${count} files`)).catch((error) => log(`Background reindex failed: ${error}`, "warning"));
+        indexMultipleFiles(changedFiles, vectorDB, embeddings, { verbose }).then((count) => log(`\u2713 Background reindex complete: ${count} files`)).catch((error) => log(`Background reindex failed: ${error}`, "warning"));
       }
     } catch (error) {
       log(`Git detection check failed: ${error}`, "warning");
     }
-  }, config.gitDetection.pollIntervalMs);
+  }, DEFAULT_GIT_POLL_INTERVAL_MS2);
   return { gitTracker, gitPollInterval };
 }
-async function setupFileWatching(watch, config, rootDir, vectorDB, embeddings, verbose, log) {
-  const fileWatchingEnabled = watch !== void 0 ? watch : config.fileWatching.enabled;
-  if (!fileWatchingEnabled) return null;
+async function setupFileWatching(watch, rootDir, vectorDB, embeddings, verbose, log) {
+  const fileWatchingEnabled = watch !== void 0 ? watch : true;
+  if (!fileWatchingEnabled) {
+    return null;
+  }
   log("\u{1F440} Starting file watcher...");
-  const fileWatcher = new FileWatcher(rootDir, config);
+  const fileWatcher = new FileWatcher(rootDir);
   try {
     await fileWatcher.start(async (event) => {
       const { type, filepath } = event;
@@ -9365,7 +9457,7 @@ async function setupFileWatching(watch, config, rootDir, vectorDB, embeddings, v
       } else {
         const action = type === "add" ? "added" : "changed";
         log(`\u{1F4DD} File ${action}: ${filepath}`);
-        indexSingleFile(filepath, vectorDB, embeddings, config, { verbose }).catch((error) => log(`Failed to reindex ${filepath}: ${error}`, "warning"));
+        indexSingleFile(filepath, vectorDB, embeddings, { verbose }).catch((error) => log(`Failed to reindex ${filepath}: ${error}`, "warning"));
       }
     });
     log(`\u2713 File watching enabled (watching ${fileWatcher.getWatchedFiles().length} files)`);
@@ -9375,56 +9467,52 @@ async function setupFileWatching(watch, config, rootDir, vectorDB, embeddings, v
     return null;
   }
 }
-function registerToolCallHandler(server, toolContext, log) {
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    log(`Handling tool call: ${name}`);
-    const handler = toolHandlers[name];
-    if (!handler) {
-      const error = new LienError2(
-        `Unknown tool: ${name}`,
-        LienErrorCode2.INVALID_INPUT,
-        { requestedTool: name, availableTools: tools.map((t) => t.name) },
-        "medium",
-        false,
-        false
-      );
-      return { isError: true, content: [{ type: "text", text: JSON.stringify(error.toJSON(), null, 2) }] };
-    }
+function setupTransport(log) {
+  const transport = new StdioServerTransport();
+  transport.onclose = () => {
+    log("Transport closed");
+  };
+  transport.onerror = (error) => {
+    log(`Transport error: ${error}`);
+  };
+  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) {
+  const checkAndReconnect = async () => {
     try {
-      return await handler(args, toolContext);
-    } catch (error) {
-      if (error instanceof LienError2) {
-        return { isError: true, content: [{ type: "text", text: JSON.stringify(error.toJSON(), null, 2) }] };
+      if (await vectorDB.checkVersion()) {
+        log("Index version changed, reconnecting...");
+        await vectorDB.reconnect();
       }
-      console.error(`Unexpected error handling tool call ${name}:`, error);
-      return {
-        isError: true,
-        content: [{
-          type: "text",
-          text: JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error", code: LienErrorCode2.INTERNAL_ERROR, tool: name }, null, 2)
-        }]
-      };
+    } catch (error) {
+      log(`Version check failed: ${error}`, "warning");
     }
+  };
+  const getIndexMetadata = () => ({
+    indexVersion: vectorDB.getCurrentVersion(),
+    indexDate: vectorDB.getVersionDate()
   });
+  const interval = setInterval(checkAndReconnect, VERSION_CHECK_INTERVAL_MS);
+  return { interval, checkAndReconnect, getIndexMetadata };
 }
-async function startMCPServer(options) {
-  const { rootDir, verbose, watch } = options;
-  const earlyLog = (message, level = "info") => {
+function createEarlyLog(verbose) {
+  return (message, level = "info") => {
     if (verbose || level === "warning" || level === "error") {
       console.error(`[Lien MCP] [${level}] ${message}`);
     }
   };
-  earlyLog("Initializing MCP server...");
-  const { embeddings, vectorDB } = await initializeDatabase(rootDir, earlyLog).catch((error) => {
-    console.error(`Failed to initialize: ${error}`);
-    process.exit(1);
-  });
-  const server = new Server(
-    { name: "lien", version: packageJson2.version },
-    { capabilities: { tools: {}, logging: {} } }
-  );
-  const log = (message, level = "info") => {
+}
+function createMCPLog(server, verbose) {
+  return (message, level = "info") => {
     if (verbose || level === "warning" || level === "error") {
       server.sendLoggingMessage({
         level,
@@ -9435,45 +9523,61 @@ async function startMCPServer(options) {
       });
     }
   };
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-  const checkAndReconnect = async () => {
-    try {
-      if (await vectorDB.checkVersion()) {
-        log("Index version changed, reconnecting...");
-        await vectorDB.reconnect();
-      }
-    } catch (error) {
-      log(`Version check failed: ${error}`, "warning");
+}
+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.`);
     }
-  };
-  const getIndexMetadata = () => ({
-    indexVersion: vectorDB.getCurrentVersion(),
-    indexDate: vectorDB.getVersionDate()
-  });
-  const versionCheckInterval = setInterval(checkAndReconnect, VERSION_CHECK_INTERVAL_MS);
-  const config = await configService2.load(rootDir);
-  const toolContext = { vectorDB, embeddings, config, rootDir, log, checkAndReconnect, getIndexMetadata };
-  registerToolCallHandler(server, toolContext, log);
-  await handleAutoIndexing(vectorDB, config, rootDir, log);
-  const { gitPollInterval } = await setupGitDetection(config, rootDir, vectorDB, embeddings, verbose, log);
-  const fileWatcher = await setupFileWatching(watch, config, rootDir, vectorDB, embeddings, verbose, log);
-  const cleanup = async () => {
-    log("Shutting down MCP server...");
-    clearInterval(versionCheckInterval);
-    if (gitPollInterval) clearInterval(gitPollInterval);
-    if (fileWatcher) await fileWatcher.stop();
-    process.exit(0);
-  };
+    return result;
+  } catch (error) {
+    console.error(`Failed to initialize: ${error}`);
+    if (error instanceof Error && error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+function createMCPServer() {
+  const serverConfig = createMCPServerConfig("lien", packageJson2.version);
+  return new Server(
+    { name: serverConfig.name, version: serverConfig.version },
+    { capabilities: serverConfig.capabilities }
+  );
+}
+async function setupAndConnectServer(server, toolContext, log, versionCheckInterval, options) {
+  const { rootDir, verbose, watch } = options;
+  const { vectorDB, embeddings } = toolContext;
+  registerMCPHandlers(server, toolContext, log);
+  await handleAutoIndexing(vectorDB, rootDir, log);
+  const { gitPollInterval } = await setupGitDetection(rootDir, vectorDB, embeddings, verbose, log);
+  const fileWatcher = await setupFileWatching(watch, rootDir, vectorDB, embeddings, verbose, log);
+  const cleanup = setupCleanupHandlers(versionCheckInterval, gitPollInterval, fileWatcher, log);
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
-  const transport = new StdioServerTransport();
+  const transport = setupTransport(log);
   transport.onclose = () => {
-    log("Transport closed");
     cleanup().catch(() => process.exit(0));
   };
-  transport.onerror = (error) => log(`Transport error: ${error}`);
-  await server.connect(transport);
-  log("MCP server started and listening on stdio");
+  try {
+    await server.connect(transport);
+    log("MCP server started and listening on stdio");
+  } catch (error) {
+    console.error(`Failed to connect MCP transport: ${error}`);
+    process.exit(1);
+  }
+}
+async function startMCPServer(options) {
+  const { rootDir, verbose, watch } = options;
+  const earlyLog = createEarlyLog(verbose);
+  earlyLog("Initializing MCP server...");
+  const { embeddings, vectorDB } = await initializeComponents(rootDir, earlyLog);
+  const server = createMCPServer();
+  const log = createMCPLog(server, verbose);
+  const { interval: versionCheckInterval, checkAndReconnect, getIndexMetadata } = setupVersionChecking(vectorDB, log);
+  const toolContext = { vectorDB, embeddings, rootDir, log, checkAndReconnect, getIndexMetadata };
+  await setupAndConnectServer(server, toolContext, log, versionCheckInterval, { rootDir, verbose, watch });
 }
 
 // src/cli/serve.ts
@@ -9525,8 +9629,7 @@ async function serveCommand(options) {
 import chalk6 from "chalk";
 import fs4 from "fs";
 import path5 from "path";
-import { VectorDB as VectorDB2 } from "@liendev/core";
-import { configService as configService3 } from "@liendev/core";
+import { VectorDB } from "@liendev/core";
 import { ComplexityAnalyzer as ComplexityAnalyzer2 } from "@liendev/core";
 import { formatReport } from "@liendev/core";
 var VALID_FAIL_ON = ["error", "warning"];
@@ -9555,47 +9658,6 @@ function validateFilesExist(files, rootDir) {
     process.exit(1);
   }
 }
-function parseThresholdValue(value, flagName) {
-  if (!value) return null;
-  const parsed = parseInt(value, 10);
-  if (isNaN(parsed)) {
-    console.error(chalk6.red(`Error: Invalid ${flagName} value "${value}". Must be a number`));
-    process.exit(1);
-  }
-  if (parsed <= 0) {
-    console.error(chalk6.red(`Error: Invalid ${flagName} value "${value}". Must be a positive number`));
-    process.exit(1);
-  }
-  return parsed;
-}
-function parseThresholdOverrides(options) {
-  const baseThreshold = parseThresholdValue(options.threshold, "--threshold");
-  const cyclomaticOverride = parseThresholdValue(options.cyclomaticThreshold, "--cyclomatic-threshold");
-  const cognitiveOverride = parseThresholdValue(options.cognitiveThreshold, "--cognitive-threshold");
-  return {
-    // Specific flags take precedence over --threshold
-    cyclomatic: cyclomaticOverride ?? baseThreshold,
-    cognitive: cognitiveOverride ?? baseThreshold
-  };
-}
-function applyThresholdOverrides(config, overrides) {
-  if (overrides.cyclomatic === null && overrides.cognitive === null) return;
-  const cfg = config;
-  if (!cfg.complexity) {
-    cfg.complexity = {
-      enabled: true,
-      thresholds: { testPaths: 15, mentalLoad: 15 }
-    };
-  } else if (!cfg.complexity.thresholds) {
-    cfg.complexity.thresholds = { testPaths: 15, mentalLoad: 15 };
-  }
-  if (overrides.cyclomatic !== null) {
-    cfg.complexity.thresholds.testPaths = overrides.cyclomatic;
-  }
-  if (overrides.cognitive !== null) {
-    cfg.complexity.thresholds.mentalLoad = overrides.cognitive;
-  }
-}
 async function ensureIndexExists(vectorDB) {
   try {
     await vectorDB.scanWithFilter({ limit: 1 });
@@ -9611,13 +9673,14 @@ async function complexityCommand(options) {
     validateFailOn(options.failOn);
     validateFormat(options.format);
     validateFilesExist(options.files, rootDir);
-    const thresholdOverrides = parseThresholdOverrides(options);
-    const config = await configService3.load(rootDir);
-    const vectorDB = new VectorDB2(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);
-    applyThresholdOverrides(config, thresholdOverrides);
-    const analyzer = new ComplexityAnalyzer2(vectorDB, config);
+    const analyzer = new ComplexityAnalyzer2(vectorDB);
     const report = await analyzer.analyze(options.files);
     console.log(formatReport(report, options.format));
     if (options.failOn) {
@@ -9633,12 +9696,12 @@ async function complexityCommand(options) {
 // src/cli/index.ts
 var __filename4 = fileURLToPath4(import.meta.url);
 var __dirname4 = dirname3(__filename4);
-var require5 = createRequire4(import.meta.url);
+var require4 = createRequire3(import.meta.url);
 var packageJson3;
 try {
-  packageJson3 = require5(join3(__dirname4, "../package.json"));
+  packageJson3 = require4(join3(__dirname4, "../package.json"));
 } catch {
-  packageJson3 = require5(join3(__dirname4, "../../package.json"));
+  packageJson3 = require4(join3(__dirname4, "../../package.json"));
 }
 var program = new Command();
 program.name("lien").description("Local semantic code search for AI assistants via MCP").version(packageJson3.version);