@liendev/lien 0.10.0 → 0.12.0

package/dist/index.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 };
 
 // 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 DEFAULT_CHUNK_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CONCURRENCY, DEFAULT_EMBEDDING_BATCH_SIZE, EMBEDDING_MICRO_BATCH_SIZE, VECTOR_DB_MAX_BATCH_SIZE, VECTOR_DB_MIN_BATCH_SIZE, EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL, DEFAULT_PORT, VERSION_CHECK_INTERVAL_MS, DEFAULT_GIT_POLL_INTERVAL_MS, DEFAULT_DEBOUNCE_MS, CURRENT_CONFIG_VERSION, INDEX_FORMAT_VERSION;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -18,6 +18,9 @@ var init_constants = __esm({
     DEFAULT_CHUNK_OVERLAP = 10;
     DEFAULT_CONCURRENCY = 4;
     DEFAULT_EMBEDDING_BATCH_SIZE = 50;
+    EMBEDDING_MICRO_BATCH_SIZE = 10;
+    VECTOR_DB_MAX_BATCH_SIZE = 1e3;
+    VECTOR_DB_MIN_BATCH_SIZE = 10;
     EMBEDDING_DIMENSIONS = 384;
     DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
     DEFAULT_PORT = 7133;
@@ -25,6 +28,7 @@ var init_constants = __esm({
     DEFAULT_GIT_POLL_INTERVAL_MS = 1e4;
     DEFAULT_DEBOUNCE_MS = 1e3;
     CURRENT_CONFIG_VERSION = "0.3.0";
+    INDEX_FORMAT_VERSION = 1;
   }
 });
 
@@ -58,8 +62,8 @@ var init_schema = __esm({
         pollIntervalMs: DEFAULT_GIT_POLL_INTERVAL_MS
       },
       fileWatching: {
-        enabled: false,
-        // Opt-in feature
+        enabled: true,
+        // Enabled by default (fast with incremental indexing!)
         debounceMs: DEFAULT_DEBOUNCE_MS
       },
       frameworks: []
@@ -116,75 +120,6 @@ var init_merge = __esm({
   }
 });
 
-// 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) {
@@ -275,13 +210,20 @@ var init_migration = __esm({
   }
 });
 
+// src/errors/codes.ts
+var init_codes = __esm({
+  "src/errors/codes.ts"() {
+    "use strict";
+  }
+});
+
 // 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",
+    "INTERNAL_ERROR" /* INTERNAL_ERROR */,
     additionalContext
   );
   if (stack) {
@@ -296,32 +238,61 @@ var LienError, ConfigError, EmbeddingError, DatabaseError;
 var init_errors = __esm({
   "src/errors/index.ts"() {
     "use strict";
+    init_codes();
+    init_codes();
     LienError = class extends Error {
-      constructor(message, code, context) {
+      constructor(message, code, context, severity = "medium", recoverable = true, retryable = false) {
         super(message);
         this.code = code;
         this.context = context;
+        this.severity = severity;
+        this.recoverable = recoverable;
+        this.retryable = retryable;
         this.name = "LienError";
         if (Error.captureStackTrace) {
           Error.captureStackTrace(this, this.constructor);
         }
       }
+      /**
+       * Serialize error to JSON for MCP responses
+       */
+      toJSON() {
+        return {
+          error: this.message,
+          code: this.code,
+          severity: this.severity,
+          recoverable: this.recoverable,
+          context: this.context
+        };
+      }
+      /**
+       * Check if this error is retryable
+       */
+      isRetryable() {
+        return this.retryable;
+      }
+      /**
+       * Check if this error is recoverable
+       */
+      isRecoverable() {
+        return this.recoverable;
+      }
     };
     ConfigError = class extends LienError {
       constructor(message, context) {
-        super(message, "CONFIG_ERROR", context);
+        super(message, "CONFIG_INVALID" /* CONFIG_INVALID */, context, "medium", true, false);
         this.name = "ConfigError";
       }
     };
     EmbeddingError = class extends LienError {
       constructor(message, context) {
-        super(message, "EMBEDDING_ERROR", context);
+        super(message, "EMBEDDING_GENERATION_FAILED" /* EMBEDDING_GENERATION_FAILED */, context, "high", true, true);
         this.name = "EmbeddingError";
       }
     };
     DatabaseError = class extends LienError {
       constructor(message, context) {
-        super(message, "DATABASE_ERROR", context);
+        super(message, "INTERNAL_ERROR" /* INTERNAL_ERROR */, context, "high", true, true);
         this.name = "DatabaseError";
       }
     };
@@ -772,6 +743,115 @@ ${validation.errors.join("\n")}`,
   }
 });
 
+// src/git/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  getChangedFiles: () => getChangedFiles,
+  getChangedFilesBetweenCommits: () => getChangedFilesBetweenCommits,
+  getChangedFilesInCommit: () => getChangedFilesInCommit,
+  getCurrentBranch: () => getCurrentBranch,
+  getCurrentCommit: () => getCurrentCommit,
+  isGitAvailable: () => isGitAvailable,
+  isGitRepo: () => isGitRepo
+});
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs7 from "fs/promises";
+import path7 from "path";
+async function isGitRepo(rootDir) {
+  try {
+    const gitDir = path7.join(rootDir, ".git");
+    await fs7.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) => path7.join(rootDir, file));
+    return files;
+  } catch (error) {
+    throw new Error(`Failed to get changed files: ${error}`);
+  }
+}
+async function getChangedFilesInCommit(rootDir, commitSha) {
+  try {
+    const { stdout } = await execAsync(
+      `git diff-tree --no-commit-id --name-only -r ${commitSha}`,
+      {
+        cwd: rootDir,
+        timeout: 1e4
+      }
+    );
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path7.join(rootDir, file));
+    return files;
+  } catch (error) {
+    throw new Error(`Failed to get changed files in commit: ${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) => path7.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;
+  }
+}
+var execAsync;
+var init_utils = __esm({
+  "src/git/utils.ts"() {
+    "use strict";
+    execAsync = promisify(exec);
+  }
+});
+
 // src/vectordb/version.ts
 import fs8 from "fs/promises";
 import path8 from "path";
@@ -1530,6 +1610,7 @@ var init_lancedb = __esm({
     init_errors();
     init_relevance();
     init_intent_classifier();
+    init_constants();
     VectorDB = class _VectorDB {
       db = null;
       table = null;
@@ -1575,27 +1656,76 @@ var init_lancedb = __esm({
             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);
+        if (vectors.length === 0) {
+          return;
+        }
+        if (vectors.length > VECTOR_DB_MAX_BATCH_SIZE) {
+          for (let i = 0; i < vectors.length; i += VECTOR_DB_MAX_BATCH_SIZE) {
+            const batchVectors = vectors.slice(i, Math.min(i + VECTOR_DB_MAX_BATCH_SIZE, vectors.length));
+            const batchMetadata = metadatas.slice(i, Math.min(i + VECTOR_DB_MAX_BATCH_SIZE, vectors.length));
+            const batchContents = contents.slice(i, Math.min(i + VECTOR_DB_MAX_BATCH_SIZE, vectors.length));
+            await this._insertBatchInternal(batchVectors, batchMetadata, batchContents);
           }
-        } catch (error) {
-          throw wrapError(error, "Failed to insert batch into vector database");
+        } else {
+          await this._insertBatchInternal(vectors, metadatas, contents);
+        }
+      }
+      /**
+       * Internal method to insert a single batch with iterative retry logic.
+       * Uses a queue-based approach to avoid deep recursion on large batch failures.
+       */
+      async _insertBatchInternal(vectors, metadatas, contents) {
+        const queue = [{ vectors, metadatas, contents }];
+        const failedRecords = [];
+        while (queue.length > 0) {
+          const batch = queue.shift();
+          try {
+            const records = batch.vectors.map((vector, i) => ({
+              vector: Array.from(vector),
+              content: batch.contents[i],
+              file: batch.metadatas[i].file,
+              startLine: batch.metadatas[i].startLine,
+              endLine: batch.metadatas[i].endLine,
+              type: batch.metadatas[i].type,
+              language: batch.metadatas[i].language,
+              // Ensure arrays have at least empty string for Arrow type inference
+              functionNames: batch.metadatas[i].symbols?.functions && batch.metadatas[i].symbols.functions.length > 0 ? batch.metadatas[i].symbols.functions : [""],
+              classNames: batch.metadatas[i].symbols?.classes && batch.metadatas[i].symbols.classes.length > 0 ? batch.metadatas[i].symbols.classes : [""],
+              interfaceNames: batch.metadatas[i].symbols?.interfaces && batch.metadatas[i].symbols.interfaces.length > 0 ? batch.metadatas[i].symbols.interfaces : [""]
+            }));
+            if (!this.table) {
+              this.table = await this.db.createTable(this.tableName, records);
+            } else {
+              await this.table.add(records);
+            }
+          } catch (error) {
+            if (batch.vectors.length > VECTOR_DB_MIN_BATCH_SIZE) {
+              const half = Math.floor(batch.vectors.length / 2);
+              queue.push({
+                vectors: batch.vectors.slice(0, half),
+                metadatas: batch.metadatas.slice(0, half),
+                contents: batch.contents.slice(0, half)
+              });
+              queue.push({
+                vectors: batch.vectors.slice(half),
+                metadatas: batch.metadatas.slice(half),
+                contents: batch.contents.slice(half)
+              });
+            } else {
+              failedRecords.push(batch);
+            }
+          }
+        }
+        if (failedRecords.length > 0) {
+          const totalFailed = failedRecords.reduce((sum, batch) => sum + batch.vectors.length, 0);
+          throw new DatabaseError(
+            `Failed to insert ${totalFailed} record(s) after retry attempts`,
+            {
+              failedBatches: failedRecords.length,
+              totalRecords: totalFailed,
+              sampleFile: failedRecords[0].metadatas[0].file
+            }
+          );
         }
       }
       async search(queryVector, limit = 5, query) {
@@ -1893,78 +2023,1018 @@ var init_lancedb = __esm({
   }
 });
 
-// src/indexer/index.ts
-var indexer_exports = {};
-__export(indexer_exports, {
-  indexCodebase: () => indexCodebase
+// src/utils/version.ts
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+function getPackageVersion() {
+  return packageJson2.version;
+}
+var __filename3, __dirname3, require3, packageJson2;
+var init_version2 = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    __filename3 = fileURLToPath3(import.meta.url);
+    __dirname3 = dirname2(__filename3);
+    require3 = createRequire2(import.meta.url);
+    try {
+      packageJson2 = require3(join2(__dirname3, "../package.json"));
+    } catch {
+      try {
+        packageJson2 = require3(join2(__dirname3, "../../package.json"));
+      } catch {
+        console.warn("[Lien] Warning: Could not load package.json, using fallback version");
+        packageJson2 = { version: "0.0.0-unknown" };
+      }
+    }
+  }
+});
+
+// src/indexer/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  ManifestManager: () => ManifestManager
 });
 import fs11 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
-        );
+import path12 from "path";
+var MANIFEST_FILE, ManifestManager;
+var init_manifest = __esm({
+  "src/indexer/manifest.ts"() {
+    "use strict";
+    init_constants();
+    init_version2();
+    MANIFEST_FILE = "manifest.json";
+    ManifestManager = class {
+      manifestPath;
+      indexPath;
+      /**
+       * Promise-based lock to prevent race conditions during concurrent updates.
+       * Ensures read-modify-write operations are atomic.
+       */
+      updateLock = Promise.resolve();
+      /**
+       * Creates a new ManifestManager
+       * @param indexPath - Path to the index directory (same as VectorDB path)
+       */
+      constructor(indexPath) {
+        this.indexPath = indexPath;
+        this.manifestPath = path12.join(indexPath, MANIFEST_FILE);
+      }
+      /**
+       * Loads the manifest from disk.
+       * Returns null if:
+       * - Manifest doesn't exist (first run)
+       * - Manifest is corrupt
+       * - Format version is incompatible (triggers full reindex)
+       * 
+       * @returns Loaded manifest or null
+       */
+      async load() {
+        try {
+          const content = await fs11.readFile(this.manifestPath, "utf-8");
+          const manifest = JSON.parse(content);
+          if (manifest.formatVersion !== INDEX_FORMAT_VERSION) {
+            console.error(
+              `[Lien] Index format v${manifest.formatVersion} is incompatible with current v${INDEX_FORMAT_VERSION}`
+            );
+            console.error(`[Lien] Full reindex required after Lien upgrade`);
+            await this.clear();
+            return null;
+          }
+          return manifest;
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return null;
+          }
+          console.error(`[Lien] Warning: Failed to load manifest: ${error}`);
+          return null;
+        }
+      }
+      /**
+       * Saves the manifest to disk.
+       * Always saves with current format and package versions.
+       * 
+       * @param manifest - Manifest to save
+       */
+      async save(manifest) {
+        try {
+          await fs11.mkdir(this.indexPath, { recursive: true });
+          const manifestToSave = {
+            ...manifest,
+            formatVersion: INDEX_FORMAT_VERSION,
+            lienVersion: getPackageVersion(),
+            lastIndexed: Date.now()
+          };
+          const content = JSON.stringify(manifestToSave, null, 2);
+          await fs11.writeFile(this.manifestPath, content, "utf-8");
+        } catch (error) {
+          console.error(`[Lien] Warning: Failed to save manifest: ${error}`);
+        }
+      }
+      /**
+       * Adds or updates a file entry in the manifest.
+       * Protected by lock to prevent race conditions during concurrent updates.
+       * 
+       * @param filepath - Path to the file
+       * @param entry - File entry metadata
+       */
+      async updateFile(filepath, entry) {
+        this.updateLock = this.updateLock.then(async () => {
+          const manifest = await this.load() || this.createEmpty();
+          manifest.files[filepath] = entry;
+          await this.save(manifest);
+        }).catch((error) => {
+          console.error(`[Lien] Failed to update manifest for ${filepath}: ${error}`);
+          return void 0;
+        });
+        await this.updateLock;
+      }
+      /**
+       * Removes a file entry from the manifest.
+       * Protected by lock to prevent race conditions during concurrent updates.
+       * 
+       * Note: If the manifest doesn't exist, this is a no-op (not an error).
+       * This can happen legitimately after clearing the index or on fresh installs.
+       * 
+       * @param filepath - Path to the file to remove
+       */
+      async removeFile(filepath) {
+        this.updateLock = this.updateLock.then(async () => {
+          const manifest = await this.load();
+          if (!manifest) {
+            return;
+          }
+          delete manifest.files[filepath];
+          await this.save(manifest);
+        }).catch((error) => {
+          console.error(`[Lien] Failed to remove manifest entry for ${filepath}: ${error}`);
+          return void 0;
+        });
+        await this.updateLock;
+      }
+      /**
+       * Updates multiple files at once (more efficient than individual updates).
+       * Protected by lock to prevent race conditions during concurrent updates.
+       * 
+       * @param entries - Array of file entries to update
+       */
+      async updateFiles(entries) {
+        this.updateLock = this.updateLock.then(async () => {
+          const manifest = await this.load() || this.createEmpty();
+          for (const entry of entries) {
+            manifest.files[entry.filepath] = entry;
+          }
+          await this.save(manifest);
+        }).catch((error) => {
+          console.error(`[Lien] Failed to update manifest for ${entries.length} files: ${error}`);
+          return void 0;
+        });
+        await this.updateLock;
+      }
+      /**
+       * Updates the git state in the manifest.
+       * Protected by lock to prevent race conditions during concurrent updates.
+       * 
+       * @param gitState - Current git state
+       */
+      async updateGitState(gitState) {
+        this.updateLock = this.updateLock.then(async () => {
+          const manifest = await this.load() || this.createEmpty();
+          manifest.gitState = gitState;
+          await this.save(manifest);
+        }).catch((error) => {
+          console.error(`[Lien] Failed to update git state in manifest: ${error}`);
+          return void 0;
+        });
+        await this.updateLock;
+      }
+      /**
+       * Gets the list of files currently in the manifest
+       * 
+       * @returns Array of filepaths
+       */
+      async getIndexedFiles() {
+        const manifest = await this.load();
+        if (!manifest) return [];
+        return Object.keys(manifest.files);
+      }
+      /**
+       * Detects which files have changed based on mtime comparison
+       * 
+       * @param currentFiles - Map of current files with their mtimes
+       * @returns Array of filepaths that have changed
+       */
+      async getChangedFiles(currentFiles) {
+        const manifest = await this.load();
+        if (!manifest) {
+          return Array.from(currentFiles.keys());
+        }
+        const changedFiles = [];
+        for (const [filepath, mtime] of currentFiles) {
+          const entry = manifest.files[filepath];
+          if (!entry) {
+            changedFiles.push(filepath);
+          } else if (entry.lastModified < mtime) {
+            changedFiles.push(filepath);
+          }
+        }
+        return changedFiles;
+      }
+      /**
+       * Gets files that are in the manifest but not in the current file list
+       * (i.e., deleted files)
+       * 
+       * @param currentFiles - Set of current file paths
+       * @returns Array of deleted file paths
+       */
+      async getDeletedFiles(currentFiles) {
+        const manifest = await this.load();
+        if (!manifest) return [];
+        const deletedFiles = [];
+        for (const filepath of Object.keys(manifest.files)) {
+          if (!currentFiles.has(filepath)) {
+            deletedFiles.push(filepath);
+          }
+        }
+        return deletedFiles;
+      }
+      /**
+       * Clears the manifest file
+       */
+      async clear() {
+        try {
+          await fs11.unlink(this.manifestPath);
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            console.error(`[Lien] Warning: Failed to clear manifest: ${error}`);
+          }
+        }
+      }
+      /**
+       * Creates an empty manifest with current version information
+       * 
+       * @returns Empty manifest
+       */
+      createEmpty() {
+        return {
+          formatVersion: INDEX_FORMAT_VERSION,
+          lienVersion: getPackageVersion(),
+          lastIndexed: Date.now(),
+          files: {}
+        };
+      }
+    };
+  }
+});
+
+// src/git/tracker.ts
+var tracker_exports = {};
+__export(tracker_exports, {
+  GitStateTracker: () => GitStateTracker
+});
+import fs12 from "fs/promises";
+import path13 from "path";
+var GitStateTracker;
+var init_tracker = __esm({
+  "src/git/tracker.ts"() {
+    "use strict";
+    init_utils();
+    GitStateTracker = class {
+      stateFile;
+      rootDir;
+      currentState = null;
+      constructor(rootDir, indexPath) {
+        this.rootDir = rootDir;
+        this.stateFile = path13.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 fs12.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 fs12.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/change-detector.ts
+import fs13 from "fs/promises";
+async function detectChanges(rootDir, vectorDB, config) {
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  const savedManifest = await manifest.load();
+  if (!savedManifest) {
+    const allFiles = await getAllFiles(rootDir, config);
+    return {
+      added: allFiles,
+      modified: [],
+      deleted: [],
+      reason: "full"
+    };
+  }
+  const gitAvailable = await isGitAvailable();
+  const isRepo = await isGitRepo(rootDir);
+  if (gitAvailable && isRepo && savedManifest.gitState) {
+    const gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
+    await gitTracker.initialize();
+    const currentState = gitTracker.getState();
+    if (currentState && (currentState.branch !== savedManifest.gitState.branch || currentState.commit !== savedManifest.gitState.commit)) {
+      try {
+        const changedFilesPaths = await getChangedFiles(
+          rootDir,
+          savedManifest.gitState.commit,
+          currentState.commit
+        );
+        const changedFilesSet = new Set(changedFilesPaths);
+        const allFiles = await getAllFiles(rootDir, config);
+        const currentFileSet = new Set(allFiles);
+        const added = [];
+        const modified = [];
+        const deleted = [];
+        for (const filepath of changedFilesPaths) {
+          if (currentFileSet.has(filepath)) {
+            if (savedManifest.files[filepath]) {
+              modified.push(filepath);
+            } else {
+              added.push(filepath);
+            }
+          }
+        }
+        for (const filepath of allFiles) {
+          if (!savedManifest.files[filepath] && !changedFilesSet.has(filepath)) {
+            added.push(filepath);
+          }
+        }
+        for (const filepath of Object.keys(savedManifest.files)) {
+          if (!currentFileSet.has(filepath)) {
+            deleted.push(filepath);
+          }
+        }
+        return {
+          added,
+          modified,
+          deleted,
+          reason: "git-state-changed"
+        };
+      } catch (error) {
+        console.warn(`[Lien] Git diff failed, falling back to full reindex: ${error}`);
+        const allFiles = await getAllFiles(rootDir, config);
+        const currentFileSet = new Set(allFiles);
+        const deleted = [];
+        for (const filepath of Object.keys(savedManifest.files)) {
+          if (!currentFileSet.has(filepath)) {
+            deleted.push(filepath);
+          }
+        }
+        return {
+          added: allFiles,
+          modified: [],
+          deleted,
+          reason: "git-state-changed"
+        };
+      }
+    }
+  }
+  return await mtimeBasedDetection(rootDir, savedManifest, config);
+}
+async function getAllFiles(rootDir, config) {
+  if (isModernConfig(config) && config.frameworks.length > 0) {
+    return await scanCodebaseWithFrameworks(rootDir, config);
+  } else if (isLegacyConfig(config)) {
+    return await scanCodebase({
+      rootDir,
+      includePatterns: config.indexing.include,
+      excludePatterns: config.indexing.exclude
+    });
+  } else {
+    return await scanCodebase({
+      rootDir,
+      includePatterns: [],
+      excludePatterns: []
+    });
+  }
+}
+async function mtimeBasedDetection(rootDir, savedManifest, config) {
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  const currentFiles = await getAllFiles(rootDir, config);
+  const currentFileSet = new Set(currentFiles);
+  const fileStats = /* @__PURE__ */ new Map();
+  for (const filepath of currentFiles) {
+    try {
+      const stats = await fs13.stat(filepath);
+      fileStats.set(filepath, stats.mtimeMs);
+    } catch {
+      continue;
+    }
+  }
+  for (const [filepath, mtime] of fileStats) {
+    const entry = savedManifest.files[filepath];
+    if (!entry) {
+      added.push(filepath);
+    } else if (entry.lastModified < mtime) {
+      modified.push(filepath);
+    }
+  }
+  for (const filepath of Object.keys(savedManifest.files)) {
+    if (!currentFileSet.has(filepath)) {
+      deleted.push(filepath);
+    }
+  }
+  return {
+    added,
+    modified,
+    deleted,
+    reason: "mtime"
+  };
+}
+var init_change_detector = __esm({
+  "src/indexer/change-detector.ts"() {
+    "use strict";
+    init_manifest();
+    init_scanner();
+    init_schema();
+    init_tracker();
+    init_utils();
+  }
+});
+
+// src/indexer/incremental.ts
+import fs14 from "fs/promises";
+async function processFileContent(filepath, content, embeddings, config, verbose) {
+  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}`);
+    }
+    return null;
+  }
+  const texts = chunks.map((c) => c.content);
+  const vectors = [];
+  for (let j = 0; j < texts.length; j += EMBEDDING_MICRO_BATCH_SIZE) {
+    const microBatch = texts.slice(j, Math.min(j + EMBEDDING_MICRO_BATCH_SIZE, texts.length));
+    const microResults = await embeddings.embedBatch(microBatch);
+    vectors.push(...microResults);
+    if (texts.length > EMBEDDING_MICRO_BATCH_SIZE) {
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+  }
+  return {
+    chunkCount: chunks.length,
+    vectors,
+    chunks,
+    texts
+  };
+}
+async function indexSingleFile(filepath, vectorDB, embeddings, config, options = {}) {
+  const { verbose } = options;
+  try {
+    try {
+      await fs14.access(filepath);
+    } catch {
+      if (verbose) {
+        console.error(`[Lien] File deleted: ${filepath}`);
+      }
+      await vectorDB.deleteByFile(filepath);
+      const manifest2 = new ManifestManager(vectorDB.dbPath);
+      await manifest2.removeFile(filepath);
+      return;
+    }
+    const content = await fs14.readFile(filepath, "utf-8");
+    const result = await processFileContent(filepath, content, embeddings, config, verbose || false);
+    const stats = await fs14.stat(filepath);
+    const manifest = new ManifestManager(vectorDB.dbPath);
+    if (result === null) {
+      await vectorDB.deleteByFile(filepath);
+      await manifest.updateFile(filepath, {
+        filepath,
+        lastModified: stats.mtimeMs,
+        chunkCount: 0
+      });
+      return;
+    }
+    await vectorDB.updateFile(
+      filepath,
+      result.vectors,
+      result.chunks.map((c) => c.metadata),
+      result.texts
+    );
+    await manifest.updateFile(filepath, {
+      filepath,
+      lastModified: stats.mtimeMs,
+      chunkCount: result.chunkCount
+    });
+    if (verbose) {
+      console.error(`[Lien] \u2713 Updated ${filepath} (${result.chunkCount} 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 processedCount = 0;
+  const manifestEntries = [];
+  for (const filepath of filepaths) {
+    let content;
+    let fileMtime;
+    try {
+      const stats = await fs14.stat(filepath);
+      fileMtime = stats.mtimeMs;
+      content = await fs14.readFile(filepath, "utf-8");
+    } catch (error) {
+      if (verbose) {
+        console.error(`[Lien] File not readable: ${filepath}`);
+      }
+      try {
+        await vectorDB.deleteByFile(filepath);
+        const manifest = new ManifestManager(vectorDB.dbPath);
+        await manifest.removeFile(filepath);
+      } catch (error2) {
+        if (verbose) {
+          console.error(`[Lien] Note: ${filepath} not in index`);
+        }
+      }
+      processedCount++;
+      continue;
+    }
+    try {
+      const result = await processFileContent(filepath, content, embeddings, config, verbose || false);
+      if (result === null) {
+        try {
+          await vectorDB.deleteByFile(filepath);
+        } catch (error) {
+        }
+        const manifest = new ManifestManager(vectorDB.dbPath);
+        await manifest.updateFile(filepath, {
+          filepath,
+          lastModified: fileMtime,
+          chunkCount: 0
+        });
+        processedCount++;
+        continue;
+      }
+      try {
+        await vectorDB.deleteByFile(filepath);
+      } catch (error) {
+      }
+      await vectorDB.insertBatch(
+        result.vectors,
+        result.chunks.map((c) => c.metadata),
+        result.texts
+      );
+      manifestEntries.push({
+        filepath,
+        chunkCount: result.chunkCount,
+        mtime: fileMtime
+      });
+      if (verbose) {
+        console.error(`[Lien] \u2713 Updated ${filepath} (${result.chunkCount} chunks)`);
+      }
+      processedCount++;
+    } catch (error) {
+      console.error(`[Lien] \u26A0\uFE0F  Failed to index ${filepath}: ${error}`);
+    }
+  }
+  if (manifestEntries.length > 0) {
+    const manifest = new ManifestManager(vectorDB.dbPath);
+    await manifest.updateFiles(
+      manifestEntries.map((entry) => ({
+        filepath: entry.filepath,
+        lastModified: entry.mtime,
+        // Use actual file mtime for accurate change detection
+        chunkCount: entry.chunkCount
+      }))
+    );
+  }
+  return processedCount;
+}
+var init_incremental = __esm({
+  "src/indexer/incremental.ts"() {
+    "use strict";
+    init_chunker();
+    init_schema();
+    init_manifest();
+    init_constants();
+  }
+});
+
+// src/utils/loading-messages.ts
+function getIndexingMessage() {
+  const message = INDEXING_MESSAGES[currentIndexingIndex % INDEXING_MESSAGES.length];
+  currentIndexingIndex++;
+  return message;
+}
+function getEmbeddingMessage() {
+  const message = EMBEDDING_MESSAGES[currentEmbeddingIndex % EMBEDDING_MESSAGES.length];
+  currentEmbeddingIndex++;
+  return message;
+}
+function getModelLoadingMessage() {
+  const message = MODEL_LOADING_MESSAGES[currentModelIndex % MODEL_LOADING_MESSAGES.length];
+  currentModelIndex++;
+  return message;
+}
+var INDEXING_MESSAGES, EMBEDDING_MESSAGES, MODEL_LOADING_MESSAGES, currentIndexingIndex, currentEmbeddingIndex, currentModelIndex;
+var init_loading_messages = __esm({
+  "src/utils/loading-messages.ts"() {
+    "use strict";
+    INDEXING_MESSAGES = [
+      "Teaching AI to read your spaghetti code...",
+      "Convincing the LLM that your variable names make sense...",
+      "Indexing your TODO comments (so many TODOs)...",
+      'Building semantic links faster than you can say "grep"...',
+      "Making your codebase searchable (the good, the bad, and the ugly)...",
+      "Chunking code like a boss...",
+      "Feeding your code to the neural network (it's hungry)...",
+      "Creating embeddings (it's like compression, but fancier)...",
+      "Teaching machines to understand your midnight commits...",
+      "Vectorizing your technical debt...",
+      "Indexing... because Ctrl+F wasn't cutting it anymore...",
+      "Making semantic connections (unlike your last refactor)...",
+      "Processing files faster than your CI pipeline...",
+      "Embedding wisdom from your comments (all 3 of them)...",
+      "Analyzing code semantics (yes, even that one function)...",
+      "Building search index (now with 100% more AI)...",
+      "Crunching vectors like it's nobody's business...",
+      "Linking code fragments across the spacetime continuum...",
+      "Teaching transformers about your coding style...",
+      "Preparing for semantic search domination...",
+      "Indexing your genius (and that hacky workaround from 2019)...",
+      "Making your codebase AI-readable (you're welcome, future you)...",
+      "Converting code to math (engineers love this trick)...",
+      "Building the neural net's mental model of your app...",
+      "Chunking files like a lumberjack, but for code..."
+    ];
+    EMBEDDING_MESSAGES = [
+      "Generating embeddings (math is happening)...",
+      "Teaching transformers about your forEach loops...",
+      "Converting code to 384-dimensional space (wild, right?)...",
+      "Running the neural network (the Matrix, but for code)...",
+      "Creating semantic vectors (fancy word for AI magic)...",
+      "Embedding your code into hyperspace...",
+      'Teaching the model what "clean code" means in your codebase...',
+      'Generating vectors faster than you can say "AI"...',
+      "Making math from your methods...",
+      "Transforming code into numbers (the AI way)...",
+      "Processing with transformers.js (yes, it runs locally!)...",
+      "Embedding semantics (your code's hidden meaning)...",
+      "Vectorizing variables (alliteration achieved)...",
+      "Teaching AI the difference between foo and bar...",
+      "Creating embeddings (384 dimensions of awesome)..."
+    ];
+    MODEL_LOADING_MESSAGES = [
+      "Waking up the neural network...",
+      "Loading transformer model (patience, young padawan)...",
+      "Downloading AI brain (first run only, promise!)...",
+      "Initializing the semantic search engine...",
+      "Booting up the language model (coffee break recommended)...",
+      "Loading 100MB of pure AI goodness...",
+      "Preparing the transformer for action...",
+      "Model loading (this is why we run locally)...",
+      "Spinning up the embedding generator...",
+      "Getting the AI ready for your codebase..."
+    ];
+    currentIndexingIndex = 0;
+    currentEmbeddingIndex = 0;
+    currentModelIndex = 0;
+  }
+});
+
+// src/indexer/index.ts
+var indexer_exports = {};
+__export(indexer_exports, {
+  indexCodebase: () => indexCodebase
+});
+import fs15 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();
+  let updateInterval;
+  try {
+    spinner.text = "Loading configuration...";
+    const config = await configService.load(rootDir);
+    spinner.text = "Initializing vector database...";
+    const vectorDB = new VectorDB(rootDir);
+    await vectorDB.initialize();
+    if (!options.force) {
+      spinner.text = "Checking for changes...";
+      const manifest2 = new ManifestManager(vectorDB.dbPath);
+      const savedManifest = await manifest2.load();
+      if (savedManifest) {
+        const changes = await detectChanges(rootDir, vectorDB, config);
+        if (changes.reason !== "full") {
+          const totalChanges = changes.added.length + changes.modified.length;
+          const totalDeleted = changes.deleted.length;
+          if (totalChanges === 0 && totalDeleted === 0) {
+            spinner.succeed("No changes detected - index is up to date!");
+            return;
+          }
+          spinner.succeed(
+            `Detected changes: ${totalChanges} files to index, ${totalDeleted} to remove (${changes.reason} detection)`
+          );
+          spinner.start(getModelLoadingMessage());
+          const embeddings2 = new LocalEmbeddings();
+          await embeddings2.initialize();
+          spinner.succeed("Embedding model loaded");
+          if (totalDeleted > 0) {
+            spinner.start(`Removing ${totalDeleted} deleted files...`);
+            let removedCount = 0;
+            for (const filepath of changes.deleted) {
+              try {
+                await vectorDB.deleteByFile(filepath);
+                await manifest2.removeFile(filepath);
+                removedCount++;
+              } catch (err) {
+                spinner.warn(`Failed to remove file "${filepath}": ${err instanceof Error ? err.message : String(err)}`);
+              }
+            }
+            spinner.succeed(`Removed ${removedCount}/${totalDeleted} deleted files`);
+          }
+          if (totalChanges > 0) {
+            spinner.start(`Reindexing ${totalChanges} changed files...`);
+            const filesToIndex = [...changes.added, ...changes.modified];
+            const count = await indexMultipleFiles(
+              filesToIndex,
+              vectorDB,
+              embeddings2,
+              config,
+              { verbose: options.verbose }
+            );
+            await writeVersionFile(vectorDB.dbPath);
+            spinner.succeed(
+              `Incremental reindex complete: ${count}/${totalChanges} files indexed successfully`
+            );
+          }
+          const { isGitAvailable: isGitAvailable3, isGitRepo: isGitRepo3 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+          const { GitStateTracker: GitStateTracker3 } = await Promise.resolve().then(() => (init_tracker(), tracker_exports));
+          const gitAvailable2 = await isGitAvailable3();
+          const isRepo2 = await isGitRepo3(rootDir);
+          if (gitAvailable2 && isRepo2) {
+            const gitTracker = new GitStateTracker3(rootDir, vectorDB.dbPath);
+            await gitTracker.initialize();
+            const gitState = gitTracker.getState();
+            if (gitState) {
+              await manifest2.updateGitState(gitState);
+            }
+          }
+          console.log(chalk4.dim("\nNext step: Run"), chalk4.bold("lien serve"), chalk4.dim("to start the MCP server"));
+          return;
+        }
+        spinner.text = "Full reindex required...";
+      }
+    } else {
+      spinner.text = "Force flag enabled, performing full reindex...";
+    }
+    spinner.text = "Scanning codebase...";
+    let files;
+    if (isModernConfig(config) && config.frameworks.length > 0) {
+      files = await scanCodebaseWithFrameworks(rootDir, config);
+    } else if (isLegacyConfig(config)) {
+      files = await scanCodebase({
+        rootDir,
+        includePatterns: config.indexing.include,
+        excludePatterns: config.indexing.exclude
+      });
+    } else {
+      files = await scanCodebase({
+        rootDir,
+        includePatterns: [],
+        excludePatterns: []
+      });
+    }
+    if (files.length === 0) {
+      spinner.fail("No files found to index");
+      return;
+    }
+    spinner.text = `Found ${files.length} files`;
+    spinner.text = getModelLoadingMessage();
+    const embeddings = new LocalEmbeddings();
+    await embeddings.initialize();
+    spinner.succeed("Embedding model loaded");
+    const concurrency = isModernConfig(config) ? config.core.concurrency : 4;
+    const embeddingBatchSize = isModernConfig(config) ? config.core.embeddingBatchSize : 50;
+    const vectorDBBatchSize = 100;
+    spinner.start(`Processing files with ${concurrency}x concurrency...`);
+    const startTime = Date.now();
+    let processedFiles = 0;
+    let processedChunks = 0;
+    const chunkAccumulator = [];
+    const limit = pLimit(concurrency);
+    const indexedFileEntries = [];
+    const progressState = {
+      processedFiles: 0,
+      totalFiles: files.length,
+      wittyMessage: getIndexingMessage()
+    };
+    const SPINNER_UPDATE_INTERVAL_MS = 200;
+    const MESSAGE_ROTATION_INTERVAL_MS = 8e3;
+    const MESSAGE_ROTATION_TICKS = Math.floor(MESSAGE_ROTATION_INTERVAL_MS / SPINNER_UPDATE_INTERVAL_MS);
+    let spinnerTick = 0;
+    updateInterval = setInterval(() => {
+      spinnerTick++;
+      if (spinnerTick >= MESSAGE_ROTATION_TICKS) {
+        progressState.wittyMessage = getIndexingMessage();
+        spinnerTick = 0;
+      }
+      spinner.text = `${progressState.processedFiles}/${progressState.totalFiles} files | ${progressState.wittyMessage}`;
+    }, SPINNER_UPDATE_INTERVAL_MS);
+    const processAccumulatedChunks = async () => {
+      if (chunkAccumulator.length === 0) return;
+      const toProcess = chunkAccumulator.splice(0, chunkAccumulator.length);
+      for (let i = 0; i < toProcess.length; i += embeddingBatchSize) {
+        const batch = toProcess.slice(i, Math.min(i + embeddingBatchSize, toProcess.length));
+        progressState.wittyMessage = getEmbeddingMessage();
+        const texts = batch.map((item) => item.content);
+        const embeddingVectors = [];
+        for (let j = 0; j < texts.length; j += EMBEDDING_MICRO_BATCH_SIZE) {
+          const microBatch = texts.slice(j, Math.min(j + EMBEDDING_MICRO_BATCH_SIZE, texts.length));
+          const microResults = await embeddings.embedBatch(microBatch);
+          embeddingVectors.push(...microResults);
+          await new Promise((resolve) => setImmediate(resolve));
+        }
         processedChunks += batch.length;
+        progressState.wittyMessage = `Inserting ${batch.length} chunks into vector space...`;
+        await vectorDB.insertBatch(
+          embeddingVectors,
+          batch.map((item) => item.chunk.metadata),
+          texts
+        );
+        await new Promise((resolve) => setImmediate(resolve));
       }
+      progressState.wittyMessage = getIndexingMessage();
     };
     const filePromises = files.map(
       (file) => limit(async () => {
         try {
-          const content = await fs11.readFile(file, "utf-8");
+          const stats = await fs15.stat(file);
+          const content = await fs15.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, {
@@ -1973,6 +3043,7 @@ async function indexCodebase(options = {}) {
           });
           if (chunks.length === 0) {
             processedFiles++;
+            progressState.processedFiles = processedFiles;
             return;
           }
           for (const chunk of chunks) {
@@ -1981,25 +3052,53 @@ async function indexCodebase(options = {}) {
               content: chunk.content
             });
           }
-          if (chunkAccumulator.length >= batchSize) {
+          indexedFileEntries.push({
+            filepath: file,
+            chunkCount: chunks.length,
+            mtime: stats.mtimeMs
+          });
+          processedFiles++;
+          progressState.processedFiles = processedFiles;
+          if (chunkAccumulator.length >= vectorDBBatchSize) {
             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++;
+          progressState.processedFiles = processedFiles;
         }
       })
     );
     await Promise.all(filePromises);
+    progressState.wittyMessage = "Processing final chunks...";
     await processAccumulatedChunks();
+    clearInterval(updateInterval);
+    spinner.start("Saving index manifest...");
+    const manifest = new ManifestManager(vectorDB.dbPath);
+    await manifest.updateFiles(
+      indexedFileEntries.map((entry) => ({
+        filepath: entry.filepath,
+        lastModified: entry.mtime,
+        // Use actual file mtime for accurate change detection
+        chunkCount: entry.chunkCount
+      }))
+    );
+    const { isGitAvailable: isGitAvailable2, isGitRepo: isGitRepo2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+    const { GitStateTracker: GitStateTracker2 } = await Promise.resolve().then(() => (init_tracker(), tracker_exports));
+    const gitAvailable = await isGitAvailable2();
+    const isRepo = await isGitRepo2(rootDir);
+    if (gitAvailable && isRepo) {
+      const gitTracker = new GitStateTracker2(rootDir, vectorDB.dbPath);
+      await gitTracker.initialize();
+      const gitState = gitTracker.getState();
+      if (gitState) {
+        await manifest.updateGitState(gitState);
+      }
+    }
+    spinner.succeed("Manifest saved");
     await writeVersionFile(vectorDB.dbPath);
     const totalTime = ((Date.now() - startTime) / 1e3).toFixed(1);
     spinner.succeed(
@@ -2007,6 +3106,9 @@ async function indexCodebase(options = {}) {
     );
     console.log(chalk4.dim("\nNext step: Run"), chalk4.bold("lien serve"), chalk4.dim("to start the MCP server"));
   } catch (error) {
+    if (updateInterval) {
+      clearInterval(updateInterval);
+    }
     spinner.fail(`Indexing failed: ${error}`);
     throw error;
   }
@@ -2021,26 +3123,91 @@ var init_indexer = __esm({
     init_service();
     init_version();
     init_schema();
+    init_manifest();
+    init_change_detector();
+    init_incremental();
+    init_loading_messages();
+    init_constants();
   }
 });
 
 // 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";
+import { createRequire as createRequire4 } from "module";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import { dirname as dirname4, join as join4 } from "path";
 
 // src/cli/init.ts
 init_schema();
 init_merge();
-init_banner();
-init_migration();
 import fs5 from "fs/promises";
 import path5 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk2 from "chalk";
 import inquirer from "inquirer";
 
+// src/utils/banner.ts
+import figlet from "figlet";
+import chalk from "chalk";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var require2 = createRequire(import.meta.url);
+var packageJson;
+try {
+  packageJson = require2(join(__dirname, "../package.json"));
+} catch {
+  packageJson = require2(join(__dirname, "../../package.json"));
+}
+var PACKAGE_NAME = packageJson.name;
+var VERSION = packageJson.version;
+function wrapInBox(text, footer, padding = 1) {
+  const lines = text.split("\n").filter((line) => line.trim().length > 0);
+  const maxLength = Math.max(...lines.map((line) => line.length));
+  const horizontalBorder = "\u2500".repeat(maxLength + padding * 2);
+  const top = `\u250C${horizontalBorder}\u2510`;
+  const bottom = `\u2514${horizontalBorder}\u2518`;
+  const separator = `\u251C${horizontalBorder}\u2524`;
+  const paddedLines = lines.map((line) => {
+    const padRight = " ".repeat(maxLength - line.length + padding);
+    const padLeft = " ".repeat(padding);
+    return `\u2502${padLeft}${line}${padRight}\u2502`;
+  });
+  const totalPad = maxLength - footer.length;
+  const leftPad = Math.floor(totalPad / 2);
+  const rightPad = totalPad - leftPad;
+  const centeredFooter = " ".repeat(leftPad) + footer + " ".repeat(rightPad);
+  const paddedFooter = `\u2502${" ".repeat(padding)}${centeredFooter}${" ".repeat(padding)}\u2502`;
+  return [top, ...paddedLines, separator, paddedFooter, bottom].join("\n");
+}
+function showBanner() {
+  const banner = figlet.textSync("LIEN", {
+    font: "ANSI Shadow",
+    horizontalLayout: "fitted",
+    verticalLayout: "fitted"
+  });
+  const footer = `${PACKAGE_NAME} - v${VERSION}`;
+  const boxedBanner = wrapInBox(banner.trim(), footer);
+  console.error(chalk.cyan(boxedBanner));
+  console.error();
+}
+function showCompactBanner() {
+  const banner = figlet.textSync("LIEN", {
+    font: "ANSI Shadow",
+    horizontalLayout: "fitted",
+    verticalLayout: "fitted"
+  });
+  const footer = `${PACKAGE_NAME} - v${VERSION}`;
+  const boxedBanner = wrapInBox(banner.trim(), footer);
+  console.log(chalk.cyan(boxedBanner));
+  console.log();
+}
+
+// src/cli/init.ts
+init_migration();
+
 // src/frameworks/detector-service.ts
 import fs4 from "fs/promises";
 import path4 from "path";
@@ -2126,17 +3293,17 @@ var nodejsDetector = {
       evidence: []
     };
     const packageJsonPath = path.join(fullPath, "package.json");
-    let packageJson4 = null;
+    let packageJson5 = null;
     try {
       const content = await fs.readFile(packageJsonPath, "utf-8");
-      packageJson4 = JSON.parse(content);
+      packageJson5 = 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) {
+    if (packageJson5.devDependencies?.typescript || packageJson5.dependencies?.typescript) {
       result.evidence.push("TypeScript detected");
     }
     const testFrameworks = [
@@ -2147,7 +3314,7 @@ var nodejsDetector = {
       { name: "@playwright/test", display: "Playwright" }
     ];
     for (const framework of testFrameworks) {
-      if (packageJson4.devDependencies?.[framework.name] || packageJson4.dependencies?.[framework.name]) {
+      if (packageJson5.devDependencies?.[framework.name] || packageJson5.dependencies?.[framework.name]) {
         result.evidence.push(`${framework.display} test framework detected`);
         break;
       }
@@ -2160,13 +3327,13 @@ var nodejsDetector = {
       { name: "@nestjs/core", display: "NestJS" }
     ];
     for (const fw of frameworks) {
-      if (packageJson4.dependencies?.[fw.name]) {
+      if (packageJson5.dependencies?.[fw.name]) {
         result.evidence.push(`${fw.display} detected`);
         break;
       }
     }
-    if (packageJson4.engines?.node) {
-      result.version = packageJson4.engines.node;
+    if (packageJson5.engines?.node) {
+      result.version = packageJson5.engines.node;
     }
     return result;
   },
@@ -2796,111 +3963,31 @@ async function upgradeConfig(configPath) {
         newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
       }
     }
-    await fs5.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 fs9 from "fs/promises";
-import path9 from "path";
-import os from "os";
-import crypto from "crypto";
-
-// src/git/utils.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-import fs7 from "fs/promises";
-import path7 from "path";
-var execAsync = promisify(exec);
-async function isGitRepo(rootDir) {
-  try {
-    const gitDir = path7.join(rootDir, ".git");
-    await fs7.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) => path7.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
-      }
+    await fs5.writeFile(
+      configPath,
+      JSON.stringify(upgradedConfig, null, 2) + "\n",
+      "utf-8"
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path7.join(rootDir, file));
-    return files;
+    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) {
-    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;
+    console.error(chalk2.red("Error upgrading config:"), error);
+    throw error;
   }
 }
 
 // src/cli/status.ts
+init_service();
+init_utils();
 init_version();
-init_banner();
+import chalk3 from "chalk";
+import fs9 from "fs/promises";
+import path9 from "path";
+import os from "os";
+import crypto from "crypto";
 init_schema();
 async function statusCommand() {
   const rootDir = process.cwd();
@@ -2986,14 +4073,25 @@ async function statusCommand() {
 
 // src/cli/index-cmd.ts
 init_indexer();
-init_banner();
 import chalk5 from "chalk";
 async function indexCommand(options) {
   showCompactBanner();
   try {
+    if (options.force) {
+      const { VectorDB: VectorDB2 } = await Promise.resolve().then(() => (init_lancedb(), lancedb_exports));
+      const { ManifestManager: ManifestManager2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      console.log(chalk5.yellow("Clearing existing index and manifest..."));
+      const vectorDB = new VectorDB2(process.cwd());
+      await vectorDB.initialize();
+      await vectorDB.clear();
+      const manifest = new ManifestManager2(vectorDB.dbPath);
+      await manifest.clear();
+      console.log(chalk5.green("\u2713 Index and manifest cleared\n"));
+    }
     await indexCodebase({
       rootDir: process.cwd(),
-      verbose: options.verbose || false
+      verbose: options.verbose || false,
+      force: options.force || false
     });
     if (options.watch) {
       console.log(chalk5.yellow("\n\u26A0\uFE0F  Watch mode not yet implemented"));
@@ -3006,8 +4104,8 @@ async function indexCommand(options) {
 
 // src/cli/serve.ts
 import chalk6 from "chalk";
-import fs14 from "fs/promises";
-import path13 from "path";
+import fs16 from "fs/promises";
+import path14 from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -3016,332 +4114,99 @@ 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";
+import { createRequire as createRequire3 } from "module";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/mcp/utils/zod-to-json-schema.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+function toMCPToolSchema(zodSchema, name, description) {
+  return {
+    name,
+    description,
+    inputSchema: zodToJsonSchema(zodSchema, {
+      target: "jsonSchema7",
+      $refStrategy: "none"
+    })
+  };
+}
+
+// src/mcp/schemas/search.schema.ts
+import { z } from "zod";
+var SemanticSearchSchema = z.object({
+  query: z.string().min(3, "Query must be at least 3 characters").max(500, "Query too long (max 500 characters)").describe(
+    "Natural language description of what you're looking for.\n\nUse full sentences describing functionality, not exact names.\n\nGood examples:\n  - 'handles user authentication'\n  - 'validates email format'\n  - 'processes payment transactions'\n\nBad examples:\n  - 'auth' (too vague)\n  - 'validateEmail' (use grep for exact names)"
+  ),
+  limit: z.number().int().min(1, "Limit must be at least 1").max(50, "Limit cannot exceed 50").default(5).describe(
+    "Number of results to return.\n\nDefault: 5\nIncrease to 10-15 for broad exploration."
+  )
+});
+
+// src/mcp/schemas/similarity.schema.ts
+import { z as z2 } from "zod";
+var FindSimilarSchema = z2.object({
+  code: z2.string().min(10, "Code snippet must be at least 10 characters").describe(
+    "Code snippet to find similar implementations for.\n\nProvide a representative code sample that demonstrates the pattern you want to find similar examples of in the codebase."
+  ),
+  limit: z2.number().int().min(1, "Limit must be at least 1").max(20, "Limit cannot exceed 20").default(5).describe(
+    "Number of similar code blocks to return.\n\nDefault: 5"
+  )
+});
+
+// src/mcp/schemas/file.schema.ts
+import { z as z3 } from "zod";
+var GetFileContextSchema = z3.object({
+  filepath: z3.string().min(1, "Filepath cannot be empty").describe(
+    "Relative path to file from workspace root.\n\nExample: 'src/components/Button.tsx'"
+  ),
+  includeRelated: z3.boolean().default(true).describe(
+    "Include semantically related chunks from nearby code.\n\nDefault: true\n\nWhen enabled, also returns related code from other files that are semantically similar to the target file's contents."
+  )
+});
+
+// src/mcp/schemas/symbols.schema.ts
+import { z as z4 } from "zod";
+var ListFunctionsSchema = z4.object({
+  pattern: z4.string().optional().describe(
+    "Regex pattern to match symbol names.\n\nExamples:\n  - '.*Controller.*' to find all Controllers\n  - 'handle.*' to find handlers\n  - '.*Service$' to find Services\n\nIf omitted, returns all symbols."
+  ),
+  language: z4.string().optional().describe(
+    "Filter by programming language.\n\nExamples: 'typescript', 'python', 'javascript', 'php'\n\nIf omitted, searches all languages."
+  )
+});
 
 // 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")'
-        }
-      }
-    }
-  }
+  toMCPToolSchema(
+    SemanticSearchSchema,
+    "semantic_search",
+    "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."
+  ),
+  toMCPToolSchema(
+    FindSimilarSchema,
+    "find_similar",
+    "Find code similar to a given code snippet. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+  ),
+  toMCPToolSchema(
+    GetFileContextSchema,
+    "get_file_context",
+    "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."
+  ),
+  toMCPToolSchema(
+    ListFunctionsSchema,
+    "list_functions",
+    "List functions, classes, and interfaces by name pattern and language"
+  )
 ];
 
 // src/mcp/server.ts
 init_lancedb();
 init_local();
-
-// src/git/tracker.ts
-import fs12 from "fs/promises";
-import path12 from "path";
-var GitStateTracker = class {
-  stateFile;
-  rootDir;
-  currentState = null;
-  constructor(rootDir, indexPath) {
-    this.rootDir = rootDir;
-    this.stateFile = path12.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 fs12.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 fs12.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 fs13 from "fs/promises";
-async function indexSingleFile(filepath, vectorDB, embeddings, config, options = {}) {
-  const { verbose } = options;
-  try {
-    try {
-      await fs13.access(filepath);
-    } catch {
-      if (verbose) {
-        console.error(`[Lien] File deleted: ${filepath}`);
-      }
-      await vectorDB.deleteByFile(filepath);
-      return;
-    }
-    const content = await fs13.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_tracker();
+init_incremental();
 init_service();
+init_manifest();
+init_utils();
 
 // src/watcher/index.ts
 init_schema();
@@ -3474,14 +4339,72 @@ var FileWatcher = class {
 
 // src/mcp/server.ts
 init_constants();
-var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname2(__filename3);
-var require3 = createRequire2(import.meta.url);
-var packageJson2;
+
+// src/mcp/utils/tool-wrapper.ts
+init_errors();
+import { ZodError } from "zod";
+function wrapToolHandler(schema, handler) {
+  return async (args) => {
+    try {
+      const validated = schema.parse(args);
+      const result = await handler(validated);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    } catch (error) {
+      if (error instanceof ZodError) {
+        return {
+          isError: true,
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: "Invalid parameters",
+              code: "INVALID_INPUT" /* INVALID_INPUT */,
+              details: error.errors.map((e) => ({
+                field: e.path.join("."),
+                message: e.message
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+      if (error instanceof LienError) {
+        return {
+          isError: true,
+          content: [{
+            type: "text",
+            text: JSON.stringify(error.toJSON(), null, 2)
+          }]
+        };
+      }
+      console.error("Unexpected error in tool handler:", error);
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: error instanceof Error ? error.message : "Unknown error",
+            code: "INTERNAL_ERROR" /* INTERNAL_ERROR */
+          }, null, 2)
+        }]
+      };
+    }
+  };
+}
+
+// src/mcp/server.ts
+init_errors();
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname3(__filename4);
+var require4 = createRequire3(import.meta.url);
+var packageJson3;
 try {
-  packageJson2 = require3(join2(__dirname3, "../package.json"));
+  packageJson3 = require4(join3(__dirname4, "../package.json"));
 } catch {
-  packageJson2 = require3(join2(__dirname3, "../../package.json"));
+  packageJson3 = require4(join3(__dirname4, "../../package.json"));
 }
 async function startMCPServer(options) {
   const { rootDir, verbose, watch } = options;
@@ -3506,7 +4429,7 @@ async function startMCPServer(options) {
   const server = new Server(
     {
       name: "lien",
-      version: packageJson2.version
+      version: packageJson3.version
     },
     {
       capabilities: {
@@ -3538,148 +4461,139 @@ async function startMCPServer(options) {
   }, VERSION_CHECK_INTERVAL_MS);
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    log(`Handling tool call: ${name}`);
     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 "semantic_search":
+          return await wrapToolHandler(
+            SemanticSearchSchema,
+            async (validatedArgs) => {
+              log(`Searching for: "${validatedArgs.query}"`);
+              await checkAndReconnect();
+              const queryEmbedding = await embeddings.embed(validatedArgs.query);
+              const results = await vectorDB.search(queryEmbedding, validatedArgs.limit, validatedArgs.query);
+              log(`Found ${results.length} results`);
+              return {
+                indexInfo: getIndexMetadata(),
+                results
+              };
+            }
+          )(args);
+        case "find_similar":
+          return await wrapToolHandler(
+            FindSimilarSchema,
+            async (validatedArgs) => {
+              log(`Finding similar code...`);
+              await checkAndReconnect();
+              const codeEmbedding = await embeddings.embed(validatedArgs.code);
+              const results = await vectorDB.search(codeEmbedding, validatedArgs.limit, validatedArgs.code);
+              log(`Found ${results.length} similar chunks`);
+              return {
+                indexInfo: getIndexMetadata(),
+                results
+              };
+            }
+          )(args);
+        case "get_file_context":
+          return await wrapToolHandler(
+            GetFileContextSchema,
+            async (validatedArgs) => {
+              log(`Getting context for: ${validatedArgs.filepath}`);
+              await checkAndReconnect();
+              const fileEmbedding = await embeddings.embed(validatedArgs.filepath);
+              const allResults = await vectorDB.search(fileEmbedding, 50, validatedArgs.filepath);
+              const fileChunks = allResults.filter(
+                (r) => r.metadata.file.includes(validatedArgs.filepath) || validatedArgs.filepath.includes(r.metadata.file)
+              );
+              let results = fileChunks;
+              if (validatedArgs.includeRelated && fileChunks.length > 0) {
+                const relatedEmbedding = await embeddings.embed(fileChunks[0].content);
+                const related = await vectorDB.search(relatedEmbedding, 5, fileChunks[0].content);
+                const relatedOtherFiles = related.filter(
+                  (r) => !r.metadata.file.includes(validatedArgs.filepath) && !validatedArgs.filepath.includes(r.metadata.file)
+                );
+                results = [...fileChunks, ...relatedOtherFiles];
               }
-            ]
-          };
-        }
-        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";
+              log(`Found ${results.length} chunks`);
+              return {
+                indexInfo: getIndexMetadata(),
+                file: validatedArgs.filepath,
+                chunks: results
+              };
             }
-          } 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)
+          )(args);
+        case "list_functions":
+          return await wrapToolHandler(
+            ListFunctionsSchema,
+            async (validatedArgs) => {
+              log("Listing functions with symbol metadata...");
+              await checkAndReconnect();
+              let results;
+              let usedMethod = "symbols";
+              try {
+                results = await vectorDB.querySymbols({
+                  language: validatedArgs.language,
+                  pattern: validatedArgs.pattern,
+                  limit: 50
+                });
+                if (results.length === 0 && (validatedArgs.language || validatedArgs.pattern)) {
+                  log("No symbol results, falling back to content scan...");
+                  results = await vectorDB.scanWithFilter({
+                    language: validatedArgs.language,
+                    pattern: validatedArgs.pattern,
+                    limit: 50
+                  });
+                  usedMethod = "content";
+                }
+              } catch (error) {
+                log(`Symbol query failed, falling back to content scan: ${error}`);
+                results = await vectorDB.scanWithFilter({
+                  language: validatedArgs.language,
+                  pattern: validatedArgs.pattern,
+                  limit: 50
+                });
+                usedMethod = "content";
               }
-            ]
-          };
-        }
+              log(`Found ${results.length} matches using ${usedMethod} method`);
+              return {
+                indexInfo: getIndexMetadata(),
+                method: usedMethod,
+                results,
+                note: usedMethod === "content" ? 'Using content search. Run "lien reindex" to enable faster symbol-based queries.' : void 0
+              };
+            }
+          )(args);
         default:
-          throw new Error(`Unknown tool: ${name}`);
+          throw new LienError(
+            `Unknown tool: ${name}`,
+            "INVALID_INPUT" /* INVALID_INPUT */,
+            { requestedTool: name, availableTools: tools.map((t) => t.name) },
+            "medium",
+            false,
+            false
+          );
       }
     } catch (error) {
-      console.error(`Error handling tool call ${name}:`, error);
-      return {
-        content: [
-          {
+      if (error instanceof LienError) {
+        return {
+          isError: true,
+          content: [{
             type: "text",
-            text: JSON.stringify({
-              error: String(error),
-              tool: name
-            })
-          }
-        ],
-        isError: true
+            text: JSON.stringify(error.toJSON(), null, 2)
+          }]
+        };
+      }
+      console.error(`Unexpected error handling tool call ${name}:`, error);
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: error instanceof Error ? error.message : "Unknown error",
+            code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+            tool: name
+          }, null, 2)
+        }]
       };
     }
   });
@@ -3762,7 +4676,7 @@ async function startMCPServer(options) {
   } else {
     log("Git detection disabled by configuration");
   }
-  const fileWatchingEnabled = watch || config.fileWatching.enabled;
+  const fileWatchingEnabled = watch !== void 0 ? watch : config.fileWatching.enabled;
   if (fileWatchingEnabled) {
     log("\u{1F440} Starting file watcher...");
     fileWatcher = new FileWatcher(rootDir, config);
@@ -3773,6 +4687,8 @@ async function startMCPServer(options) {
           log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
           try {
             await vectorDB.deleteByFile(filepath);
+            const manifest = new ManifestManager(vectorDB.dbPath);
+            await manifest.removeFile(filepath);
             log(`\u2713 Removed ${filepath} from index`);
           } catch (error) {
             log(`Warning: Failed to remove ${filepath}: ${error}`);
@@ -3818,13 +4734,12 @@ async function startMCPServer(options) {
 }
 
 // src/cli/serve.ts
-init_banner();
 async function serveCommand(options) {
-  const rootDir = options.root ? path13.resolve(options.root) : process.cwd();
+  const rootDir = options.root ? path14.resolve(options.root) : process.cwd();
   try {
     if (options.root) {
       try {
-        const stats = await fs14.stat(rootDir);
+        const stats = await fs16.stat(rootDir);
         if (!stats.isDirectory()) {
           console.error(chalk6.red(`Error: --root path is not a directory: ${rootDir}`));
           process.exit(1);
@@ -3847,10 +4762,15 @@ async function serveCommand(options) {
       console.error(chalk6.dim(`Serving from: ${rootDir}
 `));
     }
+    if (options.watch) {
+      console.error(chalk6.yellow("\u26A0\uFE0F  --watch flag is deprecated (file watching is now default)"));
+      console.error(chalk6.dim("    Use --no-watch to disable file watching\n"));
+    }
+    const watch = options.noWatch ? false : options.watch ? true : void 0;
     await startMCPServer({
       rootDir,
       verbose: true,
-      watch: options.watch
+      watch
     });
   } catch (error) {
     console.error(chalk6.red("Failed to start MCP server:"), error);
@@ -3859,42 +4779,21 @@ async function serveCommand(options) {
 }
 
 // src/cli/index.ts
-var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname3(__filename4);
-var require4 = createRequire3(import.meta.url);
-var packageJson3;
+var __filename5 = fileURLToPath5(import.meta.url);
+var __dirname5 = dirname4(__filename5);
+var require5 = createRequire4(import.meta.url);
+var packageJson4;
 try {
-  packageJson3 = require4(join3(__dirname4, "../package.json"));
+  packageJson4 = require5(join4(__dirname5, "../package.json"));
 } catch {
-  packageJson3 = require4(join3(__dirname4, "../../package.json"));
+  packageJson4 = require5(join4(__dirname5, "../../package.json"));
 }
 var program = new Command();
-program.name("lien").description("Local semantic code search for AI assistants via MCP").version(packageJson3.version);
+program.name("lien").description("Local semantic code search for AI assistants via MCP").version(packageJson4.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").option("-r, --root <path>", "Root directory to serve (defaults to current directory)").action(serveCommand);
+program.command("index").description("Index the codebase for semantic search").option("-f, --force", "Force full reindex (skip incremental)").option("-w, --watch", "Watch for changes and re-index automatically").option("-v, --verbose", "Show detailed logging during indexing").action(indexCommand);
+program.command("serve").description("Start the MCP server for Cursor integration").option("-p, --port <port>", "Port number (for future use)", "7133").option("--no-watch", "Disable file watching for this session").option("-w, --watch", "[DEPRECATED] File watching is now enabled by default").option("-r, --root <path>", "Root directory to serve (defaults to current directory)").action(serveCommand);
 program.command("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();