@liendev/lien 0.13.0 → 0.15.1

package/dist/index.js

@@ -106,59 +106,9 @@ var init_schema = __esm({
   }
 });
 
-// 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";
-  }
-});
-
 // src/config/migration.ts
+import fs from "fs/promises";
+import path from "path";
 function needsMigration(config) {
   if (!config) {
     return false;
@@ -211,7 +161,7 @@ function migrateConfig(oldConfig) {
       path: ".",
       enabled: true,
       config: {
-        include: oldConfig.indexing.include ?? ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        include: oldConfig.indexing.include ?? ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
         exclude: oldConfig.indexing.exclude ?? [
           "**/node_modules/**",
           "**/dist/**",
@@ -231,7 +181,7 @@ function migrateConfig(oldConfig) {
       path: ".",
       enabled: true,
       config: {
-        include: ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        include: ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
         exclude: [
           "**/node_modules/**",
           "**/dist/**",
@@ -248,6 +198,36 @@ 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";
@@ -256,6 +236,58 @@ var init_migration = __esm({
   }
 });
 
+// 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";
+  }
+});
+
 // src/errors/codes.ts
 var init_codes = __esm({
   "src/errors/codes.ts"() {
@@ -346,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"() {
@@ -369,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.");
             }
@@ -431,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 });
         }
@@ -445,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;
@@ -462,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 {
@@ -480,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,
@@ -578,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
@@ -742,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) {
@@ -802,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;
@@ -846,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}`);
@@ -861,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}`);
@@ -876,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}`);
@@ -899,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) {
@@ -931,8 +963,8 @@ var init_version2 = __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) {
@@ -945,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) {
     }
@@ -976,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) {
   }
@@ -998,7 +1030,7 @@ async function scanCodebase(options) {
     ".lien/**",
     ...excludePatterns
   ]);
-  const patterns = includePatterns.length > 0 ? includePatterns : ["**/*.{ts,tsx,js,jsx,py,go,rs,java,cpp,c,h,md,mdx}"];
+  const patterns = includePatterns.length > 0 ? includePatterns : ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,cpp,c,cs,h,md,mdx}"];
   const allFiles = [];
   for (const pattern of patterns) {
     const files = await glob(pattern, {
@@ -1011,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",
@@ -1355,6 +1387,8 @@ var init_symbol_extractor = __esm({
 import Parser from "tree-sitter";
 import TypeScript from "tree-sitter-typescript";
 import JavaScript from "tree-sitter-javascript";
+import PHPParser from "tree-sitter-php";
+import Python from "tree-sitter-python";
 import { extname } from "path";
 function getParser(language) {
   if (!parserCache.has(language)) {
@@ -1379,6 +1413,10 @@ function detectLanguage2(filePath) {
     case "mjs":
     case "cjs":
       return "javascript";
+    case "php":
+      return "php";
+    case "py":
+      return "python";
     default:
       return null;
   }
@@ -1411,86 +1449,116 @@ var init_parser = __esm({
     parserCache = /* @__PURE__ */ new Map();
     languageConfig = {
       typescript: TypeScript.typescript,
-      javascript: JavaScript
-      // Use proper JavaScript parser
+      javascript: JavaScript,
+      php: PHPParser.php,
+      // Note: tree-sitter-php exports both 'php' (mixed HTML/PHP) and 'php_only'
+      python: Python
     };
   }
 });
 
 // src/indexer/ast/symbols.ts
-function extractSymbolInfo(node, content, parentClass) {
-  const type = node.type;
-  if (type === "function_declaration" || type === "function") {
-    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)
-    };
-  }
-  if (type === "arrow_function" || type === "function_expression") {
-    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)
-    };
-  }
-  if (type === "method_definition") {
-    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)
-    };
-  }
-  if (type === "class_declaration") {
-    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 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";
   }
-  if (type === "interface_declaration") {
-    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}`
-    };
+  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 extractPythonFunctionInfo(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),
+    complexity: calculateComplexity(node)
+  };
+}
+function extractPythonClassInfo(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 extractSymbolInfo(node, content, parentClass, language) {
+  if (node.type === "function_definition" && language === "python") {
+    return extractPythonFunctionInfo(node, content, parentClass);
   }
-  return null;
+  const extractor = symbolExtractors[node.type];
+  return extractor ? extractor(node, content, parentClass) : null;
 }
 function extractSignature(node, content) {
   const startLine = node.startPosition.row;
@@ -1527,19 +1595,39 @@ function extractReturnType(node, _content) {
 function calculateComplexity(node) {
   let complexity = 1;
   const decisionPoints = [
+    // Common across languages (TypeScript/JavaScript/Python/PHP)
     "if_statement",
+    // if conditions
     "while_statement",
+    // while loops
+    "for_statement",
+    // for loops
+    "switch_case",
+    // switch/case statements
+    "catch_clause",
+    // try/catch error handling
+    "ternary_expression",
+    // Ternary operator (a ? b : c)
+    "binary_expression",
+    // For && and || logical operators
+    // TypeScript/JavaScript specific
     "do_statement",
     // do...while loops
-    "for_statement",
     "for_in_statement",
+    // for...in loops
     "for_of_statement",
     // for...of loops
-    "switch_case",
-    "catch_clause",
-    "ternary_expression",
-    "binary_expression"
-    // For && and ||
+    // PHP specific
+    "foreach_statement",
+    // PHP foreach loops
+    // Python specific
+    "elif_clause",
+    // Python elif (adds decision point)
+    // Note: 'else_clause' is NOT a decision point (it's the default path)
+    "except_clause",
+    // Python except (try/except)
+    "conditional_expression"
+    // Python ternary (x if cond else y)
   ];
   function traverse(n) {
     if (decisionPoints.includes(n.type)) {
@@ -1568,7 +1656,13 @@ function extractImports(rootNode) {
       if (sourceNode) {
         const importPath = sourceNode.text.replace(/['"]/g, "");
         imports.push(importPath);
+      } else {
+        const importText = node.text.split("\n")[0];
+        imports.push(importText);
       }
+    } else if (node.type === "import_from_statement") {
+      const importText = node.text.split("\n")[0];
+      imports.push(importText);
     }
     if (node === rootNode) {
       for (let i = 0; i < node.namedChildCount; i++) {
@@ -1580,9 +1674,272 @@ function extractImports(rootNode) {
   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 (Python handled via language check in extractSymbolInfo)
+      "method_declaration": extractMethodInfo,
+      // PHP methods
+      // Python
+      "async_function_definition": extractPythonFunctionInfo,
+      // Python async functions
+      "class_definition": extractPythonClassInfo
+      // Python classes
+      // Note: Python regular functions use 'function_definition' (same as PHP)
+      // They are dispatched to extractPythonFunctionInfo via language check in extractSymbolInfo()
+    };
+  }
+});
+
+// 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/python.ts
+var PythonTraverser;
+var init_python = __esm({
+  "src/indexer/ast/traversers/python.ts"() {
+    "use strict";
+    PythonTraverser = class {
+      targetNodeTypes = [
+        "function_definition",
+        "async_function_definition"
+      ];
+      containerTypes = [
+        "class_definition"
+        // We extract methods, not the class itself
+      ];
+      declarationTypes = [
+        // Python doesn't have const/let/var declarations like JS/TS
+        // Functions are always defined with 'def' or 'async def'
+      ];
+      functionTypes = [
+        "function_definition",
+        "async_function_definition"
+      ];
+      shouldExtractChildren(node) {
+        return this.containerTypes.includes(node.type);
+      }
+      isDeclarationWithFunction(_node) {
+        return false;
+      }
+      getContainerBody(node) {
+        if (node.type === "class_definition") {
+          return node.childForFieldName("body");
+        }
+        return null;
+      }
+      shouldTraverseChildren(node) {
+        return node.type === "module" || // Top-level Python file
+        node.type === "block";
+      }
+      findParentContainerName(node) {
+        let current = node.parent;
+        while (current) {
+          if (current.type === "class_definition") {
+            const nameNode = current.childForFieldName("name");
+            return nameNode?.text;
+          }
+          current = current.parent;
+        }
+        return void 0;
+      }
+      /**
+       * Python doesn't have this pattern (const x = () => {})
+       * Functions are always defined with 'def' or 'async def'
+       */
+      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();
+    init_python();
+    traverserRegistry = {
+      typescript: new TypeScriptTraverser(),
+      javascript: new JavaScriptTraverser(),
+      php: new PHPTraverser(),
+      python: new PythonTraverser()
+    };
   }
 });
 
@@ -1600,21 +1957,19 @@ function chunkByAST(filepath, content, options = {}) {
   const chunks = [];
   const lines = content.split("\n");
   const rootNode = parseResult.tree.rootNode;
+  const traverser = getTraverser(language);
   const fileImports = extractImports(rootNode);
-  const topLevelNodes = findTopLevelNodes(rootNode);
+  const topLevelNodes = findTopLevelNodes(rootNode, traverser);
   for (const node of topLevelNodes) {
     let actualNode = node;
-    if (node.type === "lexical_declaration" || node.type === "variable_declaration") {
-      const funcNode = findActualFunctionNode(node);
-      if (funcNode) {
-        actualNode = funcNode;
+    if (traverser.isDeclarationWithFunction(node)) {
+      const declInfo = traverser.findFunctionInDeclaration(node);
+      if (declInfo.functionNode) {
+        actualNode = declInfo.functionNode;
       }
     }
-    let parentClassName;
-    if (actualNode.type === "method_definition") {
-      parentClassName = findParentClassName(actualNode);
-    }
-    const symbolInfo = extractSymbolInfo(actualNode, content, parentClassName);
+    const parentClassName = traverser.findParentContainerName(actualNode);
+    const symbolInfo = extractSymbolInfo(actualNode, content, parentClassName, language);
     const nodeContent = getNodeContent(node, lines);
     chunks.push(createChunk(filepath, node, nodeContent, symbolInfo, fileImports, language));
   }
@@ -1634,57 +1989,28 @@ function chunkByAST(filepath, content, options = {}) {
   chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
   return chunks;
 }
-function findParentClassName(methodNode) {
-  let current = methodNode.parent;
-  while (current) {
-    if (current.type === "class_declaration") {
-      const nameNode = current.childForFieldName("name");
-      return nameNode?.text;
-    }
-    current = current.parent;
-  }
-  return void 0;
-}
-function findTopLevelNodes(rootNode) {
+function findTopLevelNodes(rootNode, traverser) {
   const nodes = [];
-  const targetTypes = [
-    "function_declaration",
-    "function",
-    // Note: 'class_declaration' is NOT included here - we extract methods individually
-    "interface_declaration",
-    "method_definition",
-    "lexical_declaration",
-    // For const/let with arrow functions
-    "variable_declaration"
-    // For var with functions
-  ];
   function traverse(node, depth) {
-    if ((node.type === "lexical_declaration" || node.type === "variable_declaration") && depth === 0) {
-      const hasFunction = findFunctionInDeclaration(node);
-      if (hasFunction) {
+    if (traverser.isDeclarationWithFunction(node) && depth === 0) {
+      const declInfo = traverser.findFunctionInDeclaration(node);
+      if (declInfo.hasFunction) {
         nodes.push(node);
         return;
       }
     }
-    if (depth <= 1 && targetTypes.includes(node.type)) {
+    if (depth <= 1 && traverser.targetNodeTypes.includes(node.type)) {
       nodes.push(node);
       return;
     }
-    if (node.type === "class_body") {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child) traverse(child, depth);
-      }
-      return;
-    }
-    if (node.type === "class_declaration") {
-      const body = node.childForFieldName("body");
+    if (traverser.shouldExtractChildren(node)) {
+      const body = traverser.getContainerBody(node);
       if (body) {
         traverse(body, depth + 1);
       }
       return;
     }
-    if (node.type === "program" || node.type === "export_statement") {
+    if (traverser.shouldTraverseChildren(node)) {
       for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
         if (child) traverse(child, depth);
@@ -1694,41 +2020,6 @@ function findTopLevelNodes(rootNode) {
   traverse(rootNode, 0);
   return nodes;
 }
-function findFunctionInDeclaration(node) {
-  const functionTypes = ["arrow_function", "function_expression", "function"];
-  function search(n, depth) {
-    if (depth > 3) return false;
-    if (functionTypes.includes(n.type)) {
-      return true;
-    }
-    for (let i = 0; i < n.childCount; i++) {
-      const child = n.child(i);
-      if (child && search(child, depth + 1)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  return search(node, 0);
-}
-function findActualFunctionNode(node) {
-  const functionTypes = ["arrow_function", "function_expression", "function"];
-  function search(n, depth) {
-    if (depth > 3) return null;
-    if (functionTypes.includes(n.type)) {
-      return n;
-    }
-    for (let i = 0; i < n.childCount; i++) {
-      const child = n.child(i);
-      if (child) {
-        const result = search(child, depth + 1);
-        if (result) return result;
-      }
-    }
-    return null;
-  }
-  return search(node, 0);
-}
 function getNodeContent(node, lines) {
   const startLine = node.startPosition.row;
   const endLine = node.endPosition.row;
@@ -1770,67 +2061,323 @@ function createChunk(filepath, node, content, symbolInfo, imports, language) {
     }
   };
 }
-function extractUncoveredCode(lines, coveredRanges, filepath, minChunkSize, imports, language) {
-  const chunks = [];
+function findUncoveredRanges(coveredRanges, totalLines) {
+  const uncoveredRanges = [];
   let currentStart = 0;
-  coveredRanges.sort((a, b) => a.start - b.start);
-  for (const range of coveredRanges) {
+  const sortedRanges = [...coveredRanges].sort((a, b) => a.start - b.start);
+  for (const range of sortedRanges) {
     if (currentStart < range.start) {
-      const uncoveredLines = lines.slice(currentStart, range.start);
-      const content = uncoveredLines.join("\n").trim();
-      if (content.length > 0 && uncoveredLines.length >= minChunkSize) {
-        chunks.push({
-          content,
-          metadata: {
-            file: filepath,
-            startLine: currentStart + 1,
-            endLine: range.start,
-            type: "block",
-            language,
-            // Empty symbols for uncovered code (imports, exports, etc.)
-            symbols: { functions: [], classes: [], interfaces: [] },
-            imports
-          }
-        });
-      }
+      uncoveredRanges.push({
+        start: currentStart,
+        end: range.start - 1
+      });
     }
     currentStart = range.end + 1;
   }
-  if (currentStart < lines.length) {
-    const uncoveredLines = lines.slice(currentStart);
-    const content = uncoveredLines.join("\n").trim();
-    if (content.length > 0 && uncoveredLines.length >= minChunkSize) {
+  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,
+        content: block.content,
         metadata: {
           file: filepath,
-          startLine: currentStart + 1,
-          endLine: lines.length,
+          startLine: block.startLine + 1,
+          // 1-indexed
+          endLine: block.endLine + 1,
+          language: "liquid",
           type: "block",
-          language,
-          // Empty symbols for uncovered code (imports, exports, etc.)
-          symbols: { functions: [], classes: [], interfaces: [] },
-          imports
+          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;
+      }
     }
   }
-  return chunks;
+  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);
 }
-function shouldUseAST(filepath) {
-  return isASTSupported(filepath);
+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 [];
+  }
 }
-var init_chunker = __esm({
-  "src/indexer/ast/chunker.ts"() {
+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";
-    init_parser();
-    init_symbols();
   }
 });
 
 // src/indexer/chunker.ts
 function chunkFile(filepath, content, 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, {
@@ -1884,6 +2431,8 @@ var init_chunker2 = __esm({
     init_scanner();
     init_symbol_extractor();
     init_chunker();
+    init_liquid_chunker();
+    init_json_template_chunker();
   }
 });
 
@@ -1994,18 +2543,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")) {
@@ -2052,7 +2594,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) {
@@ -2067,7 +2609,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;
@@ -2095,7 +2637,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;
@@ -2103,43 +2645,400 @@ function boostForConceptualIntent(query, filepath, baseScore) {
       score *= 0.9;
     }
   }
-  const pathSegments = filepath.toLowerCase().split(path11.sep);
-  for (const token of queryTokens) {
-    if (token.length <= 2) continue;
-    for (const segment of pathSegments) {
-      if (segment.includes(token)) {
-        score *= 0.95;
-        break;
-      }
+  const pathSegments = filepath.toLowerCase().split(path13.sep);
+  for (const token of queryTokens) {
+    if (token.length <= 2) continue;
+    for (const segment of pathSegments) {
+      if (segment.includes(token)) {
+        score *= 0.95;
+        break;
+      }
+    }
+  }
+  return score;
+}
+function boostForImplementationIntent(query, filepath, baseScore) {
+  let score = baseScore;
+  score = boostFilenameRelevance(query, filepath, score);
+  score = boostPathRelevance(query, filepath, score);
+  if (isTestFile(filepath)) {
+    score *= 0.9;
+  }
+  return score;
+}
+function applyRelevanceBoosting(query, filepath, baseScore) {
+  if (!query) {
+    return baseScore;
+  }
+  const intent = classifyQueryIntent(query);
+  switch (intent) {
+    case "location" /* LOCATION */:
+      return boostForLocationIntent(query, filepath, baseScore);
+    case "conceptual" /* CONCEPTUAL */:
+      return boostForConceptualIntent(query, filepath, baseScore);
+    case "implementation" /* IMPLEMENTATION */:
+      return boostForImplementationIntent(query, filepath, baseScore);
+    default:
+      return boostForImplementationIntent(query, filepath, baseScore);
+  }
+}
+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");
   }
-  return score;
 }
-function boostForImplementationIntent(query, filepath, baseScore) {
-  let score = baseScore;
-  score = boostFilenameRelevance(query, filepath, score);
-  score = boostPathRelevance(query, filepath, score);
-  if (isTestFile(filepath)) {
-    score *= 0.9;
+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");
   }
-  return score;
 }
-function applyRelevanceBoosting(query, filepath, baseScore) {
-  if (!query) {
-    return baseScore;
+async function updateFile(db, table, tableName, dbPath, filepath, vectors, metadatas, contents) {
+  if (!table) {
+    throw new DatabaseError("Vector database not initialized");
   }
-  const intent = classifyQueryIntent(query);
-  switch (intent) {
-    case "location" /* LOCATION */:
-      return boostForLocationIntent(query, filepath, baseScore);
-    case "conceptual" /* CONCEPTUAL */:
-      return boostForConceptualIntent(query, filepath, baseScore);
-    case "implementation" /* IMPLEMENTATION */:
-      return boostForImplementationIntent(query, filepath, baseScore);
-    default:
-      return boostForImplementationIntent(query, filepath, baseScore);
+  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"() {
@@ -2147,9 +3046,9 @@ var init_lancedb = __esm({
     init_types();
     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;
@@ -2158,9 +3057,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",
@@ -2188,150 +3087,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 : [""],
-              // 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 (!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,
-                // 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)
-            };
-          }).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.`,
@@ -2339,209 +3118,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,
-                // 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");
-        }
+        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 || []];
-            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) {
-                if (r.symbolType) {
-                  if (symbolType === "function") {
-                    return r.symbolType === "function" || r.symbolType === "method";
-                  } else if (symbolType === "class") {
-                    return r.symbolType === "class";
-                  } else if (symbolType === "interface") {
-                    return r.symbolType === "interface";
-                  }
-                  return false;
-                }
-                return nameMatches;
-              }
-              return nameMatches;
-            }
-            if (symbolType) {
-              if (r.symbolType) {
-                if (symbolType === "function") {
-                  return r.symbolType === "function" || r.symbolType === "method";
-                } else if (symbolType === "class") {
-                  return r.symbolType === "class";
-                } else if (symbolType === "interface") {
-                  return r.symbolType === "interface";
-                }
-                return false;
-              }
-              return symbols.length > 0 && symbols.some((s) => s.length > 0 && 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 || []
-                },
-                // 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");
-        }
+        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) {
@@ -2559,11 +3181,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;
@@ -2573,31 +3190,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;
@@ -2630,8 +3231,8 @@ 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"() {
@@ -2653,7 +3254,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.
@@ -2666,7 +3267,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(
@@ -2693,7 +3294,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,
@@ -2701,7 +3302,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}`);
         }
@@ -2838,7 +3439,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}`);
@@ -2867,8 +3468,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"() {
@@ -2880,7 +3481,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.
@@ -2888,7 +3489,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;
@@ -2900,7 +3501,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}`);
         }
@@ -3051,7 +3652,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();
@@ -3155,7 +3756,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;
@@ -3193,7 +3794,7 @@ 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;
@@ -3232,7 +3833,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}`);
@@ -3242,9 +3843,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);
@@ -3281,9 +3882,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}`);
@@ -3448,9 +4049,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();
@@ -3523,7 +4124,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...";
@@ -3612,8 +4213,8 @@ 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;
@@ -3647,7 +4248,7 @@ async function indexCodebase(options = {}) {
           }
         } catch (error) {
           if (options.verbose) {
-            console.error(chalk4.yellow(`
+            console.error(chalk5.yellow(`
 \u26A0\uFE0F  Skipping ${file}: ${error}`));
           }
           processedFiles++;
@@ -3687,7 +4288,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);
@@ -3722,11 +4323,10 @@ 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 fs7 from "fs/promises";
+import path7 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import inquirer from "inquirer";
 
 // src/utils/banner.ts
@@ -3788,12 +4388,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 = {
@@ -3815,8 +4514,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) {
@@ -3867,7 +4566,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",
@@ -3875,10 +4574,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 {
@@ -3926,8 +4625,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) {
@@ -3984,7 +4683,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",
@@ -3992,10 +4691,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 {
@@ -4006,9 +4705,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 {
@@ -4018,8 +4717,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++;
         }
@@ -4031,14 +4730,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 {
@@ -4056,8 +4755,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) {
@@ -4069,6 +4768,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)
@@ -4113,7 +4814,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",
@@ -4121,18 +4822,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 {
@@ -4141,8 +4842,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++;
         }
@@ -4153,14 +4854,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 {
     }
@@ -4206,7 +4907,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;
   }
@@ -4273,9 +4974,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)) {
@@ -4284,7 +4985,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);
     }
@@ -4294,44 +4995,44 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
 }
 
 // src/cli/init.ts
-init_constants();
 var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = path5.dirname(__filename3);
+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([
         {
@@ -4342,7 +5043,7 @@ async function createNewConfig(rootDir, options) {
         }
       ]);
       if (!useGeneric) {
-        console.log(chalk2.dim("Aborted."));
+        console.log(chalk3.dim("Aborted."));
         return;
       }
     }
@@ -4351,7 +5052,7 @@ async function createNewConfig(rootDir, options) {
       path: ".",
       enabled: true,
       config: {
-        include: ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        include: ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
         exclude: [
           "**/node_modules/**",
           "**/dist/**",
@@ -4365,16 +5066,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();
@@ -4389,14 +5090,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);
@@ -4418,7 +5119,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,
@@ -4439,23 +5140,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(__dirname3, "../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([
             {
@@ -4466,27 +5167,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"));
       }
     }
   }
@@ -4494,17 +5195,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([
     {
@@ -4527,155 +5228,115 @@ Customizing ${frameworkName} settings:`));
     exclude: answers.exclude
   };
 }
-async function upgradeConfig(configPath) {
-  try {
-    const existingContent = await fs5.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 fs5.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 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_version2();
-import chalk3 from "chalk";
-import fs9 from "fs/promises";
-import path9 from "path";
+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(),
@@ -4683,18 +5344,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";
@@ -4769,22 +5430,48 @@ var tools = [
   toMCPToolSchema(
     SemanticSearchSchema,
     "semantic_search",
-    "Search the codebase semantically for relevant code using natural language. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+    `Search codebase by MEANING, not text. USE THIS INSTEAD OF grep/ripgrep for finding implementations, features, or understanding how code works.
+
+Examples:
+- "Where is authentication handled?" \u2192 semantic_search({ query: "handles user authentication" })
+- "How does payment work?" \u2192 semantic_search({ query: "processes payment transactions" })
+
+Use natural language describing what the code DOES, not function names. For exact string matching, use grep instead.
+
+Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) for each match.`
   ),
   toMCPToolSchema(
     FindSimilarSchema,
     "find_similar",
-    "Find code similar to a given code snippet. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+    `Find code structurally similar to a given snippet. Use for:
+- Ensuring consistency when adding new code
+- Finding duplicate implementations
+- Refactoring similar patterns together
+
+Provide at least 10 characters of code to match against. Results include a relevance category for each match.`
   ),
   toMCPToolSchema(
     GetFileContextSchema,
     "get_file_context",
-    "Get all chunks and related context for a specific file. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+    `Get full context for a file including related code and dependencies.
+
+IMPORTANT: Call this BEFORE editing any file to understand:
+- What the file does
+- What depends on it
+- Related test files (via testAssociations)
+
+Results include a relevance category for each related chunk. Typical flow: semantic_search \u2192 find file \u2192 get_file_context \u2192 make changes.`
   ),
   toMCPToolSchema(
     ListFunctionsSchema,
     "list_functions",
-    "List functions, classes, and interfaces by name pattern and language"
+    `Fast symbol lookup by naming pattern. Use when searching by NAME, not behavior.
+
+Examples:
+- "Show all controllers" \u2192 list_functions({ pattern: ".*Controller.*" })
+- "Find service classes" \u2192 list_functions({ pattern: ".*Service$" })
+
+10x faster than semantic_search for structural/architectural queries. Use semantic_search instead when searching by what code DOES.`
   )
 ];
 
@@ -5324,36 +6011,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({
@@ -5362,7 +6049,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);
   }
 }