@liendev/lien 0.9.1 → 0.11.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) {
@@ -329,8 +264,8 @@ var init_errors = __esm({
 });
 
 // src/config/service.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 var ConfigService, configService;
 var init_service = __esm({
   "src/config/service.ts"() {
@@ -352,13 +287,13 @@ var init_service = __esm({
       async load(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs5.readFile(configPath, "utf-8");
+          const configContent = await fs6.readFile(configPath, "utf-8");
           const userConfig = JSON.parse(configContent);
           if (this.needsMigration(userConfig)) {
             console.log("\u{1F504} Migrating config from v0.2.0 to v0.3.0...");
             const result = await this.migrate(rootDir);
             if (result.migrated && result.backupPath) {
-              const backupFilename = path5.basename(result.backupPath);
+              const backupFilename = path6.basename(result.backupPath);
               console.log(`\u2705 Migration complete! Backup saved as ${backupFilename}`);
               console.log("\u{1F4DD} Your config now uses the framework-based structure.");
             }
@@ -414,7 +349,7 @@ ${validation.errors.join("\n")}`,
         }
         try {
           const configJson = JSON.stringify(config, null, 2) + "\n";
-          await fs5.writeFile(configPath, configJson, "utf-8");
+          await fs6.writeFile(configPath, configJson, "utf-8");
         } catch (error) {
           throw wrapError(error, "Failed to save configuration", { path: configPath });
         }
@@ -428,7 +363,7 @@ ${validation.errors.join("\n")}`,
       async exists(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          await fs5.access(configPath);
+          await fs6.access(configPath);
           return true;
         } catch {
           return false;
@@ -445,7 +380,7 @@ ${validation.errors.join("\n")}`,
       async migrate(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs5.readFile(configPath, "utf-8");
+          const configContent = await fs6.readFile(configPath, "utf-8");
           const oldConfig = JSON.parse(configContent);
           if (!this.needsMigration(oldConfig)) {
             return {
@@ -463,7 +398,7 @@ ${validation.errors.join("\n")}`,
             );
           }
           const backupPath = `${configPath}.v0.2.0.backup`;
-          await fs5.copyFile(configPath, backupPath);
+          await fs6.copyFile(configPath, backupPath);
           await this.save(rootDir, newConfig);
           return {
             migrated: true,
@@ -561,7 +496,7 @@ ${validation.errors.join("\n")}`,
        * Get the full path to the config file
        */
       getConfigPath(rootDir) {
-        return path5.join(rootDir, _ConfigService.CONFIG_FILENAME);
+        return path6.join(rootDir, _ConfigService.CONFIG_FILENAME);
       }
       /**
        * Validate modern (v0.3.0+) configuration
@@ -725,7 +660,7 @@ ${validation.errors.join("\n")}`,
             errors.push(`frameworks[${index}] missing required field: path`);
           } else if (typeof fw.path !== "string") {
             errors.push(`frameworks[${index}].path must be a string`);
-          } else if (path5.isAbsolute(fw.path)) {
+          } else if (path6.isAbsolute(fw.path)) {
             errors.push(`frameworks[${index}].path must be relative, got: ${fw.path}`);
           }
           if (fw.enabled === void 0) {
@@ -772,22 +707,131 @@ ${validation.errors.join("\n")}`,
   }
 });
 
-// src/vectordb/version.ts
+// 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";
 async function writeVersionFile(indexPath) {
   try {
-    const versionFilePath = path7.join(indexPath, VERSION_FILE);
+    const versionFilePath = path8.join(indexPath, VERSION_FILE);
     const timestamp = Date.now().toString();
-    await fs7.writeFile(versionFilePath, timestamp, "utf-8");
+    await fs8.writeFile(versionFilePath, timestamp, "utf-8");
   } catch (error) {
     console.error(`Warning: Failed to write version file: ${error}`);
   }
 }
 async function readVersionFile(indexPath) {
   try {
-    const versionFilePath = path7.join(indexPath, VERSION_FILE);
-    const content = await fs7.readFile(versionFilePath, "utf-8");
+    const versionFilePath = path8.join(indexPath, VERSION_FILE);
+    const content = await fs8.readFile(versionFilePath, "utf-8");
     const timestamp = parseInt(content.trim(), 10);
     return isNaN(timestamp) ? 0 : timestamp;
   } catch (error) {
@@ -805,8 +849,8 @@ var init_version = __esm({
 // src/indexer/scanner.ts
 import { glob } from "glob";
 import ignore from "ignore";
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 async function scanCodebaseWithFrameworks(rootDir, config) {
   const allFiles = [];
   for (const framework of config.frameworks) {
@@ -819,16 +863,16 @@ async function scanCodebaseWithFrameworks(rootDir, config) {
   return allFiles;
 }
 async function scanFramework(rootDir, framework) {
-  const frameworkPath = path9.join(rootDir, framework.path);
-  const gitignorePath = path9.join(frameworkPath, ".gitignore");
+  const frameworkPath = path10.join(rootDir, framework.path);
+  const gitignorePath = path10.join(frameworkPath, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs9.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs10.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
-    const rootGitignorePath = path9.join(rootDir, ".gitignore");
+    const rootGitignorePath = path10.join(rootDir, ".gitignore");
     try {
-      const gitignoreContent = await fs9.readFile(rootGitignorePath, "utf-8");
+      const gitignoreContent = await fs10.readFile(rootGitignorePath, "utf-8");
       ig = ignore().add(gitignoreContent);
     } catch (e2) {
     }
@@ -850,15 +894,15 @@ async function scanFramework(rootDir, framework) {
   }
   const uniqueFiles = Array.from(new Set(allFiles));
   return uniqueFiles.filter((file) => !ig.ignores(file)).map((file) => {
-    return framework.path === "." ? file : path9.join(framework.path, file);
+    return framework.path === "." ? file : path10.join(framework.path, file);
   });
 }
 async function scanCodebase(options) {
   const { rootDir, includePatterns = [], excludePatterns = [] } = options;
-  const gitignorePath = path9.join(rootDir, ".gitignore");
+  const gitignorePath = path10.join(rootDir, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs9.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs10.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
   }
@@ -885,12 +929,12 @@ async function scanCodebase(options) {
   }
   const uniqueFiles = Array.from(new Set(allFiles));
   return uniqueFiles.filter((file) => {
-    const relativePath = path9.relative(rootDir, file);
+    const relativePath = path10.relative(rootDir, file);
     return !ig.ignores(relativePath);
   });
 }
 function detectLanguage(filepath) {
-  const ext = path9.extname(filepath).toLowerCase();
+  const ext = path10.extname(filepath).toLowerCase();
   const languageMap = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -915,6 +959,7 @@ function detectLanguage(filepath) {
     ".kt": "kotlin",
     ".cs": "csharp",
     ".scala": "scala",
+    ".liquid": "liquid",
     ".md": "markdown",
     ".mdx": "markdown",
     ".markdown": "markdown"
@@ -1380,12 +1425,12 @@ __export(lancedb_exports, {
   VectorDB: () => VectorDB
 });
 import * as lancedb from "vectordb";
-import path10 from "path";
+import path11 from "path";
 import os2 from "os";
 import crypto2 from "crypto";
 function isDocumentationFile(filepath) {
   const lower = filepath.toLowerCase();
-  const filename = path10.basename(filepath).toLowerCase();
+  const filename = path11.basename(filepath).toLowerCase();
   if (filename.startsWith("readme")) return true;
   if (filename.startsWith("changelog")) return true;
   if (filename.endsWith(".md") || filename.endsWith(".mdx") || filename.endsWith(".markdown")) {
@@ -1432,7 +1477,7 @@ function boostPathRelevance(query, filepath, baseScore) {
   return baseScore * boostFactor;
 }
 function boostFilenameRelevance(query, filepath, baseScore) {
-  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   let boostFactor = 1;
   for (const token of queryTokens) {
@@ -1447,7 +1492,7 @@ function boostFilenameRelevance(query, filepath, baseScore) {
 }
 function boostForLocationIntent(query, filepath, baseScore) {
   let score = baseScore;
-  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
@@ -1475,7 +1520,7 @@ function boostForConceptualIntent(query, filepath, baseScore) {
   if (isUtilityFile(filepath)) {
     score *= 1.05;
   }
-  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
@@ -1483,7 +1528,7 @@ function boostForConceptualIntent(query, filepath, baseScore) {
       score *= 0.9;
     }
   }
-  const pathSegments = filepath.toLowerCase().split(path10.sep);
+  const pathSegments = filepath.toLowerCase().split(path11.sep);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
     for (const segment of pathSegments) {
@@ -1529,6 +1574,7 @@ var init_lancedb = __esm({
     init_errors();
     init_relevance();
     init_intent_classifier();
+    init_constants();
     VectorDB = class _VectorDB {
       db = null;
       table = null;
@@ -1537,9 +1583,9 @@ var init_lancedb = __esm({
       lastVersionCheck = 0;
       currentVersion = 0;
       constructor(projectRoot) {
-        const projectName = path10.basename(projectRoot);
+        const projectName = path11.basename(projectRoot);
         const pathHash = crypto2.createHash("md5").update(projectRoot).digest("hex").substring(0, 8);
-        this.dbPath = path10.join(
+        this.dbPath = path11.join(
           os2.homedir(),
           ".lien",
           "indices",
@@ -1574,27 +1620,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) {
@@ -1892,86 +1987,1027 @@ var init_lancedb = __esm({
   }
 });
 
-// src/indexer/index.ts
-var indexer_exports = {};
-__export(indexer_exports, {
-  indexCodebase: () => indexCodebase
-});
-import fs10 from "fs/promises";
-import ora from "ora";
-import chalk4 from "chalk";
-import pLimit from "p-limit";
-async function indexCodebase(options = {}) {
-  const rootDir = options.rootDir ?? process.cwd();
-  const spinner = ora("Starting indexing process...").start();
-  try {
-    spinner.text = "Loading configuration...";
-    const config = await configService.load(rootDir);
-    spinner.text = "Scanning codebase...";
-    let files;
-    if (isModernConfig(config) && config.frameworks.length > 0) {
-      files = await scanCodebaseWithFrameworks(rootDir, config);
-    } else if (isLegacyConfig(config)) {
-      files = await scanCodebase({
-        rootDir,
-        includePatterns: config.indexing.include,
-        excludePatterns: config.indexing.exclude
-      });
-    } else {
-      files = await scanCodebase({
-        rootDir,
-        includePatterns: [],
-        excludePatterns: []
-      });
-    }
-    if (files.length === 0) {
-      spinner.fail("No files found to index");
-      return;
-    }
-    spinner.text = `Found ${files.length} files`;
-    spinner.text = "Loading embedding model (this may take a minute on first run)...";
-    const embeddings = new LocalEmbeddings();
-    await embeddings.initialize();
-    spinner.succeed("Embedding model loaded");
-    spinner.start("Initializing vector database...");
-    const vectorDB = new VectorDB(rootDir);
-    await vectorDB.initialize();
-    spinner.succeed("Vector database initialized");
-    const concurrency = isModernConfig(config) ? config.core.concurrency : 4;
-    const batchSize = isModernConfig(config) ? config.core.embeddingBatchSize : 50;
-    spinner.start(`Processing files with ${concurrency}x concurrency...`);
-    const startTime = Date.now();
-    let processedFiles = 0;
-    let processedChunks = 0;
-    const chunkAccumulator = [];
-    const limit = pLimit(concurrency);
-    const processAccumulatedChunks = async () => {
-      if (chunkAccumulator.length === 0) return;
-      const toProcess = chunkAccumulator.splice(0, chunkAccumulator.length);
-      for (let i = 0; i < toProcess.length; i += batchSize) {
-        const batch = toProcess.slice(i, Math.min(i + batchSize, toProcess.length));
-        const texts = batch.map((item) => item.content);
-        const embeddingVectors = await embeddings.embedBatch(texts);
-        await vectorDB.insertBatch(
-          embeddingVectors,
-          batch.map((item) => item.chunk.metadata),
-          texts
-        );
-        processedChunks += batch.length;
+// 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" };
       }
-    };
-    const filePromises = files.map(
-      (file) => limit(async () => {
-        try {
-          const content = await fs10.readFile(file, "utf-8");
-          const chunkSize = isModernConfig(config) ? config.core.chunkSize : 75;
-          const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : 10;
-          const chunks = chunkFile(file, content, {
-            chunkSize,
-            chunkOverlap
-          });
+    }
+  }
+});
+
+// src/indexer/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  ManifestManager: () => ManifestManager
+});
+import fs11 from "fs/promises";
+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 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, {
+            chunkSize,
+            chunkOverlap
+          });
           if (chunks.length === 0) {
             processedFiles++;
+            progressState.processedFiles = processedFiles;
             return;
           }
           for (const chunk of chunks) {
@@ -1980,25 +3016,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(
@@ -2006,6 +3070,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;
   }
@@ -2020,29 +3087,94 @@ 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 fs4 from "fs/promises";
-import path4 from "path";
+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 fs3 from "fs/promises";
-import path3 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 
 // src/frameworks/types.ts
 var defaultDetectionOptions = {
@@ -2071,24 +3203,17 @@ import path from "path";
 async function generateNodeJsConfig(_rootDir, _relativePath) {
   return {
     include: [
-      "src/**/*.ts",
-      "src/**/*.tsx",
-      "src/**/*.js",
-      "src/**/*.jsx",
-      "src/**/*.mjs",
-      "src/**/*.cjs",
-      "lib/**/*.ts",
-      "lib/**/*.js",
-      "*.ts",
-      "*.js",
-      "*.mjs",
-      "*.cjs",
+      // Broader patterns to catch all common project structures
+      // (frontend/, src/, lib/, app/, components/, etc.)
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.vue",
+      "**/*.mjs",
+      "**/*.cjs",
       "**/*.md",
-      "**/*.mdx",
-      "docs/**/*.md",
-      "README.md",
-      "CHANGELOG.md",
-      "CONTRIBUTING.md"
+      "**/*.mdx"
     ],
     exclude: [
       "node_modules/**",
@@ -2097,10 +3222,22 @@ async function generateNodeJsConfig(_rootDir, _relativePath) {
       "coverage/**",
       ".next/**",
       ".nuxt/**",
+      ".vite/**",
+      ".lien/**",
       "out/**",
       "*.min.js",
       "*.min.css",
-      "*.bundle.js"
+      "*.bundle.js",
+      // Test artifacts (source files are indexed, but not output)
+      "playwright-report/**",
+      "test-results/**",
+      // Build/generated artifacts
+      "__generated__/**",
+      // Common build/cache directories
+      ".cache/**",
+      ".turbo/**",
+      ".vercel/**",
+      ".netlify/**"
     ]
   };
 }
@@ -2120,17 +3257,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 = [
@@ -2141,7 +3278,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;
       }
@@ -2154,13 +3291,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;
   },
@@ -2185,12 +3322,12 @@ async function generateLaravelConfig(_rootDir, _relativePath) {
       "resources/**/*.php",
       "tests/**/*.php",
       "*.php",
-      // Frontend assets (Vue/React/Inertia)
-      "resources/js/**/*.js",
-      "resources/js/**/*.ts",
-      "resources/js/**/*.jsx",
-      "resources/js/**/*.tsx",
-      "resources/js/**/*.vue",
+      // Frontend assets (Vue/React/Inertia) - Broadened for flexibility
+      "**/*.js",
+      "**/*.ts",
+      "**/*.jsx",
+      "**/*.tsx",
+      "**/*.vue",
       // Blade templates
       "resources/views/**/*.blade.php",
       // Documentation
@@ -2205,7 +3342,19 @@ async function generateLaravelConfig(_rootDir, _relativePath) {
       "storage/**",
       "bootstrap/cache/**",
       "public/**",
-      "node_modules/**"
+      "node_modules/**",
+      "dist/**",
+      "build/**",
+      // Test artifacts (source files are indexed, but not output)
+      "playwright-report/**",
+      "test-results/**",
+      "coverage/**",
+      // Build/generated artifacts
+      "__generated__/**",
+      // Frontend build outputs
+      ".vite/**",
+      ".nuxt/**",
+      ".next/**"
     ]
   };
 }
@@ -2276,21 +3425,153 @@ var laravelDetector = {
       } catch {
       }
     }
-    if (composerJson.require?.["laravel/framework"]) {
-      result.version = composerJson.require["laravel/framework"];
+    if (composerJson.require?.["laravel/framework"]) {
+      result.version = composerJson.require["laravel/framework"];
+    }
+    result.detected = true;
+    return result;
+  },
+  async generateConfig(rootDir, relativePath) {
+    return generateLaravelConfig(rootDir, relativePath);
+  }
+};
+
+// src/frameworks/shopify/detector.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/frameworks/shopify/config.ts
+async function generateShopifyConfig(_rootDir, _relativePath) {
+  return {
+    include: [
+      // Core Liquid templates
+      "layout/**/*.liquid",
+      "sections/**/*.liquid",
+      "snippets/**/*.liquid",
+      "templates/**/*.liquid",
+      // Matches any nesting level (e.g., templates/customers/account.liquid)
+      // Theme editor blocks (Online Store 2.0)
+      "blocks/**/*.liquid",
+      // Assets (CSS, JS with optional Liquid templating)
+      "assets/**/*.js",
+      "assets/**/*.js.liquid",
+      "assets/**/*.css",
+      "assets/**/*.css.liquid",
+      "assets/**/*.scss",
+      "assets/**/*.scss.liquid",
+      // Configuration files
+      "config/*.json",
+      // Locales (i18n)
+      "locales/*.json",
+      // Documentation
+      "*.md",
+      "docs/**/*.md",
+      // Shopify-specific config files
+      "shopify.theme.toml",
+      ".shopifyignore"
+    ],
+    exclude: [
+      "node_modules/**",
+      "dist/**",
+      "build/**",
+      ".git/**",
+      // Playwright/testing artifacts
+      "playwright-report/**",
+      "test-results/**",
+      // Build/generated artifacts
+      "__generated__/**",
+      // Common frontend build outputs
+      ".vite/**",
+      ".nuxt/**",
+      ".next/**"
+    ]
+  };
+}
+
+// src/frameworks/shopify/detector.ts
+var shopifyDetector = {
+  name: "shopify",
+  priority: 100,
+  // High priority (same as Laravel)
+  async detect(rootDir, relativePath) {
+    const fullPath = path3.join(rootDir, relativePath);
+    const result = {
+      detected: false,
+      name: "shopify",
+      path: relativePath,
+      confidence: "low",
+      evidence: []
+    };
+    const settingsSchemaPath = path3.join(fullPath, "config", "settings_schema.json");
+    let hasSettingsSchema = false;
+    try {
+      await fs3.access(settingsSchemaPath);
+      hasSettingsSchema = true;
+      result.evidence.push("Found config/settings_schema.json");
+    } catch {
+    }
+    const themeLayoutPath = path3.join(fullPath, "layout", "theme.liquid");
+    let hasThemeLayout = false;
+    try {
+      await fs3.access(themeLayoutPath);
+      hasThemeLayout = true;
+      result.evidence.push("Found layout/theme.liquid");
+    } catch {
+    }
+    const shopifyDirs = ["sections", "snippets", "templates", "locales"];
+    let foundDirs = 0;
+    for (const dir of shopifyDirs) {
+      try {
+        const dirPath = path3.join(fullPath, dir);
+        const stats = await fs3.stat(dirPath);
+        if (stats.isDirectory()) {
+          foundDirs++;
+        }
+      } catch {
+      }
+    }
+    if (foundDirs >= 2) {
+      result.evidence.push(`Shopify directory structure detected (${foundDirs}/${shopifyDirs.length} dirs)`);
+    }
+    try {
+      const tomlPath = path3.join(fullPath, "shopify.theme.toml");
+      await fs3.access(tomlPath);
+      result.evidence.push("Found shopify.theme.toml");
+    } catch {
+    }
+    try {
+      const ignorePath = path3.join(fullPath, ".shopifyignore");
+      await fs3.access(ignorePath);
+      result.evidence.push("Found .shopifyignore");
+    } catch {
+    }
+    if (hasSettingsSchema && foundDirs >= 2) {
+      result.detected = true;
+      result.confidence = "high";
+      return result;
+    }
+    if (hasSettingsSchema || hasThemeLayout && foundDirs >= 1) {
+      result.detected = true;
+      result.confidence = "medium";
+      return result;
+    }
+    if (foundDirs >= 3) {
+      result.detected = true;
+      result.confidence = "medium";
+      return result;
     }
-    result.detected = true;
     return result;
   },
   async generateConfig(rootDir, relativePath) {
-    return generateLaravelConfig(rootDir, relativePath);
+    return generateShopifyConfig(rootDir, relativePath);
   }
 };
 
 // src/frameworks/registry.ts
 var frameworkDetectors = [
   nodejsDetector,
-  laravelDetector
+  laravelDetector,
+  shopifyDetector
 ];
 function getFrameworkDetector(name) {
   return frameworkDetectors.find((d) => d.name === name);
@@ -2306,7 +3587,7 @@ async function detectAllFrameworks(rootDir, options = {}) {
   return results;
 }
 async function detectAtPath(rootDir, relativePath, results, visited) {
-  const fullPath = path3.join(rootDir, relativePath);
+  const fullPath = path4.join(rootDir, relativePath);
   if (visited.has(fullPath)) {
     return;
   }
@@ -2326,25 +3607,56 @@ async function detectAtPath(rootDir, relativePath, results, visited) {
     }
   }
   if (detectedAtPath.length > 1) {
-    detectedAtPath.sort((a, b) => b.priority - a.priority);
-    const winner = detectedAtPath[0];
-    results.push(winner);
-    const skipped = detectedAtPath.slice(1);
-    if (skipped.length > 0) {
-      const skippedNames = skipped.map((d) => d.name).join(", ");
-      console.log(`  \u2192 Skipping ${skippedNames} at ${relativePath} (${winner.name} takes precedence)`);
+    const highConfidence = detectedAtPath.filter((d) => d.confidence === "high");
+    const mediumConfidence = detectedAtPath.filter((d) => d.confidence === "medium");
+    const lowConfidence = detectedAtPath.filter((d) => d.confidence === "low");
+    if (highConfidence.length > 1) {
+      const cleanResults = highConfidence.map(({ priority, ...result }) => result);
+      results.push(...cleanResults);
+      const names = highConfidence.map((d) => d.name).join(" + ");
+      console.log(`  \u2192 Detected hybrid project: ${names}`);
+      if (mediumConfidence.length > 0 || lowConfidence.length > 0) {
+        const skippedNames = [...mediumConfidence, ...lowConfidence].map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping lower confidence detections: ${skippedNames}`);
+      }
+    } else if (highConfidence.length === 1) {
+      const { priority, ...result } = highConfidence[0];
+      results.push(result);
+      if (mediumConfidence.length > 0 || lowConfidence.length > 0) {
+        const skippedNames = [...mediumConfidence, ...lowConfidence].map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping lower confidence detections: ${skippedNames}`);
+      }
+    } else if (mediumConfidence.length > 0) {
+      mediumConfidence.sort((a, b) => b.priority - a.priority);
+      const { priority, ...winner } = mediumConfidence[0];
+      results.push(winner);
+      const skipped = [...mediumConfidence.slice(1), ...lowConfidence];
+      if (skipped.length > 0) {
+        const skippedNames = skipped.map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping ${skippedNames} at ${relativePath} (${winner.name} takes precedence)`);
+      }
+    } else if (lowConfidence.length > 0) {
+      lowConfidence.sort((a, b) => b.priority - a.priority);
+      const { priority, ...winner } = lowConfidence[0];
+      results.push(winner);
+      const skipped = lowConfidence.slice(1);
+      if (skipped.length > 0) {
+        const skippedNames = skipped.map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping ${skippedNames} at ${relativePath} (${winner.name} takes precedence)`);
+      }
     }
   } else if (detectedAtPath.length === 1) {
-    results.push(detectedAtPath[0]);
+    const { priority, ...result } = detectedAtPath[0];
+    results.push(result);
   }
 }
 async function scanSubdirectories(rootDir, relativePath, results, visited, depth, options) {
   if (depth >= options.maxDepth) {
     return;
   }
-  const fullPath = path3.join(rootDir, relativePath);
+  const fullPath = path4.join(rootDir, relativePath);
   try {
-    const entries = await fs3.readdir(fullPath, { withFileTypes: true });
+    const entries = await fs4.readdir(fullPath, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory());
     for (const dir of dirs) {
       if (options.skipDirs.includes(dir.name)) {
@@ -2353,7 +3665,7 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
       if (dir.name.startsWith(".")) {
         continue;
       }
-      const subPath = relativePath === "." ? dir.name : path3.join(relativePath, dir.name);
+      const subPath = relativePath === "." ? dir.name : path4.join(relativePath, dir.name);
       await detectAtPath(rootDir, subPath, results, visited);
       await scanSubdirectories(rootDir, subPath, results, visited, depth + 1, options);
     }
@@ -2364,14 +3676,14 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
 
 // src/cli/init.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path4.dirname(__filename2);
+var __dirname2 = path5.dirname(__filename2);
 async function initCommand(options = {}) {
   const rootDir = options.path || process.cwd();
-  const configPath = path4.join(rootDir, ".lien.config.json");
+  const configPath = path5.join(rootDir, ".lien.config.json");
   try {
     let configExists = false;
     try {
-      await fs4.access(configPath);
+      await fs5.access(configPath);
       configExists = true;
     } catch {
     }
@@ -2507,22 +3819,22 @@ async function createNewConfig(rootDir, options) {
     ]);
     if (installCursorRules) {
       try {
-        const cursorRulesDir = path4.join(rootDir, ".cursor");
-        await fs4.mkdir(cursorRulesDir, { recursive: true });
-        const templatePath = path4.join(__dirname2, "../CURSOR_RULES_TEMPLATE.md");
-        const rulesPath = path4.join(cursorRulesDir, "rules");
+        const cursorRulesDir = path5.join(rootDir, ".cursor");
+        await fs5.mkdir(cursorRulesDir, { recursive: true });
+        const templatePath = path5.join(__dirname2, "../CURSOR_RULES_TEMPLATE.md");
+        const rulesPath = path5.join(cursorRulesDir, "rules");
         let targetPath;
         let isDirectory = false;
         let isFile = false;
         try {
-          const stats = await fs4.stat(rulesPath);
+          const stats = await fs5.stat(rulesPath);
           isDirectory = stats.isDirectory();
           isFile = stats.isFile();
         } catch {
         }
         if (isDirectory) {
-          targetPath = path4.join(rulesPath, "lien.mdc");
-          await fs4.copyFile(templatePath, targetPath);
+          targetPath = path5.join(rulesPath, "lien.mdc");
+          await fs5.copyFile(templatePath, targetPath);
           console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         } else if (isFile) {
           const { convertToDir } = await inquirer.prompt([
@@ -2534,11 +3846,11 @@ async function createNewConfig(rootDir, options) {
             }
           ]);
           if (convertToDir) {
-            const existingRules = await fs4.readFile(rulesPath, "utf-8");
-            await fs4.unlink(rulesPath);
-            await fs4.mkdir(rulesPath);
-            await fs4.writeFile(path4.join(rulesPath, "project.mdc"), existingRules);
-            await fs4.copyFile(templatePath, path4.join(rulesPath, "lien.mdc"));
+            const existingRules = await fs5.readFile(rulesPath, "utf-8");
+            await fs5.unlink(rulesPath);
+            await fs5.mkdir(rulesPath);
+            await fs5.writeFile(path5.join(rulesPath, "project.mdc"), existingRules);
+            await fs5.copyFile(templatePath, path5.join(rulesPath, "lien.mdc"));
             console.log(chalk2.green("\u2713 Converted .cursor/rules to directory"));
             console.log(chalk2.green("  - Your project rules: .cursor/rules/project.mdc"));
             console.log(chalk2.green("  - Lien rules: .cursor/rules/lien.mdc"));
@@ -2546,9 +3858,9 @@ async function createNewConfig(rootDir, options) {
             console.log(chalk2.dim("Skipped Cursor rules installation (preserving existing file)"));
           }
         } else {
-          await fs4.mkdir(rulesPath, { recursive: true });
-          targetPath = path4.join(rulesPath, "lien.mdc");
-          await fs4.copyFile(templatePath, targetPath);
+          await fs5.mkdir(rulesPath, { recursive: true });
+          targetPath = path5.join(rulesPath, "lien.mdc");
+          await fs5.copyFile(templatePath, targetPath);
           console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         }
       } catch (error) {
@@ -2562,8 +3874,8 @@ async function createNewConfig(rootDir, options) {
     ...defaultConfig,
     frameworks
   };
-  const configPath = path4.join(rootDir, ".lien.config.json");
-  await fs4.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const configPath = path5.join(rootDir, ".lien.config.json");
+  await fs5.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log(chalk2.green("\n\u2713 Created .lien.config.json"));
   console.log(chalk2.green(`\u2713 Configured ${frameworks.length} framework(s)`));
   console.log(chalk2.dim("\nNext steps:"));
@@ -2598,8 +3910,8 @@ Customizing ${frameworkName} settings:`));
 async function upgradeConfig(configPath) {
   try {
     const backupPath = `${configPath}.backup`;
-    await fs4.copyFile(configPath, backupPath);
-    const existingContent = await fs4.readFile(configPath, "utf-8");
+    await fs5.copyFile(configPath, backupPath);
+    const existingContent = await fs5.readFile(configPath, "utf-8");
     const existingConfig = JSON.parse(existingContent);
     let upgradedConfig;
     let migrated = false;
@@ -2615,7 +3927,7 @@ async function upgradeConfig(configPath) {
         newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
       }
     }
-    await fs4.writeFile(
+    await fs5.writeFile(
       configPath,
       JSON.stringify(upgradedConfig, null, 2) + "\n",
       "utf-8"
@@ -2633,99 +3945,19 @@ async function upgradeConfig(configPath) {
 
 // src/cli/status.ts
 init_service();
+init_utils();
+init_version();
 import chalk3 from "chalk";
-import fs8 from "fs/promises";
-import path8 from "path";
+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 fs6 from "fs/promises";
-import path6 from "path";
-var execAsync = promisify(exec);
-async function isGitRepo(rootDir) {
-  try {
-    const gitDir = path6.join(rootDir, ".git");
-    await fs6.access(gitDir);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getCurrentBranch(rootDir) {
-  try {
-    const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD", {
-      cwd: rootDir,
-      timeout: 5e3
-      // 5 second timeout
-    });
-    return stdout.trim();
-  } catch (error) {
-    throw new Error(`Failed to get current branch: ${error}`);
-  }
-}
-async function getCurrentCommit(rootDir) {
-  try {
-    const { stdout } = await execAsync("git rev-parse HEAD", {
-      cwd: rootDir,
-      timeout: 5e3
-    });
-    return stdout.trim();
-  } catch (error) {
-    throw new Error(`Failed to get current commit: ${error}`);
-  }
-}
-async function getChangedFiles(rootDir, fromRef, toRef) {
-  try {
-    const { stdout } = await execAsync(
-      `git diff --name-only ${fromRef}...${toRef}`,
-      {
-        cwd: rootDir,
-        timeout: 1e4
-        // 10 second timeout for diffs
-      }
-    );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path6.join(rootDir, file));
-    return files;
-  } catch (error) {
-    throw new Error(`Failed to get changed files: ${error}`);
-  }
-}
-async function getChangedFilesBetweenCommits(rootDir, fromCommit, toCommit) {
-  try {
-    const { stdout } = await execAsync(
-      `git diff --name-only ${fromCommit} ${toCommit}`,
-      {
-        cwd: rootDir,
-        timeout: 1e4
-      }
-    );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path6.join(rootDir, file));
-    return files;
-  } catch (error) {
-    throw new Error(`Failed to get changed files between commits: ${error}`);
-  }
-}
-async function isGitAvailable() {
-  try {
-    await execAsync("git --version", { timeout: 3e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/cli/status.ts
-init_version();
-init_banner();
 init_schema();
 async function statusCommand() {
   const rootDir = process.cwd();
-  const projectName = path8.basename(rootDir);
+  const projectName = path9.basename(rootDir);
   const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
-  const indexPath = path8.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
+  const indexPath = path9.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
   showCompactBanner();
   console.log(chalk3.bold("Status\n"));
   const hasConfig = await configService.exists(rootDir);
@@ -2735,11 +3967,11 @@ async function statusCommand() {
     return;
   }
   try {
-    const stats = await fs8.stat(indexPath);
+    const stats = await fs9.stat(indexPath);
     console.log(chalk3.dim("Index location:"), indexPath);
     console.log(chalk3.dim("Index status:"), chalk3.green("\u2713 Exists"));
     try {
-      const files = await fs8.readdir(indexPath, { recursive: true });
+      const files = await fs9.readdir(indexPath, { recursive: true });
       console.log(chalk3.dim("Index files:"), files.length);
     } catch (e) {
     }
@@ -2768,9 +4000,9 @@ async function statusCommand() {
         const commit = await getCurrentCommit(rootDir);
         console.log(chalk3.dim("  Current branch:"), branch);
         console.log(chalk3.dim("  Current commit:"), commit.substring(0, 8));
-        const gitStateFile = path8.join(indexPath, ".git-state.json");
+        const gitStateFile = path9.join(indexPath, ".git-state.json");
         try {
-          const gitStateContent = await fs8.readFile(gitStateFile, "utf-8");
+          const gitStateContent = await fs9.readFile(gitStateFile, "utf-8");
           const gitState = JSON.parse(gitStateContent);
           if (gitState.branch !== branch || gitState.commit !== commit) {
             console.log(chalk3.yellow("  \u26A0\uFE0F  Git state changed - will reindex on next serve"));
@@ -2805,14 +4037,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"));
@@ -2825,6 +4068,8 @@ async function indexCommand(options) {
 
 // src/cli/serve.ts
 import chalk6 from "chalk";
+import fs16 from "fs/promises";
+import path14 from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -2833,9 +4078,9 @@ 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/tools.ts
 var tools = [
@@ -2918,247 +4163,11 @@ var tools = [
 // src/mcp/server.ts
 init_lancedb();
 init_local();
-
-// src/git/tracker.ts
-import fs11 from "fs/promises";
-import path11 from "path";
-var GitStateTracker = class {
-  stateFile;
-  rootDir;
-  currentState = null;
-  constructor(rootDir, indexPath) {
-    this.rootDir = rootDir;
-    this.stateFile = path11.join(indexPath, ".git-state.json");
-  }
-  /**
-   * Loads the last known git state from disk.
-   * Returns null if no state file exists (first run).
-   */
-  async loadState() {
-    try {
-      const content = await fs11.readFile(this.stateFile, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Saves the current git state to disk.
-   */
-  async saveState(state) {
-    try {
-      const content = JSON.stringify(state, null, 2);
-      await fs11.writeFile(this.stateFile, content, "utf-8");
-    } catch (error) {
-      console.error(`[Lien] Warning: Failed to save git state: ${error}`);
-    }
-  }
-  /**
-   * Gets the current git state from the repository.
-   * 
-   * @returns Current git state
-   * @throws Error if git commands fail
-   */
-  async getCurrentGitState() {
-    const branch = await getCurrentBranch(this.rootDir);
-    const commit = await getCurrentCommit(this.rootDir);
-    return {
-      branch,
-      commit,
-      timestamp: Date.now()
-    };
-  }
-  /**
-   * Initializes the tracker by loading saved state and checking current state.
-   * Should be called once when MCP server starts.
-   * 
-   * @returns Array of changed files if state changed, null if no changes or first run
-   */
-  async initialize() {
-    const isRepo = await isGitRepo(this.rootDir);
-    if (!isRepo) {
-      return null;
-    }
-    try {
-      this.currentState = await this.getCurrentGitState();
-      const previousState = await this.loadState();
-      if (!previousState) {
-        await this.saveState(this.currentState);
-        return null;
-      }
-      const branchChanged = previousState.branch !== this.currentState.branch;
-      const commitChanged = previousState.commit !== this.currentState.commit;
-      if (!branchChanged && !commitChanged) {
-        return null;
-      }
-      let changedFiles = [];
-      if (branchChanged) {
-        try {
-          changedFiles = await getChangedFiles(
-            this.rootDir,
-            previousState.branch,
-            this.currentState.branch
-          );
-        } catch (error) {
-          console.error(`[Lien] Branch diff failed, using commit diff: ${error}`);
-          changedFiles = await getChangedFilesBetweenCommits(
-            this.rootDir,
-            previousState.commit,
-            this.currentState.commit
-          );
-        }
-      } else if (commitChanged) {
-        changedFiles = await getChangedFilesBetweenCommits(
-          this.rootDir,
-          previousState.commit,
-          this.currentState.commit
-        );
-      }
-      await this.saveState(this.currentState);
-      return changedFiles;
-    } catch (error) {
-      console.error(`[Lien] Failed to initialize git tracker: ${error}`);
-      return null;
-    }
-  }
-  /**
-   * Checks for git state changes since last check.
-   * This is called periodically by the MCP server.
-   * 
-   * @returns Array of changed files if state changed, null if no changes
-   */
-  async detectChanges() {
-    const isRepo = await isGitRepo(this.rootDir);
-    if (!isRepo) {
-      return null;
-    }
-    try {
-      const newState = await this.getCurrentGitState();
-      if (!this.currentState) {
-        this.currentState = newState;
-        await this.saveState(newState);
-        return null;
-      }
-      const branchChanged = this.currentState.branch !== newState.branch;
-      const commitChanged = this.currentState.commit !== newState.commit;
-      if (!branchChanged && !commitChanged) {
-        return null;
-      }
-      let changedFiles = [];
-      if (branchChanged) {
-        try {
-          changedFiles = await getChangedFiles(
-            this.rootDir,
-            this.currentState.branch,
-            newState.branch
-          );
-        } catch (error) {
-          console.error(`[Lien] Branch diff failed, using commit diff: ${error}`);
-          changedFiles = await getChangedFilesBetweenCommits(
-            this.rootDir,
-            this.currentState.commit,
-            newState.commit
-          );
-        }
-      } else if (commitChanged) {
-        changedFiles = await getChangedFilesBetweenCommits(
-          this.rootDir,
-          this.currentState.commit,
-          newState.commit
-        );
-      }
-      this.currentState = newState;
-      await this.saveState(newState);
-      return changedFiles;
-    } catch (error) {
-      console.error(`[Lien] Failed to detect git changes: ${error}`);
-      return null;
-    }
-  }
-  /**
-   * Gets the current git state.
-   * Useful for status display.
-   */
-  getState() {
-    return this.currentState;
-  }
-  /**
-   * Manually updates the saved state.
-   * Useful after manual reindexing to sync state.
-   */
-  async updateState() {
-    try {
-      this.currentState = await this.getCurrentGitState();
-      await this.saveState(this.currentState);
-    } catch (error) {
-      console.error(`[Lien] Failed to update git state: ${error}`);
-    }
-  }
-};
-
-// src/indexer/incremental.ts
-init_chunker();
-init_schema();
-import fs12 from "fs/promises";
-async function indexSingleFile(filepath, vectorDB, embeddings, config, options = {}) {
-  const { verbose } = options;
-  try {
-    try {
-      await fs12.access(filepath);
-    } catch {
-      if (verbose) {
-        console.error(`[Lien] File deleted: ${filepath}`);
-      }
-      await vectorDB.deleteByFile(filepath);
-      return;
-    }
-    const content = await fs12.readFile(filepath, "utf-8");
-    const chunkSize = isModernConfig(config) ? config.core.chunkSize : isLegacyConfig(config) ? config.indexing.chunkSize : 75;
-    const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : isLegacyConfig(config) ? config.indexing.chunkOverlap : 10;
-    const chunks = chunkFile(filepath, content, {
-      chunkSize,
-      chunkOverlap
-    });
-    if (chunks.length === 0) {
-      if (verbose) {
-        console.error(`[Lien] Empty file: ${filepath}`);
-      }
-      await vectorDB.deleteByFile(filepath);
-      return;
-    }
-    const texts = chunks.map((c) => c.content);
-    const vectors = await embeddings.embedBatch(texts);
-    await vectorDB.updateFile(
-      filepath,
-      vectors,
-      chunks.map((c) => c.metadata),
-      texts
-    );
-    if (verbose) {
-      console.error(`[Lien] \u2713 Updated ${filepath} (${chunks.length} chunks)`);
-    }
-  } catch (error) {
-    console.error(`[Lien] \u26A0\uFE0F  Failed to index ${filepath}: ${error}`);
-  }
-}
-async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, options = {}) {
-  const { verbose } = options;
-  let successCount = 0;
-  for (const filepath of filepaths) {
-    try {
-      await indexSingleFile(filepath, vectorDB, embeddings, config, options);
-      successCount++;
-    } catch (error) {
-      if (verbose) {
-        console.error(`[Lien] Failed to process ${filepath}`);
-      }
-    }
-  }
-  return successCount;
-}
-
-// src/mcp/server.ts
+init_tracker();
+init_incremental();
 init_service();
+init_manifest();
+init_utils();
 
 // src/watcher/index.ts
 init_schema();
@@ -3291,14 +4300,14 @@ 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;
+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;
@@ -3323,7 +4332,7 @@ async function startMCPServer(options) {
   const server = new Server(
     {
       name: "lien",
-      version: packageJson2.version
+      version: packageJson3.version
     },
     {
       capabilities: {
@@ -3353,14 +4362,6 @@ async function startMCPServer(options) {
   const versionCheckInterval = setInterval(async () => {
     await checkAndReconnect();
   }, VERSION_CHECK_INTERVAL_MS);
-  process.on("SIGINT", () => {
-    clearInterval(versionCheckInterval);
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    clearInterval(versionCheckInterval);
-    process.exit(0);
-  });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
@@ -3587,7 +4588,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);
@@ -3598,6 +4599,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}`);
@@ -3619,6 +4622,7 @@ async function startMCPServer(options) {
   }
   const cleanup = async () => {
     log("Shutting down MCP server...");
+    clearInterval(versionCheckInterval);
     if (gitPollInterval) {
       clearInterval(gitPollInterval);
     }
@@ -3630,21 +4634,55 @@ async function startMCPServer(options) {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   const transport = new StdioServerTransport();
+  transport.onclose = () => {
+    log("Transport closed, parent process likely terminated");
+    cleanup().catch(() => process.exit(0));
+  };
+  transport.onerror = (error) => {
+    log(`Transport error: ${error}`);
+  };
   await server.connect(transport);
   log("MCP server started and listening on stdio");
 }
 
 // src/cli/serve.ts
-init_banner();
 async function serveCommand(options) {
-  const rootDir = process.cwd();
+  const rootDir = options.root ? path14.resolve(options.root) : process.cwd();
   try {
+    if (options.root) {
+      try {
+        const stats = await fs16.stat(rootDir);
+        if (!stats.isDirectory()) {
+          console.error(chalk6.red(`Error: --root path is not a directory: ${rootDir}`));
+          process.exit(1);
+        }
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          console.error(chalk6.red(`Error: --root directory does not exist: ${rootDir}`));
+        } else if (error.code === "EACCES") {
+          console.error(chalk6.red(`Error: --root directory is not accessible: ${rootDir}`));
+        } else {
+          console.error(chalk6.red(`Error: Failed to access --root directory: ${rootDir}`));
+          console.error(chalk6.dim(error.message));
+        }
+        process.exit(1);
+      }
+    }
     showBanner();
     console.error(chalk6.bold("Starting MCP server...\n"));
+    if (options.root) {
+      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);
@@ -3653,42 +4691,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").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();