@liendev/lien 0.12.0 → 0.14.0

package/dist/index.js

@@ -9,11 +9,39 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/version.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function getPackageVersion() {
+  return packageJson.version;
+}
+var __filename, __dirname, require2, packageJson;
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    require2 = createRequire(import.meta.url);
+    try {
+      packageJson = require2(join(__dirname, "../package.json"));
+    } catch {
+      try {
+        packageJson = require2(join(__dirname, "../../package.json"));
+      } catch {
+        console.warn("[Lien] Warning: Could not load package.json, using fallback version");
+        packageJson = { version: "0.0.0-unknown" };
+      }
+    }
+  }
+});
+
 // src/constants.ts
 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";
+    init_version();
     DEFAULT_CHUNK_SIZE = 75;
     DEFAULT_CHUNK_OVERLAP = 10;
     DEFAULT_CONCURRENCY = 4;
@@ -27,8 +55,8 @@ var init_constants = __esm({
     VERSION_CHECK_INTERVAL_MS = 2e3;
     DEFAULT_GIT_POLL_INTERVAL_MS = 1e4;
     DEFAULT_DEBOUNCE_MS = 1e3;
-    CURRENT_CONFIG_VERSION = "0.3.0";
-    INDEX_FORMAT_VERSION = 1;
+    CURRENT_CONFIG_VERSION = getPackageVersion();
+    INDEX_FORMAT_VERSION = 2;
   }
 });
 
@@ -52,6 +80,12 @@ var init_schema = __esm({
         concurrency: DEFAULT_CONCURRENCY,
         embeddingBatchSize: DEFAULT_EMBEDDING_BATCH_SIZE
       },
+      chunking: {
+        useAST: true,
+        // AST-based chunking enabled by default (v0.13.0)
+        astFallback: "line-based"
+        // Fallback to line-based on errors
+      },
       mcp: {
         port: DEFAULT_PORT,
         transport: "stdio",
@@ -72,60 +106,17 @@ var init_schema = __esm({
   }
 });
 
-// src/config/merge.ts
-function deepMergeConfig(defaults, user) {
-  return {
-    version: user.version ?? defaults.version,
-    core: {
-      ...defaults.core,
-      ...user.core
-    },
-    mcp: {
-      ...defaults.mcp,
-      ...user.mcp
-    },
-    gitDetection: {
-      ...defaults.gitDetection,
-      ...user.gitDetection
-    },
-    fileWatching: {
-      ...defaults.fileWatching,
-      ...user.fileWatching
-    },
-    frameworks: user.frameworks ?? defaults.frameworks
-  };
-}
-function detectNewFields(before, after) {
-  const newFields = [];
-  for (const key of Object.keys(after)) {
-    if (!(key in before)) {
-      newFields.push(key);
-      continue;
-    }
-    if (typeof after[key] === "object" && after[key] !== null && !Array.isArray(after[key])) {
-      const beforeSection = before[key] || {};
-      const afterSection = after[key];
-      for (const nestedKey of Object.keys(afterSection)) {
-        if (!(nestedKey in beforeSection)) {
-          newFields.push(`${key}.${nestedKey}`);
-        }
-      }
-    }
-  }
-  return newFields;
-}
-var init_merge = __esm({
-  "src/config/merge.ts"() {
-    "use strict";
-  }
-});
-
 // src/config/migration.ts
+import fs from "fs/promises";
+import path from "path";
 function needsMigration(config) {
   if (!config) {
     return false;
   }
-  if (config.frameworks !== void 0) {
+  if (config.frameworks !== void 0 && !config.chunking) {
+    return true;
+  }
+  if (config.frameworks !== void 0 && config.chunking !== void 0) {
     return false;
   }
   if (config.indexing !== void 0) {
@@ -138,12 +129,16 @@ function needsMigration(config) {
 }
 function migrateConfig(oldConfig) {
   const newConfig = {
-    version: "0.3.0",
+    version: CURRENT_CONFIG_VERSION,
     core: {
-      chunkSize: oldConfig.indexing?.chunkSize ?? defaultConfig.core.chunkSize,
-      chunkOverlap: oldConfig.indexing?.chunkOverlap ?? defaultConfig.core.chunkOverlap,
-      concurrency: oldConfig.indexing?.concurrency ?? defaultConfig.core.concurrency,
-      embeddingBatchSize: oldConfig.indexing?.embeddingBatchSize ?? defaultConfig.core.embeddingBatchSize
+      chunkSize: oldConfig.indexing?.chunkSize ?? oldConfig.core?.chunkSize ?? defaultConfig.core.chunkSize,
+      chunkOverlap: oldConfig.indexing?.chunkOverlap ?? oldConfig.core?.chunkOverlap ?? defaultConfig.core.chunkOverlap,
+      concurrency: oldConfig.indexing?.concurrency ?? oldConfig.core?.concurrency ?? defaultConfig.core.concurrency,
+      embeddingBatchSize: oldConfig.indexing?.embeddingBatchSize ?? oldConfig.core?.embeddingBatchSize ?? defaultConfig.core.embeddingBatchSize
+    },
+    chunking: {
+      useAST: oldConfig.chunking?.useAST ?? defaultConfig.chunking.useAST,
+      astFallback: oldConfig.chunking?.astFallback ?? defaultConfig.chunking.astFallback
     },
     mcp: {
       port: oldConfig.mcp?.port ?? defaultConfig.mcp.port,
@@ -158,9 +153,9 @@ function migrateConfig(oldConfig) {
       enabled: oldConfig.fileWatching?.enabled ?? defaultConfig.fileWatching.enabled,
       debounceMs: oldConfig.fileWatching?.debounceMs ?? defaultConfig.fileWatching.debounceMs
     },
-    frameworks: []
+    frameworks: oldConfig.frameworks ?? []
   };
-  if (oldConfig.indexing) {
+  if (oldConfig.indexing && newConfig.frameworks.length === 0) {
     const genericFramework = {
       name: "generic",
       path: ".",
@@ -180,7 +175,7 @@ function migrateConfig(oldConfig) {
       }
     };
     newConfig.frameworks.push(genericFramework);
-  } else {
+  } else if (newConfig.frameworks.length === 0) {
     const genericFramework = {
       name: "generic",
       path: ".",
@@ -203,10 +198,93 @@ function migrateConfig(oldConfig) {
   }
   return newConfig;
 }
+async function migrateConfigFile(rootDir = process.cwd()) {
+  const configPath = path.join(rootDir, ".lien.config.json");
+  try {
+    const configContent = await fs.readFile(configPath, "utf-8");
+    const oldConfig = JSON.parse(configContent);
+    if (!needsMigration(oldConfig)) {
+      return {
+        migrated: false,
+        config: oldConfig
+      };
+    }
+    const newConfig = migrateConfig(oldConfig);
+    const backupPath = `${configPath}.v0.2.0.backup`;
+    await fs.copyFile(configPath, backupPath);
+    await fs.writeFile(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+    return {
+      migrated: true,
+      backupPath,
+      config: newConfig
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        migrated: false,
+        config: defaultConfig
+      };
+    }
+    throw error;
+  }
+}
 var init_migration = __esm({
   "src/config/migration.ts"() {
     "use strict";
     init_schema();
+    init_constants();
+  }
+});
+
+// src/config/merge.ts
+function deepMergeConfig(defaults, user) {
+  return {
+    version: user.version ?? defaults.version,
+    core: {
+      ...defaults.core,
+      ...user.core
+    },
+    chunking: {
+      ...defaults.chunking,
+      ...user.chunking
+    },
+    mcp: {
+      ...defaults.mcp,
+      ...user.mcp
+    },
+    gitDetection: {
+      ...defaults.gitDetection,
+      ...user.gitDetection
+    },
+    fileWatching: {
+      ...defaults.fileWatching,
+      ...user.fileWatching
+    },
+    frameworks: user.frameworks ?? defaults.frameworks
+  };
+}
+function detectNewFields(before, after) {
+  const newFields = [];
+  for (const key of Object.keys(after)) {
+    if (!(key in before)) {
+      newFields.push(key);
+      continue;
+    }
+    if (typeof after[key] === "object" && after[key] !== null && !Array.isArray(after[key])) {
+      const beforeSection = before[key] || {};
+      const afterSection = after[key];
+      for (const nestedKey of Object.keys(afterSection)) {
+        if (!(nestedKey in beforeSection)) {
+          newFields.push(`${key}.${nestedKey}`);
+        }
+      }
+    }
+  }
+  return newFields;
+}
+var init_merge = __esm({
+  "src/config/merge.ts"() {
+    "use strict";
   }
 });
 
@@ -300,8 +378,8 @@ var init_errors = __esm({
 });
 
 // src/config/service.ts
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 var ConfigService, configService;
 var init_service = __esm({
   "src/config/service.ts"() {
@@ -323,13 +401,13 @@ var init_service = __esm({
       async load(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs6.readFile(configPath, "utf-8");
+          const configContent = await fs8.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 = path6.basename(result.backupPath);
+              const backupFilename = path8.basename(result.backupPath);
               console.log(`\u2705 Migration complete! Backup saved as ${backupFilename}`);
               console.log("\u{1F4DD} Your config now uses the framework-based structure.");
             }
@@ -385,7 +463,7 @@ ${validation.errors.join("\n")}`,
         }
         try {
           const configJson = JSON.stringify(config, null, 2) + "\n";
-          await fs6.writeFile(configPath, configJson, "utf-8");
+          await fs8.writeFile(configPath, configJson, "utf-8");
         } catch (error) {
           throw wrapError(error, "Failed to save configuration", { path: configPath });
         }
@@ -399,7 +477,7 @@ ${validation.errors.join("\n")}`,
       async exists(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          await fs6.access(configPath);
+          await fs8.access(configPath);
           return true;
         } catch {
           return false;
@@ -416,7 +494,7 @@ ${validation.errors.join("\n")}`,
       async migrate(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs6.readFile(configPath, "utf-8");
+          const configContent = await fs8.readFile(configPath, "utf-8");
           const oldConfig = JSON.parse(configContent);
           if (!this.needsMigration(oldConfig)) {
             return {
@@ -434,7 +512,7 @@ ${validation.errors.join("\n")}`,
             );
           }
           const backupPath = `${configPath}.v0.2.0.backup`;
-          await fs6.copyFile(configPath, backupPath);
+          await fs8.copyFile(configPath, backupPath);
           await this.save(rootDir, newConfig);
           return {
             migrated: true,
@@ -532,7 +610,7 @@ ${validation.errors.join("\n")}`,
        * Get the full path to the config file
        */
       getConfigPath(rootDir) {
-        return path6.join(rootDir, _ConfigService.CONFIG_FILENAME);
+        return path8.join(rootDir, _ConfigService.CONFIG_FILENAME);
       }
       /**
        * Validate modern (v0.3.0+) configuration
@@ -696,7 +774,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 (path6.isAbsolute(fw.path)) {
+          } else if (path8.isAbsolute(fw.path)) {
             errors.push(`frameworks[${index}].path must be relative, got: ${fw.path}`);
           }
           if (fw.enabled === void 0) {
@@ -756,12 +834,12 @@ __export(utils_exports, {
 });
 import { exec } from "child_process";
 import { promisify } from "util";
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 async function isGitRepo(rootDir) {
   try {
-    const gitDir = path7.join(rootDir, ".git");
-    await fs7.access(gitDir);
+    const gitDir = path9.join(rootDir, ".git");
+    await fs9.access(gitDir);
     return true;
   } catch {
     return false;
@@ -800,7 +878,7 @@ async function getChangedFiles(rootDir, fromRef, toRef) {
         // 10 second timeout for diffs
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path7.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path9.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files: ${error}`);
@@ -815,7 +893,7 @@ async function getChangedFilesInCommit(rootDir, commitSha) {
         timeout: 1e4
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path7.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path9.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files in commit: ${error}`);
@@ -830,7 +908,7 @@ async function getChangedFilesBetweenCommits(rootDir, fromCommit, toCommit) {
         timeout: 1e4
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path7.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path9.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files between commits: ${error}`);
@@ -853,21 +931,21 @@ var init_utils = __esm({
 });
 
 // src/vectordb/version.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 async function writeVersionFile(indexPath) {
   try {
-    const versionFilePath = path8.join(indexPath, VERSION_FILE);
+    const versionFilePath = path10.join(indexPath, VERSION_FILE);
     const timestamp = Date.now().toString();
-    await fs8.writeFile(versionFilePath, timestamp, "utf-8");
+    await fs10.writeFile(versionFilePath, timestamp, "utf-8");
   } catch (error) {
     console.error(`Warning: Failed to write version file: ${error}`);
   }
 }
 async function readVersionFile(indexPath) {
   try {
-    const versionFilePath = path8.join(indexPath, VERSION_FILE);
-    const content = await fs8.readFile(versionFilePath, "utf-8");
+    const versionFilePath = path10.join(indexPath, VERSION_FILE);
+    const content = await fs10.readFile(versionFilePath, "utf-8");
     const timestamp = parseInt(content.trim(), 10);
     return isNaN(timestamp) ? 0 : timestamp;
   } catch (error) {
@@ -875,7 +953,7 @@ async function readVersionFile(indexPath) {
   }
 }
 var VERSION_FILE;
-var init_version = __esm({
+var init_version2 = __esm({
   "src/vectordb/version.ts"() {
     "use strict";
     VERSION_FILE = ".lien-index-version";
@@ -885,8 +963,8 @@ var init_version = __esm({
 // src/indexer/scanner.ts
 import { glob } from "glob";
 import ignore from "ignore";
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 async function scanCodebaseWithFrameworks(rootDir, config) {
   const allFiles = [];
   for (const framework of config.frameworks) {
@@ -899,16 +977,16 @@ async function scanCodebaseWithFrameworks(rootDir, config) {
   return allFiles;
 }
 async function scanFramework(rootDir, framework) {
-  const frameworkPath = path10.join(rootDir, framework.path);
-  const gitignorePath = path10.join(frameworkPath, ".gitignore");
+  const frameworkPath = path12.join(rootDir, framework.path);
+  const gitignorePath = path12.join(frameworkPath, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs10.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs12.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
-    const rootGitignorePath = path10.join(rootDir, ".gitignore");
+    const rootGitignorePath = path12.join(rootDir, ".gitignore");
     try {
-      const gitignoreContent = await fs10.readFile(rootGitignorePath, "utf-8");
+      const gitignoreContent = await fs12.readFile(rootGitignorePath, "utf-8");
       ig = ignore().add(gitignoreContent);
     } catch (e2) {
     }
@@ -930,15 +1008,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 : path10.join(framework.path, file);
+    return framework.path === "." ? file : path12.join(framework.path, file);
   });
 }
 async function scanCodebase(options) {
   const { rootDir, includePatterns = [], excludePatterns = [] } = options;
-  const gitignorePath = path10.join(rootDir, ".gitignore");
+  const gitignorePath = path12.join(rootDir, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs10.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs12.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
   }
@@ -965,12 +1043,12 @@ async function scanCodebase(options) {
   }
   const uniqueFiles = Array.from(new Set(allFiles));
   return uniqueFiles.filter((file) => {
-    const relativePath = path10.relative(rootDir, file);
+    const relativePath = path12.relative(rootDir, file);
     return !ig.ignores(relativePath);
   });
 }
 function detectLanguage(filepath) {
-  const ext = path10.extname(filepath).toLowerCase();
+  const ext = path12.extname(filepath).toLowerCase();
   const languageMap = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -1305,9 +1383,890 @@ var init_symbol_extractor = __esm({
   }
 });
 
+// src/indexer/ast/parser.ts
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+import JavaScript from "tree-sitter-javascript";
+import PHPParser from "tree-sitter-php";
+import { extname } from "path";
+function getParser(language) {
+  if (!parserCache.has(language)) {
+    const parser = new Parser();
+    const grammar = languageConfig[language];
+    if (!grammar) {
+      throw new Error(`No grammar available for language: ${language}`);
+    }
+    parser.setLanguage(grammar);
+    parserCache.set(language, parser);
+  }
+  return parserCache.get(language);
+}
+function detectLanguage2(filePath) {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  switch (ext) {
+    case "ts":
+    case "tsx":
+      return "typescript";
+    case "js":
+    case "jsx":
+    case "mjs":
+    case "cjs":
+      return "javascript";
+    case "php":
+      return "php";
+    default:
+      return null;
+  }
+}
+function isASTSupported(filePath) {
+  return detectLanguage2(filePath) !== null;
+}
+function parseAST(content, language) {
+  try {
+    const parser = getParser(language);
+    const tree = parser.parse(content);
+    if (tree.rootNode.hasError) {
+      return {
+        tree,
+        error: "Parse completed with errors"
+      };
+    }
+    return { tree };
+  } catch (error) {
+    return {
+      tree: null,
+      error: error instanceof Error ? error.message : "Unknown parse error"
+    };
+  }
+}
+var parserCache, languageConfig;
+var init_parser = __esm({
+  "src/indexer/ast/parser.ts"() {
+    "use strict";
+    parserCache = /* @__PURE__ */ new Map();
+    languageConfig = {
+      typescript: TypeScript.typescript,
+      javascript: JavaScript,
+      php: PHPParser.php
+      // Note: tree-sitter-php exports both 'php' (mixed HTML/PHP) and 'php_only'
+    };
+  }
+});
+
+// src/indexer/ast/symbols.ts
+function extractFunctionInfo(node, content, parentClass) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: nameNode.text,
+    type: parentClass ? "method" : "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    parentClass,
+    signature: extractSignature(node, content),
+    parameters: extractParameters(node, content),
+    returnType: extractReturnType(node, content),
+    complexity: calculateComplexity(node)
+  };
+}
+function extractArrowFunctionInfo(node, content, parentClass) {
+  const parent = node.parent;
+  let name = "anonymous";
+  if (parent?.type === "variable_declarator") {
+    const nameNode = parent.childForFieldName("name");
+    name = nameNode?.text || "anonymous";
+  }
+  return {
+    name,
+    type: parentClass ? "method" : "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    parentClass,
+    signature: extractSignature(node, content),
+    parameters: extractParameters(node, content),
+    complexity: calculateComplexity(node)
+  };
+}
+function extractMethodInfo(node, content, parentClass) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: nameNode.text,
+    type: "method",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    parentClass,
+    signature: extractSignature(node, content),
+    parameters: extractParameters(node, content),
+    returnType: extractReturnType(node, content),
+    complexity: calculateComplexity(node)
+  };
+}
+function extractClassInfo(node, _content, _parentClass) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: nameNode.text,
+    type: "class",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature: `class ${nameNode.text}`
+  };
+}
+function extractInterfaceInfo(node, _content, _parentClass) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: nameNode.text,
+    type: "interface",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature: `interface ${nameNode.text}`
+  };
+}
+function extractSymbolInfo(node, content, parentClass) {
+  const extractor = symbolExtractors[node.type];
+  return extractor ? extractor(node, content, parentClass) : null;
+}
+function extractSignature(node, content) {
+  const startLine = node.startPosition.row;
+  const lines = content.split("\n");
+  let signature = lines[startLine] || "";
+  let currentLine = startLine;
+  while (currentLine < node.endPosition.row && !signature.includes("{") && !signature.includes("=>")) {
+    currentLine++;
+    signature += " " + (lines[currentLine] || "");
+  }
+  signature = signature.split("{")[0].split("=>")[0].trim();
+  if (signature.length > 200) {
+    signature = signature.substring(0, 197) + "...";
+  }
+  return signature;
+}
+function extractParameters(node, _content) {
+  const parameters = [];
+  const paramsNode = node.childForFieldName("parameters");
+  if (!paramsNode) return parameters;
+  for (let i = 0; i < paramsNode.namedChildCount; i++) {
+    const param = paramsNode.namedChild(i);
+    if (param) {
+      parameters.push(param.text);
+    }
+  }
+  return parameters;
+}
+function extractReturnType(node, _content) {
+  const returnTypeNode = node.childForFieldName("return_type");
+  if (!returnTypeNode) return void 0;
+  return returnTypeNode.text;
+}
+function calculateComplexity(node) {
+  let complexity = 1;
+  const decisionPoints = [
+    // TypeScript/JavaScript
+    "if_statement",
+    "while_statement",
+    "do_statement",
+    // do...while loops
+    "for_statement",
+    "for_in_statement",
+    "for_of_statement",
+    // for...of loops
+    "switch_case",
+    "catch_clause",
+    "ternary_expression",
+    "binary_expression",
+    // For && and ||
+    // PHP
+    "foreach_statement"
+    // PHP foreach loops
+  ];
+  function traverse(n) {
+    if (decisionPoints.includes(n.type)) {
+      if (n.type === "binary_expression") {
+        const operator = n.childForFieldName("operator");
+        if (operator && (operator.text === "&&" || operator.text === "||")) {
+          complexity++;
+        }
+      } else {
+        complexity++;
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const child = n.namedChild(i);
+      if (child) traverse(child);
+    }
+  }
+  traverse(node);
+  return complexity;
+}
+function extractImports(rootNode) {
+  const imports = [];
+  function traverse(node) {
+    if (node.type === "import_statement") {
+      const sourceNode = node.childForFieldName("source");
+      if (sourceNode) {
+        const importPath = sourceNode.text.replace(/['"]/g, "");
+        imports.push(importPath);
+      }
+    }
+    if (node === rootNode) {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) traverse(child);
+      }
+    }
+  }
+  traverse(rootNode);
+  return imports;
+}
+var symbolExtractors;
+var init_symbols = __esm({
+  "src/indexer/ast/symbols.ts"() {
+    "use strict";
+    symbolExtractors = {
+      // TypeScript/JavaScript
+      "function_declaration": extractFunctionInfo,
+      "function": extractFunctionInfo,
+      "arrow_function": extractArrowFunctionInfo,
+      "function_expression": extractArrowFunctionInfo,
+      "method_definition": extractMethodInfo,
+      "class_declaration": extractClassInfo,
+      "interface_declaration": extractInterfaceInfo,
+      // PHP
+      "function_definition": extractFunctionInfo,
+      // PHP functions
+      "method_declaration": extractMethodInfo
+      // PHP methods
+    };
+  }
+});
+
+// src/indexer/ast/traversers/typescript.ts
+var TypeScriptTraverser, JavaScriptTraverser;
+var init_typescript = __esm({
+  "src/indexer/ast/traversers/typescript.ts"() {
+    "use strict";
+    TypeScriptTraverser = class {
+      targetNodeTypes = [
+        "function_declaration",
+        "function",
+        "interface_declaration",
+        "method_definition",
+        "lexical_declaration",
+        // For const/let with arrow functions
+        "variable_declaration"
+        // For var with functions
+      ];
+      containerTypes = [
+        "class_declaration"
+        // We extract methods, not the class itself
+      ];
+      declarationTypes = [
+        "lexical_declaration",
+        // const/let
+        "variable_declaration"
+        // var
+      ];
+      functionTypes = [
+        "arrow_function",
+        "function_expression",
+        "function"
+      ];
+      shouldExtractChildren(node) {
+        return this.containerTypes.includes(node.type);
+      }
+      isDeclarationWithFunction(node) {
+        return this.declarationTypes.includes(node.type);
+      }
+      getContainerBody(node) {
+        if (node.type === "class_declaration") {
+          return node.childForFieldName("body");
+        }
+        return null;
+      }
+      shouldTraverseChildren(node) {
+        return node.type === "program" || node.type === "export_statement" || node.type === "class_body";
+      }
+      findParentContainerName(node) {
+        let current = node.parent;
+        while (current) {
+          if (current.type === "class_declaration") {
+            const nameNode = current.childForFieldName("name");
+            return nameNode?.text;
+          }
+          current = current.parent;
+        }
+        return void 0;
+      }
+      /**
+       * Check if a declaration node contains a function (arrow, function expression, etc.)
+       */
+      findFunctionInDeclaration(node) {
+        const search2 = (n, depth) => {
+          if (depth > 3) return null;
+          if (this.functionTypes.includes(n.type)) {
+            return n;
+          }
+          for (let i = 0; i < n.childCount; i++) {
+            const child = n.child(i);
+            if (child) {
+              const result = search2(child, depth + 1);
+              if (result) return result;
+            }
+          }
+          return null;
+        };
+        const functionNode = search2(node, 0);
+        return {
+          hasFunction: functionNode !== null,
+          functionNode
+        };
+      }
+    };
+    JavaScriptTraverser = class extends TypeScriptTraverser {
+    };
+  }
+});
+
+// src/indexer/ast/traversers/php.ts
+var PHPTraverser;
+var init_php = __esm({
+  "src/indexer/ast/traversers/php.ts"() {
+    "use strict";
+    PHPTraverser = class {
+      targetNodeTypes = [
+        "function_definition",
+        // function foo() {}
+        "method_declaration"
+        // public function bar() {}
+      ];
+      containerTypes = [
+        "class_declaration",
+        // We extract methods, not the class itself
+        "trait_declaration",
+        // PHP traits
+        "interface_declaration"
+        // PHP interfaces (for interface methods)
+      ];
+      declarationTypes = [
+        // PHP doesn't have arrow functions or const/let like JS
+        // Functions are always defined with 'function' keyword
+      ];
+      functionTypes = [
+        "function_definition",
+        "method_declaration"
+      ];
+      shouldExtractChildren(node) {
+        return this.containerTypes.includes(node.type);
+      }
+      isDeclarationWithFunction(_node) {
+        return false;
+      }
+      getContainerBody(node) {
+        if (node.type === "class_declaration" || node.type === "trait_declaration" || node.type === "interface_declaration") {
+          return node.childForFieldName("body");
+        }
+        return null;
+      }
+      shouldTraverseChildren(node) {
+        return node.type === "program" || // Top-level PHP file
+        node.type === "php" || // PHP block
+        node.type === "declaration_list";
+      }
+      findParentContainerName(node) {
+        let current = node.parent;
+        while (current) {
+          if (current.type === "class_declaration" || current.type === "trait_declaration") {
+            const nameNode = current.childForFieldName("name");
+            return nameNode?.text;
+          }
+          current = current.parent;
+        }
+        return void 0;
+      }
+      findFunctionInDeclaration(_node) {
+        return {
+          hasFunction: false,
+          functionNode: null
+        };
+      }
+    };
+  }
+});
+
+// src/indexer/ast/traversers/index.ts
+function getTraverser(language) {
+  const traverser = traverserRegistry[language];
+  if (!traverser) {
+    throw new Error(`No traverser available for language: ${language}`);
+  }
+  return traverser;
+}
+var traverserRegistry;
+var init_traversers = __esm({
+  "src/indexer/ast/traversers/index.ts"() {
+    "use strict";
+    init_typescript();
+    init_php();
+    traverserRegistry = {
+      typescript: new TypeScriptTraverser(),
+      javascript: new JavaScriptTraverser(),
+      php: new PHPTraverser()
+    };
+  }
+});
+
+// src/indexer/ast/chunker.ts
+function chunkByAST(filepath, content, options = {}) {
+  const { minChunkSize = 5 } = options;
+  const language = detectLanguage2(filepath);
+  if (!language) {
+    throw new Error(`Unsupported language for file: ${filepath}`);
+  }
+  const parseResult = parseAST(content, language);
+  if (!parseResult.tree) {
+    throw new Error(`Failed to parse ${filepath}: ${parseResult.error}`);
+  }
+  const chunks = [];
+  const lines = content.split("\n");
+  const rootNode = parseResult.tree.rootNode;
+  const traverser = getTraverser(language);
+  const fileImports = extractImports(rootNode);
+  const topLevelNodes = findTopLevelNodes(rootNode, traverser);
+  for (const node of topLevelNodes) {
+    let actualNode = node;
+    if (traverser.isDeclarationWithFunction(node)) {
+      const declInfo = traverser.findFunctionInDeclaration(node);
+      if (declInfo.functionNode) {
+        actualNode = declInfo.functionNode;
+      }
+    }
+    const parentClassName = traverser.findParentContainerName(actualNode);
+    const symbolInfo = extractSymbolInfo(actualNode, content, parentClassName);
+    const nodeContent = getNodeContent(node, lines);
+    chunks.push(createChunk(filepath, node, nodeContent, symbolInfo, fileImports, language));
+  }
+  const coveredRanges = topLevelNodes.map((n) => ({
+    start: n.startPosition.row,
+    end: n.endPosition.row
+  }));
+  const uncoveredChunks = extractUncoveredCode(
+    lines,
+    coveredRanges,
+    filepath,
+    minChunkSize,
+    fileImports,
+    language
+  );
+  chunks.push(...uncoveredChunks);
+  chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+  return chunks;
+}
+function findTopLevelNodes(rootNode, traverser) {
+  const nodes = [];
+  function traverse(node, depth) {
+    if (traverser.isDeclarationWithFunction(node) && depth === 0) {
+      const declInfo = traverser.findFunctionInDeclaration(node);
+      if (declInfo.hasFunction) {
+        nodes.push(node);
+        return;
+      }
+    }
+    if (depth <= 1 && traverser.targetNodeTypes.includes(node.type)) {
+      nodes.push(node);
+      return;
+    }
+    if (traverser.shouldExtractChildren(node)) {
+      const body = traverser.getContainerBody(node);
+      if (body) {
+        traverse(body, depth + 1);
+      }
+      return;
+    }
+    if (traverser.shouldTraverseChildren(node)) {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) traverse(child, depth);
+      }
+    }
+  }
+  traverse(rootNode, 0);
+  return nodes;
+}
+function getNodeContent(node, lines) {
+  const startLine = node.startPosition.row;
+  const endLine = node.endPosition.row;
+  return lines.slice(startLine, endLine + 1).join("\n");
+}
+function createChunk(filepath, node, content, symbolInfo, imports, language) {
+  const symbols = {
+    functions: [],
+    classes: [],
+    interfaces: []
+  };
+  if (symbolInfo?.name) {
+    if (symbolInfo.type === "function" || symbolInfo.type === "method") {
+      symbols.functions.push(symbolInfo.name);
+    } else if (symbolInfo.type === "class") {
+      symbols.classes.push(symbolInfo.name);
+    } else if (symbolInfo.type === "interface") {
+      symbols.interfaces.push(symbolInfo.name);
+    }
+  }
+  return {
+    content,
+    metadata: {
+      file: filepath,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      type: symbolInfo == null ? "block" : symbolInfo.type === "class" ? "class" : "function",
+      language,
+      // Legacy symbols field for backward compatibility
+      symbols,
+      // New AST-derived metadata
+      symbolName: symbolInfo?.name,
+      symbolType: symbolInfo?.type,
+      parentClass: symbolInfo?.parentClass,
+      complexity: symbolInfo?.complexity,
+      parameters: symbolInfo?.parameters,
+      signature: symbolInfo?.signature,
+      imports
+    }
+  };
+}
+function findUncoveredRanges(coveredRanges, totalLines) {
+  const uncoveredRanges = [];
+  let currentStart = 0;
+  const sortedRanges = [...coveredRanges].sort((a, b) => a.start - b.start);
+  for (const range of sortedRanges) {
+    if (currentStart < range.start) {
+      uncoveredRanges.push({
+        start: currentStart,
+        end: range.start - 1
+      });
+    }
+    currentStart = range.end + 1;
+  }
+  if (currentStart < totalLines) {
+    uncoveredRanges.push({
+      start: currentStart,
+      end: totalLines - 1
+    });
+  }
+  return uncoveredRanges;
+}
+function createChunkFromRange(range, lines, filepath, language, imports) {
+  const uncoveredLines = lines.slice(range.start, range.end + 1);
+  const content = uncoveredLines.join("\n").trim();
+  return {
+    content,
+    metadata: {
+      file: filepath,
+      startLine: range.start + 1,
+      endLine: range.end + 1,
+      type: "block",
+      language,
+      // Empty symbols for uncovered code (imports, exports, etc.)
+      symbols: { functions: [], classes: [], interfaces: [] },
+      imports
+    }
+  };
+}
+function isValidChunk(chunk, minChunkSize) {
+  const lineCount = chunk.metadata.endLine - chunk.metadata.startLine + 1;
+  return chunk.content.length > 0 && lineCount >= minChunkSize;
+}
+function extractUncoveredCode(lines, coveredRanges, filepath, minChunkSize, imports, language) {
+  const uncoveredRanges = findUncoveredRanges(coveredRanges, lines.length);
+  return uncoveredRanges.map((range) => createChunkFromRange(range, lines, filepath, language, imports)).filter((chunk) => isValidChunk(chunk, minChunkSize));
+}
+function shouldUseAST(filepath) {
+  return isASTSupported(filepath);
+}
+var init_chunker = __esm({
+  "src/indexer/ast/chunker.ts"() {
+    "use strict";
+    init_parser();
+    init_symbols();
+    init_traversers();
+  }
+});
+
+// src/indexer/liquid-chunker.ts
+function extractSchemaName(schemaContent) {
+  try {
+    let jsonContent = schemaContent.replace(/\{%-?\s*schema\s*-?%\}/g, "").replace(/\{%-?\s*endschema\s*-?%\}/g, "").trim();
+    const schema = JSON.parse(jsonContent);
+    return typeof schema.name === "string" ? schema.name : void 0;
+  } catch (error) {
+  }
+  return void 0;
+}
+function removeComments(content) {
+  return content.replace(/\{%-?\s*comment\s*-?%\}[\s\S]*?\{%-?\s*endcomment\s*-?%\}/g, "");
+}
+function extractRenderTags(contentWithoutComments) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const renderPattern = /\{%-?\s*render\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = renderPattern.exec(contentWithoutComments)) !== null) {
+    dependencies.add(match[1]);
+  }
+  const includePattern = /\{%-?\s*include\s+['"]([^'"]+)['"]/g;
+  while ((match = includePattern.exec(contentWithoutComments)) !== null) {
+    dependencies.add(match[1]);
+  }
+  const sectionPattern = /\{%-?\s*section\s+['"]([^'"]+)['"]/g;
+  while ((match = sectionPattern.exec(contentWithoutComments)) !== null) {
+    dependencies.add(match[1]);
+  }
+  return Array.from(dependencies);
+}
+function findLiquidBlocks(content) {
+  const lines = content.split("\n");
+  const blocks = [];
+  const blockPatterns = [
+    { type: "schema", start: /\{%-?\s*schema\s*-?%\}/, end: /\{%-?\s*endschema\s*-?%\}/ },
+    { type: "style", start: /\{%-?\s*style\s*-?%\}/, end: /\{%-?\s*endstyle\s*-?%\}/ },
+    { type: "javascript", start: /\{%-?\s*javascript\s*-?%\}/, end: /\{%-?\s*endjavascript\s*-?%\}/ }
+  ];
+  for (const pattern of blockPatterns) {
+    let searchStart = 0;
+    while (searchStart < lines.length) {
+      const startIdx = lines.findIndex(
+        (line, idx) => idx >= searchStart && pattern.start.test(line)
+      );
+      if (startIdx === -1) break;
+      const endIdx = lines.findIndex(
+        (line, idx) => idx >= startIdx && pattern.end.test(line)
+      );
+      if (endIdx === -1) {
+        break;
+      }
+      const blockContent = lines.slice(startIdx, endIdx + 1).join("\n");
+      blocks.push({
+        type: pattern.type,
+        startLine: startIdx,
+        endLine: endIdx,
+        content: blockContent
+      });
+      searchStart = endIdx + 1;
+    }
+  }
+  return blocks.sort((a, b) => a.startLine - b.startLine);
+}
+function chunkLiquidFile(filepath, content, chunkSize = 75, chunkOverlap = 10) {
+  const lines = content.split("\n");
+  const blocks = findLiquidBlocks(content);
+  const chunks = [];
+  const contentWithoutComments = removeComments(content);
+  const linesWithoutComments = contentWithoutComments.split("\n");
+  const coveredLines = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    for (let i = block.startLine; i <= block.endLine; i++) {
+      coveredLines.add(i);
+    }
+    let symbolName;
+    if (block.type === "schema") {
+      symbolName = extractSchemaName(block.content);
+    }
+    const blockContentWithoutComments = linesWithoutComments.slice(block.startLine, block.endLine + 1).join("\n");
+    const imports = extractRenderTags(blockContentWithoutComments);
+    const blockLineCount = block.endLine - block.startLine + 1;
+    const maxBlockSize = chunkSize * 3;
+    if (blockLineCount <= maxBlockSize) {
+      chunks.push({
+        content: block.content,
+        metadata: {
+          file: filepath,
+          startLine: block.startLine + 1,
+          // 1-indexed
+          endLine: block.endLine + 1,
+          language: "liquid",
+          type: "block",
+          symbolName,
+          symbolType: block.type,
+          imports: imports.length > 0 ? imports : void 0
+        }
+      });
+    } else {
+      const blockLines = block.content.split("\n");
+      for (let offset = 0; offset < blockLines.length; offset += chunkSize - chunkOverlap) {
+        const endOffset = Math.min(offset + chunkSize, blockLines.length);
+        const chunkContent = blockLines.slice(offset, endOffset).join("\n");
+        if (chunkContent.trim().length > 0) {
+          chunks.push({
+            content: chunkContent,
+            metadata: {
+              file: filepath,
+              startLine: block.startLine + offset + 1,
+              // 1-indexed
+              endLine: block.startLine + endOffset,
+              // 1-indexed (endOffset already accounts for exclusivity)
+              language: "liquid",
+              type: "block",
+              symbolName,
+              // Preserve symbol name for all split chunks
+              symbolType: block.type,
+              imports: imports.length > 0 ? imports : void 0
+            }
+          });
+        }
+        if (endOffset >= blockLines.length) break;
+      }
+    }
+  }
+  let currentChunk = [];
+  let chunkStartLine = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (coveredLines.has(i)) {
+      if (currentChunk.length > 0) {
+        const chunkContent = currentChunk.join("\n");
+        if (chunkContent.trim().length > 0) {
+          const cleanedChunk = linesWithoutComments.slice(chunkStartLine, i).join("\n");
+          const imports = extractRenderTags(cleanedChunk);
+          chunks.push({
+            content: chunkContent,
+            metadata: {
+              file: filepath,
+              startLine: chunkStartLine + 1,
+              endLine: i,
+              language: "liquid",
+              type: "template",
+              imports: imports.length > 0 ? imports : void 0
+            }
+          });
+        }
+        currentChunk = [];
+      }
+      continue;
+    }
+    if (currentChunk.length === 0) {
+      chunkStartLine = i;
+    }
+    currentChunk.push(lines[i]);
+    if (currentChunk.length >= chunkSize) {
+      const chunkContent = currentChunk.join("\n");
+      if (chunkContent.trim().length > 0) {
+        const cleanedChunk = linesWithoutComments.slice(chunkStartLine, i + 1).join("\n");
+        const imports = extractRenderTags(cleanedChunk);
+        chunks.push({
+          content: chunkContent,
+          metadata: {
+            file: filepath,
+            startLine: chunkStartLine + 1,
+            endLine: i + 1,
+            language: "liquid",
+            type: "template",
+            imports: imports.length > 0 ? imports : void 0
+          }
+        });
+      }
+      currentChunk = currentChunk.slice(-chunkOverlap);
+      chunkStartLine = Math.max(0, i + 1 - chunkOverlap);
+    }
+  }
+  if (currentChunk.length > 0) {
+    const chunkContent = currentChunk.join("\n");
+    if (chunkContent.trim().length === 0) {
+      return chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+    }
+    const cleanedChunk = linesWithoutComments.slice(chunkStartLine, lines.length).join("\n");
+    const imports = extractRenderTags(cleanedChunk);
+    chunks.push({
+      content: chunkContent,
+      metadata: {
+        file: filepath,
+        startLine: chunkStartLine + 1,
+        endLine: lines.length,
+        language: "liquid",
+        type: "template",
+        imports: imports.length > 0 ? imports : void 0
+      }
+    });
+  }
+  return chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+}
+var init_liquid_chunker = __esm({
+  "src/indexer/liquid-chunker.ts"() {
+    "use strict";
+  }
+});
+
+// src/indexer/json-template-chunker.ts
+function extractSectionReferences(jsonContent) {
+  try {
+    const template = JSON.parse(jsonContent);
+    const sectionTypes = /* @__PURE__ */ new Set();
+    if (template.sections && typeof template.sections === "object") {
+      for (const section of Object.values(template.sections)) {
+        if (typeof section === "object" && section !== null && "type" in section && typeof section.type === "string") {
+          sectionTypes.add(section.type);
+        }
+      }
+    }
+    return Array.from(sectionTypes);
+  } catch (error) {
+    console.warn(`[Lien] Failed to parse JSON template: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+function extractTemplateName(filepath) {
+  const match = filepath.match(/templates\/(.+)\.json$/);
+  return match ? match[1] : void 0;
+}
+function chunkJSONTemplate(filepath, content) {
+  if (content.trim().length === 0) {
+    return [];
+  }
+  const lines = content.split("\n");
+  const templateName = extractTemplateName(filepath);
+  const sectionReferences = extractSectionReferences(content);
+  return [{
+    content,
+    metadata: {
+      file: filepath,
+      startLine: 1,
+      endLine: lines.length,
+      language: "json",
+      type: "template",
+      symbolName: templateName,
+      symbolType: "template",
+      imports: sectionReferences.length > 0 ? sectionReferences : void 0
+    }
+  }];
+}
+var init_json_template_chunker = __esm({
+  "src/indexer/json-template-chunker.ts"() {
+    "use strict";
+  }
+});
+
 // src/indexer/chunker.ts
 function chunkFile(filepath, content, options = {}) {
-  const { chunkSize = 75, chunkOverlap = 10 } = options;
+  const { chunkSize = 75, chunkOverlap = 10, useAST = true, astFallback = "line-based" } = options;
+  if (filepath.endsWith(".liquid")) {
+    return chunkLiquidFile(filepath, content, chunkSize, chunkOverlap);
+  }
+  if (filepath.endsWith(".json") && /(?:^|\/)templates\//.test(filepath)) {
+    return chunkJSONTemplate(filepath, content);
+  }
+  if (useAST && shouldUseAST(filepath)) {
+    try {
+      return chunkByAST(filepath, content, {
+        minChunkSize: Math.floor(chunkSize / 10)
+      });
+    } catch (error) {
+      if (astFallback === "error") {
+        throw new Error(`AST chunking failed for ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      console.warn(`AST chunking failed for ${filepath}, falling back to line-based:`, error);
+    }
+  }
+  return chunkByLines(filepath, content, chunkSize, chunkOverlap);
+}
+function chunkByLines(filepath, content, chunkSize, chunkOverlap) {
   const lines = content.split("\n");
   const chunks = [];
   const language = detectLanguage(filepath);
@@ -1340,11 +2299,14 @@ function chunkFile(filepath, content, options = {}) {
   }
   return chunks;
 }
-var init_chunker = __esm({
+var init_chunker2 = __esm({
   "src/indexer/chunker.ts"() {
     "use strict";
     init_scanner();
     init_symbol_extractor();
+    init_chunker();
+    init_liquid_chunker();
+    init_json_template_chunker();
   }
 });
 
@@ -1455,18 +2417,11 @@ var init_intent_classifier = __esm({
   }
 });
 
-// src/vectordb/lancedb.ts
-var lancedb_exports = {};
-__export(lancedb_exports, {
-  VectorDB: () => VectorDB
-});
-import * as lancedb from "vectordb";
-import path11 from "path";
-import os2 from "os";
-import crypto2 from "crypto";
+// src/vectordb/query.ts
+import path13 from "path";
 function isDocumentationFile(filepath) {
   const lower = filepath.toLowerCase();
-  const filename = path11.basename(filepath).toLowerCase();
+  const filename = path13.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")) {
@@ -1513,7 +2468,7 @@ function boostPathRelevance(query, filepath, baseScore) {
   return baseScore * boostFactor;
 }
 function boostFilenameRelevance(query, filepath, baseScore) {
-  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
+  const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   let boostFactor = 1;
   for (const token of queryTokens) {
@@ -1528,7 +2483,7 @@ function boostFilenameRelevance(query, filepath, baseScore) {
 }
 function boostForLocationIntent(query, filepath, baseScore) {
   let score = baseScore;
-  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
+  const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
@@ -1556,7 +2511,7 @@ function boostForConceptualIntent(query, filepath, baseScore) {
   if (isUtilityFile(filepath)) {
     score *= 1.05;
   }
-  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
+  const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
@@ -1564,7 +2519,7 @@ function boostForConceptualIntent(query, filepath, baseScore) {
       score *= 0.9;
     }
   }
-  const pathSegments = filepath.toLowerCase().split(path11.sep);
+  const pathSegments = filepath.toLowerCase().split(path13.sep);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
     for (const segment of pathSegments) {
@@ -1601,16 +2556,373 @@ function applyRelevanceBoosting(query, filepath, baseScore) {
       return boostForImplementationIntent(query, filepath, baseScore);
   }
 }
+function dbRecordToSearchResult(r, query) {
+  const baseScore = r._distance ?? 0;
+  const boostedScore = applyRelevanceBoosting(query, r.file, baseScore);
+  return {
+    content: r.content,
+    metadata: {
+      file: r.file,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      type: r.type,
+      language: r.language,
+      // AST-derived metadata (v0.13.0)
+      symbolName: r.symbolName || void 0,
+      symbolType: r.symbolType,
+      parentClass: r.parentClass || void 0,
+      complexity: r.complexity || void 0,
+      parameters: r.parameters && r.parameters.length > 0 && r.parameters[0] !== "" ? r.parameters : void 0,
+      signature: r.signature || void 0,
+      imports: r.imports && r.imports.length > 0 && r.imports[0] !== "" ? r.imports : void 0
+    },
+    score: boostedScore,
+    relevance: calculateRelevance(boostedScore)
+  };
+}
+async function search(table, queryVector, limit = 5, query) {
+  if (!table) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  try {
+    const results = await table.search(Array.from(queryVector)).limit(limit + 20).execute();
+    const filtered = results.filter(
+      (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
+    ).map((r) => dbRecordToSearchResult(r, query)).sort((a, b) => a.score - b.score).slice(0, limit);
+    return filtered;
+  } catch (error) {
+    const errorMsg = String(error);
+    if (errorMsg.includes("Not found:") || errorMsg.includes(".lance")) {
+      throw new DatabaseError(
+        `Index appears corrupted or outdated. Please restart the MCP server or run 'lien reindex' in the project directory.`,
+        { originalError: error }
+      );
+    }
+    throw wrapError(error, "Failed to search vector database");
+  }
+}
+async function scanWithFilter(table, options) {
+  if (!table) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  const { language, pattern, limit = 100 } = options;
+  try {
+    const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
+    const query = table.search(zeroVector).where('file != ""').limit(Math.max(limit * 5, 200));
+    const results = await query.execute();
+    let filtered = results.filter(
+      (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
+    );
+    if (language) {
+      filtered = filtered.filter(
+        (r) => r.language && r.language.toLowerCase() === language.toLowerCase()
+      );
+    }
+    if (pattern) {
+      const regex = new RegExp(pattern, "i");
+      filtered = filtered.filter(
+        (r) => regex.test(r.content) || regex.test(r.file)
+      );
+    }
+    return filtered.slice(0, limit).map((r) => {
+      const score = 0;
+      return {
+        content: r.content,
+        metadata: {
+          file: r.file,
+          startLine: r.startLine,
+          endLine: r.endLine,
+          type: r.type,
+          language: r.language,
+          // AST-derived metadata (v0.13.0)
+          symbolName: r.symbolName || void 0,
+          symbolType: r.symbolType,
+          parentClass: r.parentClass || void 0,
+          complexity: r.complexity || void 0,
+          parameters: r.parameters && r.parameters.length > 0 && r.parameters[0] !== "" ? r.parameters : void 0,
+          signature: r.signature || void 0,
+          imports: r.imports && r.imports.length > 0 && r.imports[0] !== "" ? r.imports : void 0
+        },
+        score,
+        relevance: calculateRelevance(score)
+      };
+    });
+  } catch (error) {
+    throw wrapError(error, "Failed to scan with filter");
+  }
+}
+function matchesSymbolType(record, symbolType, symbols) {
+  if (record.symbolType) {
+    if (symbolType === "function") {
+      return record.symbolType === "function" || record.symbolType === "method";
+    } else if (symbolType === "class") {
+      return record.symbolType === "class";
+    } else if (symbolType === "interface") {
+      return record.symbolType === "interface";
+    }
+    return false;
+  }
+  return symbols.length > 0 && symbols.some((s) => s.length > 0 && s !== "");
+}
+async function querySymbols(table, options) {
+  if (!table) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  const { language, pattern, symbolType, limit = 50 } = options;
+  try {
+    const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
+    const query = table.search(zeroVector).where('file != ""').limit(Math.max(limit * 10, 500));
+    const results = await query.execute();
+    let filtered = results.filter((r) => {
+      if (!r.content || r.content.trim().length === 0) {
+        return false;
+      }
+      if (!r.file || r.file.length === 0) {
+        return false;
+      }
+      if (language && (!r.language || r.language.toLowerCase() !== language.toLowerCase())) {
+        return false;
+      }
+      const symbols = symbolType === "function" ? r.functionNames || [] : symbolType === "class" ? r.classNames || [] : symbolType === "interface" ? r.interfaceNames || [] : [...r.functionNames || [], ...r.classNames || [], ...r.interfaceNames || []];
+      const astSymbolName = r.symbolName || "";
+      if (symbols.length === 0 && !astSymbolName) {
+        return false;
+      }
+      if (pattern) {
+        const regex = new RegExp(pattern, "i");
+        const matchesOldSymbols = symbols.some((s) => regex.test(s));
+        const matchesASTSymbol = regex.test(astSymbolName);
+        const nameMatches = matchesOldSymbols || matchesASTSymbol;
+        if (!nameMatches) return false;
+        if (symbolType) {
+          return matchesSymbolType(r, symbolType, symbols);
+        }
+        return nameMatches;
+      }
+      if (symbolType) {
+        return matchesSymbolType(r, symbolType, symbols);
+      }
+      return true;
+    });
+    return filtered.slice(0, limit).map((r) => {
+      const score = 0;
+      return {
+        content: r.content,
+        metadata: {
+          file: r.file,
+          startLine: r.startLine,
+          endLine: r.endLine,
+          type: r.type,
+          language: r.language,
+          symbols: {
+            functions: r.functionNames && r.functionNames.length > 0 && r.functionNames[0] !== "" ? r.functionNames : [],
+            classes: r.classNames && r.classNames.length > 0 && r.classNames[0] !== "" ? r.classNames : [],
+            interfaces: r.interfaceNames && r.interfaceNames.length > 0 && r.interfaceNames[0] !== "" ? r.interfaceNames : []
+          },
+          // AST-derived metadata (v0.13.0)
+          symbolName: r.symbolName || void 0,
+          symbolType: r.symbolType,
+          parentClass: r.parentClass || void 0,
+          complexity: r.complexity || void 0,
+          parameters: r.parameters && r.parameters.length > 0 && r.parameters[0] !== "" ? r.parameters : void 0,
+          signature: r.signature || void 0,
+          imports: r.imports && r.imports.length > 0 && r.imports[0] !== "" ? r.imports : void 0
+        },
+        score,
+        relevance: calculateRelevance(score)
+      };
+    });
+  } catch (error) {
+    throw wrapError(error, "Failed to query symbols");
+  }
+}
+var init_query = __esm({
+  "src/vectordb/query.ts"() {
+    "use strict";
+    init_types();
+    init_errors();
+    init_relevance();
+    init_intent_classifier();
+  }
+});
+
+// src/vectordb/batch-insert.ts
+async function insertBatch(db, table, tableName, vectors, metadatas, contents) {
+  if (!db) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  if (vectors.length !== metadatas.length || vectors.length !== contents.length) {
+    throw new DatabaseError("Vectors, metadatas, and contents arrays must have the same length", {
+      vectorsLength: vectors.length,
+      metadatasLength: metadatas.length,
+      contentsLength: contents.length
+    });
+  }
+  if (vectors.length === 0) {
+    return table;
+  }
+  if (vectors.length > VECTOR_DB_MAX_BATCH_SIZE) {
+    let currentTable = table;
+    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));
+      currentTable = await insertBatchInternal(db, currentTable, tableName, batchVectors, batchMetadata, batchContents);
+    }
+    if (!currentTable) {
+      throw new DatabaseError("Failed to create table during batch insert");
+    }
+    return currentTable;
+  } else {
+    return insertBatchInternal(db, table, tableName, vectors, metadatas, contents);
+  }
+}
+async function insertBatchInternal(db, table, tableName, vectors, metadatas, contents) {
+  const queue = [{ vectors, metadatas, contents }];
+  const failedRecords = [];
+  let currentTable = table;
+  while (queue.length > 0) {
+    const batch = queue.shift();
+    if (!batch) break;
+    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 : [""],
+        // AST-derived metadata (v0.13.0)
+        symbolName: batch.metadatas[i].symbolName || "",
+        symbolType: batch.metadatas[i].symbolType || "",
+        parentClass: batch.metadatas[i].parentClass || "",
+        complexity: batch.metadatas[i].complexity || 0,
+        parameters: batch.metadatas[i].parameters && batch.metadatas[i].parameters.length > 0 ? batch.metadatas[i].parameters : [""],
+        signature: batch.metadatas[i].signature || "",
+        imports: batch.metadatas[i].imports && batch.metadatas[i].imports.length > 0 ? batch.metadatas[i].imports : [""]
+      }));
+      if (!currentTable) {
+        currentTable = await db.createTable(tableName, records);
+      } else {
+        await currentTable.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
+      }
+    );
+  }
+  if (!currentTable) {
+    throw new DatabaseError("Failed to create table during batch insert");
+  }
+  return currentTable;
+}
+var init_batch_insert = __esm({
+  "src/vectordb/batch-insert.ts"() {
+    "use strict";
+    init_errors();
+    init_constants();
+  }
+});
+
+// src/vectordb/maintenance.ts
+async function clear(db, table, tableName) {
+  if (!db) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  try {
+    if (table) {
+      await db.dropTable(tableName);
+    }
+  } catch (error) {
+    throw wrapError(error, "Failed to clear vector database");
+  }
+}
+async function deleteByFile(table, filepath) {
+  if (!table) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  try {
+    await table.delete(`file = "${filepath}"`);
+  } catch (error) {
+    throw wrapError(error, "Failed to delete file from vector database");
+  }
+}
+async function updateFile(db, table, tableName, dbPath, filepath, vectors, metadatas, contents) {
+  if (!table) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  try {
+    await deleteByFile(table, filepath);
+    let updatedTable = table;
+    if (vectors.length > 0) {
+      updatedTable = await insertBatch(db, table, tableName, vectors, metadatas, contents);
+      if (!updatedTable) {
+        throw new DatabaseError("insertBatch unexpectedly returned null");
+      }
+    }
+    await writeVersionFile(dbPath);
+    return updatedTable;
+  } catch (error) {
+    throw wrapError(error, "Failed to update file in vector database");
+  }
+}
+var init_maintenance = __esm({
+  "src/vectordb/maintenance.ts"() {
+    "use strict";
+    init_errors();
+    init_version2();
+    init_batch_insert();
+  }
+});
+
+// src/vectordb/lancedb.ts
+var lancedb_exports = {};
+__export(lancedb_exports, {
+  VectorDB: () => VectorDB
+});
+import * as lancedb from "vectordb";
+import path14 from "path";
+import os2 from "os";
+import crypto2 from "crypto";
 var VectorDB;
 var init_lancedb = __esm({
   "src/vectordb/lancedb.ts"() {
     "use strict";
     init_types();
-    init_version();
+    init_version2();
     init_errors();
-    init_relevance();
-    init_intent_classifier();
-    init_constants();
+    init_query();
+    init_batch_insert();
+    init_maintenance();
     VectorDB = class _VectorDB {
       db = null;
       table = null;
@@ -1619,9 +2931,9 @@ var init_lancedb = __esm({
       lastVersionCheck = 0;
       currentVersion = 0;
       constructor(projectRoot) {
-        const projectName = path11.basename(projectRoot);
+        const projectName = path14.basename(projectRoot);
         const pathHash = crypto2.createHash("md5").update(projectRoot).digest("hex").substring(0, 8);
-        this.dbPath = path11.join(
+        this.dbPath = path14.join(
           os2.homedir(),
           ".lien",
           "indices",
@@ -1649,134 +2961,30 @@ var init_lancedb = __esm({
         if (!this.db) {
           throw new DatabaseError("Vector database not initialized");
         }
-        if (vectors.length !== metadatas.length || vectors.length !== contents.length) {
-          throw new DatabaseError("Vectors, metadatas, and contents arrays must have the same length", {
-            vectorsLength: vectors.length,
-            metadatasLength: metadatas.length,
-            contentsLength: contents.length
-          });
-        }
-        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);
-          }
-        } 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
-            }
-          );
-        }
+        this.table = await insertBatch(
+          this.db,
+          this.table,
+          this.tableName,
+          vectors,
+          metadatas,
+          contents
+        );
       }
       async search(queryVector, limit = 5, query) {
         if (!this.table) {
           throw new DatabaseError("Vector database not initialized");
         }
         try {
-          const results = await this.table.search(Array.from(queryVector)).limit(limit + 20).execute();
-          const filtered = results.filter(
-            (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
-          ).map((r) => {
-            const baseScore = r._distance ?? 0;
-            const boostedScore = applyRelevanceBoosting(query, r.file, baseScore);
-            return {
-              content: r.content,
-              metadata: {
-                file: r.file,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                type: r.type,
-                language: r.language
-              },
-              score: boostedScore,
-              relevance: calculateRelevance(boostedScore)
-            };
-          }).sort((a, b) => a.score - b.score).slice(0, limit);
-          return filtered;
+          return await search(this.table, queryVector, limit, query);
         } catch (error) {
           const errorMsg = String(error);
           if (errorMsg.includes("Not found:") || errorMsg.includes(".lance")) {
             try {
               await this.initialize();
-              const results = await this.table.search(Array.from(queryVector)).limit(limit + 20).execute();
-              return results.filter(
-                (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
-              ).map((r) => {
-                const baseScore = r._distance ?? 0;
-                const boostedScore = applyRelevanceBoosting(query, r.file, baseScore);
-                return {
-                  content: r.content,
-                  metadata: {
-                    file: r.file,
-                    startLine: r.startLine,
-                    endLine: r.endLine,
-                    type: r.type,
-                    language: r.language
-                  },
-                  score: boostedScore,
-                  relevance: calculateRelevance(boostedScore)
-                };
-              }).sort((a, b) => a.score - b.score).slice(0, limit);
+              if (!this.table) {
+                throw new DatabaseError("Vector database not initialized after reconnection");
+              }
+              return await search(this.table, queryVector, limit, query);
             } catch (retryError) {
               throw new DatabaseError(
                 `Index appears corrupted or outdated. Please restart the MCP server or run 'lien reindex' in the project directory.`,
@@ -1784,162 +2992,52 @@ var init_lancedb = __esm({
               );
             }
           }
-          throw wrapError(error, "Failed to search vector database");
+          throw error;
         }
       }
       async scanWithFilter(options) {
         if (!this.table) {
           throw new DatabaseError("Vector database not initialized");
         }
-        const { language, pattern, limit = 100 } = options;
-        try {
-          const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
-          const query = this.table.search(zeroVector).where('file != ""').limit(Math.max(limit * 5, 200));
-          const results = await query.execute();
-          let filtered = results.filter(
-            (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
-          );
-          if (language) {
-            filtered = filtered.filter(
-              (r) => r.language && r.language.toLowerCase() === language.toLowerCase()
-            );
-          }
-          if (pattern) {
-            const regex = new RegExp(pattern, "i");
-            filtered = filtered.filter(
-              (r) => regex.test(r.content) || regex.test(r.file)
-            );
-          }
-          return filtered.slice(0, limit).map((r) => {
-            const score = 0;
-            return {
-              content: r.content,
-              metadata: {
-                file: r.file,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                type: r.type,
-                language: r.language
-              },
-              score,
-              relevance: calculateRelevance(score)
-            };
-          });
-        } catch (error) {
-          throw wrapError(error, "Failed to scan with filter");
-        }
+        return scanWithFilter(this.table, options);
       }
       async querySymbols(options) {
         if (!this.table) {
           throw new DatabaseError("Vector database not initialized");
         }
-        const { language, pattern, symbolType, limit = 50 } = options;
-        try {
-          const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
-          const query = this.table.search(zeroVector).where('file != ""').limit(Math.max(limit * 10, 500));
-          const results = await query.execute();
-          let filtered = results.filter((r) => {
-            if (!r.content || r.content.trim().length === 0) {
-              return false;
-            }
-            if (!r.file || r.file.length === 0) {
-              return false;
-            }
-            if (language && (!r.language || r.language.toLowerCase() !== language.toLowerCase())) {
-              return false;
-            }
-            const symbols = symbolType === "function" ? r.functionNames || [] : symbolType === "class" ? r.classNames || [] : symbolType === "interface" ? r.interfaceNames || [] : [...r.functionNames || [], ...r.classNames || [], ...r.interfaceNames || []];
-            if (symbols.length === 0) {
-              return false;
-            }
-            if (pattern) {
-              const regex = new RegExp(pattern, "i");
-              return symbols.some((s) => regex.test(s));
-            }
-            return true;
-          });
-          return filtered.slice(0, limit).map((r) => {
-            const score = 0;
-            return {
-              content: r.content,
-              metadata: {
-                file: r.file,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                type: r.type,
-                language: r.language,
-                symbols: {
-                  functions: r.functionNames || [],
-                  classes: r.classNames || [],
-                  interfaces: r.interfaceNames || []
-                }
-              },
-              score,
-              relevance: calculateRelevance(score)
-            };
-          });
-        } catch (error) {
-          throw wrapError(error, "Failed to query symbols");
-        }
+        return querySymbols(this.table, options);
       }
       async clear() {
         if (!this.db) {
           throw new DatabaseError("Vector database not initialized");
         }
-        try {
-          if (this.table) {
-            await this.db.dropTable(this.tableName);
-          }
-          this.table = null;
-        } catch (error) {
-          throw wrapError(error, "Failed to clear vector database");
-        }
+        await clear(this.db, this.table, this.tableName);
+        this.table = null;
       }
-      /**
-       * Deletes all chunks from a specific file.
-       * Used for incremental reindexing when a file is deleted or needs to be re-indexed.
-       * 
-       * @param filepath - Path to the file whose chunks should be deleted
-       */
       async deleteByFile(filepath) {
         if (!this.table) {
           throw new DatabaseError("Vector database not initialized");
         }
-        try {
-          await this.table.delete(`file = "${filepath}"`);
-        } catch (error) {
-          throw wrapError(error, "Failed to delete file from vector database");
-        }
+        await deleteByFile(this.table, filepath);
       }
-      /**
-       * Updates a file in the index by atomically deleting old chunks and inserting new ones.
-       * This is the primary method for incremental reindexing.
-       * 
-       * @param filepath - Path to the file being updated
-       * @param vectors - New embedding vectors
-       * @param metadatas - New chunk metadata
-       * @param contents - New chunk contents
-       */
       async updateFile(filepath, vectors, metadatas, contents) {
-        if (!this.table) {
-          throw new DatabaseError("Vector database not initialized");
+        if (!this.db) {
+          throw new DatabaseError("Vector database connection not initialized");
         }
-        try {
-          await this.deleteByFile(filepath);
-          if (vectors.length > 0) {
-            await this.insertBatch(vectors, metadatas, contents);
-          }
-          await writeVersionFile(this.dbPath);
-        } catch (error) {
-          throw wrapError(error, "Failed to update file in vector database");
+        if (!this.table) {
+          throw new DatabaseError("Vector database table not initialized");
         }
+        this.table = await updateFile(
+          this.db,
+          this.table,
+          this.tableName,
+          this.dbPath,
+          filepath,
+          vectors,
+          metadatas,
+          contents
+        );
       }
-      /**
-       * Checks if the index version has changed since last check.
-       * Uses caching to minimize I/O overhead (checks at most once per second).
-       * 
-       * @returns true if version has changed, false otherwise
-       */
       async checkVersion() {
         const now = Date.now();
         if (now - this.lastVersionCheck < 1e3) {
@@ -1957,11 +3055,6 @@ var init_lancedb = __esm({
           return false;
         }
       }
-      /**
-       * Reconnects to the database by reinitializing the connection.
-       * Used when the index has been rebuilt/reindexed.
-       * Forces a complete reload from disk by closing existing connections first.
-       */
       async reconnect() {
         try {
           this.table = null;
@@ -1971,31 +3064,15 @@ var init_lancedb = __esm({
           throw wrapError(error, "Failed to reconnect to vector database");
         }
       }
-      /**
-       * Gets the current index version (timestamp of last reindex).
-       * 
-       * @returns Version timestamp, or 0 if unknown
-       */
       getCurrentVersion() {
         return this.currentVersion;
       }
-      /**
-       * Gets the current index version as a human-readable date string.
-       * 
-       * @returns Formatted date string, or 'Unknown' if no version
-       */
       getVersionDate() {
         if (this.currentVersion === 0) {
           return "Unknown";
         }
         return new Date(this.currentVersion).toLocaleString();
       }
-      /**
-       * Checks if the database contains real indexed data.
-       * Used to detect first run and trigger auto-indexing.
-       * 
-       * @returns true if database has real code chunks, false if empty or only schema rows
-       */
       async hasData() {
         if (!this.table) {
           return false;
@@ -2023,46 +3100,19 @@ var init_lancedb = __esm({
   }
 });
 
-// src/utils/version.ts
-import { createRequire as createRequire2 } from "module";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname2, join as join2 } from "path";
-function getPackageVersion() {
-  return packageJson2.version;
-}
-var __filename3, __dirname3, require3, packageJson2;
-var init_version2 = __esm({
-  "src/utils/version.ts"() {
-    "use strict";
-    __filename3 = fileURLToPath3(import.meta.url);
-    __dirname3 = dirname2(__filename3);
-    require3 = createRequire2(import.meta.url);
-    try {
-      packageJson2 = require3(join2(__dirname3, "../package.json"));
-    } catch {
-      try {
-        packageJson2 = require3(join2(__dirname3, "../../package.json"));
-      } catch {
-        console.warn("[Lien] Warning: Could not load package.json, using fallback version");
-        packageJson2 = { version: "0.0.0-unknown" };
-      }
-    }
-  }
-});
-
 // src/indexer/manifest.ts
 var manifest_exports = {};
 __export(manifest_exports, {
   ManifestManager: () => ManifestManager
 });
-import fs11 from "fs/promises";
-import path12 from "path";
+import fs13 from "fs/promises";
+import path15 from "path";
 var MANIFEST_FILE, ManifestManager;
 var init_manifest = __esm({
   "src/indexer/manifest.ts"() {
     "use strict";
     init_constants();
-    init_version2();
+    init_version();
     MANIFEST_FILE = "manifest.json";
     ManifestManager = class {
       manifestPath;
@@ -2078,7 +3128,7 @@ var init_manifest = __esm({
        */
       constructor(indexPath) {
         this.indexPath = indexPath;
-        this.manifestPath = path12.join(indexPath, MANIFEST_FILE);
+        this.manifestPath = path15.join(indexPath, MANIFEST_FILE);
       }
       /**
        * Loads the manifest from disk.
@@ -2091,7 +3141,7 @@ var init_manifest = __esm({
        */
       async load() {
         try {
-          const content = await fs11.readFile(this.manifestPath, "utf-8");
+          const content = await fs13.readFile(this.manifestPath, "utf-8");
           const manifest = JSON.parse(content);
           if (manifest.formatVersion !== INDEX_FORMAT_VERSION) {
             console.error(
@@ -2118,7 +3168,7 @@ var init_manifest = __esm({
        */
       async save(manifest) {
         try {
-          await fs11.mkdir(this.indexPath, { recursive: true });
+          await fs13.mkdir(this.indexPath, { recursive: true });
           const manifestToSave = {
             ...manifest,
             formatVersion: INDEX_FORMAT_VERSION,
@@ -2126,7 +3176,7 @@ var init_manifest = __esm({
             lastIndexed: Date.now()
           };
           const content = JSON.stringify(manifestToSave, null, 2);
-          await fs11.writeFile(this.manifestPath, content, "utf-8");
+          await fs13.writeFile(this.manifestPath, content, "utf-8");
         } catch (error) {
           console.error(`[Lien] Warning: Failed to save manifest: ${error}`);
         }
@@ -2263,7 +3313,7 @@ var init_manifest = __esm({
        */
       async clear() {
         try {
-          await fs11.unlink(this.manifestPath);
+          await fs13.unlink(this.manifestPath);
         } catch (error) {
           if (error.code !== "ENOENT") {
             console.error(`[Lien] Warning: Failed to clear manifest: ${error}`);
@@ -2292,8 +3342,8 @@ var tracker_exports = {};
 __export(tracker_exports, {
   GitStateTracker: () => GitStateTracker
 });
-import fs12 from "fs/promises";
-import path13 from "path";
+import fs14 from "fs/promises";
+import path16 from "path";
 var GitStateTracker;
 var init_tracker = __esm({
   "src/git/tracker.ts"() {
@@ -2305,7 +3355,7 @@ var init_tracker = __esm({
       currentState = null;
       constructor(rootDir, indexPath) {
         this.rootDir = rootDir;
-        this.stateFile = path13.join(indexPath, ".git-state.json");
+        this.stateFile = path16.join(indexPath, ".git-state.json");
       }
       /**
        * Loads the last known git state from disk.
@@ -2313,7 +3363,7 @@ var init_tracker = __esm({
        */
       async loadState() {
         try {
-          const content = await fs12.readFile(this.stateFile, "utf-8");
+          const content = await fs14.readFile(this.stateFile, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -2325,7 +3375,7 @@ var init_tracker = __esm({
       async saveState(state) {
         try {
           const content = JSON.stringify(state, null, 2);
-          await fs12.writeFile(this.stateFile, content, "utf-8");
+          await fs14.writeFile(this.stateFile, content, "utf-8");
         } catch (error) {
           console.error(`[Lien] Warning: Failed to save git state: ${error}`);
         }
@@ -2476,7 +3526,7 @@ var init_tracker = __esm({
 });
 
 // src/indexer/change-detector.ts
-import fs13 from "fs/promises";
+import fs15 from "fs/promises";
 async function detectChanges(rootDir, vectorDB, config) {
   const manifest = new ManifestManager(vectorDB.dbPath);
   const savedManifest = await manifest.load();
@@ -2580,7 +3630,7 @@ async function mtimeBasedDetection(rootDir, savedManifest, config) {
   const fileStats = /* @__PURE__ */ new Map();
   for (const filepath of currentFiles) {
     try {
-      const stats = await fs13.stat(filepath);
+      const stats = await fs15.stat(filepath);
       fileStats.set(filepath, stats.mtimeMs);
     } catch {
       continue;
@@ -2618,13 +3668,17 @@ var init_change_detector = __esm({
 });
 
 // src/indexer/incremental.ts
-import fs14 from "fs/promises";
+import fs16 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 useAST = isModernConfig(config) ? config.chunking.useAST : true;
+  const astFallback = isModernConfig(config) ? config.chunking.astFallback : "line-based";
   const chunks = chunkFile(filepath, content, {
     chunkSize,
-    chunkOverlap
+    chunkOverlap,
+    useAST,
+    astFallback
   });
   if (chunks.length === 0) {
     if (verbose) {
@@ -2653,7 +3707,7 @@ async function indexSingleFile(filepath, vectorDB, embeddings, config, options =
   const { verbose } = options;
   try {
     try {
-      await fs14.access(filepath);
+      await fs16.access(filepath);
     } catch {
       if (verbose) {
         console.error(`[Lien] File deleted: ${filepath}`);
@@ -2663,9 +3717,9 @@ async function indexSingleFile(filepath, vectorDB, embeddings, config, options =
       await manifest2.removeFile(filepath);
       return;
     }
-    const content = await fs14.readFile(filepath, "utf-8");
+    const content = await fs16.readFile(filepath, "utf-8");
     const result = await processFileContent(filepath, content, embeddings, config, verbose || false);
-    const stats = await fs14.stat(filepath);
+    const stats = await fs16.stat(filepath);
     const manifest = new ManifestManager(vectorDB.dbPath);
     if (result === null) {
       await vectorDB.deleteByFile(filepath);
@@ -2702,9 +3756,9 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
     let content;
     let fileMtime;
     try {
-      const stats = await fs14.stat(filepath);
+      const stats = await fs16.stat(filepath);
       fileMtime = stats.mtimeMs;
-      content = await fs14.readFile(filepath, "utf-8");
+      content = await fs16.readFile(filepath, "utf-8");
     } catch (error) {
       if (verbose) {
         console.error(`[Lien] File not readable: ${filepath}`);
@@ -2775,7 +3829,7 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
 var init_incremental = __esm({
   "src/indexer/incremental.ts"() {
     "use strict";
-    init_chunker();
+    init_chunker2();
     init_schema();
     init_manifest();
     init_constants();
@@ -2869,9 +3923,9 @@ var indexer_exports = {};
 __export(indexer_exports, {
   indexCodebase: () => indexCodebase
 });
-import fs15 from "fs/promises";
+import fs17 from "fs/promises";
 import ora from "ora";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import pLimit from "p-limit";
 async function indexCodebase(options = {}) {
   const rootDir = options.rootDir ?? process.cwd();
@@ -2944,7 +3998,7 @@ async function indexCodebase(options = {}) {
               await manifest2.updateGitState(gitState);
             }
           }
-          console.log(chalk4.dim("\nNext step: Run"), chalk4.bold("lien serve"), chalk4.dim("to start the MCP server"));
+          console.log(chalk5.dim("\nNext step: Run"), chalk5.bold("lien serve"), chalk5.dim("to start the MCP server"));
           return;
         }
         spinner.text = "Full reindex required...";
@@ -3033,13 +4087,17 @@ async function indexCodebase(options = {}) {
     const filePromises = files.map(
       (file) => limit(async () => {
         try {
-          const stats = await fs15.stat(file);
-          const content = await fs15.readFile(file, "utf-8");
+          const stats = await fs17.stat(file);
+          const content = await fs17.readFile(file, "utf-8");
           const chunkSize = isModernConfig(config) ? config.core.chunkSize : 75;
           const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : 10;
+          const useAST = isModernConfig(config) ? config.chunking.useAST : true;
+          const astFallback = isModernConfig(config) ? config.chunking.astFallback : "line-based";
           const chunks = chunkFile(file, content, {
             chunkSize,
-            chunkOverlap
+            chunkOverlap,
+            useAST,
+            astFallback
           });
           if (chunks.length === 0) {
             processedFiles++;
@@ -3064,7 +4122,7 @@ async function indexCodebase(options = {}) {
           }
         } catch (error) {
           if (options.verbose) {
-            console.error(chalk4.yellow(`
+            console.error(chalk5.yellow(`
 \u26A0\uFE0F  Skipping ${file}: ${error}`));
           }
           processedFiles++;
@@ -3104,7 +4162,7 @@ async function indexCodebase(options = {}) {
     spinner.succeed(
       `Indexed ${processedFiles} files (${processedChunks} chunks) in ${totalTime}s using ${concurrency}x concurrency`
     );
-    console.log(chalk4.dim("\nNext step: Run"), chalk4.bold("lien serve"), chalk4.dim("to start the MCP server"));
+    console.log(chalk5.dim("\nNext step: Run"), chalk5.bold("lien serve"), chalk5.dim("to start the MCP server"));
   } catch (error) {
     if (updateInterval) {
       clearInterval(updateInterval);
@@ -3117,11 +4175,11 @@ var init_indexer = __esm({
   "src/indexer/index.ts"() {
     "use strict";
     init_scanner();
-    init_chunker();
+    init_chunker2();
     init_local();
     init_lancedb();
     init_service();
-    init_version();
+    init_version2();
     init_schema();
     init_manifest();
     init_change_detector();
@@ -3139,30 +4197,29 @@ import { dirname as dirname4, join as join4 } from "path";
 
 // src/cli/init.ts
 init_schema();
-init_merge();
-import fs5 from "fs/promises";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk2 from "chalk";
+import fs7 from "fs/promises";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import chalk3 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;
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var require3 = createRequire2(import.meta.url);
+var packageJson2;
 try {
-  packageJson = require2(join(__dirname, "../package.json"));
+  packageJson2 = require3(join2(__dirname2, "../package.json"));
 } catch {
-  packageJson = require2(join(__dirname, "../../package.json"));
+  packageJson2 = require3(join2(__dirname2, "../../package.json"));
 }
-var PACKAGE_NAME = packageJson.name;
-var VERSION = packageJson.version;
+var PACKAGE_NAME = packageJson2.name;
+var VERSION = packageJson2.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));
@@ -3205,12 +4262,111 @@ function showCompactBanner() {
   console.log();
 }
 
-// src/cli/init.ts
+// src/config/migration-manager.ts
+init_schema();
 init_migration();
+init_merge();
+init_constants();
+import fs2 from "fs/promises";
+import path2 from "path";
+import chalk2 from "chalk";
+var MigrationManager = class {
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+  }
+  /**
+   * Get the config file path
+   */
+  getConfigPath() {
+    return path2.join(this.rootDir, ".lien.config.json");
+  }
+  /**
+   * Check if the current config needs migration
+   */
+  async needsMigration() {
+    try {
+      const configPath = this.getConfigPath();
+      const content = await fs2.readFile(configPath, "utf-8");
+      const config = JSON.parse(content);
+      return needsMigration(config);
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Perform silent migration (for auto-migration during load)
+   * Returns the migrated config without user interaction
+   */
+  async autoMigrate() {
+    const result = await migrateConfigFile(this.rootDir);
+    if (result.migrated && result.backupPath) {
+      const backupFilename = path2.basename(result.backupPath);
+      console.log(`\u2705 Migration complete! Backup saved as ${backupFilename}`);
+      console.log("\u{1F4DD} Your config now uses the framework-based structure.");
+    }
+    return result.config;
+  }
+  /**
+   * Perform interactive upgrade (for CLI upgrade command)
+   * Provides detailed feedback and handles edge cases
+   */
+  async upgradeInteractive() {
+    const configPath = this.getConfigPath();
+    try {
+      const existingContent = await fs2.readFile(configPath, "utf-8");
+      const existingConfig = JSON.parse(existingContent);
+      const migrationNeeded = needsMigration(existingConfig);
+      const newFields = migrationNeeded ? [] : detectNewFields(existingConfig, defaultConfig);
+      const hasChanges = migrationNeeded || newFields.length > 0;
+      if (!hasChanges) {
+        console.log(chalk2.green("\u2713 Config is already up to date"));
+        console.log(chalk2.dim("No changes needed"));
+        return;
+      }
+      const backupPath = `${configPath}.backup`;
+      await fs2.copyFile(configPath, backupPath);
+      let upgradedConfig;
+      let migrated = false;
+      if (migrationNeeded) {
+        console.log(chalk2.blue(`\u{1F504} Migrating config from v0.2.0 to v${CURRENT_CONFIG_VERSION}...`));
+        upgradedConfig = migrateConfig(existingConfig);
+        migrated = true;
+      } else {
+        upgradedConfig = deepMergeConfig(defaultConfig, existingConfig);
+        console.log(chalk2.dim("\nNew options added:"));
+        newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
+      }
+      await fs2.writeFile(
+        configPath,
+        JSON.stringify(upgradedConfig, null, 2) + "\n",
+        "utf-8"
+      );
+      console.log(chalk2.green("\u2713 Config upgraded successfully"));
+      console.log(chalk2.dim("Backup saved to:"), backupPath);
+      if (migrated) {
+        console.log(chalk2.dim("\n\u{1F4DD} Your config now uses the framework-based structure."));
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.log(chalk2.red("Error: No config file found"));
+        console.log(chalk2.dim("Run"), chalk2.bold("lien init"), chalk2.dim("to create a config file"));
+        return;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Perform migration and return result
+   * Used when programmatic access to migration result is needed
+   */
+  async migrate() {
+    return migrateConfigFile(this.rootDir);
+  }
+};
 
 // src/frameworks/detector-service.ts
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 
 // src/frameworks/types.ts
 var defaultDetectionOptions = {
@@ -3232,8 +4388,8 @@ var defaultDetectionOptions = {
 };
 
 // src/frameworks/nodejs/detector.ts
-import fs from "fs/promises";
-import path from "path";
+import fs3 from "fs/promises";
+import path3 from "path";
 
 // src/frameworks/nodejs/config.ts
 async function generateNodeJsConfig(_rootDir, _relativePath) {
@@ -3284,7 +4440,7 @@ var nodejsDetector = {
   priority: 50,
   // Generic, yields to specific frameworks like Laravel
   async detect(rootDir, relativePath) {
-    const fullPath = path.join(rootDir, relativePath);
+    const fullPath = path3.join(rootDir, relativePath);
     const result = {
       detected: false,
       name: "nodejs",
@@ -3292,10 +4448,10 @@ var nodejsDetector = {
       confidence: "low",
       evidence: []
     };
-    const packageJsonPath = path.join(fullPath, "package.json");
+    const packageJsonPath = path3.join(fullPath, "package.json");
     let packageJson5 = null;
     try {
-      const content = await fs.readFile(packageJsonPath, "utf-8");
+      const content = await fs3.readFile(packageJsonPath, "utf-8");
       packageJson5 = JSON.parse(content);
       result.evidence.push("Found package.json");
     } catch {
@@ -3343,8 +4499,8 @@ var nodejsDetector = {
 };
 
 // src/frameworks/laravel/detector.ts
-import fs2 from "fs/promises";
-import path2 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 
 // src/frameworks/laravel/config.ts
 async function generateLaravelConfig(_rootDir, _relativePath) {
@@ -3401,7 +4557,7 @@ var laravelDetector = {
   priority: 100,
   // Laravel takes precedence over Node.js
   async detect(rootDir, relativePath) {
-    const fullPath = path2.join(rootDir, relativePath);
+    const fullPath = path4.join(rootDir, relativePath);
     const result = {
       detected: false,
       name: "laravel",
@@ -3409,10 +4565,10 @@ var laravelDetector = {
       confidence: "low",
       evidence: []
     };
-    const composerJsonPath = path2.join(fullPath, "composer.json");
+    const composerJsonPath = path4.join(fullPath, "composer.json");
     let composerJson = null;
     try {
-      const content = await fs2.readFile(composerJsonPath, "utf-8");
+      const content = await fs4.readFile(composerJsonPath, "utf-8");
       composerJson = JSON.parse(content);
       result.evidence.push("Found composer.json");
     } catch {
@@ -3423,9 +4579,9 @@ var laravelDetector = {
       return result;
     }
     result.evidence.push("Laravel framework detected in composer.json");
-    const artisanPath = path2.join(fullPath, "artisan");
+    const artisanPath = path4.join(fullPath, "artisan");
     try {
-      await fs2.access(artisanPath);
+      await fs4.access(artisanPath);
       result.evidence.push("Found artisan file");
       result.confidence = "high";
     } catch {
@@ -3435,8 +4591,8 @@ var laravelDetector = {
     let foundDirs = 0;
     for (const dir of laravelDirs) {
       try {
-        const dirPath = path2.join(fullPath, dir);
-        const stats = await fs2.stat(dirPath);
+        const dirPath = path4.join(fullPath, dir);
+        const stats = await fs4.stat(dirPath);
         if (stats.isDirectory()) {
           foundDirs++;
         }
@@ -3448,14 +4604,14 @@ var laravelDetector = {
       result.confidence = "high";
     }
     const testDirsToCheck = [
-      path2.join(fullPath, "tests", "Feature"),
-      path2.join(fullPath, "tests", "Unit")
+      path4.join(fullPath, "tests", "Feature"),
+      path4.join(fullPath, "tests", "Unit")
     ];
     for (const testDir of testDirsToCheck) {
       try {
-        const stats = await fs2.stat(testDir);
+        const stats = await fs4.stat(testDir);
         if (stats.isDirectory()) {
-          const dirName = path2.basename(path2.dirname(testDir)) + "/" + path2.basename(testDir);
+          const dirName = path4.basename(path4.dirname(testDir)) + "/" + path4.basename(testDir);
           result.evidence.push(`Found ${dirName} test directory`);
         }
       } catch {
@@ -3473,8 +4629,8 @@ var laravelDetector = {
 };
 
 // src/frameworks/shopify/detector.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 
 // src/frameworks/shopify/config.ts
 async function generateShopifyConfig(_rootDir, _relativePath) {
@@ -3486,6 +4642,8 @@ async function generateShopifyConfig(_rootDir, _relativePath) {
       "snippets/**/*.liquid",
       "templates/**/*.liquid",
       // Matches any nesting level (e.g., templates/customers/account.liquid)
+      "templates/**/*.json",
+      // JSON template definitions (Shopify 2.0+)
       // Theme editor blocks (Online Store 2.0)
       "blocks/**/*.liquid",
       // Assets (CSS, JS with optional Liquid templating)
@@ -3530,7 +4688,7 @@ var shopifyDetector = {
   priority: 100,
   // High priority (same as Laravel)
   async detect(rootDir, relativePath) {
-    const fullPath = path3.join(rootDir, relativePath);
+    const fullPath = path5.join(rootDir, relativePath);
     const result = {
       detected: false,
       name: "shopify",
@@ -3538,18 +4696,18 @@ var shopifyDetector = {
       confidence: "low",
       evidence: []
     };
-    const settingsSchemaPath = path3.join(fullPath, "config", "settings_schema.json");
+    const settingsSchemaPath = path5.join(fullPath, "config", "settings_schema.json");
     let hasSettingsSchema = false;
     try {
-      await fs3.access(settingsSchemaPath);
+      await fs5.access(settingsSchemaPath);
       hasSettingsSchema = true;
       result.evidence.push("Found config/settings_schema.json");
     } catch {
     }
-    const themeLayoutPath = path3.join(fullPath, "layout", "theme.liquid");
+    const themeLayoutPath = path5.join(fullPath, "layout", "theme.liquid");
     let hasThemeLayout = false;
     try {
-      await fs3.access(themeLayoutPath);
+      await fs5.access(themeLayoutPath);
       hasThemeLayout = true;
       result.evidence.push("Found layout/theme.liquid");
     } catch {
@@ -3558,8 +4716,8 @@ var shopifyDetector = {
     let foundDirs = 0;
     for (const dir of shopifyDirs) {
       try {
-        const dirPath = path3.join(fullPath, dir);
-        const stats = await fs3.stat(dirPath);
+        const dirPath = path5.join(fullPath, dir);
+        const stats = await fs5.stat(dirPath);
         if (stats.isDirectory()) {
           foundDirs++;
         }
@@ -3570,14 +4728,14 @@ var shopifyDetector = {
       result.evidence.push(`Shopify directory structure detected (${foundDirs}/${shopifyDirs.length} dirs)`);
     }
     try {
-      const tomlPath = path3.join(fullPath, "shopify.theme.toml");
-      await fs3.access(tomlPath);
+      const tomlPath = path5.join(fullPath, "shopify.theme.toml");
+      await fs5.access(tomlPath);
       result.evidence.push("Found shopify.theme.toml");
     } catch {
     }
     try {
-      const ignorePath = path3.join(fullPath, ".shopifyignore");
-      await fs3.access(ignorePath);
+      const ignorePath = path5.join(fullPath, ".shopifyignore");
+      await fs5.access(ignorePath);
       result.evidence.push("Found .shopifyignore");
     } catch {
     }
@@ -3623,7 +4781,7 @@ async function detectAllFrameworks(rootDir, options = {}) {
   return results;
 }
 async function detectAtPath(rootDir, relativePath, results, visited) {
-  const fullPath = path4.join(rootDir, relativePath);
+  const fullPath = path6.join(rootDir, relativePath);
   if (visited.has(fullPath)) {
     return;
   }
@@ -3690,9 +4848,9 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
   if (depth >= options.maxDepth) {
     return;
   }
-  const fullPath = path4.join(rootDir, relativePath);
+  const fullPath = path6.join(rootDir, relativePath);
   try {
-    const entries = await fs4.readdir(fullPath, { withFileTypes: true });
+    const entries = await fs6.readdir(fullPath, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory());
     for (const dir of dirs) {
       if (options.skipDirs.includes(dir.name)) {
@@ -3701,7 +4859,7 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
       if (dir.name.startsWith(".")) {
         continue;
       }
-      const subPath = relativePath === "." ? dir.name : path4.join(relativePath, dir.name);
+      const subPath = relativePath === "." ? dir.name : path6.join(relativePath, dir.name);
       await detectAtPath(rootDir, subPath, results, visited);
       await scanSubdirectories(rootDir, subPath, results, visited, depth + 1, options);
     }
@@ -3711,43 +4869,44 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
 }
 
 // src/cli/init.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path5.dirname(__filename2);
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path7.dirname(__filename3);
 async function initCommand(options = {}) {
   const rootDir = options.path || process.cwd();
-  const configPath = path5.join(rootDir, ".lien.config.json");
+  const configPath = path7.join(rootDir, ".lien.config.json");
   try {
     let configExists = false;
     try {
-      await fs5.access(configPath);
+      await fs7.access(configPath);
       configExists = true;
     } catch {
     }
     if (configExists && options.upgrade) {
-      await upgradeConfig(configPath);
+      const migrationManager = new MigrationManager(rootDir);
+      await migrationManager.upgradeInteractive();
       return;
     }
     if (configExists && !options.upgrade) {
-      console.log(chalk2.yellow("\u26A0\uFE0F  .lien.config.json already exists"));
-      console.log(chalk2.dim("Run"), chalk2.bold("lien init --upgrade"), chalk2.dim("to merge new config options"));
+      console.log(chalk3.yellow("\u26A0\uFE0F  .lien.config.json already exists"));
+      console.log(chalk3.dim("Run"), chalk3.bold("lien init --upgrade"), chalk3.dim("to merge new config options"));
       return;
     }
     if (!configExists) {
       await createNewConfig(rootDir, options);
     }
   } catch (error) {
-    console.error(chalk2.red("Error creating config file:"), error);
+    console.error(chalk3.red("Error creating config file:"), error);
     process.exit(1);
   }
 }
 async function createNewConfig(rootDir, options) {
   showCompactBanner();
-  console.log(chalk2.bold("Initializing Lien...\n"));
-  console.log(chalk2.dim("\u{1F50D} Detecting frameworks in"), chalk2.bold(rootDir));
+  console.log(chalk3.bold("Initializing Lien...\n"));
+  console.log(chalk3.dim("\u{1F50D} Detecting frameworks in"), chalk3.bold(rootDir));
   const detections = await detectAllFrameworks(rootDir);
   let frameworks = [];
   if (detections.length === 0) {
-    console.log(chalk2.yellow("\n\u26A0\uFE0F  No frameworks detected"));
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  No frameworks detected"));
     if (!options.yes) {
       const { useGeneric } = await inquirer.prompt([
         {
@@ -3758,7 +4917,7 @@ async function createNewConfig(rootDir, options) {
         }
       ]);
       if (!useGeneric) {
-        console.log(chalk2.dim("Aborted."));
+        console.log(chalk3.dim("Aborted."));
         return;
       }
     }
@@ -3781,16 +4940,16 @@ async function createNewConfig(rootDir, options) {
       }
     });
   } else {
-    console.log(chalk2.green(`
+    console.log(chalk3.green(`
 \u2713 Found ${detections.length} framework(s):
 `));
     for (const det of detections) {
       const pathDisplay = det.path === "." ? "root" : det.path;
-      console.log(chalk2.bold(`  ${det.name}`), chalk2.dim(`(${det.confidence} confidence)`));
-      console.log(chalk2.dim(`    Location: ${pathDisplay}`));
+      console.log(chalk3.bold(`  ${det.name}`), chalk3.dim(`(${det.confidence} confidence)`));
+      console.log(chalk3.dim(`    Location: ${pathDisplay}`));
       if (det.evidence.length > 0) {
         det.evidence.forEach((e) => {
-          console.log(chalk2.dim(`    \u2022 ${e}`));
+          console.log(chalk3.dim(`    \u2022 ${e}`));
         });
       }
       console.log();
@@ -3805,14 +4964,14 @@ async function createNewConfig(rootDir, options) {
         }
       ]);
       if (!confirm) {
-        console.log(chalk2.dim("Aborted."));
+        console.log(chalk3.dim("Aborted."));
         return;
       }
     }
     for (const det of detections) {
       const detector = getFrameworkDetector(det.name);
       if (!detector) {
-        console.warn(chalk2.yellow(`\u26A0\uFE0F  No detector found for ${det.name}, skipping`));
+        console.warn(chalk3.yellow(`\u26A0\uFE0F  No detector found for ${det.name}, skipping`));
         continue;
       }
       const frameworkConfig = await detector.generateConfig(rootDir, det.path);
@@ -3834,7 +4993,7 @@ async function createNewConfig(rootDir, options) {
         finalConfig = { ...frameworkConfig, ...customized };
       } else {
         const pathDisplay = det.path === "." ? "root" : det.path;
-        console.log(chalk2.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
+        console.log(chalk3.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
       }
       frameworks.push({
         name: det.name,
@@ -3855,23 +5014,23 @@ async function createNewConfig(rootDir, options) {
     ]);
     if (installCursorRules) {
       try {
-        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");
+        const cursorRulesDir = path7.join(rootDir, ".cursor");
+        await fs7.mkdir(cursorRulesDir, { recursive: true });
+        const templatePath = path7.join(__dirname3, "../CURSOR_RULES_TEMPLATE.md");
+        const rulesPath = path7.join(cursorRulesDir, "rules");
         let targetPath;
         let isDirectory = false;
         let isFile = false;
         try {
-          const stats = await fs5.stat(rulesPath);
+          const stats = await fs7.stat(rulesPath);
           isDirectory = stats.isDirectory();
           isFile = stats.isFile();
         } catch {
         }
         if (isDirectory) {
-          targetPath = path5.join(rulesPath, "lien.mdc");
-          await fs5.copyFile(templatePath, targetPath);
-          console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
+          targetPath = path7.join(rulesPath, "lien.mdc");
+          await fs7.copyFile(templatePath, targetPath);
+          console.log(chalk3.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         } else if (isFile) {
           const { convertToDir } = await inquirer.prompt([
             {
@@ -3882,27 +5041,27 @@ async function createNewConfig(rootDir, options) {
             }
           ]);
           if (convertToDir) {
-            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"));
+            const existingRules = await fs7.readFile(rulesPath, "utf-8");
+            await fs7.unlink(rulesPath);
+            await fs7.mkdir(rulesPath);
+            await fs7.writeFile(path7.join(rulesPath, "project.mdc"), existingRules);
+            await fs7.copyFile(templatePath, path7.join(rulesPath, "lien.mdc"));
+            console.log(chalk3.green("\u2713 Converted .cursor/rules to directory"));
+            console.log(chalk3.green("  - Your project rules: .cursor/rules/project.mdc"));
+            console.log(chalk3.green("  - Lien rules: .cursor/rules/lien.mdc"));
           } else {
-            console.log(chalk2.dim("Skipped Cursor rules installation (preserving existing file)"));
+            console.log(chalk3.dim("Skipped Cursor rules installation (preserving existing file)"));
           }
         } else {
-          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"));
+          await fs7.mkdir(rulesPath, { recursive: true });
+          targetPath = path7.join(rulesPath, "lien.mdc");
+          await fs7.copyFile(templatePath, targetPath);
+          console.log(chalk3.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         }
       } catch (error) {
-        console.log(chalk2.yellow("\u26A0\uFE0F  Could not install Cursor rules"));
-        console.log(chalk2.dim(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
-        console.log(chalk2.dim("You can manually copy CURSOR_RULES_TEMPLATE.md to .cursor/rules/lien.mdc"));
+        console.log(chalk3.yellow("\u26A0\uFE0F  Could not install Cursor rules"));
+        console.log(chalk3.dim(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+        console.log(chalk3.dim("You can manually copy CURSOR_RULES_TEMPLATE.md to .cursor/rules/lien.mdc"));
       }
     }
   }
@@ -3910,17 +5069,17 @@ async function createNewConfig(rootDir, options) {
     ...defaultConfig,
     frameworks
   };
-  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:"));
-  console.log(chalk2.dim("  1. Run"), chalk2.bold("lien index"), chalk2.dim("to index your codebase"));
-  console.log(chalk2.dim("  2. Run"), chalk2.bold("lien serve"), chalk2.dim("to start the MCP server"));
-  console.log(chalk2.dim("  3. Configure Cursor to use the MCP server (see README.md)"));
+  const configPath = path7.join(rootDir, ".lien.config.json");
+  await fs7.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  console.log(chalk3.green("\n\u2713 Created .lien.config.json"));
+  console.log(chalk3.green(`\u2713 Configured ${frameworks.length} framework(s)`));
+  console.log(chalk3.dim("\nNext steps:"));
+  console.log(chalk3.dim("  1. Run"), chalk3.bold("lien index"), chalk3.dim("to index your codebase"));
+  console.log(chalk3.dim("  2. Run"), chalk3.bold("lien serve"), chalk3.dim("to start the MCP server"));
+  console.log(chalk3.dim("  3. Configure Cursor to use the MCP server (see README.md)"));
 }
 async function promptForCustomization(frameworkName, config) {
-  console.log(chalk2.bold(`
+  console.log(chalk3.bold(`
 Customizing ${frameworkName} settings:`));
   const answers = await inquirer.prompt([
     {
@@ -3943,150 +5102,115 @@ Customizing ${frameworkName} settings:`));
     exclude: answers.exclude
   };
 }
-async function upgradeConfig(configPath) {
-  try {
-    const backupPath = `${configPath}.backup`;
-    await fs5.copyFile(configPath, backupPath);
-    const existingContent = await fs5.readFile(configPath, "utf-8");
-    const existingConfig = JSON.parse(existingContent);
-    let upgradedConfig;
-    let migrated = false;
-    if (needsMigration(existingConfig)) {
-      console.log(chalk2.blue("\u{1F504} Migrating config from v0.2.0 to v0.3.0..."));
-      upgradedConfig = migrateConfig(existingConfig);
-      migrated = true;
-    } else {
-      const newFields = detectNewFields(existingConfig, defaultConfig);
-      upgradedConfig = deepMergeConfig(defaultConfig, existingConfig);
-      if (newFields.length > 0) {
-        console.log(chalk2.dim("\nNew options added:"));
-        newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
-      }
-    }
-    await fs5.writeFile(
-      configPath,
-      JSON.stringify(upgradedConfig, null, 2) + "\n",
-      "utf-8"
-    );
-    console.log(chalk2.green("\u2713 Config upgraded successfully"));
-    console.log(chalk2.dim("Backup saved to:"), backupPath);
-    if (migrated) {
-      console.log(chalk2.dim("\n\u{1F4DD} Your config now uses the framework-based structure."));
-    }
-  } catch (error) {
-    console.error(chalk2.red("Error upgrading config:"), error);
-    throw error;
-  }
-}
 
 // src/cli/status.ts
 init_service();
 init_utils();
-init_version();
-import chalk3 from "chalk";
-import fs9 from "fs/promises";
-import path9 from "path";
+init_version2();
+import chalk4 from "chalk";
+import fs11 from "fs/promises";
+import path11 from "path";
 import os from "os";
 import crypto from "crypto";
 init_schema();
 async function statusCommand() {
   const rootDir = process.cwd();
-  const projectName = path9.basename(rootDir);
+  const projectName = path11.basename(rootDir);
   const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
-  const indexPath = path9.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
+  const indexPath = path11.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
   showCompactBanner();
-  console.log(chalk3.bold("Status\n"));
+  console.log(chalk4.bold("Status\n"));
   const hasConfig = await configService.exists(rootDir);
-  console.log(chalk3.dim("Configuration:"), hasConfig ? chalk3.green("\u2713 Found") : chalk3.red("\u2717 Not initialized"));
+  console.log(chalk4.dim("Configuration:"), hasConfig ? chalk4.green("\u2713 Found") : chalk4.red("\u2717 Not initialized"));
   if (!hasConfig) {
-    console.log(chalk3.yellow("\nRun"), chalk3.bold("lien init"), chalk3.yellow("to initialize"));
+    console.log(chalk4.yellow("\nRun"), chalk4.bold("lien init"), chalk4.yellow("to initialize"));
     return;
   }
   try {
-    const stats = await fs9.stat(indexPath);
-    console.log(chalk3.dim("Index location:"), indexPath);
-    console.log(chalk3.dim("Index status:"), chalk3.green("\u2713 Exists"));
+    const stats = await fs11.stat(indexPath);
+    console.log(chalk4.dim("Index location:"), indexPath);
+    console.log(chalk4.dim("Index status:"), chalk4.green("\u2713 Exists"));
     try {
-      const files = await fs9.readdir(indexPath, { recursive: true });
-      console.log(chalk3.dim("Index files:"), files.length);
+      const files = await fs11.readdir(indexPath, { recursive: true });
+      console.log(chalk4.dim("Index files:"), files.length);
     } catch (e) {
     }
-    console.log(chalk3.dim("Last modified:"), stats.mtime.toLocaleString());
+    console.log(chalk4.dim("Last modified:"), stats.mtime.toLocaleString());
     try {
       const version = await readVersionFile(indexPath);
       if (version > 0) {
         const versionDate = new Date(version);
-        console.log(chalk3.dim("Last reindex:"), versionDate.toLocaleString());
+        console.log(chalk4.dim("Last reindex:"), versionDate.toLocaleString());
       }
     } catch {
     }
   } catch (error) {
-    console.log(chalk3.dim("Index status:"), chalk3.yellow("\u2717 Not indexed"));
-    console.log(chalk3.yellow("\nRun"), chalk3.bold("lien index"), chalk3.yellow("to index your codebase"));
+    console.log(chalk4.dim("Index status:"), chalk4.yellow("\u2717 Not indexed"));
+    console.log(chalk4.yellow("\nRun"), chalk4.bold("lien index"), chalk4.yellow("to index your codebase"));
   }
   try {
     const config = await configService.load(rootDir);
-    console.log(chalk3.bold("\nFeatures:"));
+    console.log(chalk4.bold("\nFeatures:"));
     const isRepo = await isGitRepo(rootDir);
     if (config.gitDetection.enabled && isRepo) {
-      console.log(chalk3.dim("Git detection:"), chalk3.green("\u2713 Enabled"));
-      console.log(chalk3.dim("  Poll interval:"), `${config.gitDetection.pollIntervalMs / 1e3}s`);
+      console.log(chalk4.dim("Git detection:"), chalk4.green("\u2713 Enabled"));
+      console.log(chalk4.dim("  Poll interval:"), `${config.gitDetection.pollIntervalMs / 1e3}s`);
       try {
         const branch = await getCurrentBranch(rootDir);
         const commit = await getCurrentCommit(rootDir);
-        console.log(chalk3.dim("  Current branch:"), branch);
-        console.log(chalk3.dim("  Current commit:"), commit.substring(0, 8));
-        const gitStateFile = path9.join(indexPath, ".git-state.json");
+        console.log(chalk4.dim("  Current branch:"), branch);
+        console.log(chalk4.dim("  Current commit:"), commit.substring(0, 8));
+        const gitStateFile = path11.join(indexPath, ".git-state.json");
         try {
-          const gitStateContent = await fs9.readFile(gitStateFile, "utf-8");
+          const gitStateContent = await fs11.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"));
+            console.log(chalk4.yellow("  \u26A0\uFE0F  Git state changed - will reindex on next serve"));
           }
         } catch {
         }
       } catch {
       }
     } else if (config.gitDetection.enabled && !isRepo) {
-      console.log(chalk3.dim("Git detection:"), chalk3.yellow("Enabled (not a git repo)"));
+      console.log(chalk4.dim("Git detection:"), chalk4.yellow("Enabled (not a git repo)"));
     } else {
-      console.log(chalk3.dim("Git detection:"), chalk3.gray("Disabled"));
+      console.log(chalk4.dim("Git detection:"), chalk4.gray("Disabled"));
     }
     if (config.fileWatching.enabled) {
-      console.log(chalk3.dim("File watching:"), chalk3.green("\u2713 Enabled"));
-      console.log(chalk3.dim("  Debounce:"), `${config.fileWatching.debounceMs}ms`);
+      console.log(chalk4.dim("File watching:"), chalk4.green("\u2713 Enabled"));
+      console.log(chalk4.dim("  Debounce:"), `${config.fileWatching.debounceMs}ms`);
     } else {
-      console.log(chalk3.dim("File watching:"), chalk3.gray("Disabled"));
-      console.log(chalk3.dim("  Enable with:"), chalk3.bold("lien serve --watch"));
+      console.log(chalk4.dim("File watching:"), chalk4.gray("Disabled"));
+      console.log(chalk4.dim("  Enable with:"), chalk4.bold("lien serve --watch"));
     }
-    console.log(chalk3.bold("\nIndexing Settings:"));
+    console.log(chalk4.bold("\nIndexing Settings:"));
     if (isModernConfig(config)) {
-      console.log(chalk3.dim("Concurrency:"), config.core.concurrency);
-      console.log(chalk3.dim("Batch size:"), config.core.embeddingBatchSize);
-      console.log(chalk3.dim("Chunk size:"), config.core.chunkSize);
-      console.log(chalk3.dim("Chunk overlap:"), config.core.chunkOverlap);
+      console.log(chalk4.dim("Concurrency:"), config.core.concurrency);
+      console.log(chalk4.dim("Batch size:"), config.core.embeddingBatchSize);
+      console.log(chalk4.dim("Chunk size:"), config.core.chunkSize);
+      console.log(chalk4.dim("Chunk overlap:"), config.core.chunkOverlap);
     }
   } catch (error) {
-    console.log(chalk3.yellow("\nWarning: Could not load configuration"));
+    console.log(chalk4.yellow("\nWarning: Could not load configuration"));
   }
 }
 
 // src/cli/index-cmd.ts
 init_indexer();
-import chalk5 from "chalk";
+import chalk6 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..."));
+      console.log(chalk6.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"));
+      console.log(chalk6.green("\u2713 Index and manifest cleared\n"));
     }
     await indexCodebase({
       rootDir: process.cwd(),
@@ -4094,18 +5218,18 @@ async function indexCommand(options) {
       force: options.force || false
     });
     if (options.watch) {
-      console.log(chalk5.yellow("\n\u26A0\uFE0F  Watch mode not yet implemented"));
+      console.log(chalk6.yellow("\n\u26A0\uFE0F  Watch mode not yet implemented"));
     }
   } catch (error) {
-    console.error(chalk5.red("Error during indexing:"), error);
+    console.error(chalk6.red("Error during indexing:"), error);
     process.exit(1);
   }
 }
 
 // src/cli/serve.ts
-import chalk6 from "chalk";
-import fs16 from "fs/promises";
-import path14 from "path";
+import chalk7 from "chalk";
+import fs18 from "fs/promises";
+import path17 from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -4735,36 +5859,36 @@ async function startMCPServer(options) {
 
 // src/cli/serve.ts
 async function serveCommand(options) {
-  const rootDir = options.root ? path14.resolve(options.root) : process.cwd();
+  const rootDir = options.root ? path17.resolve(options.root) : process.cwd();
   try {
     if (options.root) {
       try {
-        const stats = await fs16.stat(rootDir);
+        const stats = await fs18.stat(rootDir);
         if (!stats.isDirectory()) {
-          console.error(chalk6.red(`Error: --root path is not a directory: ${rootDir}`));
+          console.error(chalk7.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}`));
+          console.error(chalk7.red(`Error: --root directory does not exist: ${rootDir}`));
         } else if (error.code === "EACCES") {
-          console.error(chalk6.red(`Error: --root directory is not accessible: ${rootDir}`));
+          console.error(chalk7.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));
+          console.error(chalk7.red(`Error: Failed to access --root directory: ${rootDir}`));
+          console.error(chalk7.dim(error.message));
         }
         process.exit(1);
       }
     }
     showBanner();
-    console.error(chalk6.bold("Starting MCP server...\n"));
+    console.error(chalk7.bold("Starting MCP server...\n"));
     if (options.root) {
-      console.error(chalk6.dim(`Serving from: ${rootDir}
+      console.error(chalk7.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"));
+      console.error(chalk7.yellow("\u26A0\uFE0F  --watch flag is deprecated (file watching is now default)"));
+      console.error(chalk7.dim("    Use --no-watch to disable file watching\n"));
     }
     const watch = options.noWatch ? false : options.watch ? true : void 0;
     await startMCPServer({
@@ -4773,7 +5897,7 @@ async function serveCommand(options) {
       watch
     });
   } catch (error) {
-    console.error(chalk6.red("Failed to start MCP server:"), error);
+    console.error(chalk7.red("Failed to start MCP server:"), error);
     process.exit(1);
   }
 }