@liendev/lien 0.12.0 → 0.13.0

package/dist/index.js

@@ -9,11 +9,39 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/version.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function getPackageVersion() {
+  return packageJson.version;
+}
+var __filename, __dirname, require2, packageJson;
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    require2 = createRequire(import.meta.url);
+    try {
+      packageJson = require2(join(__dirname, "../package.json"));
+    } catch {
+      try {
+        packageJson = require2(join(__dirname, "../../package.json"));
+      } catch {
+        console.warn("[Lien] Warning: Could not load package.json, using fallback version");
+        packageJson = { version: "0.0.0-unknown" };
+      }
+    }
+  }
+});
+
 // src/constants.ts
 var DEFAULT_CHUNK_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CONCURRENCY, DEFAULT_EMBEDDING_BATCH_SIZE, EMBEDDING_MICRO_BATCH_SIZE, VECTOR_DB_MAX_BATCH_SIZE, VECTOR_DB_MIN_BATCH_SIZE, EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL, DEFAULT_PORT, VERSION_CHECK_INTERVAL_MS, DEFAULT_GIT_POLL_INTERVAL_MS, DEFAULT_DEBOUNCE_MS, CURRENT_CONFIG_VERSION, INDEX_FORMAT_VERSION;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
+    init_version();
     DEFAULT_CHUNK_SIZE = 75;
     DEFAULT_CHUNK_OVERLAP = 10;
     DEFAULT_CONCURRENCY = 4;
@@ -27,8 +55,8 @@ var init_constants = __esm({
     VERSION_CHECK_INTERVAL_MS = 2e3;
     DEFAULT_GIT_POLL_INTERVAL_MS = 1e4;
     DEFAULT_DEBOUNCE_MS = 1e3;
-    CURRENT_CONFIG_VERSION = "0.3.0";
-    INDEX_FORMAT_VERSION = 1;
+    CURRENT_CONFIG_VERSION = getPackageVersion();
+    INDEX_FORMAT_VERSION = 2;
   }
 });
 
@@ -52,6 +80,12 @@ var init_schema = __esm({
         concurrency: DEFAULT_CONCURRENCY,
         embeddingBatchSize: DEFAULT_EMBEDDING_BATCH_SIZE
       },
+      chunking: {
+        useAST: true,
+        // AST-based chunking enabled by default (v0.13.0)
+        astFallback: "line-based"
+        // Fallback to line-based on errors
+      },
       mcp: {
         port: DEFAULT_PORT,
         transport: "stdio",
@@ -80,6 +114,10 @@ function deepMergeConfig(defaults, user) {
       ...defaults.core,
       ...user.core
     },
+    chunking: {
+      ...defaults.chunking,
+      ...user.chunking
+    },
     mcp: {
       ...defaults.mcp,
       ...user.mcp
@@ -125,7 +163,10 @@ function needsMigration(config) {
   if (!config) {
     return false;
   }
-  if (config.frameworks !== void 0) {
+  if (config.frameworks !== void 0 && !config.chunking) {
+    return true;
+  }
+  if (config.frameworks !== void 0 && config.chunking !== void 0) {
     return false;
   }
   if (config.indexing !== void 0) {
@@ -138,12 +179,16 @@ function needsMigration(config) {
 }
 function migrateConfig(oldConfig) {
   const newConfig = {
-    version: "0.3.0",
+    version: CURRENT_CONFIG_VERSION,
     core: {
-      chunkSize: oldConfig.indexing?.chunkSize ?? defaultConfig.core.chunkSize,
-      chunkOverlap: oldConfig.indexing?.chunkOverlap ?? defaultConfig.core.chunkOverlap,
-      concurrency: oldConfig.indexing?.concurrency ?? defaultConfig.core.concurrency,
-      embeddingBatchSize: oldConfig.indexing?.embeddingBatchSize ?? defaultConfig.core.embeddingBatchSize
+      chunkSize: oldConfig.indexing?.chunkSize ?? oldConfig.core?.chunkSize ?? defaultConfig.core.chunkSize,
+      chunkOverlap: oldConfig.indexing?.chunkOverlap ?? oldConfig.core?.chunkOverlap ?? defaultConfig.core.chunkOverlap,
+      concurrency: oldConfig.indexing?.concurrency ?? oldConfig.core?.concurrency ?? defaultConfig.core.concurrency,
+      embeddingBatchSize: oldConfig.indexing?.embeddingBatchSize ?? oldConfig.core?.embeddingBatchSize ?? defaultConfig.core.embeddingBatchSize
+    },
+    chunking: {
+      useAST: oldConfig.chunking?.useAST ?? defaultConfig.chunking.useAST,
+      astFallback: oldConfig.chunking?.astFallback ?? defaultConfig.chunking.astFallback
     },
     mcp: {
       port: oldConfig.mcp?.port ?? defaultConfig.mcp.port,
@@ -158,9 +203,9 @@ function migrateConfig(oldConfig) {
       enabled: oldConfig.fileWatching?.enabled ?? defaultConfig.fileWatching.enabled,
       debounceMs: oldConfig.fileWatching?.debounceMs ?? defaultConfig.fileWatching.debounceMs
     },
-    frameworks: []
+    frameworks: oldConfig.frameworks ?? []
   };
-  if (oldConfig.indexing) {
+  if (oldConfig.indexing && newConfig.frameworks.length === 0) {
     const genericFramework = {
       name: "generic",
       path: ".",
@@ -180,7 +225,7 @@ function migrateConfig(oldConfig) {
       }
     };
     newConfig.frameworks.push(genericFramework);
-  } else {
+  } else if (newConfig.frameworks.length === 0) {
     const genericFramework = {
       name: "generic",
       path: ".",
@@ -207,6 +252,7 @@ var init_migration = __esm({
   "src/config/migration.ts"() {
     "use strict";
     init_schema();
+    init_constants();
   }
 });
 
@@ -875,7 +921,7 @@ async function readVersionFile(indexPath) {
   }
 }
 var VERSION_FILE;
-var init_version = __esm({
+var init_version2 = __esm({
   "src/vectordb/version.ts"() {
     "use strict";
     VERSION_FILE = ".lien-index-version";
@@ -1305,9 +1351,501 @@ var init_symbol_extractor = __esm({
   }
 });
 
+// src/indexer/ast/parser.ts
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+import JavaScript from "tree-sitter-javascript";
+import { extname } from "path";
+function getParser(language) {
+  if (!parserCache.has(language)) {
+    const parser = new Parser();
+    const grammar = languageConfig[language];
+    if (!grammar) {
+      throw new Error(`No grammar available for language: ${language}`);
+    }
+    parser.setLanguage(grammar);
+    parserCache.set(language, parser);
+  }
+  return parserCache.get(language);
+}
+function detectLanguage2(filePath) {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  switch (ext) {
+    case "ts":
+    case "tsx":
+      return "typescript";
+    case "js":
+    case "jsx":
+    case "mjs":
+    case "cjs":
+      return "javascript";
+    default:
+      return null;
+  }
+}
+function isASTSupported(filePath) {
+  return detectLanguage2(filePath) !== null;
+}
+function parseAST(content, language) {
+  try {
+    const parser = getParser(language);
+    const tree = parser.parse(content);
+    if (tree.rootNode.hasError) {
+      return {
+        tree,
+        error: "Parse completed with errors"
+      };
+    }
+    return { tree };
+  } catch (error) {
+    return {
+      tree: null,
+      error: error instanceof Error ? error.message : "Unknown parse error"
+    };
+  }
+}
+var parserCache, languageConfig;
+var init_parser = __esm({
+  "src/indexer/ast/parser.ts"() {
+    "use strict";
+    parserCache = /* @__PURE__ */ new Map();
+    languageConfig = {
+      typescript: TypeScript.typescript,
+      javascript: JavaScript
+      // Use proper JavaScript parser
+    };
+  }
+});
+
+// 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}`
+    };
+  }
+  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 null;
+}
+function extractSignature(node, content) {
+  const startLine = node.startPosition.row;
+  const lines = content.split("\n");
+  let signature = lines[startLine] || "";
+  let currentLine = startLine;
+  while (currentLine < node.endPosition.row && !signature.includes("{") && !signature.includes("=>")) {
+    currentLine++;
+    signature += " " + (lines[currentLine] || "");
+  }
+  signature = signature.split("{")[0].split("=>")[0].trim();
+  if (signature.length > 200) {
+    signature = signature.substring(0, 197) + "...";
+  }
+  return signature;
+}
+function extractParameters(node, _content) {
+  const parameters = [];
+  const paramsNode = node.childForFieldName("parameters");
+  if (!paramsNode) return parameters;
+  for (let i = 0; i < paramsNode.namedChildCount; i++) {
+    const param = paramsNode.namedChild(i);
+    if (param) {
+      parameters.push(param.text);
+    }
+  }
+  return parameters;
+}
+function extractReturnType(node, _content) {
+  const returnTypeNode = node.childForFieldName("return_type");
+  if (!returnTypeNode) return void 0;
+  return returnTypeNode.text;
+}
+function calculateComplexity(node) {
+  let complexity = 1;
+  const decisionPoints = [
+    "if_statement",
+    "while_statement",
+    "do_statement",
+    // do...while loops
+    "for_statement",
+    "for_in_statement",
+    "for_of_statement",
+    // for...of loops
+    "switch_case",
+    "catch_clause",
+    "ternary_expression",
+    "binary_expression"
+    // For && and ||
+  ];
+  function traverse(n) {
+    if (decisionPoints.includes(n.type)) {
+      if (n.type === "binary_expression") {
+        const operator = n.childForFieldName("operator");
+        if (operator && (operator.text === "&&" || operator.text === "||")) {
+          complexity++;
+        }
+      } else {
+        complexity++;
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const child = n.namedChild(i);
+      if (child) traverse(child);
+    }
+  }
+  traverse(node);
+  return complexity;
+}
+function extractImports(rootNode) {
+  const imports = [];
+  function traverse(node) {
+    if (node.type === "import_statement") {
+      const sourceNode = node.childForFieldName("source");
+      if (sourceNode) {
+        const importPath = sourceNode.text.replace(/['"]/g, "");
+        imports.push(importPath);
+      }
+    }
+    if (node === rootNode) {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) traverse(child);
+      }
+    }
+  }
+  traverse(rootNode);
+  return imports;
+}
+var init_symbols = __esm({
+  "src/indexer/ast/symbols.ts"() {
+    "use strict";
+  }
+});
+
+// src/indexer/ast/chunker.ts
+function chunkByAST(filepath, content, options = {}) {
+  const { minChunkSize = 5 } = options;
+  const language = detectLanguage2(filepath);
+  if (!language) {
+    throw new Error(`Unsupported language for file: ${filepath}`);
+  }
+  const parseResult = parseAST(content, language);
+  if (!parseResult.tree) {
+    throw new Error(`Failed to parse ${filepath}: ${parseResult.error}`);
+  }
+  const chunks = [];
+  const lines = content.split("\n");
+  const rootNode = parseResult.tree.rootNode;
+  const fileImports = extractImports(rootNode);
+  const topLevelNodes = findTopLevelNodes(rootNode);
+  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;
+      }
+    }
+    let parentClassName;
+    if (actualNode.type === "method_definition") {
+      parentClassName = findParentClassName(actualNode);
+    }
+    const symbolInfo = extractSymbolInfo(actualNode, content, parentClassName);
+    const nodeContent = getNodeContent(node, lines);
+    chunks.push(createChunk(filepath, node, nodeContent, symbolInfo, fileImports, language));
+  }
+  const coveredRanges = topLevelNodes.map((n) => ({
+    start: n.startPosition.row,
+    end: n.endPosition.row
+  }));
+  const uncoveredChunks = extractUncoveredCode(
+    lines,
+    coveredRanges,
+    filepath,
+    minChunkSize,
+    fileImports,
+    language
+  );
+  chunks.push(...uncoveredChunks);
+  chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+  return chunks;
+}
+function 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) {
+  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) {
+        nodes.push(node);
+        return;
+      }
+    }
+    if (depth <= 1 && targetTypes.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 (body) {
+        traverse(body, depth + 1);
+      }
+      return;
+    }
+    if (node.type === "program" || node.type === "export_statement") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child) traverse(child, depth);
+      }
+    }
+  }
+  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;
+  return lines.slice(startLine, endLine + 1).join("\n");
+}
+function createChunk(filepath, node, content, symbolInfo, imports, language) {
+  const symbols = {
+    functions: [],
+    classes: [],
+    interfaces: []
+  };
+  if (symbolInfo?.name) {
+    if (symbolInfo.type === "function" || symbolInfo.type === "method") {
+      symbols.functions.push(symbolInfo.name);
+    } else if (symbolInfo.type === "class") {
+      symbols.classes.push(symbolInfo.name);
+    } else if (symbolInfo.type === "interface") {
+      symbols.interfaces.push(symbolInfo.name);
+    }
+  }
+  return {
+    content,
+    metadata: {
+      file: filepath,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      type: symbolInfo == null ? "block" : symbolInfo.type === "class" ? "class" : "function",
+      language,
+      // Legacy symbols field for backward compatibility
+      symbols,
+      // New AST-derived metadata
+      symbolName: symbolInfo?.name,
+      symbolType: symbolInfo?.type,
+      parentClass: symbolInfo?.parentClass,
+      complexity: symbolInfo?.complexity,
+      parameters: symbolInfo?.parameters,
+      signature: symbolInfo?.signature,
+      imports
+    }
+  };
+}
+function extractUncoveredCode(lines, coveredRanges, filepath, minChunkSize, imports, language) {
+  const chunks = [];
+  let currentStart = 0;
+  coveredRanges.sort((a, b) => a.start - b.start);
+  for (const range of coveredRanges) {
+    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
+          }
+        });
+      }
+    }
+    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) {
+      chunks.push({
+        content,
+        metadata: {
+          file: filepath,
+          startLine: currentStart + 1,
+          endLine: lines.length,
+          type: "block",
+          language,
+          // Empty symbols for uncovered code (imports, exports, etc.)
+          symbols: { functions: [], classes: [], interfaces: [] },
+          imports
+        }
+      });
+    }
+  }
+  return chunks;
+}
+function shouldUseAST(filepath) {
+  return isASTSupported(filepath);
+}
+var init_chunker = __esm({
+  "src/indexer/ast/chunker.ts"() {
+    "use strict";
+    init_parser();
+    init_symbols();
+  }
+});
+
 // src/indexer/chunker.ts
 function chunkFile(filepath, content, options = {}) {
-  const { chunkSize = 75, chunkOverlap = 10 } = options;
+  const { chunkSize = 75, chunkOverlap = 10, useAST = true, astFallback = "line-based" } = options;
+  if (useAST && shouldUseAST(filepath)) {
+    try {
+      return chunkByAST(filepath, content, {
+        minChunkSize: Math.floor(chunkSize / 10)
+      });
+    } catch (error) {
+      if (astFallback === "error") {
+        throw new Error(`AST chunking failed for ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      console.warn(`AST chunking failed for ${filepath}, falling back to line-based:`, error);
+    }
+  }
+  return chunkByLines(filepath, content, chunkSize, chunkOverlap);
+}
+function chunkByLines(filepath, content, chunkSize, chunkOverlap) {
   const lines = content.split("\n");
   const chunks = [];
   const language = detectLanguage(filepath);
@@ -1340,11 +1878,12 @@ function chunkFile(filepath, content, options = {}) {
   }
   return chunks;
 }
-var init_chunker = __esm({
+var init_chunker2 = __esm({
   "src/indexer/chunker.ts"() {
     "use strict";
     init_scanner();
     init_symbol_extractor();
+    init_chunker();
   }
 });
 
@@ -1606,7 +2145,7 @@ var init_lancedb = __esm({
   "src/vectordb/lancedb.ts"() {
     "use strict";
     init_types();
-    init_version();
+    init_version2();
     init_errors();
     init_relevance();
     init_intent_classifier();
@@ -1691,7 +2230,15 @@ var init_lancedb = __esm({
               // 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 : [""]
+              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);
@@ -1746,7 +2293,15 @@ var init_lancedb = __esm({
                 startLine: r.startLine,
                 endLine: r.endLine,
                 type: r.type,
-                language: r.language
+                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)
@@ -1819,7 +2374,15 @@ var init_lancedb = __esm({
                 startLine: r.startLine,
                 endLine: r.endLine,
                 type: r.type,
-                language: r.language
+                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)
@@ -1849,12 +2412,43 @@ var init_lancedb = __esm({
               return false;
             }
             const symbols = symbolType === "function" ? r.functionNames || [] : symbolType === "class" ? r.classNames || [] : symbolType === "interface" ? r.interfaceNames || [] : [...r.functionNames || [], ...r.classNames || [], ...r.interfaceNames || []];
-            if (symbols.length === 0) {
+            const astSymbolName = r.symbolName || "";
+            if (symbols.length === 0 && !astSymbolName) {
               return false;
             }
             if (pattern) {
               const regex = new RegExp(pattern, "i");
-              return symbols.some((s) => regex.test(s));
+              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;
           });
@@ -1872,7 +2466,15 @@ var init_lancedb = __esm({
                   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)
@@ -2023,33 +2625,6 @@ var init_lancedb = __esm({
   }
 });
 
-// src/utils/version.ts
-import { createRequire as createRequire2 } from "module";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname2, join as join2 } from "path";
-function getPackageVersion() {
-  return packageJson2.version;
-}
-var __filename3, __dirname3, require3, packageJson2;
-var init_version2 = __esm({
-  "src/utils/version.ts"() {
-    "use strict";
-    __filename3 = fileURLToPath3(import.meta.url);
-    __dirname3 = dirname2(__filename3);
-    require3 = createRequire2(import.meta.url);
-    try {
-      packageJson2 = require3(join2(__dirname3, "../package.json"));
-    } catch {
-      try {
-        packageJson2 = require3(join2(__dirname3, "../../package.json"));
-      } catch {
-        console.warn("[Lien] Warning: Could not load package.json, using fallback version");
-        packageJson2 = { version: "0.0.0-unknown" };
-      }
-    }
-  }
-});
-
 // src/indexer/manifest.ts
 var manifest_exports = {};
 __export(manifest_exports, {
@@ -2062,7 +2637,7 @@ var init_manifest = __esm({
   "src/indexer/manifest.ts"() {
     "use strict";
     init_constants();
-    init_version2();
+    init_version();
     MANIFEST_FILE = "manifest.json";
     ManifestManager = class {
       manifestPath;
@@ -2622,9 +3197,13 @@ import fs14 from "fs/promises";
 async function processFileContent(filepath, content, embeddings, config, verbose) {
   const chunkSize = isModernConfig(config) ? config.core.chunkSize : isLegacyConfig(config) ? config.indexing.chunkSize : 75;
   const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : isLegacyConfig(config) ? config.indexing.chunkOverlap : 10;
+  const useAST = isModernConfig(config) ? config.chunking.useAST : true;
+  const astFallback = isModernConfig(config) ? config.chunking.astFallback : "line-based";
   const chunks = chunkFile(filepath, content, {
     chunkSize,
-    chunkOverlap
+    chunkOverlap,
+    useAST,
+    astFallback
   });
   if (chunks.length === 0) {
     if (verbose) {
@@ -2775,7 +3354,7 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
 var init_incremental = __esm({
   "src/indexer/incremental.ts"() {
     "use strict";
-    init_chunker();
+    init_chunker2();
     init_schema();
     init_manifest();
     init_constants();
@@ -3037,9 +3616,13 @@ async function indexCodebase(options = {}) {
           const content = await fs15.readFile(file, "utf-8");
           const chunkSize = isModernConfig(config) ? config.core.chunkSize : 75;
           const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : 10;
+          const useAST = isModernConfig(config) ? config.chunking.useAST : true;
+          const astFallback = isModernConfig(config) ? config.chunking.astFallback : "line-based";
           const chunks = chunkFile(file, content, {
             chunkSize,
-            chunkOverlap
+            chunkOverlap,
+            useAST,
+            astFallback
           });
           if (chunks.length === 0) {
             processedFiles++;
@@ -3117,11 +3700,11 @@ var init_indexer = __esm({
   "src/indexer/index.ts"() {
     "use strict";
     init_scanner();
-    init_chunker();
+    init_chunker2();
     init_local();
     init_lancedb();
     init_service();
-    init_version();
+    init_version2();
     init_schema();
     init_manifest();
     init_change_detector();
@@ -3142,27 +3725,27 @@ init_schema();
 init_merge();
 import fs5 from "fs/promises";
 import path5 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import chalk2 from "chalk";
 import inquirer from "inquirer";
 
 // src/utils/banner.ts
 import figlet from "figlet";
 import chalk from "chalk";
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var require2 = createRequire(import.meta.url);
-var packageJson;
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var require3 = createRequire2(import.meta.url);
+var packageJson2;
 try {
-  packageJson = require2(join(__dirname, "../package.json"));
+  packageJson2 = require3(join2(__dirname2, "../package.json"));
 } catch {
-  packageJson = require2(join(__dirname, "../../package.json"));
+  packageJson2 = require3(join2(__dirname2, "../../package.json"));
 }
-var PACKAGE_NAME = packageJson.name;
-var VERSION = packageJson.version;
+var PACKAGE_NAME = packageJson2.name;
+var VERSION = packageJson2.version;
 function wrapInBox(text, footer, padding = 1) {
   const lines = text.split("\n").filter((line) => line.trim().length > 0);
   const maxLength = Math.max(...lines.map((line) => line.length));
@@ -3711,8 +4294,9 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
 }
 
 // src/cli/init.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path5.dirname(__filename2);
+init_constants();
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path5.dirname(__filename3);
 async function initCommand(options = {}) {
   const rootDir = options.path || process.cwd();
   const configPath = path5.join(rootDir, ".lien.config.json");
@@ -3857,7 +4441,7 @@ async function createNewConfig(rootDir, options) {
       try {
         const cursorRulesDir = path5.join(rootDir, ".cursor");
         await fs5.mkdir(cursorRulesDir, { recursive: true });
-        const templatePath = path5.join(__dirname2, "../CURSOR_RULES_TEMPLATE.md");
+        const templatePath = path5.join(__dirname3, "../CURSOR_RULES_TEMPLATE.md");
         const rulesPath = path5.join(cursorRulesDir, "rules");
         let targetPath;
         let isDirectory = false;
@@ -3945,23 +4529,28 @@ Customizing ${frameworkName} settings:`));
 }
 async function upgradeConfig(configPath) {
   try {
-    const backupPath = `${configPath}.backup`;
-    await fs5.copyFile(configPath, backupPath);
     const existingContent = await fs5.readFile(configPath, "utf-8");
     const existingConfig = JSON.parse(existingContent);
+    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 (needsMigration(existingConfig)) {
-      console.log(chalk2.blue("\u{1F504} Migrating config from v0.2.0 to v0.3.0..."));
+    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 {
-      const newFields = detectNewFields(existingConfig, defaultConfig);
       upgradedConfig = deepMergeConfig(defaultConfig, existingConfig);
-      if (newFields.length > 0) {
-        console.log(chalk2.dim("\nNew options added:"));
-        newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
-      }
+      console.log(chalk2.dim("\nNew options added:"));
+      newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
     }
     await fs5.writeFile(
       configPath,
@@ -3982,7 +4571,7 @@ async function upgradeConfig(configPath) {
 // src/cli/status.ts
 init_service();
 init_utils();
-init_version();
+init_version2();
 import chalk3 from "chalk";
 import fs9 from "fs/promises";
 import path9 from "path";