@liendev/lien 0.11.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,14 @@ var init_migration = __esm({
   "src/config/migration.ts"() {
     "use strict";
     init_schema();
+    init_constants();
+  }
+});
+
+// src/errors/codes.ts
+var init_codes = __esm({
+  "src/errors/codes.ts"() {
+    "use strict";
   }
 });
 
@@ -216,7 +269,7 @@ function wrapError(error, context, additionalContext) {
   const stack = error instanceof Error ? error.stack : void 0;
   const wrappedError = new LienError(
     `${context}: ${message}`,
-    "WRAPPED_ERROR",
+    "INTERNAL_ERROR" /* INTERNAL_ERROR */,
     additionalContext
   );
   if (stack) {
@@ -231,32 +284,61 @@ var LienError, ConfigError, EmbeddingError, DatabaseError;
 var init_errors = __esm({
   "src/errors/index.ts"() {
     "use strict";
+    init_codes();
+    init_codes();
     LienError = class extends Error {
-      constructor(message, code, context) {
+      constructor(message, code, context, severity = "medium", recoverable = true, retryable = false) {
         super(message);
         this.code = code;
         this.context = context;
+        this.severity = severity;
+        this.recoverable = recoverable;
+        this.retryable = retryable;
         this.name = "LienError";
         if (Error.captureStackTrace) {
           Error.captureStackTrace(this, this.constructor);
         }
       }
+      /**
+       * Serialize error to JSON for MCP responses
+       */
+      toJSON() {
+        return {
+          error: this.message,
+          code: this.code,
+          severity: this.severity,
+          recoverable: this.recoverable,
+          context: this.context
+        };
+      }
+      /**
+       * Check if this error is retryable
+       */
+      isRetryable() {
+        return this.retryable;
+      }
+      /**
+       * Check if this error is recoverable
+       */
+      isRecoverable() {
+        return this.recoverable;
+      }
     };
     ConfigError = class extends LienError {
       constructor(message, context) {
-        super(message, "CONFIG_ERROR", context);
+        super(message, "CONFIG_INVALID" /* CONFIG_INVALID */, context, "medium", true, false);
         this.name = "ConfigError";
       }
     };
     EmbeddingError = class extends LienError {
       constructor(message, context) {
-        super(message, "EMBEDDING_ERROR", context);
+        super(message, "EMBEDDING_GENERATION_FAILED" /* EMBEDDING_GENERATION_FAILED */, context, "high", true, true);
         this.name = "EmbeddingError";
       }
     };
     DatabaseError = class extends LienError {
       constructor(message, context) {
-        super(message, "DATABASE_ERROR", context);
+        super(message, "INTERNAL_ERROR" /* INTERNAL_ERROR */, context, "high", true, true);
         this.name = "DatabaseError";
       }
     };
@@ -839,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";
@@ -1269,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);
@@ -1304,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();
   }
 });
 
@@ -1570,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();
@@ -1655,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);
@@ -1710,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)
@@ -1783,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)
@@ -1813,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;
           });
@@ -1836,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)
@@ -1987,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, {
@@ -2026,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;
@@ -2586,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) {
@@ -2739,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();
@@ -3001,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++;
@@ -3081,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();
@@ -3106,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));
@@ -3675,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");
@@ -3821,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;
@@ -3909,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,
@@ -3946,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";
@@ -4082,82 +4707,85 @@ import { createRequire as createRequire3 } from "module";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { dirname as dirname3, join as join3 } from "path";
 
+// src/mcp/utils/zod-to-json-schema.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+function toMCPToolSchema(zodSchema, name, description) {
+  return {
+    name,
+    description,
+    inputSchema: zodToJsonSchema(zodSchema, {
+      target: "jsonSchema7",
+      $refStrategy: "none"
+    })
+  };
+}
+
+// src/mcp/schemas/search.schema.ts
+import { z } from "zod";
+var SemanticSearchSchema = z.object({
+  query: z.string().min(3, "Query must be at least 3 characters").max(500, "Query too long (max 500 characters)").describe(
+    "Natural language description of what you're looking for.\n\nUse full sentences describing functionality, not exact names.\n\nGood examples:\n  - 'handles user authentication'\n  - 'validates email format'\n  - 'processes payment transactions'\n\nBad examples:\n  - 'auth' (too vague)\n  - 'validateEmail' (use grep for exact names)"
+  ),
+  limit: z.number().int().min(1, "Limit must be at least 1").max(50, "Limit cannot exceed 50").default(5).describe(
+    "Number of results to return.\n\nDefault: 5\nIncrease to 10-15 for broad exploration."
+  )
+});
+
+// src/mcp/schemas/similarity.schema.ts
+import { z as z2 } from "zod";
+var FindSimilarSchema = z2.object({
+  code: z2.string().min(10, "Code snippet must be at least 10 characters").describe(
+    "Code snippet to find similar implementations for.\n\nProvide a representative code sample that demonstrates the pattern you want to find similar examples of in the codebase."
+  ),
+  limit: z2.number().int().min(1, "Limit must be at least 1").max(20, "Limit cannot exceed 20").default(5).describe(
+    "Number of similar code blocks to return.\n\nDefault: 5"
+  )
+});
+
+// src/mcp/schemas/file.schema.ts
+import { z as z3 } from "zod";
+var GetFileContextSchema = z3.object({
+  filepath: z3.string().min(1, "Filepath cannot be empty").describe(
+    "Relative path to file from workspace root.\n\nExample: 'src/components/Button.tsx'"
+  ),
+  includeRelated: z3.boolean().default(true).describe(
+    "Include semantically related chunks from nearby code.\n\nDefault: true\n\nWhen enabled, also returns related code from other files that are semantically similar to the target file's contents."
+  )
+});
+
+// src/mcp/schemas/symbols.schema.ts
+import { z as z4 } from "zod";
+var ListFunctionsSchema = z4.object({
+  pattern: z4.string().optional().describe(
+    "Regex pattern to match symbol names.\n\nExamples:\n  - '.*Controller.*' to find all Controllers\n  - 'handle.*' to find handlers\n  - '.*Service$' to find Services\n\nIf omitted, returns all symbols."
+  ),
+  language: z4.string().optional().describe(
+    "Filter by programming language.\n\nExamples: 'typescript', 'python', 'javascript', 'php'\n\nIf omitted, searches all languages."
+  )
+});
+
 // src/mcp/tools.ts
 var tools = [
-  {
-    name: "semantic_search",
-    description: "Search the codebase semantically for relevant code using natural language. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: 'Natural language search query (e.g., "authentication logic", "database connection handling")'
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results to return",
-          default: 5
-        }
-      },
-      required: ["query"]
-    }
-  },
-  {
-    name: "find_similar",
-    description: "Find code similar to a given code snippet. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        code: {
-          type: "string",
-          description: "Code snippet to find similar implementations"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results to return",
-          default: 5
-        }
-      },
-      required: ["code"]
-    }
-  },
-  {
-    name: "get_file_context",
-    description: "Get all chunks and related context for a specific file. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filepath: {
-          type: "string",
-          description: "Path to the file (relative to project root)"
-        },
-        includeRelated: {
-          type: "boolean",
-          description: "Include semantically related chunks from other files",
-          default: true
-        }
-      },
-      required: ["filepath"]
-    }
-  },
-  {
-    name: "list_functions",
-    description: "List functions, classes, and interfaces by name pattern and language",
-    inputSchema: {
-      type: "object",
-      properties: {
-        pattern: {
-          type: "string",
-          description: 'Regex pattern to match symbol names (e.g., ".*Service$", "handle.*")'
-        },
-        language: {
-          type: "string",
-          description: 'Language filter (e.g., "typescript", "python", "php")'
-        }
-      }
-    }
-  }
+  toMCPToolSchema(
+    SemanticSearchSchema,
+    "semantic_search",
+    "Search the codebase semantically for relevant code using natural language. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+  ),
+  toMCPToolSchema(
+    FindSimilarSchema,
+    "find_similar",
+    "Find code similar to a given code snippet. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+  ),
+  toMCPToolSchema(
+    GetFileContextSchema,
+    "get_file_context",
+    "Get all chunks and related context for a specific file. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+  ),
+  toMCPToolSchema(
+    ListFunctionsSchema,
+    "list_functions",
+    "List functions, classes, and interfaces by name pattern and language"
+  )
 ];
 
 // src/mcp/server.ts
@@ -4300,6 +4928,64 @@ var FileWatcher = class {
 
 // src/mcp/server.ts
 init_constants();
+
+// src/mcp/utils/tool-wrapper.ts
+init_errors();
+import { ZodError } from "zod";
+function wrapToolHandler(schema, handler) {
+  return async (args) => {
+    try {
+      const validated = schema.parse(args);
+      const result = await handler(validated);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    } catch (error) {
+      if (error instanceof ZodError) {
+        return {
+          isError: true,
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: "Invalid parameters",
+              code: "INVALID_INPUT" /* INVALID_INPUT */,
+              details: error.errors.map((e) => ({
+                field: e.path.join("."),
+                message: e.message
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+      if (error instanceof LienError) {
+        return {
+          isError: true,
+          content: [{
+            type: "text",
+            text: JSON.stringify(error.toJSON(), null, 2)
+          }]
+        };
+      }
+      console.error("Unexpected error in tool handler:", error);
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: error instanceof Error ? error.message : "Unknown error",
+            code: "INTERNAL_ERROR" /* INTERNAL_ERROR */
+          }, null, 2)
+        }]
+      };
+    }
+  };
+}
+
+// src/mcp/server.ts
+init_errors();
 var __filename4 = fileURLToPath4(import.meta.url);
 var __dirname4 = dirname3(__filename4);
 var require4 = createRequire3(import.meta.url);
@@ -4364,148 +5050,139 @@ async function startMCPServer(options) {
   }, VERSION_CHECK_INTERVAL_MS);
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    log(`Handling tool call: ${name}`);
     try {
-      log(`Handling tool call: ${name}`);
       switch (name) {
-        case "semantic_search": {
-          const query = args?.query;
-          const limit = args?.limit || 5;
-          log(`Searching for: "${query}"`);
-          await checkAndReconnect();
-          const queryEmbedding = await embeddings.embed(query);
-          const results = await vectorDB.search(queryEmbedding, limit, query);
-          log(`Found ${results.length} results`);
-          const response = {
-            indexInfo: getIndexMetadata(),
-            results
-          };
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(response, null, 2)
-              }
-            ]
-          };
-        }
-        case "find_similar": {
-          const code = args?.code;
-          const limit = args?.limit || 5;
-          log(`Finding similar code...`);
-          await checkAndReconnect();
-          const codeEmbedding = await embeddings.embed(code);
-          const results = await vectorDB.search(codeEmbedding, limit, code);
-          log(`Found ${results.length} similar chunks`);
-          const response = {
-            indexInfo: getIndexMetadata(),
-            results
-          };
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(response, null, 2)
-              }
-            ]
-          };
-        }
-        case "get_file_context": {
-          const filepath = args?.filepath;
-          const includeRelated = args?.includeRelated ?? true;
-          log(`Getting context for: ${filepath}`);
-          await checkAndReconnect();
-          const fileEmbedding = await embeddings.embed(filepath);
-          const allResults = await vectorDB.search(fileEmbedding, 50, filepath);
-          const fileChunks = allResults.filter(
-            (r) => r.metadata.file.includes(filepath) || filepath.includes(r.metadata.file)
-          );
-          let results = fileChunks;
-          if (includeRelated && fileChunks.length > 0) {
-            const relatedEmbedding = await embeddings.embed(fileChunks[0].content);
-            const related = await vectorDB.search(relatedEmbedding, 5, fileChunks[0].content);
-            const relatedOtherFiles = related.filter(
-              (r) => !r.metadata.file.includes(filepath) && !filepath.includes(r.metadata.file)
-            );
-            results = [...fileChunks, ...relatedOtherFiles];
-          }
-          log(`Found ${results.length} chunks`);
-          const response = {
-            indexInfo: getIndexMetadata(),
-            file: filepath,
-            chunks: results
-          };
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(response, null, 2)
+        case "semantic_search":
+          return await wrapToolHandler(
+            SemanticSearchSchema,
+            async (validatedArgs) => {
+              log(`Searching for: "${validatedArgs.query}"`);
+              await checkAndReconnect();
+              const queryEmbedding = await embeddings.embed(validatedArgs.query);
+              const results = await vectorDB.search(queryEmbedding, validatedArgs.limit, validatedArgs.query);
+              log(`Found ${results.length} results`);
+              return {
+                indexInfo: getIndexMetadata(),
+                results
+              };
+            }
+          )(args);
+        case "find_similar":
+          return await wrapToolHandler(
+            FindSimilarSchema,
+            async (validatedArgs) => {
+              log(`Finding similar code...`);
+              await checkAndReconnect();
+              const codeEmbedding = await embeddings.embed(validatedArgs.code);
+              const results = await vectorDB.search(codeEmbedding, validatedArgs.limit, validatedArgs.code);
+              log(`Found ${results.length} similar chunks`);
+              return {
+                indexInfo: getIndexMetadata(),
+                results
+              };
+            }
+          )(args);
+        case "get_file_context":
+          return await wrapToolHandler(
+            GetFileContextSchema,
+            async (validatedArgs) => {
+              log(`Getting context for: ${validatedArgs.filepath}`);
+              await checkAndReconnect();
+              const fileEmbedding = await embeddings.embed(validatedArgs.filepath);
+              const allResults = await vectorDB.search(fileEmbedding, 50, validatedArgs.filepath);
+              const fileChunks = allResults.filter(
+                (r) => r.metadata.file.includes(validatedArgs.filepath) || validatedArgs.filepath.includes(r.metadata.file)
+              );
+              let results = fileChunks;
+              if (validatedArgs.includeRelated && fileChunks.length > 0) {
+                const relatedEmbedding = await embeddings.embed(fileChunks[0].content);
+                const related = await vectorDB.search(relatedEmbedding, 5, fileChunks[0].content);
+                const relatedOtherFiles = related.filter(
+                  (r) => !r.metadata.file.includes(validatedArgs.filepath) && !validatedArgs.filepath.includes(r.metadata.file)
+                );
+                results = [...fileChunks, ...relatedOtherFiles];
               }
-            ]
-          };
-        }
-        case "list_functions": {
-          const pattern = args?.pattern;
-          const language = args?.language;
-          log("Listing functions with symbol metadata...");
-          await checkAndReconnect();
-          let results;
-          let usedMethod = "symbols";
-          try {
-            results = await vectorDB.querySymbols({
-              language,
-              pattern,
-              limit: 50
-            });
-            if (results.length === 0 && (language || pattern)) {
-              log("No symbol results, falling back to content scan...");
-              results = await vectorDB.scanWithFilter({
-                language,
-                pattern,
-                limit: 50
-              });
-              usedMethod = "content";
+              log(`Found ${results.length} chunks`);
+              return {
+                indexInfo: getIndexMetadata(),
+                file: validatedArgs.filepath,
+                chunks: results
+              };
             }
-          } catch (error) {
-            log(`Symbol query failed, falling back to content scan: ${error}`);
-            results = await vectorDB.scanWithFilter({
-              language,
-              pattern,
-              limit: 50
-            });
-            usedMethod = "content";
-          }
-          log(`Found ${results.length} matches using ${usedMethod} method`);
-          const response = {
-            indexInfo: getIndexMetadata(),
-            method: usedMethod,
-            results,
-            note: usedMethod === "content" ? 'Using content search. Run "lien reindex" to enable faster symbol-based queries.' : void 0
-          };
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(response, null, 2)
+          )(args);
+        case "list_functions":
+          return await wrapToolHandler(
+            ListFunctionsSchema,
+            async (validatedArgs) => {
+              log("Listing functions with symbol metadata...");
+              await checkAndReconnect();
+              let results;
+              let usedMethod = "symbols";
+              try {
+                results = await vectorDB.querySymbols({
+                  language: validatedArgs.language,
+                  pattern: validatedArgs.pattern,
+                  limit: 50
+                });
+                if (results.length === 0 && (validatedArgs.language || validatedArgs.pattern)) {
+                  log("No symbol results, falling back to content scan...");
+                  results = await vectorDB.scanWithFilter({
+                    language: validatedArgs.language,
+                    pattern: validatedArgs.pattern,
+                    limit: 50
+                  });
+                  usedMethod = "content";
+                }
+              } catch (error) {
+                log(`Symbol query failed, falling back to content scan: ${error}`);
+                results = await vectorDB.scanWithFilter({
+                  language: validatedArgs.language,
+                  pattern: validatedArgs.pattern,
+                  limit: 50
+                });
+                usedMethod = "content";
               }
-            ]
-          };
-        }
+              log(`Found ${results.length} matches using ${usedMethod} method`);
+              return {
+                indexInfo: getIndexMetadata(),
+                method: usedMethod,
+                results,
+                note: usedMethod === "content" ? 'Using content search. Run "lien reindex" to enable faster symbol-based queries.' : void 0
+              };
+            }
+          )(args);
         default:
-          throw new Error(`Unknown tool: ${name}`);
+          throw new LienError(
+            `Unknown tool: ${name}`,
+            "INVALID_INPUT" /* INVALID_INPUT */,
+            { requestedTool: name, availableTools: tools.map((t) => t.name) },
+            "medium",
+            false,
+            false
+          );
       }
     } catch (error) {
-      console.error(`Error handling tool call ${name}:`, error);
-      return {
-        content: [
-          {
+      if (error instanceof LienError) {
+        return {
+          isError: true,
+          content: [{
             type: "text",
-            text: JSON.stringify({
-              error: String(error),
-              tool: name
-            })
-          }
-        ],
-        isError: true
+            text: JSON.stringify(error.toJSON(), null, 2)
+          }]
+        };
+      }
+      console.error(`Unexpected error handling tool call ${name}:`, error);
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: error instanceof Error ? error.message : "Unknown error",
+            code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+            tool: name
+          }, null, 2)
+        }]
       };
     }
   });