@liendev/lien 0.8.1

package/dist/index.js

@@ -0,0 +1,3695 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants.ts
+var DEFAULT_CHUNK_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CONCURRENCY, DEFAULT_EMBEDDING_BATCH_SIZE, EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL, DEFAULT_PORT, VERSION_CHECK_INTERVAL_MS, DEFAULT_GIT_POLL_INTERVAL_MS, DEFAULT_DEBOUNCE_MS, CURRENT_CONFIG_VERSION;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    DEFAULT_CHUNK_SIZE = 75;
+    DEFAULT_CHUNK_OVERLAP = 10;
+    DEFAULT_CONCURRENCY = 4;
+    DEFAULT_EMBEDDING_BATCH_SIZE = 50;
+    EMBEDDING_DIMENSIONS = 384;
+    DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
+    DEFAULT_PORT = 7133;
+    VERSION_CHECK_INTERVAL_MS = 2e3;
+    DEFAULT_GIT_POLL_INTERVAL_MS = 1e4;
+    DEFAULT_DEBOUNCE_MS = 1e3;
+    CURRENT_CONFIG_VERSION = "0.3.0";
+  }
+});
+
+// src/config/schema.ts
+function isLegacyConfig(config) {
+  return "indexing" in config && !("frameworks" in config);
+}
+function isModernConfig(config) {
+  return "frameworks" in config;
+}
+var defaultConfig;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    "use strict";
+    init_constants();
+    defaultConfig = {
+      version: CURRENT_CONFIG_VERSION,
+      core: {
+        chunkSize: DEFAULT_CHUNK_SIZE,
+        chunkOverlap: DEFAULT_CHUNK_OVERLAP,
+        concurrency: DEFAULT_CONCURRENCY,
+        embeddingBatchSize: DEFAULT_EMBEDDING_BATCH_SIZE
+      },
+      mcp: {
+        port: DEFAULT_PORT,
+        transport: "stdio",
+        autoIndexOnFirstRun: true
+      },
+      gitDetection: {
+        enabled: true,
+        pollIntervalMs: DEFAULT_GIT_POLL_INTERVAL_MS
+      },
+      fileWatching: {
+        enabled: false,
+        // Opt-in feature
+        debounceMs: DEFAULT_DEBOUNCE_MS
+      },
+      frameworks: []
+      // Will be populated by lien init via framework detection
+    };
+  }
+});
+
+// src/config/merge.ts
+function deepMergeConfig(defaults, user) {
+  return {
+    version: user.version ?? defaults.version,
+    core: {
+      ...defaults.core,
+      ...user.core
+    },
+    mcp: {
+      ...defaults.mcp,
+      ...user.mcp
+    },
+    gitDetection: {
+      ...defaults.gitDetection,
+      ...user.gitDetection
+    },
+    fileWatching: {
+      ...defaults.fileWatching,
+      ...user.fileWatching
+    },
+    frameworks: user.frameworks ?? defaults.frameworks
+  };
+}
+function detectNewFields(before, after) {
+  const newFields = [];
+  for (const key of Object.keys(after)) {
+    if (!(key in before)) {
+      newFields.push(key);
+      continue;
+    }
+    if (typeof after[key] === "object" && after[key] !== null && !Array.isArray(after[key])) {
+      const beforeSection = before[key] || {};
+      const afterSection = after[key];
+      for (const nestedKey of Object.keys(afterSection)) {
+        if (!(nestedKey in beforeSection)) {
+          newFields.push(`${key}.${nestedKey}`);
+        }
+      }
+    }
+  }
+  return newFields;
+}
+var init_merge = __esm({
+  "src/config/merge.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/banner.ts
+var banner_exports = {};
+__export(banner_exports, {
+  showBanner: () => showBanner,
+  showCompactBanner: () => showCompactBanner
+});
+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;
+  }
+});
+
+// src/config/migration.ts
+function needsMigration(config) {
+  if (!config) {
+    return false;
+  }
+  if (config.frameworks !== void 0) {
+    return false;
+  }
+  if (config.indexing !== void 0) {
+    return true;
+  }
+  if (config.version && config.version.startsWith("0.2")) {
+    return true;
+  }
+  return false;
+}
+function migrateConfig(oldConfig) {
+  const newConfig = {
+    version: "0.3.0",
+    core: {
+      chunkSize: oldConfig.indexing?.chunkSize ?? defaultConfig.core.chunkSize,
+      chunkOverlap: oldConfig.indexing?.chunkOverlap ?? defaultConfig.core.chunkOverlap,
+      concurrency: oldConfig.indexing?.concurrency ?? defaultConfig.core.concurrency,
+      embeddingBatchSize: oldConfig.indexing?.embeddingBatchSize ?? defaultConfig.core.embeddingBatchSize
+    },
+    mcp: {
+      port: oldConfig.mcp?.port ?? defaultConfig.mcp.port,
+      transport: oldConfig.mcp?.transport ?? defaultConfig.mcp.transport,
+      autoIndexOnFirstRun: oldConfig.mcp?.autoIndexOnFirstRun ?? defaultConfig.mcp.autoIndexOnFirstRun
+    },
+    gitDetection: {
+      enabled: oldConfig.gitDetection?.enabled ?? defaultConfig.gitDetection.enabled,
+      pollIntervalMs: oldConfig.gitDetection?.pollIntervalMs ?? defaultConfig.gitDetection.pollIntervalMs
+    },
+    fileWatching: {
+      enabled: oldConfig.fileWatching?.enabled ?? defaultConfig.fileWatching.enabled,
+      debounceMs: oldConfig.fileWatching?.debounceMs ?? defaultConfig.fileWatching.debounceMs
+    },
+    frameworks: []
+  };
+  if (oldConfig.indexing) {
+    const genericFramework = {
+      name: "generic",
+      path: ".",
+      enabled: true,
+      config: {
+        include: oldConfig.indexing.include ?? ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        exclude: oldConfig.indexing.exclude ?? [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/.git/**",
+          "**/coverage/**",
+          "**/.next/**",
+          "**/.nuxt/**",
+          "**/vendor/**"
+        ]
+      }
+    };
+    newConfig.frameworks.push(genericFramework);
+  } else {
+    const genericFramework = {
+      name: "generic",
+      path: ".",
+      enabled: true,
+      config: {
+        include: ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        exclude: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/.git/**",
+          "**/coverage/**",
+          "**/.next/**",
+          "**/.nuxt/**",
+          "**/vendor/**"
+        ]
+      }
+    };
+    newConfig.frameworks.push(genericFramework);
+  }
+  return newConfig;
+}
+var init_migration = __esm({
+  "src/config/migration.ts"() {
+    "use strict";
+    init_schema();
+  }
+});
+
+// src/errors/index.ts
+function wrapError(error, context, additionalContext) {
+  const message = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack : void 0;
+  const wrappedError = new LienError(
+    `${context}: ${message}`,
+    "WRAPPED_ERROR",
+    additionalContext
+  );
+  if (stack) {
+    wrappedError.stack = `${wrappedError.stack}
+
+Caused by:
+${stack}`;
+  }
+  return wrappedError;
+}
+var LienError, ConfigError, EmbeddingError, DatabaseError;
+var init_errors = __esm({
+  "src/errors/index.ts"() {
+    "use strict";
+    LienError = class extends Error {
+      constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = "LienError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+      }
+    };
+    ConfigError = class extends LienError {
+      constructor(message, context) {
+        super(message, "CONFIG_ERROR", context);
+        this.name = "ConfigError";
+      }
+    };
+    EmbeddingError = class extends LienError {
+      constructor(message, context) {
+        super(message, "EMBEDDING_ERROR", context);
+        this.name = "EmbeddingError";
+      }
+    };
+    DatabaseError = class extends LienError {
+      constructor(message, context) {
+        super(message, "DATABASE_ERROR", context);
+        this.name = "DatabaseError";
+      }
+    };
+  }
+});
+
+// src/config/service.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+var ConfigService, configService;
+var init_service = __esm({
+  "src/config/service.ts"() {
+    "use strict";
+    init_schema();
+    init_merge();
+    init_migration();
+    init_errors();
+    ConfigService = class _ConfigService {
+      static CONFIG_FILENAME = ".lien.config.json";
+      /**
+       * Load configuration from the specified directory.
+       * Automatically handles migration if needed.
+       * 
+       * @param rootDir - Root directory containing the config file
+       * @returns Loaded and validated configuration
+       * @throws {ConfigError} If config is invalid or cannot be loaded
+       */
+      async load(rootDir = process.cwd()) {
+        const configPath = this.getConfigPath(rootDir);
+        try {
+          const configContent = await fs5.readFile(configPath, "utf-8");
+          const userConfig = JSON.parse(configContent);
+          if (this.needsMigration(userConfig)) {
+            console.log("\u{1F504} Migrating config from v0.2.0 to v0.3.0...");
+            const result = await this.migrate(rootDir);
+            if (result.migrated && result.backupPath) {
+              const backupFilename = path5.basename(result.backupPath);
+              console.log(`\u2705 Migration complete! Backup saved as ${backupFilename}`);
+              console.log("\u{1F4DD} Your config now uses the framework-based structure.");
+            }
+            return result.config;
+          }
+          const mergedConfig = deepMergeConfig(defaultConfig, userConfig);
+          const validation = this.validate(mergedConfig);
+          if (!validation.valid) {
+            throw new ConfigError(
+              `Invalid configuration:
+${validation.errors.join("\n")}`,
+              { errors: validation.errors, warnings: validation.warnings }
+            );
+          }
+          if (validation.warnings.length > 0) {
+            console.warn("\u26A0\uFE0F  Configuration warnings:");
+            validation.warnings.forEach((warning) => console.warn(`   ${warning}`));
+          }
+          return mergedConfig;
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return defaultConfig;
+          }
+          if (error instanceof ConfigError) {
+            throw error;
+          }
+          if (error instanceof SyntaxError) {
+            throw new ConfigError(
+              "Failed to parse config file: Invalid JSON syntax",
+              { path: configPath, originalError: error.message }
+            );
+          }
+          throw wrapError(error, "Failed to load configuration", { path: configPath });
+        }
+      }
+      /**
+       * Save configuration to the specified directory.
+       * Validates the config before saving.
+       * 
+       * @param rootDir - Root directory to save the config file
+       * @param config - Configuration to save
+       * @throws {ConfigError} If config is invalid or cannot be saved
+       */
+      async save(rootDir, config) {
+        const configPath = this.getConfigPath(rootDir);
+        const validation = this.validate(config);
+        if (!validation.valid) {
+          throw new ConfigError(
+            `Cannot save invalid configuration:
+${validation.errors.join("\n")}`,
+            { errors: validation.errors }
+          );
+        }
+        try {
+          const configJson = JSON.stringify(config, null, 2) + "\n";
+          await fs5.writeFile(configPath, configJson, "utf-8");
+        } catch (error) {
+          throw wrapError(error, "Failed to save configuration", { path: configPath });
+        }
+      }
+      /**
+       * Check if a configuration file exists in the specified directory.
+       * 
+       * @param rootDir - Root directory to check
+       * @returns True if config file exists
+       */
+      async exists(rootDir = process.cwd()) {
+        const configPath = this.getConfigPath(rootDir);
+        try {
+          await fs5.access(configPath);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Migrate configuration from v0.2.0 to v0.3.0 format.
+       * Creates a backup of the original config file.
+       * 
+       * @param rootDir - Root directory containing the config file
+       * @returns Migration result with status and new config
+       * @throws {ConfigError} If migration fails
+       */
+      async migrate(rootDir = process.cwd()) {
+        const configPath = this.getConfigPath(rootDir);
+        try {
+          const configContent = await fs5.readFile(configPath, "utf-8");
+          const oldConfig = JSON.parse(configContent);
+          if (!this.needsMigration(oldConfig)) {
+            return {
+              migrated: false,
+              config: oldConfig
+            };
+          }
+          const newConfig = migrateConfig(oldConfig);
+          const validation = this.validate(newConfig);
+          if (!validation.valid) {
+            throw new ConfigError(
+              `Migration produced invalid configuration:
+${validation.errors.join("\n")}`,
+              { errors: validation.errors }
+            );
+          }
+          const backupPath = `${configPath}.v0.2.0.backup`;
+          await fs5.copyFile(configPath, backupPath);
+          await this.save(rootDir, newConfig);
+          return {
+            migrated: true,
+            backupPath,
+            config: newConfig
+          };
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return {
+              migrated: false,
+              config: defaultConfig
+            };
+          }
+          if (error instanceof ConfigError) {
+            throw error;
+          }
+          throw wrapError(error, "Configuration migration failed", { path: configPath });
+        }
+      }
+      /**
+       * Check if a config object needs migration from v0.2.0 to v0.3.0.
+       * 
+       * @param config - Config object to check
+       * @returns True if migration is needed
+       */
+      needsMigration(config) {
+        return needsMigration(config);
+      }
+      /**
+       * Validate a configuration object.
+       * Checks all constraints and returns detailed validation results.
+       * 
+       * @param config - Configuration to validate
+       * @returns Validation result with errors and warnings
+       */
+      validate(config) {
+        const errors = [];
+        const warnings = [];
+        if (!config || typeof config !== "object") {
+          return {
+            valid: false,
+            errors: ["Configuration must be an object"],
+            warnings: []
+          };
+        }
+        const cfg = config;
+        if (!cfg.version) {
+          errors.push("Missing required field: version");
+        }
+        if (isModernConfig(cfg)) {
+          this.validateModernConfig(cfg, errors, warnings);
+        } else if (isLegacyConfig(cfg)) {
+          this.validateLegacyConfig(cfg, errors, warnings);
+        } else {
+          errors.push('Configuration format not recognized. Must have either "frameworks" or "indexing" field');
+        }
+        return {
+          valid: errors.length === 0,
+          errors,
+          warnings
+        };
+      }
+      /**
+       * Validate a partial configuration object.
+       * Useful for validating user input before merging with defaults.
+       * 
+       * @param config - Partial configuration to validate
+       * @returns Validation result with errors and warnings
+       */
+      validatePartial(config) {
+        const errors = [];
+        const warnings = [];
+        if (config.core) {
+          this.validateCoreConfig(config.core, errors, warnings);
+        }
+        if (config.mcp) {
+          this.validateMCPConfig(config.mcp, errors, warnings);
+        }
+        if (config.gitDetection) {
+          this.validateGitDetectionConfig(config.gitDetection, errors, warnings);
+        }
+        if (config.fileWatching) {
+          this.validateFileWatchingConfig(config.fileWatching, errors, warnings);
+        }
+        if (config.frameworks) {
+          this.validateFrameworks(config.frameworks, errors, warnings);
+        }
+        return {
+          valid: errors.length === 0,
+          errors,
+          warnings
+        };
+      }
+      /**
+       * Get the full path to the config file
+       */
+      getConfigPath(rootDir) {
+        return path5.join(rootDir, _ConfigService.CONFIG_FILENAME);
+      }
+      /**
+       * Validate modern (v0.3.0+) configuration
+       */
+      validateModernConfig(config, errors, warnings) {
+        if (!config.core) {
+          errors.push("Missing required field: core");
+          return;
+        }
+        this.validateCoreConfig(config.core, errors, warnings);
+        if (!config.mcp) {
+          errors.push("Missing required field: mcp");
+          return;
+        }
+        this.validateMCPConfig(config.mcp, errors, warnings);
+        if (!config.gitDetection) {
+          errors.push("Missing required field: gitDetection");
+          return;
+        }
+        this.validateGitDetectionConfig(config.gitDetection, errors, warnings);
+        if (!config.fileWatching) {
+          errors.push("Missing required field: fileWatching");
+          return;
+        }
+        this.validateFileWatchingConfig(config.fileWatching, errors, warnings);
+        if (!config.frameworks) {
+          errors.push("Missing required field: frameworks");
+          return;
+        }
+        this.validateFrameworks(config.frameworks, errors, warnings);
+      }
+      /**
+       * Validate legacy (v0.2.0) configuration
+       */
+      validateLegacyConfig(config, errors, warnings) {
+        warnings.push('Using legacy configuration format. Consider running "lien init" to migrate to v0.3.0');
+        if (!config.indexing) {
+          errors.push("Missing required field: indexing");
+          return;
+        }
+        const { indexing } = config;
+        if (typeof indexing.chunkSize !== "number" || indexing.chunkSize <= 0) {
+          errors.push("indexing.chunkSize must be a positive number");
+        }
+        if (typeof indexing.chunkOverlap !== "number" || indexing.chunkOverlap < 0) {
+          errors.push("indexing.chunkOverlap must be a non-negative number");
+        }
+        if (typeof indexing.concurrency !== "number" || indexing.concurrency < 1 || indexing.concurrency > 16) {
+          errors.push("indexing.concurrency must be between 1 and 16");
+        }
+        if (typeof indexing.embeddingBatchSize !== "number" || indexing.embeddingBatchSize <= 0) {
+          errors.push("indexing.embeddingBatchSize must be a positive number");
+        }
+        if (config.mcp) {
+          this.validateMCPConfig(config.mcp, errors, warnings);
+        }
+      }
+      /**
+       * Validate core configuration settings
+       */
+      validateCoreConfig(core, errors, warnings) {
+        if (core.chunkSize !== void 0) {
+          if (typeof core.chunkSize !== "number" || core.chunkSize <= 0) {
+            errors.push("core.chunkSize must be a positive number");
+          } else if (core.chunkSize < 50) {
+            warnings.push("core.chunkSize is very small (<50 lines). This may result in poor search quality");
+          } else if (core.chunkSize > 500) {
+            warnings.push("core.chunkSize is very large (>500 lines). This may impact performance");
+          }
+        }
+        if (core.chunkOverlap !== void 0) {
+          if (typeof core.chunkOverlap !== "number" || core.chunkOverlap < 0) {
+            errors.push("core.chunkOverlap must be a non-negative number");
+          }
+        }
+        if (core.concurrency !== void 0) {
+          if (typeof core.concurrency !== "number" || core.concurrency < 1 || core.concurrency > 16) {
+            errors.push("core.concurrency must be between 1 and 16");
+          }
+        }
+        if (core.embeddingBatchSize !== void 0) {
+          if (typeof core.embeddingBatchSize !== "number" || core.embeddingBatchSize <= 0) {
+            errors.push("core.embeddingBatchSize must be a positive number");
+          } else if (core.embeddingBatchSize > 100) {
+            warnings.push("core.embeddingBatchSize is very large (>100). This may cause memory issues");
+          }
+        }
+      }
+      /**
+       * Validate MCP configuration settings
+       */
+      validateMCPConfig(mcp, errors, _warnings) {
+        if (mcp.port !== void 0) {
+          if (typeof mcp.port !== "number" || mcp.port < 1024 || mcp.port > 65535) {
+            errors.push("mcp.port must be between 1024 and 65535");
+          }
+        }
+        if (mcp.transport !== void 0) {
+          if (mcp.transport !== "stdio" && mcp.transport !== "socket") {
+            errors.push('mcp.transport must be either "stdio" or "socket"');
+          }
+        }
+        if (mcp.autoIndexOnFirstRun !== void 0) {
+          if (typeof mcp.autoIndexOnFirstRun !== "boolean") {
+            errors.push("mcp.autoIndexOnFirstRun must be a boolean");
+          }
+        }
+      }
+      /**
+       * Validate git detection configuration settings
+       */
+      validateGitDetectionConfig(gitDetection, errors, _warnings) {
+        if (gitDetection.enabled !== void 0) {
+          if (typeof gitDetection.enabled !== "boolean") {
+            errors.push("gitDetection.enabled must be a boolean");
+          }
+        }
+        if (gitDetection.pollIntervalMs !== void 0) {
+          if (typeof gitDetection.pollIntervalMs !== "number" || gitDetection.pollIntervalMs < 100) {
+            errors.push("gitDetection.pollIntervalMs must be at least 100ms");
+          } else if (gitDetection.pollIntervalMs < 1e3) {
+            _warnings.push("gitDetection.pollIntervalMs is very short (<1s). This may impact performance");
+          }
+        }
+      }
+      /**
+       * Validate file watching configuration settings
+       */
+      validateFileWatchingConfig(fileWatching, errors, warnings) {
+        if (fileWatching.enabled !== void 0) {
+          if (typeof fileWatching.enabled !== "boolean") {
+            errors.push("fileWatching.enabled must be a boolean");
+          }
+        }
+        if (fileWatching.debounceMs !== void 0) {
+          if (typeof fileWatching.debounceMs !== "number" || fileWatching.debounceMs < 0) {
+            errors.push("fileWatching.debounceMs must be a non-negative number");
+          } else if (fileWatching.debounceMs < 100) {
+            warnings.push("fileWatching.debounceMs is very short (<100ms). This may cause excessive reindexing");
+          }
+        }
+      }
+      /**
+       * Validate frameworks configuration
+       */
+      validateFrameworks(frameworks, errors, warnings) {
+        if (!Array.isArray(frameworks)) {
+          errors.push("frameworks must be an array");
+          return;
+        }
+        frameworks.forEach((framework, index) => {
+          if (!framework || typeof framework !== "object") {
+            errors.push(`frameworks[${index}] must be an object`);
+            return;
+          }
+          const fw = framework;
+          if (!fw.name) {
+            errors.push(`frameworks[${index}] missing required field: name`);
+          }
+          if (fw.path === void 0) {
+            errors.push(`frameworks[${index}] missing required field: path`);
+          } else if (typeof fw.path !== "string") {
+            errors.push(`frameworks[${index}].path must be a string`);
+          } else if (path5.isAbsolute(fw.path)) {
+            errors.push(`frameworks[${index}].path must be relative, got: ${fw.path}`);
+          }
+          if (fw.enabled === void 0) {
+            errors.push(`frameworks[${index}] missing required field: enabled`);
+          } else if (typeof fw.enabled !== "boolean") {
+            errors.push(`frameworks[${index}].enabled must be a boolean`);
+          }
+          if (!fw.config) {
+            errors.push(`frameworks[${index}] missing required field: config`);
+          } else {
+            this.validateFrameworkConfig(fw.config, `frameworks[${index}].config`, errors, warnings);
+          }
+        });
+      }
+      /**
+       * Validate framework-specific configuration
+       */
+      validateFrameworkConfig(config, prefix, errors, _warnings) {
+        if (!config || typeof config !== "object") {
+          errors.push(`${prefix} must be an object`);
+          return;
+        }
+        if (!Array.isArray(config.include)) {
+          errors.push(`${prefix}.include must be an array`);
+        } else {
+          config.include.forEach((pattern, i) => {
+            if (typeof pattern !== "string") {
+              errors.push(`${prefix}.include[${i}] must be a string`);
+            }
+          });
+        }
+        if (!Array.isArray(config.exclude)) {
+          errors.push(`${prefix}.exclude must be an array`);
+        } else {
+          config.exclude.forEach((pattern, i) => {
+            if (typeof pattern !== "string") {
+              errors.push(`${prefix}.exclude[${i}] must be a string`);
+            }
+          });
+        }
+      }
+    };
+    configService = new ConfigService();
+  }
+});
+
+// src/vectordb/version.ts
+import fs7 from "fs/promises";
+import path7 from "path";
+async function writeVersionFile(indexPath) {
+  try {
+    const versionFilePath = path7.join(indexPath, VERSION_FILE);
+    const timestamp = Date.now().toString();
+    await fs7.writeFile(versionFilePath, timestamp, "utf-8");
+  } catch (error) {
+    console.error(`Warning: Failed to write version file: ${error}`);
+  }
+}
+async function readVersionFile(indexPath) {
+  try {
+    const versionFilePath = path7.join(indexPath, VERSION_FILE);
+    const content = await fs7.readFile(versionFilePath, "utf-8");
+    const timestamp = parseInt(content.trim(), 10);
+    return isNaN(timestamp) ? 0 : timestamp;
+  } catch (error) {
+    return 0;
+  }
+}
+var VERSION_FILE;
+var init_version = __esm({
+  "src/vectordb/version.ts"() {
+    "use strict";
+    VERSION_FILE = ".lien-index-version";
+  }
+});
+
+// src/indexer/scanner.ts
+import { glob } from "glob";
+import ignore from "ignore";
+import fs9 from "fs/promises";
+import path9 from "path";
+async function scanCodebaseWithFrameworks(rootDir, config) {
+  const allFiles = [];
+  for (const framework of config.frameworks) {
+    if (!framework.enabled) {
+      continue;
+    }
+    const frameworkFiles = await scanFramework(rootDir, framework);
+    allFiles.push(...frameworkFiles);
+  }
+  return allFiles;
+}
+async function scanFramework(rootDir, framework) {
+  const frameworkPath = path9.join(rootDir, framework.path);
+  const gitignorePath = path9.join(frameworkPath, ".gitignore");
+  let ig = ignore();
+  try {
+    const gitignoreContent = await fs9.readFile(gitignorePath, "utf-8");
+    ig = ignore().add(gitignoreContent);
+  } catch (e) {
+    const rootGitignorePath = path9.join(rootDir, ".gitignore");
+    try {
+      const gitignoreContent = await fs9.readFile(rootGitignorePath, "utf-8");
+      ig = ignore().add(gitignoreContent);
+    } catch (e2) {
+    }
+  }
+  ig.add([
+    ...framework.config.exclude,
+    ".lien/**"
+  ]);
+  const allFiles = [];
+  for (const pattern of framework.config.include) {
+    const files = await glob(pattern, {
+      cwd: frameworkPath,
+      absolute: false,
+      // Get paths relative to framework path
+      nodir: true,
+      ignore: framework.config.exclude
+    });
+    allFiles.push(...files);
+  }
+  const uniqueFiles = Array.from(new Set(allFiles));
+  return uniqueFiles.filter((file) => !ig.ignores(file)).map((file) => {
+    return framework.path === "." ? file : path9.join(framework.path, file);
+  });
+}
+async function scanCodebase(options) {
+  const { rootDir, includePatterns = [], excludePatterns = [] } = options;
+  const gitignorePath = path9.join(rootDir, ".gitignore");
+  let ig = ignore();
+  try {
+    const gitignoreContent = await fs9.readFile(gitignorePath, "utf-8");
+    ig = ignore().add(gitignoreContent);
+  } catch (e) {
+  }
+  ig.add([
+    "node_modules/**",
+    ".git/**",
+    "dist/**",
+    "build/**",
+    "*.min.js",
+    "*.min.css",
+    ".lien/**",
+    ...excludePatterns
+  ]);
+  const patterns = includePatterns.length > 0 ? includePatterns : ["**/*.{ts,tsx,js,jsx,py,go,rs,java,cpp,c,h,md,mdx}"];
+  const allFiles = [];
+  for (const pattern of patterns) {
+    const files = await glob(pattern, {
+      cwd: rootDir,
+      absolute: true,
+      nodir: true,
+      ignore: ["node_modules/**", ".git/**"]
+    });
+    allFiles.push(...files);
+  }
+  const uniqueFiles = Array.from(new Set(allFiles));
+  return uniqueFiles.filter((file) => {
+    const relativePath = path9.relative(rootDir, file);
+    return !ig.ignores(relativePath);
+  });
+}
+function detectLanguage(filepath) {
+  const ext = path9.extname(filepath).toLowerCase();
+  const languageMap = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".vue": "vue",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".c": "c",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".php": "php",
+    ".rb": "ruby",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".cs": "csharp",
+    ".scala": "scala",
+    ".md": "markdown",
+    ".mdx": "markdown",
+    ".markdown": "markdown"
+  };
+  return languageMap[ext] || "unknown";
+}
+var init_scanner = __esm({
+  "src/indexer/scanner.ts"() {
+    "use strict";
+  }
+});
+
+// src/indexer/symbol-extractor.ts
+function extractSymbols(content, language) {
+  const symbols = {
+    functions: [],
+    classes: [],
+    interfaces: []
+  };
+  const normalizedLang = language.toLowerCase();
+  switch (normalizedLang) {
+    case "typescript":
+    case "tsx":
+      symbols.functions = extractTSFunctions(content);
+      symbols.classes = extractTSClasses(content);
+      symbols.interfaces = extractTSInterfaces(content);
+      break;
+    case "javascript":
+    case "jsx":
+      symbols.functions = extractJSFunctions(content);
+      symbols.classes = extractJSClasses(content);
+      break;
+    case "python":
+    case "py":
+      symbols.functions = extractPythonFunctions(content);
+      symbols.classes = extractPythonClasses(content);
+      break;
+    case "php":
+      symbols.functions = extractPHPFunctions(content);
+      symbols.classes = extractPHPClasses(content);
+      symbols.interfaces = extractPHPInterfaces(content);
+      break;
+    case "vue":
+      symbols.functions = extractVueFunctions(content);
+      symbols.classes = extractVueComponents(content);
+      break;
+    case "go":
+      symbols.functions = extractGoFunctions(content);
+      symbols.interfaces = extractGoInterfaces(content);
+      break;
+    case "java":
+      symbols.functions = extractJavaFunctions(content);
+      symbols.classes = extractJavaClasses(content);
+      symbols.interfaces = extractJavaInterfaces(content);
+      break;
+    case "csharp":
+    case "cs":
+      symbols.functions = extractCSharpFunctions(content);
+      symbols.classes = extractCSharpClasses(content);
+      symbols.interfaces = extractCSharpInterfaces(content);
+      break;
+    case "ruby":
+    case "rb":
+      symbols.functions = extractRubyFunctions(content);
+      symbols.classes = extractRubyClasses(content);
+      break;
+    case "rust":
+    case "rs":
+      symbols.functions = extractRustFunctions(content);
+      break;
+  }
+  return symbols;
+}
+function extractTSFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const functionMatches = content.matchAll(/(?:async\s+)?function\s+(\w+)\s*\(/g);
+  for (const match of functionMatches) {
+    names.add(match[1]);
+  }
+  const arrowMatches = content.matchAll(/(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g);
+  for (const match of arrowMatches) {
+    names.add(match[1]);
+  }
+  const methodMatches = content.matchAll(/(?:async\s+)?(\w+)\s*\([^)]*\)\s*[:{]/g);
+  for (const match of methodMatches) {
+    if (!["if", "for", "while", "switch", "catch"].includes(match[1])) {
+      names.add(match[1]);
+    }
+  }
+  const exportMatches = content.matchAll(/export\s+(?:async\s+)?function\s+(\w+)\s*\(/g);
+  for (const match of exportMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractJSFunctions(content) {
+  return extractTSFunctions(content);
+}
+function extractTSClasses(content) {
+  const names = /* @__PURE__ */ new Set();
+  const classMatches = content.matchAll(/(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/g);
+  for (const match of classMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractJSClasses(content) {
+  return extractTSClasses(content);
+}
+function extractTSInterfaces(content) {
+  const names = /* @__PURE__ */ new Set();
+  const interfaceMatches = content.matchAll(/(?:export\s+)?interface\s+(\w+)/g);
+  for (const match of interfaceMatches) {
+    names.add(match[1]);
+  }
+  const typeMatches = content.matchAll(/(?:export\s+)?type\s+(\w+)\s*=/g);
+  for (const match of typeMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractPythonFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const functionMatches = content.matchAll(/def\s+(\w+)\s*\(/g);
+  for (const match of functionMatches) {
+    names.add(match[1]);
+  }
+  const asyncMatches = content.matchAll(/async\s+def\s+(\w+)\s*\(/g);
+  for (const match of asyncMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractPythonClasses(content) {
+  const names = /* @__PURE__ */ new Set();
+  const classMatches = content.matchAll(/class\s+(\w+)(?:\s*\(|:)/g);
+  for (const match of classMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractPHPFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const functionMatches = content.matchAll(/(?:public|private|protected)?\s*function\s+(\w+)\s*\(/g);
+  for (const match of functionMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractPHPClasses(content) {
+  const names = /* @__PURE__ */ new Set();
+  const classMatches = content.matchAll(/(?:abstract\s+)?class\s+(\w+)/g);
+  for (const match of classMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractPHPInterfaces(content) {
+  const names = /* @__PURE__ */ new Set();
+  const interfaceMatches = content.matchAll(/interface\s+(\w+)/g);
+  for (const match of interfaceMatches) {
+    names.add(match[1]);
+  }
+  const traitMatches = content.matchAll(/trait\s+(\w+)/g);
+  for (const match of traitMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractGoFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const functionMatches = content.matchAll(/func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(/g);
+  for (const match of functionMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractGoInterfaces(content) {
+  const names = /* @__PURE__ */ new Set();
+  const interfaceMatches = content.matchAll(/type\s+(\w+)\s+interface\s*\{/g);
+  for (const match of interfaceMatches) {
+    names.add(match[1]);
+  }
+  const structMatches = content.matchAll(/type\s+(\w+)\s+struct\s*\{/g);
+  for (const match of structMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractJavaFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const methodMatches = content.matchAll(/(?:public|private|protected)\s+(?:static\s+)?(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/g);
+  for (const match of methodMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractJavaClasses(content) {
+  const names = /* @__PURE__ */ new Set();
+  const classMatches = content.matchAll(/(?:public\s+)?(?:abstract\s+)?class\s+(\w+)/g);
+  for (const match of classMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractJavaInterfaces(content) {
+  const names = /* @__PURE__ */ new Set();
+  const interfaceMatches = content.matchAll(/(?:public\s+)?interface\s+(\w+)/g);
+  for (const match of interfaceMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractCSharpFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const methodMatches = content.matchAll(/(?:public|private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/g);
+  for (const match of methodMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractCSharpClasses(content) {
+  const names = /* @__PURE__ */ new Set();
+  const classMatches = content.matchAll(/(?:public|internal)?\s*(?:abstract\s+)?class\s+(\w+)/g);
+  for (const match of classMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractCSharpInterfaces(content) {
+  const names = /* @__PURE__ */ new Set();
+  const interfaceMatches = content.matchAll(/(?:public|internal)?\s*interface\s+(\w+)/g);
+  for (const match of interfaceMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractRubyFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const methodMatches = content.matchAll(/def\s+(?:self\.)?(\w+)/g);
+  for (const match of methodMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractRubyClasses(content) {
+  const names = /* @__PURE__ */ new Set();
+  const classMatches = content.matchAll(/class\s+(\w+)/g);
+  for (const match of classMatches) {
+    names.add(match[1]);
+  }
+  const moduleMatches = content.matchAll(/module\s+(\w+)/g);
+  for (const match of moduleMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractRustFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const functionMatches = content.matchAll(/(?:pub\s+)?fn\s+(\w+)\s*\(/g);
+  for (const match of functionMatches) {
+    names.add(match[1]);
+  }
+  const structMatches = content.matchAll(/(?:pub\s+)?struct\s+(\w+)/g);
+  for (const match of structMatches) {
+    names.add(match[1]);
+  }
+  const traitMatches = content.matchAll(/(?:pub\s+)?trait\s+(\w+)/g);
+  for (const match of traitMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractVueFunctions(content) {
+  const names = /* @__PURE__ */ new Set();
+  const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+  if (!scriptMatch) return [];
+  const scriptContent = scriptMatch[1];
+  const compositionMatches = scriptContent.matchAll(/(?:const|function)\s+(\w+)\s*=/g);
+  for (const match of compositionMatches) {
+    names.add(match[1]);
+  }
+  const methodMatches = scriptContent.matchAll(/(\w+)\s*\([^)]*\)\s*{/g);
+  for (const match of methodMatches) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractVueComponents(content) {
+  const names = /* @__PURE__ */ new Set();
+  const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+  if (!scriptMatch) return [];
+  const scriptContent = scriptMatch[1];
+  const nameMatch = scriptContent.match(/name:\s*['"](\w+)['"]/);
+  if (nameMatch) {
+    names.add(nameMatch[1]);
+  }
+  const defineComponentMatch = scriptContent.match(/defineComponent\s*\(/);
+  if (defineComponentMatch) {
+    names.add("VueComponent");
+  }
+  return Array.from(names);
+}
+var init_symbol_extractor = __esm({
+  "src/indexer/symbol-extractor.ts"() {
+    "use strict";
+  }
+});
+
+// src/indexer/chunker.ts
+function chunkFile(filepath, content, options = {}) {
+  const { chunkSize = 75, chunkOverlap = 10 } = options;
+  const lines = content.split("\n");
+  const chunks = [];
+  const language = detectLanguage(filepath);
+  if (lines.length === 0 || lines.length === 1 && lines[0].trim() === "") {
+    return chunks;
+  }
+  for (let i = 0; i < lines.length; i += chunkSize - chunkOverlap) {
+    const endLine = Math.min(i + chunkSize, lines.length);
+    const chunkLines = lines.slice(i, endLine);
+    const chunkContent = chunkLines.join("\n");
+    if (chunkContent.trim().length === 0) {
+      continue;
+    }
+    const symbols = extractSymbols(chunkContent, language);
+    chunks.push({
+      content: chunkContent,
+      metadata: {
+        file: filepath,
+        startLine: i + 1,
+        endLine,
+        type: "block",
+        // MVP: all chunks are 'block' type
+        language,
+        symbols
+      }
+    });
+    if (endLine >= lines.length) {
+      break;
+    }
+  }
+  return chunks;
+}
+var init_chunker = __esm({
+  "src/indexer/chunker.ts"() {
+    "use strict";
+    init_scanner();
+    init_symbol_extractor();
+  }
+});
+
+// src/embeddings/local.ts
+import { pipeline, env } from "@xenova/transformers";
+var LocalEmbeddings;
+var init_local = __esm({
+  "src/embeddings/local.ts"() {
+    "use strict";
+    init_errors();
+    init_constants();
+    env.allowRemoteModels = true;
+    env.allowLocalModels = true;
+    LocalEmbeddings = class {
+      extractor = null;
+      modelName = DEFAULT_EMBEDDING_MODEL;
+      initPromise = null;
+      async initialize() {
+        if (this.initPromise) {
+          return this.initPromise;
+        }
+        if (this.extractor) {
+          return;
+        }
+        this.initPromise = (async () => {
+          try {
+            this.extractor = await pipeline("feature-extraction", this.modelName);
+          } catch (error) {
+            this.initPromise = null;
+            throw wrapError(error, "Failed to initialize embedding model");
+          }
+        })();
+        return this.initPromise;
+      }
+      async embed(text) {
+        await this.initialize();
+        if (!this.extractor) {
+          throw new EmbeddingError("Embedding model not initialized");
+        }
+        try {
+          const output = await this.extractor(text, {
+            pooling: "mean",
+            normalize: true
+          });
+          return output.data;
+        } catch (error) {
+          throw wrapError(error, "Failed to generate embedding", { textLength: text.length });
+        }
+      }
+      async embedBatch(texts) {
+        await this.initialize();
+        if (!this.extractor) {
+          throw new EmbeddingError("Embedding model not initialized");
+        }
+        try {
+          const results = await Promise.all(
+            texts.map((text) => this.embed(text))
+          );
+          return results;
+        } catch (error) {
+          throw wrapError(error, "Failed to generate batch embeddings", { batchSize: texts.length });
+        }
+      }
+    };
+  }
+});
+
+// src/embeddings/types.ts
+var EMBEDDING_DIMENSION;
+var init_types = __esm({
+  "src/embeddings/types.ts"() {
+    "use strict";
+    init_constants();
+    EMBEDDING_DIMENSION = EMBEDDING_DIMENSIONS;
+  }
+});
+
+// src/vectordb/relevance.ts
+function calculateRelevance(score) {
+  if (score < 1) return "highly_relevant";
+  if (score < 1.3) return "relevant";
+  if (score < 1.5) return "loosely_related";
+  return "not_relevant";
+}
+var init_relevance = __esm({
+  "src/vectordb/relevance.ts"() {
+    "use strict";
+  }
+});
+
+// src/vectordb/intent-classifier.ts
+function classifyQueryIntent(query) {
+  const lower = query.toLowerCase().trim();
+  if (lower.match(/where\s+(is|are|does|can\s+i\s+find)/) || lower.match(/find\s+the\s+/) || lower.match(/locate\s+/)) {
+    return "location" /* LOCATION */;
+  }
+  if (lower.match(/how\s+does\s+.*\s+work/) || lower.match(/what\s+(is|are|does)/) || lower.match(/explain\s+/) || lower.match(/understand\s+/) || lower.match(/\b(process|workflow|architecture)\b/)) {
+    return "conceptual" /* CONCEPTUAL */;
+  }
+  if (lower.match(/how\s+(is|are)\s+.*\s+(implemented|built|coded)/) || lower.match(/implementation\s+of/) || lower.match(/source\s+code\s+for/)) {
+    return "implementation" /* IMPLEMENTATION */;
+  }
+  return "implementation" /* IMPLEMENTATION */;
+}
+var init_intent_classifier = __esm({
+  "src/vectordb/intent-classifier.ts"() {
+    "use strict";
+  }
+});
+
+// src/vectordb/lancedb.ts
+var lancedb_exports = {};
+__export(lancedb_exports, {
+  VectorDB: () => VectorDB
+});
+import * as lancedb from "vectordb";
+import path10 from "path";
+import os2 from "os";
+import crypto2 from "crypto";
+function isDocumentationFile(filepath) {
+  const lower = filepath.toLowerCase();
+  const filename = path10.basename(filepath).toLowerCase();
+  if (filename.startsWith("readme")) return true;
+  if (filename.startsWith("changelog")) return true;
+  if (filename.endsWith(".md") || filename.endsWith(".mdx") || filename.endsWith(".markdown")) {
+    return true;
+  }
+  if (lower.includes("/docs/") || lower.includes("/documentation/") || lower.includes("/wiki/") || lower.includes("/.github/")) {
+    return true;
+  }
+  if (lower.includes("architecture") || lower.includes("workflow") || lower.includes("/flow/")) {
+    return true;
+  }
+  return false;
+}
+function isTestFile(filepath) {
+  const lower = filepath.toLowerCase();
+  if (lower.includes("/test/") || lower.includes("/tests/") || lower.includes("/__tests__/")) {
+    return true;
+  }
+  if (lower.includes(".test.") || lower.includes(".spec.") || lower.includes("_test.") || lower.includes("_spec.")) {
+    return true;
+  }
+  return false;
+}
+function isUtilityFile(filepath) {
+  const lower = filepath.toLowerCase();
+  if (lower.includes("/utils/") || lower.includes("/utilities/") || lower.includes("/helpers/") || lower.includes("/lib/")) {
+    return true;
+  }
+  if (lower.includes(".util.") || lower.includes(".helper.") || lower.includes("-util.") || lower.includes("-helper.")) {
+    return true;
+  }
+  return false;
+}
+function boostPathRelevance(query, filepath, baseScore) {
+  const queryTokens = query.toLowerCase().split(/\s+/);
+  const pathSegments = filepath.toLowerCase().split("/");
+  let boostFactor = 1;
+  for (const token of queryTokens) {
+    if (token.length <= 2) continue;
+    if (pathSegments.some((seg) => seg.includes(token))) {
+      boostFactor *= 0.9;
+    }
+  }
+  return baseScore * boostFactor;
+}
+function boostFilenameRelevance(query, filepath, baseScore) {
+  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const queryTokens = query.toLowerCase().split(/\s+/);
+  let boostFactor = 1;
+  for (const token of queryTokens) {
+    if (token.length <= 2) continue;
+    if (filename === token) {
+      boostFactor *= 0.7;
+    } else if (filename.includes(token)) {
+      boostFactor *= 0.8;
+    }
+  }
+  return baseScore * boostFactor;
+}
+function boostForLocationIntent(query, filepath, baseScore) {
+  let score = baseScore;
+  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const queryTokens = query.toLowerCase().split(/\s+/);
+  for (const token of queryTokens) {
+    if (token.length <= 2) continue;
+    if (filename === token) {
+      score *= 0.6;
+    } else if (filename.includes(token)) {
+      score *= 0.7;
+    }
+  }
+  score = boostPathRelevance(query, filepath, score);
+  if (isTestFile(filepath)) {
+    score *= 1.1;
+  }
+  return score;
+}
+function boostForConceptualIntent(query, filepath, baseScore) {
+  let score = baseScore;
+  if (isDocumentationFile(filepath)) {
+    score *= 0.65;
+    const lower = filepath.toLowerCase();
+    if (lower.includes("architecture") || lower.includes("workflow") || lower.includes("flow")) {
+      score *= 0.9;
+    }
+  }
+  if (isUtilityFile(filepath)) {
+    score *= 1.05;
+  }
+  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const queryTokens = query.toLowerCase().split(/\s+/);
+  for (const token of queryTokens) {
+    if (token.length <= 2) continue;
+    if (filename.includes(token)) {
+      score *= 0.9;
+    }
+  }
+  const pathSegments = filepath.toLowerCase().split(path10.sep);
+  for (const token of queryTokens) {
+    if (token.length <= 2) continue;
+    for (const segment of pathSegments) {
+      if (segment.includes(token)) {
+        score *= 0.95;
+        break;
+      }
+    }
+  }
+  return score;
+}
+function boostForImplementationIntent(query, filepath, baseScore) {
+  let score = baseScore;
+  score = boostFilenameRelevance(query, filepath, score);
+  score = boostPathRelevance(query, filepath, score);
+  if (isTestFile(filepath)) {
+    score *= 0.9;
+  }
+  return score;
+}
+function applyRelevanceBoosting(query, filepath, baseScore) {
+  if (!query) {
+    return baseScore;
+  }
+  const intent = classifyQueryIntent(query);
+  switch (intent) {
+    case "location" /* LOCATION */:
+      return boostForLocationIntent(query, filepath, baseScore);
+    case "conceptual" /* CONCEPTUAL */:
+      return boostForConceptualIntent(query, filepath, baseScore);
+    case "implementation" /* IMPLEMENTATION */:
+      return boostForImplementationIntent(query, filepath, baseScore);
+    default:
+      return boostForImplementationIntent(query, filepath, baseScore);
+  }
+}
+var VectorDB;
+var init_lancedb = __esm({
+  "src/vectordb/lancedb.ts"() {
+    "use strict";
+    init_types();
+    init_version();
+    init_errors();
+    init_relevance();
+    init_intent_classifier();
+    VectorDB = class _VectorDB {
+      db = null;
+      table = null;
+      dbPath;
+      tableName = "code_chunks";
+      lastVersionCheck = 0;
+      currentVersion = 0;
+      constructor(projectRoot) {
+        const projectName = path10.basename(projectRoot);
+        const pathHash = crypto2.createHash("md5").update(projectRoot).digest("hex").substring(0, 8);
+        this.dbPath = path10.join(
+          os2.homedir(),
+          ".lien",
+          "indices",
+          `${projectName}-${pathHash}`
+        );
+      }
+      async initialize() {
+        try {
+          this.db = await lancedb.connect(this.dbPath);
+          try {
+            this.table = await this.db.openTable(this.tableName);
+          } catch {
+            this.table = null;
+          }
+          try {
+            this.currentVersion = await readVersionFile(this.dbPath);
+          } catch {
+            this.currentVersion = 0;
+          }
+        } catch (error) {
+          throw wrapError(error, "Failed to initialize vector database", { dbPath: this.dbPath });
+        }
+      }
+      async insertBatch(vectors, metadatas, contents) {
+        if (!this.db) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        if (vectors.length !== metadatas.length || vectors.length !== contents.length) {
+          throw new DatabaseError("Vectors, metadatas, and contents arrays must have the same length", {
+            vectorsLength: vectors.length,
+            metadatasLength: metadatas.length,
+            contentsLength: contents.length
+          });
+        }
+        try {
+          const records = vectors.map((vector, i) => ({
+            vector: Array.from(vector),
+            content: contents[i],
+            file: metadatas[i].file,
+            startLine: metadatas[i].startLine,
+            endLine: metadatas[i].endLine,
+            type: metadatas[i].type,
+            language: metadatas[i].language,
+            // Ensure arrays have at least empty string for Arrow type inference
+            functionNames: metadatas[i].symbols?.functions && metadatas[i].symbols.functions.length > 0 ? metadatas[i].symbols.functions : [""],
+            classNames: metadatas[i].symbols?.classes && metadatas[i].symbols.classes.length > 0 ? metadatas[i].symbols.classes : [""],
+            interfaceNames: metadatas[i].symbols?.interfaces && metadatas[i].symbols.interfaces.length > 0 ? metadatas[i].symbols.interfaces : [""]
+          }));
+          if (!this.table) {
+            this.table = await this.db.createTable(this.tableName, records);
+          } else {
+            await this.table.add(records);
+          }
+        } catch (error) {
+          throw wrapError(error, "Failed to insert batch into vector database");
+        }
+      }
+      async search(queryVector, limit = 5, query) {
+        if (!this.table) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        try {
+          const results = await this.table.search(Array.from(queryVector)).limit(limit + 20).execute();
+          const filtered = results.filter(
+            (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
+          ).map((r) => {
+            const baseScore = r._distance ?? 0;
+            const boostedScore = applyRelevanceBoosting(query, r.file, baseScore);
+            return {
+              content: r.content,
+              metadata: {
+                file: r.file,
+                startLine: r.startLine,
+                endLine: r.endLine,
+                type: r.type,
+                language: r.language
+              },
+              score: boostedScore,
+              relevance: calculateRelevance(boostedScore)
+            };
+          }).sort((a, b) => a.score - b.score).slice(0, limit);
+          return filtered;
+        } catch (error) {
+          const errorMsg = String(error);
+          if (errorMsg.includes("Not found:") || errorMsg.includes(".lance")) {
+            try {
+              await this.initialize();
+              const results = await this.table.search(Array.from(queryVector)).limit(limit + 20).execute();
+              return results.filter(
+                (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
+              ).map((r) => {
+                const baseScore = r._distance ?? 0;
+                const boostedScore = applyRelevanceBoosting(query, r.file, baseScore);
+                return {
+                  content: r.content,
+                  metadata: {
+                    file: r.file,
+                    startLine: r.startLine,
+                    endLine: r.endLine,
+                    type: r.type,
+                    language: r.language
+                  },
+                  score: boostedScore,
+                  relevance: calculateRelevance(boostedScore)
+                };
+              }).sort((a, b) => a.score - b.score).slice(0, limit);
+            } catch (retryError) {
+              throw new DatabaseError(
+                `Index appears corrupted or outdated. Please restart the MCP server or run 'lien reindex' in the project directory.`,
+                { originalError: retryError }
+              );
+            }
+          }
+          throw wrapError(error, "Failed to search vector database");
+        }
+      }
+      async scanWithFilter(options) {
+        if (!this.table) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        const { language, pattern, limit = 100 } = options;
+        try {
+          const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
+          const query = this.table.search(zeroVector).where('file != ""').limit(Math.max(limit * 5, 200));
+          const results = await query.execute();
+          let filtered = results.filter(
+            (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
+          );
+          if (language) {
+            filtered = filtered.filter(
+              (r) => r.language && r.language.toLowerCase() === language.toLowerCase()
+            );
+          }
+          if (pattern) {
+            const regex = new RegExp(pattern, "i");
+            filtered = filtered.filter(
+              (r) => regex.test(r.content) || regex.test(r.file)
+            );
+          }
+          return filtered.slice(0, limit).map((r) => {
+            const score = 0;
+            return {
+              content: r.content,
+              metadata: {
+                file: r.file,
+                startLine: r.startLine,
+                endLine: r.endLine,
+                type: r.type,
+                language: r.language
+              },
+              score,
+              relevance: calculateRelevance(score)
+            };
+          });
+        } catch (error) {
+          throw wrapError(error, "Failed to scan with filter");
+        }
+      }
+      async querySymbols(options) {
+        if (!this.table) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        const { language, pattern, symbolType, limit = 50 } = options;
+        try {
+          const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
+          const query = this.table.search(zeroVector).where('file != ""').limit(Math.max(limit * 10, 500));
+          const results = await query.execute();
+          let filtered = results.filter((r) => {
+            if (!r.content || r.content.trim().length === 0) {
+              return false;
+            }
+            if (!r.file || r.file.length === 0) {
+              return false;
+            }
+            if (language && (!r.language || r.language.toLowerCase() !== language.toLowerCase())) {
+              return false;
+            }
+            const symbols = symbolType === "function" ? r.functionNames || [] : symbolType === "class" ? r.classNames || [] : symbolType === "interface" ? r.interfaceNames || [] : [...r.functionNames || [], ...r.classNames || [], ...r.interfaceNames || []];
+            if (symbols.length === 0) {
+              return false;
+            }
+            if (pattern) {
+              const regex = new RegExp(pattern, "i");
+              return symbols.some((s) => regex.test(s));
+            }
+            return true;
+          });
+          return filtered.slice(0, limit).map((r) => {
+            const score = 0;
+            return {
+              content: r.content,
+              metadata: {
+                file: r.file,
+                startLine: r.startLine,
+                endLine: r.endLine,
+                type: r.type,
+                language: r.language,
+                symbols: {
+                  functions: r.functionNames || [],
+                  classes: r.classNames || [],
+                  interfaces: r.interfaceNames || []
+                }
+              },
+              score,
+              relevance: calculateRelevance(score)
+            };
+          });
+        } catch (error) {
+          throw wrapError(error, "Failed to query symbols");
+        }
+      }
+      async clear() {
+        if (!this.db) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        try {
+          if (this.table) {
+            await this.db.dropTable(this.tableName);
+          }
+          this.table = null;
+        } catch (error) {
+          throw wrapError(error, "Failed to clear vector database");
+        }
+      }
+      /**
+       * Deletes all chunks from a specific file.
+       * Used for incremental reindexing when a file is deleted or needs to be re-indexed.
+       * 
+       * @param filepath - Path to the file whose chunks should be deleted
+       */
+      async deleteByFile(filepath) {
+        if (!this.table) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        try {
+          await this.table.delete(`file = "${filepath}"`);
+        } catch (error) {
+          throw wrapError(error, "Failed to delete file from vector database");
+        }
+      }
+      /**
+       * Updates a file in the index by atomically deleting old chunks and inserting new ones.
+       * This is the primary method for incremental reindexing.
+       * 
+       * @param filepath - Path to the file being updated
+       * @param vectors - New embedding vectors
+       * @param metadatas - New chunk metadata
+       * @param contents - New chunk contents
+       */
+      async updateFile(filepath, vectors, metadatas, contents) {
+        if (!this.table) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        try {
+          await this.deleteByFile(filepath);
+          if (vectors.length > 0) {
+            await this.insertBatch(vectors, metadatas, contents);
+          }
+          await writeVersionFile(this.dbPath);
+        } catch (error) {
+          throw wrapError(error, "Failed to update file in vector database");
+        }
+      }
+      /**
+       * Checks if the index version has changed since last check.
+       * Uses caching to minimize I/O overhead (checks at most once per second).
+       * 
+       * @returns true if version has changed, false otherwise
+       */
+      async checkVersion() {
+        const now = Date.now();
+        if (now - this.lastVersionCheck < 1e3) {
+          return false;
+        }
+        this.lastVersionCheck = now;
+        try {
+          const version = await readVersionFile(this.dbPath);
+          if (version > this.currentVersion) {
+            this.currentVersion = version;
+            return true;
+          }
+          return false;
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * Reconnects to the database by reinitializing the connection.
+       * Used when the index has been rebuilt/reindexed.
+       * Forces a complete reload from disk by closing existing connections first.
+       */
+      async reconnect() {
+        try {
+          this.table = null;
+          this.db = null;
+          await this.initialize();
+        } catch (error) {
+          throw wrapError(error, "Failed to reconnect to vector database");
+        }
+      }
+      /**
+       * Gets the current index version (timestamp of last reindex).
+       * 
+       * @returns Version timestamp, or 0 if unknown
+       */
+      getCurrentVersion() {
+        return this.currentVersion;
+      }
+      /**
+       * Gets the current index version as a human-readable date string.
+       * 
+       * @returns Formatted date string, or 'Unknown' if no version
+       */
+      getVersionDate() {
+        if (this.currentVersion === 0) {
+          return "Unknown";
+        }
+        return new Date(this.currentVersion).toLocaleString();
+      }
+      /**
+       * Checks if the database contains real indexed data.
+       * Used to detect first run and trigger auto-indexing.
+       * 
+       * @returns true if database has real code chunks, false if empty or only schema rows
+       */
+      async hasData() {
+        if (!this.table) {
+          return false;
+        }
+        try {
+          const count = await this.table.countRows();
+          if (count === 0) {
+            return false;
+          }
+          const sample = await this.table.search(Array(EMBEDDING_DIMENSION).fill(0)).limit(Math.min(count, 5)).execute();
+          const hasRealData = sample.some(
+            (r) => r.content && r.content.trim().length > 0
+          );
+          return hasRealData;
+        } catch {
+          return false;
+        }
+      }
+      static async load(projectRoot) {
+        const db = new _VectorDB(projectRoot);
+        await db.initialize();
+        return db;
+      }
+    };
+  }
+});
+
+// src/indexer/index.ts
+var indexer_exports = {};
+__export(indexer_exports, {
+  indexCodebase: () => indexCodebase
+});
+import fs10 from "fs/promises";
+import ora from "ora";
+import chalk4 from "chalk";
+import pLimit from "p-limit";
+async function indexCodebase(options = {}) {
+  const rootDir = options.rootDir ?? process.cwd();
+  const spinner = ora("Starting indexing process...").start();
+  try {
+    spinner.text = "Loading configuration...";
+    const config = await configService.load(rootDir);
+    spinner.text = "Scanning codebase...";
+    let files;
+    if (isModernConfig(config) && config.frameworks.length > 0) {
+      files = await scanCodebaseWithFrameworks(rootDir, config);
+    } else if (isLegacyConfig(config)) {
+      files = await scanCodebase({
+        rootDir,
+        includePatterns: config.indexing.include,
+        excludePatterns: config.indexing.exclude
+      });
+    } else {
+      files = await scanCodebase({
+        rootDir,
+        includePatterns: [],
+        excludePatterns: []
+      });
+    }
+    if (files.length === 0) {
+      spinner.fail("No files found to index");
+      return;
+    }
+    spinner.text = `Found ${files.length} files`;
+    spinner.text = "Loading embedding model (this may take a minute on first run)...";
+    const embeddings = new LocalEmbeddings();
+    await embeddings.initialize();
+    spinner.succeed("Embedding model loaded");
+    spinner.start("Initializing vector database...");
+    const vectorDB = new VectorDB(rootDir);
+    await vectorDB.initialize();
+    spinner.succeed("Vector database initialized");
+    const concurrency = isModernConfig(config) ? config.core.concurrency : 4;
+    const batchSize = isModernConfig(config) ? config.core.embeddingBatchSize : 50;
+    spinner.start(`Processing files with ${concurrency}x concurrency...`);
+    const startTime = Date.now();
+    let processedFiles = 0;
+    let processedChunks = 0;
+    const chunkAccumulator = [];
+    const limit = pLimit(concurrency);
+    const processAccumulatedChunks = async () => {
+      if (chunkAccumulator.length === 0) return;
+      const toProcess = chunkAccumulator.splice(0, chunkAccumulator.length);
+      for (let i = 0; i < toProcess.length; i += batchSize) {
+        const batch = toProcess.slice(i, Math.min(i + batchSize, toProcess.length));
+        const texts = batch.map((item) => item.content);
+        const embeddingVectors = await embeddings.embedBatch(texts);
+        await vectorDB.insertBatch(
+          embeddingVectors,
+          batch.map((item) => item.chunk.metadata),
+          texts
+        );
+        processedChunks += batch.length;
+      }
+    };
+    const filePromises = files.map(
+      (file) => limit(async () => {
+        try {
+          const content = await fs10.readFile(file, "utf-8");
+          const chunkSize = isModernConfig(config) ? config.core.chunkSize : 75;
+          const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : 10;
+          const chunks = chunkFile(file, content, {
+            chunkSize,
+            chunkOverlap
+          });
+          if (chunks.length === 0) {
+            processedFiles++;
+            return;
+          }
+          for (const chunk of chunks) {
+            chunkAccumulator.push({
+              chunk,
+              content: chunk.content
+            });
+          }
+          if (chunkAccumulator.length >= batchSize) {
+            await processAccumulatedChunks();
+          }
+          processedFiles++;
+          const elapsed = (Date.now() - startTime) / 1e3;
+          const rate = processedFiles / elapsed;
+          const eta = rate > 0 ? Math.round((files.length - processedFiles) / rate) : 0;
+          spinner.text = `Indexed ${processedFiles}/${files.length} files (${processedChunks} chunks) | ${concurrency}x concurrency | ETA: ${eta}s`;
+        } catch (error) {
+          if (options.verbose) {
+            console.error(chalk4.yellow(`
+\u26A0\uFE0F  Skipping ${file}: ${error}`));
+          }
+          processedFiles++;
+        }
+      })
+    );
+    await Promise.all(filePromises);
+    await processAccumulatedChunks();
+    await writeVersionFile(vectorDB.dbPath);
+    const totalTime = ((Date.now() - startTime) / 1e3).toFixed(1);
+    spinner.succeed(
+      `Indexed ${processedFiles} files (${processedChunks} chunks) in ${totalTime}s using ${concurrency}x concurrency`
+    );
+    console.log(chalk4.dim("\nNext step: Run"), chalk4.bold("lien serve"), chalk4.dim("to start the MCP server"));
+  } catch (error) {
+    spinner.fail(`Indexing failed: ${error}`);
+    throw error;
+  }
+}
+var init_indexer = __esm({
+  "src/indexer/index.ts"() {
+    "use strict";
+    init_scanner();
+    init_chunker();
+    init_local();
+    init_lancedb();
+    init_service();
+    init_version();
+    init_schema();
+  }
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { createRequire as createRequire3 } from "module";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/cli/init.ts
+init_schema();
+init_merge();
+init_banner();
+init_migration();
+import fs4 from "fs/promises";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk2 from "chalk";
+import inquirer from "inquirer";
+
+// src/frameworks/detector-service.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/frameworks/types.ts
+var defaultDetectionOptions = {
+  maxDepth: 3,
+  skipDirs: [
+    "node_modules",
+    "vendor",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    "coverage",
+    ".git",
+    ".idea",
+    ".vscode",
+    "tmp",
+    "temp"
+  ]
+};
+
+// src/frameworks/nodejs/detector.ts
+import fs from "fs/promises";
+import path from "path";
+
+// src/frameworks/nodejs/config.ts
+async function generateNodeJsConfig(_rootDir, _relativePath) {
+  return {
+    include: [
+      "src/**/*.ts",
+      "src/**/*.tsx",
+      "src/**/*.js",
+      "src/**/*.jsx",
+      "src/**/*.mjs",
+      "src/**/*.cjs",
+      "lib/**/*.ts",
+      "lib/**/*.js",
+      "*.ts",
+      "*.js",
+      "*.mjs",
+      "*.cjs",
+      "**/*.md",
+      "**/*.mdx",
+      "docs/**/*.md",
+      "README.md",
+      "CHANGELOG.md",
+      "CONTRIBUTING.md"
+    ],
+    exclude: [
+      "node_modules/**",
+      "dist/**",
+      "build/**",
+      "coverage/**",
+      ".next/**",
+      ".nuxt/**",
+      "out/**",
+      "*.min.js",
+      "*.min.css",
+      "*.bundle.js"
+    ]
+  };
+}
+
+// src/frameworks/nodejs/detector.ts
+var nodejsDetector = {
+  name: "nodejs",
+  priority: 50,
+  // Generic, yields to specific frameworks like Laravel
+  async detect(rootDir, relativePath) {
+    const fullPath = path.join(rootDir, relativePath);
+    const result = {
+      detected: false,
+      name: "nodejs",
+      path: relativePath,
+      confidence: "low",
+      evidence: []
+    };
+    const packageJsonPath = path.join(fullPath, "package.json");
+    let packageJson4 = null;
+    try {
+      const content = await fs.readFile(packageJsonPath, "utf-8");
+      packageJson4 = JSON.parse(content);
+      result.evidence.push("Found package.json");
+    } catch {
+      return result;
+    }
+    result.detected = true;
+    result.confidence = "high";
+    if (packageJson4.devDependencies?.typescript || packageJson4.dependencies?.typescript) {
+      result.evidence.push("TypeScript detected");
+    }
+    const testFrameworks = [
+      { name: "jest", display: "Jest" },
+      { name: "vitest", display: "Vitest" },
+      { name: "mocha", display: "Mocha" },
+      { name: "ava", display: "AVA" },
+      { name: "@playwright/test", display: "Playwright" }
+    ];
+    for (const framework of testFrameworks) {
+      if (packageJson4.devDependencies?.[framework.name] || packageJson4.dependencies?.[framework.name]) {
+        result.evidence.push(`${framework.display} test framework detected`);
+        break;
+      }
+    }
+    const frameworks = [
+      { name: "next", display: "Next.js" },
+      { name: "react", display: "React" },
+      { name: "vue", display: "Vue" },
+      { name: "express", display: "Express" },
+      { name: "@nestjs/core", display: "NestJS" }
+    ];
+    for (const fw of frameworks) {
+      if (packageJson4.dependencies?.[fw.name]) {
+        result.evidence.push(`${fw.display} detected`);
+        break;
+      }
+    }
+    if (packageJson4.engines?.node) {
+      result.version = packageJson4.engines.node;
+    }
+    return result;
+  },
+  async generateConfig(rootDir, relativePath) {
+    return generateNodeJsConfig(rootDir, relativePath);
+  }
+};
+
+// src/frameworks/laravel/detector.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/frameworks/laravel/config.ts
+async function generateLaravelConfig(_rootDir, _relativePath) {
+  return {
+    include: [
+      // PHP backend
+      "app/**/*.php",
+      "routes/**/*.php",
+      "config/**/*.php",
+      "database/**/*.php",
+      "resources/**/*.php",
+      "tests/**/*.php",
+      "*.php",
+      // Frontend assets (Vue/React/Inertia)
+      "resources/js/**/*.js",
+      "resources/js/**/*.ts",
+      "resources/js/**/*.jsx",
+      "resources/js/**/*.tsx",
+      "resources/js/**/*.vue",
+      // Blade templates
+      "resources/views/**/*.blade.php",
+      // Documentation
+      "**/*.md",
+      "**/*.mdx",
+      "docs/**/*.md",
+      "README.md",
+      "CHANGELOG.md"
+    ],
+    exclude: [
+      "vendor/**",
+      "storage/**",
+      "bootstrap/cache/**",
+      "public/**",
+      "node_modules/**"
+    ]
+  };
+}
+
+// src/frameworks/laravel/detector.ts
+var laravelDetector = {
+  name: "laravel",
+  priority: 100,
+  // Laravel takes precedence over Node.js
+  async detect(rootDir, relativePath) {
+    const fullPath = path2.join(rootDir, relativePath);
+    const result = {
+      detected: false,
+      name: "laravel",
+      path: relativePath,
+      confidence: "low",
+      evidence: []
+    };
+    const composerJsonPath = path2.join(fullPath, "composer.json");
+    let composerJson = null;
+    try {
+      const content = await fs2.readFile(composerJsonPath, "utf-8");
+      composerJson = JSON.parse(content);
+      result.evidence.push("Found composer.json");
+    } catch {
+      return result;
+    }
+    const hasLaravel = composerJson.require?.["laravel/framework"] || composerJson["require-dev"]?.["laravel/framework"];
+    if (!hasLaravel) {
+      return result;
+    }
+    result.evidence.push("Laravel framework detected in composer.json");
+    const artisanPath = path2.join(fullPath, "artisan");
+    try {
+      await fs2.access(artisanPath);
+      result.evidence.push("Found artisan file");
+      result.confidence = "high";
+    } catch {
+      result.confidence = "medium";
+    }
+    const laravelDirs = ["app", "routes", "config", "database"];
+    let foundDirs = 0;
+    for (const dir of laravelDirs) {
+      try {
+        const dirPath = path2.join(fullPath, dir);
+        const stats = await fs2.stat(dirPath);
+        if (stats.isDirectory()) {
+          foundDirs++;
+        }
+      } catch {
+      }
+    }
+    if (foundDirs >= 2) {
+      result.evidence.push(`Laravel directory structure detected (${foundDirs}/${laravelDirs.length} dirs)`);
+      result.confidence = "high";
+    }
+    const testDirsToCheck = [
+      path2.join(fullPath, "tests", "Feature"),
+      path2.join(fullPath, "tests", "Unit")
+    ];
+    for (const testDir of testDirsToCheck) {
+      try {
+        const stats = await fs2.stat(testDir);
+        if (stats.isDirectory()) {
+          const dirName = path2.basename(path2.dirname(testDir)) + "/" + path2.basename(testDir);
+          result.evidence.push(`Found ${dirName} test directory`);
+        }
+      } catch {
+      }
+    }
+    if (composerJson.require?.["laravel/framework"]) {
+      result.version = composerJson.require["laravel/framework"];
+    }
+    result.detected = true;
+    return result;
+  },
+  async generateConfig(rootDir, relativePath) {
+    return generateLaravelConfig(rootDir, relativePath);
+  }
+};
+
+// src/frameworks/registry.ts
+var frameworkDetectors = [
+  nodejsDetector,
+  laravelDetector
+];
+function getFrameworkDetector(name) {
+  return frameworkDetectors.find((d) => d.name === name);
+}
+
+// src/frameworks/detector-service.ts
+async function detectAllFrameworks(rootDir, options = {}) {
+  const opts = { ...defaultDetectionOptions, ...options };
+  const results = [];
+  const visited = /* @__PURE__ */ new Set();
+  await detectAtPath(rootDir, ".", results, visited);
+  await scanSubdirectories(rootDir, ".", results, visited, 0, opts);
+  return results;
+}
+async function detectAtPath(rootDir, relativePath, results, visited) {
+  const fullPath = path3.join(rootDir, relativePath);
+  if (visited.has(fullPath)) {
+    return;
+  }
+  visited.add(fullPath);
+  const detectedAtPath = [];
+  for (const detector of frameworkDetectors) {
+    try {
+      const result = await detector.detect(rootDir, relativePath);
+      if (result.detected) {
+        detectedAtPath.push({
+          ...result,
+          priority: detector.priority ?? 0
+        });
+      }
+    } catch (error) {
+      console.error(`Error running detector '${detector.name}' at ${relativePath}:`, error);
+    }
+  }
+  if (detectedAtPath.length > 1) {
+    detectedAtPath.sort((a, b) => b.priority - a.priority);
+    const winner = detectedAtPath[0];
+    results.push(winner);
+    const skipped = detectedAtPath.slice(1);
+    if (skipped.length > 0) {
+      const skippedNames = skipped.map((d) => d.name).join(", ");
+      console.log(`  \u2192 Skipping ${skippedNames} at ${relativePath} (${winner.name} takes precedence)`);
+    }
+  } else if (detectedAtPath.length === 1) {
+    results.push(detectedAtPath[0]);
+  }
+}
+async function scanSubdirectories(rootDir, relativePath, results, visited, depth, options) {
+  if (depth >= options.maxDepth) {
+    return;
+  }
+  const fullPath = path3.join(rootDir, relativePath);
+  try {
+    const entries = await fs3.readdir(fullPath, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory());
+    for (const dir of dirs) {
+      if (options.skipDirs.includes(dir.name)) {
+        continue;
+      }
+      if (dir.name.startsWith(".")) {
+        continue;
+      }
+      const subPath = relativePath === "." ? dir.name : path3.join(relativePath, dir.name);
+      await detectAtPath(rootDir, subPath, results, visited);
+      await scanSubdirectories(rootDir, subPath, results, visited, depth + 1, options);
+    }
+  } catch (error) {
+    return;
+  }
+}
+
+// src/cli/init.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+async function initCommand(options = {}) {
+  const rootDir = options.path || process.cwd();
+  const configPath = path4.join(rootDir, ".lien.config.json");
+  try {
+    let configExists = false;
+    try {
+      await fs4.access(configPath);
+      configExists = true;
+    } catch {
+    }
+    if (configExists && options.upgrade) {
+      await upgradeConfig(configPath);
+      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);
+  }
+}
+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);
+  let frameworks = [];
+  if (detections.length === 0) {
+    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;
+      }
+    }
+    frameworks.push({
+      name: "generic",
+      path: ".",
+      enabled: true,
+      config: {
+        include: ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        exclude: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/.git/**",
+          "**/coverage/**",
+          "**/.next/**",
+          "**/.nuxt/**",
+          "**/vendor/**"
+        ]
+      }
+    });
+  } else {
+    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();
+    }
+    if (!options.yes) {
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Configure these frameworks?",
+          default: true
+        }
+      ]);
+      if (!confirm) {
+        console.log(chalk2.dim("Aborted."));
+        return;
+      }
+    }
+    for (const det of detections) {
+      const detector = getFrameworkDetector(det.name);
+      if (!detector) {
+        console.warn(chalk2.yellow(`\u26A0\uFE0F  No detector found for ${det.name}, skipping`));
+        continue;
+      }
+      const frameworkConfig = await detector.generateConfig(rootDir, det.path);
+      let shouldCustomize = false;
+      if (!options.yes) {
+        const { customize } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "customize",
+            message: `Customize ${det.name} settings?`,
+            default: false
+          }
+        ]);
+        shouldCustomize = customize;
+      }
+      let finalConfig = frameworkConfig;
+      if (shouldCustomize) {
+        const customized = await promptForCustomization(det.name, frameworkConfig);
+        finalConfig = { ...frameworkConfig, ...customized };
+      } else {
+        const pathDisplay = det.path === "." ? "root" : det.path;
+        console.log(chalk2.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
+      }
+      frameworks.push({
+        name: det.name,
+        path: det.path,
+        enabled: true,
+        config: finalConfig
+      });
+    }
+  }
+  if (!options.yes) {
+    const { installCursorRules } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "installCursorRules",
+        message: "Install recommended Cursor rules?",
+        default: true
+      }
+    ]);
+    if (installCursorRules) {
+      try {
+        const cursorRulesDir = path4.join(rootDir, ".cursor");
+        await fs4.mkdir(cursorRulesDir, { recursive: true });
+        const templatePath = path4.join(__dirname2, "../CURSOR_RULES_TEMPLATE.md");
+        const rulesPath = path4.join(cursorRulesDir, "rules");
+        let targetPath;
+        let isDirectory = false;
+        let isFile = false;
+        try {
+          const stats = await fs4.stat(rulesPath);
+          isDirectory = stats.isDirectory();
+          isFile = stats.isFile();
+        } catch {
+        }
+        if (isDirectory) {
+          targetPath = path4.join(rulesPath, "lien.mdc");
+          await fs4.copyFile(templatePath, targetPath);
+          console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
+        } else if (isFile) {
+          const { convertToDir } = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "convertToDir",
+              message: "Existing .cursor/rules file found. Convert to directory and preserve your rules?",
+              default: true
+            }
+          ]);
+          if (convertToDir) {
+            const existingRules = await fs4.readFile(rulesPath, "utf-8");
+            await fs4.unlink(rulesPath);
+            await fs4.mkdir(rulesPath);
+            await fs4.writeFile(path4.join(rulesPath, "project.mdc"), existingRules);
+            await fs4.copyFile(templatePath, path4.join(rulesPath, "lien.mdc"));
+            console.log(chalk2.green("\u2713 Converted .cursor/rules to directory"));
+            console.log(chalk2.green("  - Your project rules: .cursor/rules/project.mdc"));
+            console.log(chalk2.green("  - Lien rules: .cursor/rules/lien.mdc"));
+          } else {
+            console.log(chalk2.dim("Skipped Cursor rules installation (preserving existing file)"));
+          }
+        } else {
+          await fs4.mkdir(rulesPath, { recursive: true });
+          targetPath = path4.join(rulesPath, "lien.mdc");
+          await fs4.copyFile(templatePath, targetPath);
+          console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
+        }
+      } catch (error) {
+        console.log(chalk2.yellow("\u26A0\uFE0F  Could not install Cursor rules"));
+        console.log(chalk2.dim(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+        console.log(chalk2.dim("You can manually copy CURSOR_RULES_TEMPLATE.md to .cursor/rules/lien.mdc"));
+      }
+    }
+  }
+  const config = {
+    ...defaultConfig,
+    frameworks
+  };
+  const configPath = path4.join(rootDir, ".lien.config.json");
+  await fs4.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 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
+  };
+}
+async function upgradeConfig(configPath) {
+  try {
+    const backupPath = `${configPath}.backup`;
+    await fs4.copyFile(configPath, backupPath);
+    const existingContent = await fs4.readFile(configPath, "utf-8");
+    const existingConfig = JSON.parse(existingContent);
+    let upgradedConfig;
+    let migrated = false;
+    if (needsMigration(existingConfig)) {
+      console.log(chalk2.blue("\u{1F504} Migrating config from v0.2.0 to v0.3.0..."));
+      upgradedConfig = migrateConfig(existingConfig);
+      migrated = true;
+    } else {
+      const newFields = detectNewFields(existingConfig, defaultConfig);
+      upgradedConfig = deepMergeConfig(defaultConfig, existingConfig);
+      if (newFields.length > 0) {
+        console.log(chalk2.dim("\nNew options added:"));
+        newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
+      }
+    }
+    await fs4.writeFile(
+      configPath,
+      JSON.stringify(upgradedConfig, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(chalk2.green("\u2713 Config upgraded successfully"));
+    console.log(chalk2.dim("Backup saved to:"), backupPath);
+    if (migrated) {
+      console.log(chalk2.dim("\n\u{1F4DD} Your config now uses the framework-based structure."));
+    }
+  } catch (error) {
+    console.error(chalk2.red("Error upgrading config:"), error);
+    throw error;
+  }
+}
+
+// src/cli/status.ts
+init_service();
+import chalk3 from "chalk";
+import fs8 from "fs/promises";
+import path8 from "path";
+import os from "os";
+import crypto from "crypto";
+
+// src/git/utils.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs6 from "fs/promises";
+import path6 from "path";
+var execAsync = promisify(exec);
+async function isGitRepo(rootDir) {
+  try {
+    const gitDir = path6.join(rootDir, ".git");
+    await fs6.access(gitDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCurrentBranch(rootDir) {
+  try {
+    const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", {
+      cwd: rootDir,
+      timeout: 5e3
+      // 5 second timeout
+    });
+    return stdout.trim();
+  } catch (error) {
+    throw new Error(`Failed to get current branch: ${error}`);
+  }
+}
+async function getCurrentCommit(rootDir) {
+  try {
+    const { stdout } = await execAsync("git rev-parse HEAD", {
+      cwd: rootDir,
+      timeout: 5e3
+    });
+    return stdout.trim();
+  } catch (error) {
+    throw new Error(`Failed to get current commit: ${error}`);
+  }
+}
+async function getChangedFiles(rootDir, fromRef, toRef) {
+  try {
+    const { stdout } = await execAsync(
+      `git diff --name-only ${fromRef}...${toRef}`,
+      {
+        cwd: rootDir,
+        timeout: 1e4
+        // 10 second timeout for diffs
+      }
+    );
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path6.join(rootDir, file));
+    return files;
+  } catch (error) {
+    throw new Error(`Failed to get changed files: ${error}`);
+  }
+}
+async function getChangedFilesBetweenCommits(rootDir, fromCommit, toCommit) {
+  try {
+    const { stdout } = await execAsync(
+      `git diff --name-only ${fromCommit} ${toCommit}`,
+      {
+        cwd: rootDir,
+        timeout: 1e4
+      }
+    );
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path6.join(rootDir, file));
+    return files;
+  } catch (error) {
+    throw new Error(`Failed to get changed files between commits: ${error}`);
+  }
+}
+async function isGitAvailable() {
+  try {
+    await execAsync("git --version", { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/status.ts
+init_version();
+init_banner();
+init_schema();
+async function statusCommand() {
+  const rootDir = process.cwd();
+  const projectName = path8.basename(rootDir);
+  const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
+  const indexPath = path8.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;
+  }
+  try {
+    const stats = await fs8.stat(indexPath);
+    console.log(chalk3.dim("Index location:"), indexPath);
+    console.log(chalk3.dim("Index status:"), chalk3.green("\u2713 Exists"));
+    try {
+      const files = await fs8.readdir(indexPath, { recursive: true });
+      console.log(chalk3.dim("Index files:"), files.length);
+    } catch (e) {
+    }
+    console.log(chalk3.dim("Last modified:"), stats.mtime.toLocaleString());
+    try {
+      const version = await readVersionFile(indexPath);
+      if (version > 0) {
+        const versionDate = new Date(version);
+        console.log(chalk3.dim("Last reindex:"), versionDate.toLocaleString());
+      }
+    } catch {
+    }
+  } catch (error) {
+    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`);
+      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 = path8.join(indexPath, ".git-state.json");
+        try {
+          const gitStateContent = await fs8.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 {
+        }
+      } 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 (error) {
+    console.log(chalk3.yellow("\nWarning: Could not load configuration"));
+  }
+}
+
+// src/cli/index-cmd.ts
+init_indexer();
+init_banner();
+import chalk5 from "chalk";
+async function indexCommand(options) {
+  showCompactBanner();
+  try {
+    await indexCodebase({
+      rootDir: process.cwd(),
+      verbose: options.verbose || false
+    });
+    if (options.watch) {
+      console.log(chalk5.yellow("\n\u26A0\uFE0F  Watch mode not yet implemented"));
+    }
+  } catch (error) {
+    console.error(chalk5.red("Error during indexing:"), error);
+    process.exit(1);
+  }
+}
+
+// src/cli/serve.ts
+import chalk6 from "chalk";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/mcp/tools.ts
+var tools = [
+  {
+    name: "semantic_search",
+    description: "Search the codebase semantically for relevant code using natural language. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Natural language search query (e.g., "authentication logic", "database connection handling")'
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return",
+          default: 5
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "find_similar",
+    description: "Find code similar to a given code snippet. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "Code snippet to find similar implementations"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return",
+          default: 5
+        }
+      },
+      required: ["code"]
+    }
+  },
+  {
+    name: "get_file_context",
+    description: "Get all chunks and related context for a specific file. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filepath: {
+          type: "string",
+          description: "Path to the file (relative to project root)"
+        },
+        includeRelated: {
+          type: "boolean",
+          description: "Include semantically related chunks from other files",
+          default: true
+        }
+      },
+      required: ["filepath"]
+    }
+  },
+  {
+    name: "list_functions",
+    description: "List functions, classes, and interfaces by name pattern and language",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: 'Regex pattern to match symbol names (e.g., ".*Service$", "handle.*")'
+        },
+        language: {
+          type: "string",
+          description: 'Language filter (e.g., "typescript", "python", "php")'
+        }
+      }
+    }
+  }
+];
+
+// src/mcp/server.ts
+init_lancedb();
+init_local();
+
+// src/git/tracker.ts
+import fs11 from "fs/promises";
+import path11 from "path";
+var GitStateTracker = class {
+  stateFile;
+  rootDir;
+  currentState = null;
+  constructor(rootDir, indexPath) {
+    this.rootDir = rootDir;
+    this.stateFile = path11.join(indexPath, ".git-state.json");
+  }
+  /**
+   * Loads the last known git state from disk.
+   * Returns null if no state file exists (first run).
+   */
+  async loadState() {
+    try {
+      const content = await fs11.readFile(this.stateFile, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Saves the current git state to disk.
+   */
+  async saveState(state) {
+    try {
+      const content = JSON.stringify(state, null, 2);
+      await fs11.writeFile(this.stateFile, content, "utf-8");
+    } catch (error) {
+      console.error(`[Lien] Warning: Failed to save git state: ${error}`);
+    }
+  }
+  /**
+   * Gets the current git state from the repository.
+   * 
+   * @returns Current git state
+   * @throws Error if git commands fail
+   */
+  async getCurrentGitState() {
+    const branch = await getCurrentBranch(this.rootDir);
+    const commit = await getCurrentCommit(this.rootDir);
+    return {
+      branch,
+      commit,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Initializes the tracker by loading saved state and checking current state.
+   * Should be called once when MCP server starts.
+   * 
+   * @returns Array of changed files if state changed, null if no changes or first run
+   */
+  async initialize() {
+    const isRepo = await isGitRepo(this.rootDir);
+    if (!isRepo) {
+      return null;
+    }
+    try {
+      this.currentState = await this.getCurrentGitState();
+      const previousState = await this.loadState();
+      if (!previousState) {
+        await this.saveState(this.currentState);
+        return null;
+      }
+      const branchChanged = previousState.branch !== this.currentState.branch;
+      const commitChanged = previousState.commit !== this.currentState.commit;
+      if (!branchChanged && !commitChanged) {
+        return null;
+      }
+      let changedFiles = [];
+      if (branchChanged) {
+        try {
+          changedFiles = await getChangedFiles(
+            this.rootDir,
+            previousState.branch,
+            this.currentState.branch
+          );
+        } catch (error) {
+          console.error(`[Lien] Branch diff failed, using commit diff: ${error}`);
+          changedFiles = await getChangedFilesBetweenCommits(
+            this.rootDir,
+            previousState.commit,
+            this.currentState.commit
+          );
+        }
+      } else if (commitChanged) {
+        changedFiles = await getChangedFilesBetweenCommits(
+          this.rootDir,
+          previousState.commit,
+          this.currentState.commit
+        );
+      }
+      await this.saveState(this.currentState);
+      return changedFiles;
+    } catch (error) {
+      console.error(`[Lien] Failed to initialize git tracker: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Checks for git state changes since last check.
+   * This is called periodically by the MCP server.
+   * 
+   * @returns Array of changed files if state changed, null if no changes
+   */
+  async detectChanges() {
+    const isRepo = await isGitRepo(this.rootDir);
+    if (!isRepo) {
+      return null;
+    }
+    try {
+      const newState = await this.getCurrentGitState();
+      if (!this.currentState) {
+        this.currentState = newState;
+        await this.saveState(newState);
+        return null;
+      }
+      const branchChanged = this.currentState.branch !== newState.branch;
+      const commitChanged = this.currentState.commit !== newState.commit;
+      if (!branchChanged && !commitChanged) {
+        return null;
+      }
+      let changedFiles = [];
+      if (branchChanged) {
+        try {
+          changedFiles = await getChangedFiles(
+            this.rootDir,
+            this.currentState.branch,
+            newState.branch
+          );
+        } catch (error) {
+          console.error(`[Lien] Branch diff failed, using commit diff: ${error}`);
+          changedFiles = await getChangedFilesBetweenCommits(
+            this.rootDir,
+            this.currentState.commit,
+            newState.commit
+          );
+        }
+      } else if (commitChanged) {
+        changedFiles = await getChangedFilesBetweenCommits(
+          this.rootDir,
+          this.currentState.commit,
+          newState.commit
+        );
+      }
+      this.currentState = newState;
+      await this.saveState(newState);
+      return changedFiles;
+    } catch (error) {
+      console.error(`[Lien] Failed to detect git changes: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * Gets the current git state.
+   * Useful for status display.
+   */
+  getState() {
+    return this.currentState;
+  }
+  /**
+   * Manually updates the saved state.
+   * Useful after manual reindexing to sync state.
+   */
+  async updateState() {
+    try {
+      this.currentState = await this.getCurrentGitState();
+      await this.saveState(this.currentState);
+    } catch (error) {
+      console.error(`[Lien] Failed to update git state: ${error}`);
+    }
+  }
+};
+
+// src/indexer/incremental.ts
+init_chunker();
+init_schema();
+import fs12 from "fs/promises";
+async function indexSingleFile(filepath, vectorDB, embeddings, config, options = {}) {
+  const { verbose } = options;
+  try {
+    try {
+      await fs12.access(filepath);
+    } catch {
+      if (verbose) {
+        console.error(`[Lien] File deleted: ${filepath}`);
+      }
+      await vectorDB.deleteByFile(filepath);
+      return;
+    }
+    const content = await fs12.readFile(filepath, "utf-8");
+    const chunkSize = isModernConfig(config) ? config.core.chunkSize : isLegacyConfig(config) ? config.indexing.chunkSize : 75;
+    const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : isLegacyConfig(config) ? config.indexing.chunkOverlap : 10;
+    const chunks = chunkFile(filepath, content, {
+      chunkSize,
+      chunkOverlap
+    });
+    if (chunks.length === 0) {
+      if (verbose) {
+        console.error(`[Lien] Empty file: ${filepath}`);
+      }
+      await vectorDB.deleteByFile(filepath);
+      return;
+    }
+    const texts = chunks.map((c) => c.content);
+    const vectors = await embeddings.embedBatch(texts);
+    await vectorDB.updateFile(
+      filepath,
+      vectors,
+      chunks.map((c) => c.metadata),
+      texts
+    );
+    if (verbose) {
+      console.error(`[Lien] \u2713 Updated ${filepath} (${chunks.length} chunks)`);
+    }
+  } catch (error) {
+    console.error(`[Lien] \u26A0\uFE0F  Failed to index ${filepath}: ${error}`);
+  }
+}
+async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, options = {}) {
+  const { verbose } = options;
+  let successCount = 0;
+  for (const filepath of filepaths) {
+    try {
+      await indexSingleFile(filepath, vectorDB, embeddings, config, options);
+      successCount++;
+    } catch (error) {
+      if (verbose) {
+        console.error(`[Lien] Failed to process ${filepath}`);
+      }
+    }
+  }
+  return successCount;
+}
+
+// src/mcp/server.ts
+init_service();
+
+// src/watcher/index.ts
+init_schema();
+import chokidar from "chokidar";
+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 (isModernConfig(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
+      awaitWriteFinish: {
+        stabilityThreshold: 500,
+        // Wait 500ms for file to stop changing
+        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 = filepath.startsWith("/") ? filepath : `${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);
+    }
+    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.ts
+init_constants();
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname2(__filename3);
+var require3 = createRequire2(import.meta.url);
+var packageJson2;
+try {
+  packageJson2 = require3(join2(__dirname3, "../package.json"));
+} catch {
+  packageJson2 = require3(join2(__dirname3, "../../package.json"));
+}
+async function startMCPServer(options) {
+  const { rootDir, verbose, watch } = options;
+  const log = (message) => {
+    if (verbose) {
+      console.error(`[Lien MCP] ${message}`);
+    }
+  };
+  log("Initializing MCP server...");
+  const embeddings = new LocalEmbeddings();
+  const vectorDB = new VectorDB(rootDir);
+  try {
+    log("Loading embedding model...");
+    await embeddings.initialize();
+    log("Loading vector database...");
+    await vectorDB.initialize();
+    log("Embeddings and vector DB ready");
+  } catch (error) {
+    console.error(`Failed to initialize: ${error}`);
+    process.exit(1);
+  }
+  const server = new Server(
+    {
+      name: "lien",
+      version: packageJson2.version
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools
+  }));
+  const checkAndReconnect = async () => {
+    try {
+      const versionChanged = await vectorDB.checkVersion();
+      if (versionChanged) {
+        log("Index version changed, reconnecting to database...");
+        await vectorDB.reconnect();
+        log("Reconnected to updated index");
+      }
+    } catch (error) {
+      log(`Version check failed: ${error}`);
+    }
+  };
+  const getIndexMetadata = () => ({
+    indexVersion: vectorDB.getCurrentVersion(),
+    indexDate: vectorDB.getVersionDate()
+  });
+  const versionCheckInterval = setInterval(async () => {
+    await checkAndReconnect();
+  }, VERSION_CHECK_INTERVAL_MS);
+  process.on("SIGINT", () => {
+    clearInterval(versionCheckInterval);
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    clearInterval(versionCheckInterval);
+    process.exit(0);
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      log(`Handling tool call: ${name}`);
+      switch (name) {
+        case "semantic_search": {
+          const query = args?.query;
+          const limit = args?.limit || 5;
+          log(`Searching for: "${query}"`);
+          await checkAndReconnect();
+          const queryEmbedding = await embeddings.embed(query);
+          const results = await vectorDB.search(queryEmbedding, limit, query);
+          log(`Found ${results.length} results`);
+          const response = {
+            indexInfo: getIndexMetadata(),
+            results
+          };
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(response, null, 2)
+              }
+            ]
+          };
+        }
+        case "find_similar": {
+          const code = args?.code;
+          const limit = args?.limit || 5;
+          log(`Finding similar code...`);
+          await checkAndReconnect();
+          const codeEmbedding = await embeddings.embed(code);
+          const results = await vectorDB.search(codeEmbedding, limit, code);
+          log(`Found ${results.length} similar chunks`);
+          const response = {
+            indexInfo: getIndexMetadata(),
+            results
+          };
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(response, null, 2)
+              }
+            ]
+          };
+        }
+        case "get_file_context": {
+          const filepath = args?.filepath;
+          const includeRelated = args?.includeRelated ?? true;
+          log(`Getting context for: ${filepath}`);
+          await checkAndReconnect();
+          const fileEmbedding = await embeddings.embed(filepath);
+          const allResults = await vectorDB.search(fileEmbedding, 50, filepath);
+          const fileChunks = allResults.filter(
+            (r) => r.metadata.file.includes(filepath) || filepath.includes(r.metadata.file)
+          );
+          let results = fileChunks;
+          if (includeRelated && fileChunks.length > 0) {
+            const relatedEmbedding = await embeddings.embed(fileChunks[0].content);
+            const related = await vectorDB.search(relatedEmbedding, 5, fileChunks[0].content);
+            const relatedOtherFiles = related.filter(
+              (r) => !r.metadata.file.includes(filepath) && !filepath.includes(r.metadata.file)
+            );
+            results = [...fileChunks, ...relatedOtherFiles];
+          }
+          log(`Found ${results.length} chunks`);
+          const response = {
+            indexInfo: getIndexMetadata(),
+            file: filepath,
+            chunks: results
+          };
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(response, null, 2)
+              }
+            ]
+          };
+        }
+        case "list_functions": {
+          const pattern = args?.pattern;
+          const language = args?.language;
+          log("Listing functions with symbol metadata...");
+          await checkAndReconnect();
+          let results;
+          let usedMethod = "symbols";
+          try {
+            results = await vectorDB.querySymbols({
+              language,
+              pattern,
+              limit: 50
+            });
+            if (results.length === 0 && (language || pattern)) {
+              log("No symbol results, falling back to content scan...");
+              results = await vectorDB.scanWithFilter({
+                language,
+                pattern,
+                limit: 50
+              });
+              usedMethod = "content";
+            }
+          } catch (error) {
+            log(`Symbol query failed, falling back to content scan: ${error}`);
+            results = await vectorDB.scanWithFilter({
+              language,
+              pattern,
+              limit: 50
+            });
+            usedMethod = "content";
+          }
+          log(`Found ${results.length} matches using ${usedMethod} method`);
+          const response = {
+            indexInfo: getIndexMetadata(),
+            method: usedMethod,
+            results,
+            note: usedMethod === "content" ? 'Using content search. Run "lien reindex" to enable faster symbol-based queries.' : void 0
+          };
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(response, null, 2)
+              }
+            ]
+          };
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      console.error(`Error handling tool call ${name}:`, error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: String(error),
+              tool: name
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  const config = await configService.load(rootDir);
+  const hasIndex = await vectorDB.hasData();
+  if (!hasIndex && config.mcp.autoIndexOnFirstRun) {
+    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 Promise.resolve().then(() => (init_indexer(), indexer_exports));
+      await indexCodebase2({ rootDir, verbose: true });
+      log("\u2705 Initial indexing complete!");
+    } catch (error) {
+      log(`\u26A0\uFE0F  Initial indexing failed: ${error}`);
+      log("You can manually run: lien index");
+    }
+  } else if (!hasIndex) {
+    log("\u26A0\uFE0F  No index found. Auto-indexing is disabled in config.");
+    log('Run "lien index" to index your codebase.');
+  }
+  let gitTracker = null;
+  let gitPollInterval = null;
+  let fileWatcher = null;
+  if (config.gitDetection.enabled) {
+    const gitAvailable = await isGitAvailable();
+    const isRepo = await isGitRepo(rootDir);
+    if (gitAvailable && isRepo) {
+      log("\u2713 Detected git repository");
+      gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
+      try {
+        log("Checking for git changes...");
+        const changedFiles = await gitTracker.initialize();
+        if (changedFiles && changedFiles.length > 0) {
+          log(`\u{1F33F} Git changes detected: ${changedFiles.length} files changed`);
+          log("Reindexing changed files...");
+          const count = await indexMultipleFiles(
+            changedFiles,
+            vectorDB,
+            embeddings,
+            config,
+            { verbose }
+          );
+          log(`\u2713 Reindexed ${count} files`);
+        } else {
+          log("\u2713 Index is up to date with git state");
+        }
+      } catch (error) {
+        log(`Warning: Failed to check git state on startup: ${error}`);
+      }
+      log(`\u2713 Git detection enabled (checking every ${config.gitDetection.pollIntervalMs / 1e3}s)`);
+      gitPollInterval = setInterval(async () => {
+        try {
+          const changedFiles = await gitTracker.detectChanges();
+          if (changedFiles && changedFiles.length > 0) {
+            log(`\u{1F33F} Git change detected: ${changedFiles.length} files changed`);
+            log("Reindexing in background...");
+            indexMultipleFiles(
+              changedFiles,
+              vectorDB,
+              embeddings,
+              config,
+              { verbose }
+            ).then((count) => {
+              log(`\u2713 Background reindex complete: ${count} files`);
+            }).catch((error) => {
+              log(`Warning: Background reindex failed: ${error}`);
+            });
+          }
+        } catch (error) {
+          log(`Warning: Git detection check failed: ${error}`);
+        }
+      }, config.gitDetection.pollIntervalMs);
+    } else {
+      if (!gitAvailable) {
+        log("Git not available - git detection disabled");
+      } else if (!isRepo) {
+        log("Not a git repository - git detection disabled");
+      }
+    }
+  } else {
+    log("Git detection disabled by configuration");
+  }
+  const fileWatchingEnabled = watch || config.fileWatching.enabled;
+  if (fileWatchingEnabled) {
+    log("\u{1F440} Starting file watcher...");
+    fileWatcher = new FileWatcher(rootDir, config);
+    try {
+      await fileWatcher.start(async (event) => {
+        const { type, filepath } = event;
+        if (type === "unlink") {
+          log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
+          try {
+            await vectorDB.deleteByFile(filepath);
+            log(`\u2713 Removed ${filepath} from index`);
+          } catch (error) {
+            log(`Warning: Failed to remove ${filepath}: ${error}`);
+          }
+        } else {
+          const action = type === "add" ? "added" : "changed";
+          log(`\u{1F4DD} File ${action}: ${filepath}`);
+          indexSingleFile(filepath, vectorDB, embeddings, config, { verbose }).catch((error) => {
+            log(`Warning: Failed to reindex ${filepath}: ${error}`);
+          });
+        }
+      });
+      const watchedCount = fileWatcher.getWatchedFiles().length;
+      log(`\u2713 File watching enabled (watching ${watchedCount} files)`);
+    } catch (error) {
+      log(`Warning: Failed to start file watcher: ${error}`);
+      fileWatcher = null;
+    }
+  }
+  const cleanup = async () => {
+    log("Shutting down MCP server...");
+    if (gitPollInterval) {
+      clearInterval(gitPollInterval);
+    }
+    if (fileWatcher) {
+      await fileWatcher.stop();
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log("MCP server started and listening on stdio");
+}
+
+// src/cli/serve.ts
+init_banner();
+async function serveCommand(options) {
+  const rootDir = process.cwd();
+  try {
+    showBanner();
+    console.error(chalk6.bold("Starting MCP server...\n"));
+    await startMCPServer({
+      rootDir,
+      verbose: true,
+      watch: options.watch
+    });
+  } catch (error) {
+    console.error(chalk6.red("Failed to start MCP server:"), error);
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname3(__filename4);
+var require4 = createRequire3(import.meta.url);
+var packageJson3;
+try {
+  packageJson3 = require4(join3(__dirname4, "../package.json"));
+} catch {
+  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);
+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("-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("-w, --watch", "Enable file watching for real-time reindexing").action(serveCommand);
+program.command("status").description("Show indexing status and statistics").action(statusCommand);
+program.command("reindex").description("Clear index and re-index the entire codebase").option("-v, --verbose", "Show detailed logging during indexing").action(async (options) => {
+  const { showCompactBanner: showCompactBanner2 } = await Promise.resolve().then(() => (init_banner(), banner_exports));
+  const chalk7 = (await import("chalk")).default;
+  const { VectorDB: VectorDB2 } = await Promise.resolve().then(() => (init_lancedb(), lancedb_exports));
+  const { indexCodebase: indexCodebase2 } = await Promise.resolve().then(() => (init_indexer(), indexer_exports));
+  showCompactBanner2();
+  try {
+    console.log(chalk7.yellow("Clearing existing index..."));
+    const vectorDB = new VectorDB2(process.cwd());
+    await vectorDB.initialize();
+    await vectorDB.clear();
+    console.log(chalk7.green("\u2713 Index cleared\n"));
+    await indexCodebase2({
+      rootDir: process.cwd(),
+      verbose: options.verbose || false
+    });
+  } catch (error) {
+    console.error(chalk7.red("Error during re-indexing:"), error);
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+program.parse();
+//# sourceMappingURL=index.js.map