@liendev/lien 0.18.0 → 0.19.0

package/dist/index.js

@@ -56,7 +56,7 @@ var init_constants = __esm({
     DEFAULT_GIT_POLL_INTERVAL_MS = 1e4;
     DEFAULT_DEBOUNCE_MS = 1e3;
     CURRENT_CONFIG_VERSION = getPackageVersion();
-    INDEX_FORMAT_VERSION = 2;
+    INDEX_FORMAT_VERSION = 4;
   }
 });
 
@@ -100,6 +100,19 @@ var init_schema = __esm({
         // Enabled by default (fast with incremental indexing!)
         debounceMs: DEFAULT_DEBOUNCE_MS
       },
+      complexity: {
+        enabled: true,
+        thresholds: {
+          testPaths: 15,
+          // 🔀 Max test paths per function
+          mentalLoad: 15,
+          // 🧠 Max mental load score
+          timeToUnderstandMinutes: 60,
+          // ⏱️ Functions taking >1 hour to understand
+          estimatedBugs: 1.5
+          // 🐛 Functions estimated to have >1.5 bugs
+        }
+      },
       frameworks: []
       // Will be populated by lien init via framework detection
     };
@@ -260,6 +273,13 @@ function deepMergeConfig(defaults, user) {
       ...defaults.fileWatching,
       ...user.fileWatching
     },
+    complexity: user.complexity ? {
+      enabled: user.complexity.enabled ?? defaults.complexity?.enabled ?? true,
+      thresholds: {
+        ...defaults.complexity?.thresholds,
+        ...user.complexity.thresholds || {}
+      }
+    } : defaults.complexity,
     frameworks: user.frameworks ?? defaults.frameworks
   };
 }
@@ -1457,6 +1477,613 @@ var init_parser = __esm({
   }
 });
 
+// src/indexer/ast/complexity/cyclomatic.ts
+function calculateComplexity(node) {
+  let complexity = 1;
+  function traverse(n) {
+    if (DECISION_POINTS.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;
+}
+var DECISION_POINTS;
+var init_cyclomatic = __esm({
+  "src/indexer/ast/complexity/cyclomatic.ts"() {
+    "use strict";
+    DECISION_POINTS = [
+      // Common across languages (TypeScript/JavaScript/Python/PHP)
+      "if_statement",
+      // if conditions
+      "while_statement",
+      // while loops
+      "for_statement",
+      // for loops
+      "switch_case",
+      // switch/case statements
+      "catch_clause",
+      // try/catch error handling
+      "ternary_expression",
+      // Ternary operator (a ? b : c)
+      "binary_expression",
+      // For && and || logical operators
+      // TypeScript/JavaScript specific
+      "do_statement",
+      // do...while loops
+      "for_in_statement",
+      // for...in loops
+      "for_of_statement",
+      // for...of loops
+      // PHP specific
+      "foreach_statement",
+      // PHP foreach loops
+      // Python specific
+      "elif_clause",
+      // Python elif (adds decision point)
+      // Note: 'else_clause' is NOT a decision point (it's the default path)
+      "except_clause",
+      // Python except (try/except)
+      "conditional_expression"
+      // Python ternary (x if cond else y)
+    ];
+  }
+});
+
+// src/indexer/ast/complexity/cognitive.ts
+function getLogicalOperator(node) {
+  if (node.type !== "binary_expression" && node.type !== "boolean_operator") {
+    return null;
+  }
+  const operator = node.childForFieldName("operator");
+  const opText = operator?.text;
+  if (opText === "&&" || opText === "and") return "&&";
+  if (opText === "||" || opText === "or") return "||";
+  return null;
+}
+function getChildNestingLevel(parent, child, currentLevel) {
+  const isCondition = parent.childForFieldName("condition") === child;
+  const isElseClause = NON_NESTING_TYPES.has(child.type);
+  return !isCondition && !isElseClause ? currentLevel + 1 : currentLevel;
+}
+function getNestedLambdaIncrement(nodeType, nestingLevel) {
+  return LAMBDA_TYPES.has(nodeType) && nestingLevel > 0 ? 1 : 0;
+}
+function traverseLogicalChildren(n, level, op, ctx) {
+  const operator = n.childForFieldName("operator");
+  for (let i = 0; i < n.namedChildCount; i++) {
+    const child = n.namedChild(i);
+    if (child && child !== operator) ctx.traverse(child, level, op);
+  }
+}
+function traverseNestingChildren(n, level, ctx) {
+  for (let i = 0; i < n.namedChildCount; i++) {
+    const child = n.namedChild(i);
+    if (child) ctx.traverse(child, getChildNestingLevel(n, child, level), null);
+  }
+}
+function traverseAllChildren(n, level, ctx) {
+  for (let i = 0; i < n.namedChildCount; i++) {
+    const child = n.namedChild(i);
+    if (child) ctx.traverse(child, level, null);
+  }
+}
+function calculateCognitiveComplexity(node) {
+  let complexity = 0;
+  const ctx = { traverse };
+  function traverse(n, nestingLevel, lastLogicalOp) {
+    const logicalOp = getLogicalOperator(n);
+    if (logicalOp) {
+      complexity += lastLogicalOp !== logicalOp ? 1 : 0;
+      traverseLogicalChildren(n, nestingLevel, logicalOp, ctx);
+      return;
+    }
+    if (NESTING_TYPES.has(n.type)) {
+      complexity += 1 + nestingLevel;
+      traverseNestingChildren(n, nestingLevel, ctx);
+      return;
+    }
+    if (NON_NESTING_TYPES.has(n.type)) {
+      complexity += 1;
+      traverseAllChildren(n, nestingLevel + 1, ctx);
+      return;
+    }
+    complexity += getNestedLambdaIncrement(n.type, nestingLevel);
+    traverseAllChildren(n, nestingLevel, ctx);
+  }
+  traverse(node, 0, null);
+  return complexity;
+}
+var NESTING_TYPES, NON_NESTING_TYPES, LAMBDA_TYPES;
+var init_cognitive = __esm({
+  "src/indexer/ast/complexity/cognitive.ts"() {
+    "use strict";
+    NESTING_TYPES = /* @__PURE__ */ new Set([
+      "if_statement",
+      "for_statement",
+      "while_statement",
+      "switch_statement",
+      "catch_clause",
+      "except_clause",
+      "do_statement",
+      "for_in_statement",
+      "for_of_statement",
+      "foreach_statement",
+      "match_statement"
+    ]);
+    NON_NESTING_TYPES = /* @__PURE__ */ new Set([
+      "else_clause",
+      "elif_clause",
+      "ternary_expression",
+      "conditional_expression"
+    ]);
+    LAMBDA_TYPES = /* @__PURE__ */ new Set(["arrow_function", "function_expression", "lambda"]);
+  }
+});
+
+// src/indexer/ast/complexity/halstead.ts
+function getOperatorSymbols(language) {
+  return OPERATOR_SYMBOLS[language] || OPERATOR_SYMBOLS.typescript;
+}
+function getOperatorKeywords(language) {
+  return OPERATOR_KEYWORDS[language] || OPERATOR_KEYWORDS.typescript;
+}
+function isOperator(node, language) {
+  const nodeType = node.type;
+  const nodeText = node.text;
+  if (OPERATOR_NODE_TYPES.has(nodeType)) {
+    return true;
+  }
+  const symbols = getOperatorSymbols(language);
+  const keywords = getOperatorKeywords(language);
+  return symbols.has(nodeText) || keywords.has(nodeText);
+}
+function isOperand(node) {
+  return OPERAND_NODE_TYPES.has(node.type);
+}
+function getOperatorKey(node) {
+  if (OPERATOR_NODE_TYPES.has(node.type)) {
+    const operator = node.childForFieldName("operator");
+    if (operator) {
+      return operator.text;
+    }
+    return node.type;
+  }
+  return node.text;
+}
+function getOperandKey(node) {
+  return node.text;
+}
+function sumValues(map) {
+  let sum = 0;
+  for (const count of map.values()) {
+    sum += count;
+  }
+  return sum;
+}
+function countHalstead(node, language) {
+  const operators = /* @__PURE__ */ new Map();
+  const operands = /* @__PURE__ */ new Map();
+  function traverse(n) {
+    if (isOperator(n, language)) {
+      const key = getOperatorKey(n);
+      operators.set(key, (operators.get(key) || 0) + 1);
+    }
+    if (isOperand(n)) {
+      const key = getOperandKey(n);
+      operands.set(key, (operands.get(key) || 0) + 1);
+    }
+    for (const child of n.children) {
+      traverse(child);
+    }
+  }
+  traverse(node);
+  return {
+    n1: operators.size,
+    n2: operands.size,
+    N1: sumValues(operators),
+    N2: sumValues(operands),
+    operators,
+    operands
+  };
+}
+function calculateHalsteadMetrics(counts) {
+  const { n1, n2, N1, N2 } = counts;
+  const vocabulary = n1 + n2;
+  const length = N1 + N2;
+  const volume = vocabulary > 0 ? length * Math.log2(vocabulary) : 0;
+  const difficulty = n2 > 0 ? n1 / 2 * (N2 / n2) : 0;
+  const effort = difficulty * volume;
+  const time = effort / 18;
+  const bugs = volume / 3e3;
+  return {
+    vocabulary: Math.round(vocabulary),
+    length: Math.round(length),
+    volume: Math.round(volume * 100) / 100,
+    difficulty: Math.round(difficulty * 100) / 100,
+    effort: Math.round(effort),
+    time: Math.round(time),
+    bugs: Math.round(bugs * 1e3) / 1e3
+  };
+}
+function calculateHalstead(node, language) {
+  const counts = countHalstead(node, language);
+  return calculateHalsteadMetrics(counts);
+}
+var OPERATOR_SYMBOLS, OPERATOR_KEYWORDS, OPERATOR_NODE_TYPES, OPERAND_NODE_TYPES;
+var init_halstead = __esm({
+  "src/indexer/ast/complexity/halstead.ts"() {
+    "use strict";
+    OPERATOR_SYMBOLS = {
+      typescript: /* @__PURE__ */ new Set([
+        // Arithmetic
+        "+",
+        "-",
+        "*",
+        "/",
+        "%",
+        "**",
+        // Comparison
+        "==",
+        "===",
+        "!=",
+        "!==",
+        "<",
+        ">",
+        "<=",
+        ">=",
+        // Logical
+        "&&",
+        "||",
+        "!",
+        "??",
+        // Assignment
+        "=",
+        "+=",
+        "-=",
+        "*=",
+        "/=",
+        "%=",
+        "**=",
+        "&&=",
+        "||=",
+        "??=",
+        // Bitwise
+        "&",
+        "|",
+        "^",
+        "~",
+        "<<",
+        ">>",
+        ">>>",
+        "&=",
+        "|=",
+        "^=",
+        "<<=",
+        ">>=",
+        ">>>=",
+        // Other
+        "?",
+        ":",
+        ".",
+        "?.",
+        "++",
+        "--",
+        "...",
+        "=>",
+        // Brackets/parens (counted as operators)
+        "(",
+        ")",
+        "[",
+        "]",
+        "{",
+        "}"
+      ]),
+      python: /* @__PURE__ */ new Set([
+        // Arithmetic
+        "+",
+        "-",
+        "*",
+        "/",
+        "%",
+        "**",
+        "//",
+        // Comparison
+        "==",
+        "!=",
+        "<",
+        ">",
+        "<=",
+        ">=",
+        // Logical (handled via keywords below)
+        // Assignment
+        "=",
+        "+=",
+        "-=",
+        "*=",
+        "/=",
+        "%=",
+        "**=",
+        "//=",
+        "&=",
+        "|=",
+        "^=",
+        "<<=",
+        ">>=",
+        // Bitwise
+        "&",
+        "|",
+        "^",
+        "~",
+        "<<",
+        ">>",
+        // Other
+        ".",
+        ":",
+        "->",
+        "@",
+        "(",
+        ")",
+        "[",
+        "]",
+        "{",
+        "}"
+      ]),
+      php: /* @__PURE__ */ new Set([
+        // Arithmetic
+        "+",
+        "-",
+        "*",
+        "/",
+        "%",
+        "**",
+        // Comparison
+        "==",
+        "===",
+        "!=",
+        "!==",
+        "<>",
+        "<",
+        ">",
+        "<=",
+        ">=",
+        "<=>",
+        // Logical
+        "&&",
+        "||",
+        "!",
+        "and",
+        "or",
+        "xor",
+        // Assignment
+        "=",
+        "+=",
+        "-=",
+        "*=",
+        "/=",
+        "%=",
+        "**=",
+        ".=",
+        "&=",
+        "|=",
+        "^=",
+        "<<=",
+        ">>=",
+        "??=",
+        // Bitwise
+        "&",
+        "|",
+        "^",
+        "~",
+        "<<",
+        ">>",
+        // String
+        ".",
+        // Other
+        "?",
+        ":",
+        "::",
+        "->",
+        "=>",
+        "??",
+        "@",
+        "(",
+        ")",
+        "[",
+        "]",
+        "{",
+        "}"
+      ])
+    };
+    OPERATOR_KEYWORDS = {
+      typescript: /* @__PURE__ */ new Set([
+        "if",
+        "else",
+        "for",
+        "while",
+        "do",
+        "switch",
+        "case",
+        "default",
+        "return",
+        "throw",
+        "try",
+        "catch",
+        "finally",
+        "new",
+        "delete",
+        "typeof",
+        "instanceof",
+        "in",
+        "of",
+        "await",
+        "yield",
+        "break",
+        "continue",
+        "const",
+        "let",
+        "var",
+        "function",
+        "class",
+        "extends",
+        "implements",
+        "import",
+        "export",
+        "from",
+        "as"
+      ]),
+      python: /* @__PURE__ */ new Set([
+        "if",
+        "elif",
+        "else",
+        "for",
+        "while",
+        "match",
+        "case",
+        "return",
+        "raise",
+        "try",
+        "except",
+        "finally",
+        "and",
+        "or",
+        "not",
+        "is",
+        "in",
+        "await",
+        "yield",
+        "break",
+        "continue",
+        "pass",
+        "def",
+        "class",
+        "lambda",
+        "async",
+        "import",
+        "from",
+        "as",
+        "with",
+        "global",
+        "nonlocal",
+        "del",
+        "assert"
+      ]),
+      php: /* @__PURE__ */ new Set([
+        "if",
+        "elseif",
+        "else",
+        "for",
+        "foreach",
+        "while",
+        "do",
+        "switch",
+        "case",
+        "default",
+        "match",
+        "return",
+        "throw",
+        "try",
+        "catch",
+        "finally",
+        "new",
+        "clone",
+        "instanceof",
+        "yield",
+        "break",
+        "continue",
+        "function",
+        "class",
+        "extends",
+        "implements",
+        "trait",
+        "interface",
+        "use",
+        "namespace",
+        "as",
+        "echo",
+        "print",
+        "include",
+        "require",
+        "include_once",
+        "require_once",
+        "global",
+        "static",
+        "const",
+        "public",
+        "private",
+        "protected",
+        "readonly"
+      ])
+    };
+    OPERATOR_NODE_TYPES = /* @__PURE__ */ new Set([
+      // Expression operators
+      "binary_expression",
+      "unary_expression",
+      "update_expression",
+      "assignment_expression",
+      "augmented_assignment_expression",
+      "ternary_expression",
+      "conditional_expression",
+      // Call/access operators
+      "call_expression",
+      "method_call",
+      "member_expression",
+      "subscript_expression",
+      "attribute",
+      // Object/array literals ([] and {} are operators)
+      "array",
+      "object",
+      "dictionary",
+      "list"
+    ]);
+    OPERAND_NODE_TYPES = /* @__PURE__ */ new Set([
+      // Identifiers
+      "identifier",
+      "property_identifier",
+      "shorthand_property_identifier",
+      "variable_name",
+      "name",
+      // Literals
+      "number",
+      "integer",
+      "float",
+      "string",
+      "string_fragment",
+      "template_string",
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "none",
+      // Special
+      "this",
+      "self",
+      "super"
+    ]);
+  }
+});
+
+// src/indexer/ast/complexity/index.ts
+var init_complexity = __esm({
+  "src/indexer/ast/complexity/index.ts"() {
+    "use strict";
+    init_cyclomatic();
+    init_cognitive();
+    init_halstead();
+  }
+});
+
 // src/indexer/ast/symbols.ts
 function extractFunctionInfo(node, content, parentClass) {
   const nameNode = node.childForFieldName("name");
@@ -1592,62 +2219,6 @@ function extractReturnType(node, _content) {
   if (!returnTypeNode) return void 0;
   return returnTypeNode.text;
 }
-function calculateComplexity(node) {
-  let complexity = 1;
-  const decisionPoints = [
-    // Common across languages (TypeScript/JavaScript/Python/PHP)
-    "if_statement",
-    // if conditions
-    "while_statement",
-    // while loops
-    "for_statement",
-    // for loops
-    "switch_case",
-    // switch/case statements
-    "catch_clause",
-    // try/catch error handling
-    "ternary_expression",
-    // Ternary operator (a ? b : c)
-    "binary_expression",
-    // For && and || logical operators
-    // TypeScript/JavaScript specific
-    "do_statement",
-    // do...while loops
-    "for_in_statement",
-    // for...in loops
-    "for_of_statement",
-    // for...of loops
-    // PHP specific
-    "foreach_statement",
-    // PHP foreach loops
-    // Python specific
-    "elif_clause",
-    // Python elif (adds decision point)
-    // Note: 'else_clause' is NOT a decision point (it's the default path)
-    "except_clause",
-    // Python except (try/except)
-    "conditional_expression"
-    // Python ternary (x if cond else y)
-  ];
-  function traverse(n) {
-    if (decisionPoints.includes(n.type)) {
-      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) {
@@ -1678,6 +2249,7 @@ var symbolExtractors;
 var init_symbols = __esm({
   "src/indexer/ast/symbols.ts"() {
     "use strict";
+    init_complexity();
     symbolExtractors = {
       // TypeScript/JavaScript
       "function_declaration": extractFunctionInfo,
@@ -1989,32 +2561,29 @@ function chunkByAST(filepath, content, options = {}) {
   chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
   return chunks;
 }
+function isFunctionDeclaration(node, depth, traverser) {
+  if (depth !== 0 || !traverser.isDeclarationWithFunction(node)) return false;
+  return traverser.findFunctionInDeclaration(node).hasFunction;
+}
+function isTargetNode(node, depth, traverser) {
+  return depth <= 1 && traverser.targetNodeTypes.includes(node.type);
+}
 function findTopLevelNodes(rootNode, traverser) {
   const nodes = [];
   function traverse(node, depth) {
-    if (traverser.isDeclarationWithFunction(node) && depth === 0) {
-      const declInfo = traverser.findFunctionInDeclaration(node);
-      if (declInfo.hasFunction) {
-        nodes.push(node);
-        return;
-      }
-    }
-    if (depth <= 1 && traverser.targetNodeTypes.includes(node.type)) {
+    if (isFunctionDeclaration(node, depth, traverser) || isTargetNode(node, depth, traverser)) {
       nodes.push(node);
       return;
     }
     if (traverser.shouldExtractChildren(node)) {
       const body = traverser.getContainerBody(node);
-      if (body) {
-        traverse(body, depth + 1);
-      }
+      if (body) traverse(body, depth + 1);
       return;
     }
-    if (traverser.shouldTraverseChildren(node)) {
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child) traverse(child, depth);
-      }
+    if (!traverser.shouldTraverseChildren(node)) return;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) traverse(child, depth);
     }
   }
   traverse(rootNode, 0);
@@ -2025,39 +2594,45 @@ function getNodeContent(node, lines) {
   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);
-    }
+function buildLegacySymbols(symbolInfo) {
+  const symbols = { functions: [], classes: [], interfaces: [] };
+  if (symbolInfo?.name && symbolInfo.type) {
+    const arrayKey = SYMBOL_TYPE_TO_ARRAY[symbolInfo.type];
+    if (arrayKey) symbols[arrayKey].push(symbolInfo.name);
   }
+  return symbols;
+}
+function getChunkType(symbolInfo) {
+  if (!symbolInfo) return "block";
+  return symbolInfo.type === "class" ? "class" : "function";
+}
+function createChunk(filepath, node, content, symbolInfo, imports, language) {
+  const symbols = buildLegacySymbols(symbolInfo);
+  const shouldCalcComplexity = symbolInfo?.type && COMPLEXITY_SYMBOL_TYPES.has(symbolInfo.type);
+  const cognitiveComplexity = shouldCalcComplexity ? calculateCognitiveComplexity(node) : void 0;
+  const halstead = shouldCalcComplexity ? calculateHalstead(node, language) : void 0;
   return {
     content,
     metadata: {
       file: filepath,
       startLine: node.startPosition.row + 1,
       endLine: node.endPosition.row + 1,
-      type: symbolInfo == null ? "block" : symbolInfo.type === "class" ? "class" : "function",
+      type: getChunkType(symbolInfo),
       language,
-      // Legacy symbols field for backward compatibility
       symbols,
-      // New AST-derived metadata
       symbolName: symbolInfo?.name,
       symbolType: symbolInfo?.type,
       parentClass: symbolInfo?.parentClass,
       complexity: symbolInfo?.complexity,
+      cognitiveComplexity,
       parameters: symbolInfo?.parameters,
       signature: symbolInfo?.signature,
-      imports
+      imports,
+      // Halstead metrics
+      halsteadVolume: halstead?.volume,
+      halsteadDifficulty: halstead?.difficulty,
+      halsteadEffort: halstead?.effort,
+      halsteadBugs: halstead?.bugs
     }
   };
 }
@@ -2110,12 +2685,21 @@ function extractUncoveredCode(lines, coveredRanges, filepath, minChunkSize, impo
 function shouldUseAST(filepath) {
   return isASTSupported(filepath);
 }
+var SYMBOL_TYPE_TO_ARRAY, COMPLEXITY_SYMBOL_TYPES;
 var init_chunker = __esm({
   "src/indexer/ast/chunker.ts"() {
     "use strict";
     init_parser();
     init_symbols();
+    init_complexity();
     init_traversers();
+    SYMBOL_TYPE_TO_ARRAY = {
+      function: "functions",
+      method: "functions",
+      class: "classes",
+      interface: "interfaces"
+    };
+    COMPLEXITY_SYMBOL_TYPES = /* @__PURE__ */ new Set(["function", "method"]);
   }
 });
 
@@ -2778,6 +3362,46 @@ var init_boosting = __esm({
 });
 
 // src/vectordb/query.ts
+function isValidRecord(r) {
+  return Boolean(
+    r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
+  );
+}
+function hasValidArrayEntries(arr) {
+  return Boolean(arr && arr.length > 0 && arr[0] !== "");
+}
+function getSymbolsForType(r, symbolType) {
+  if (symbolType === "function") return r.functionNames || [];
+  if (symbolType === "class") return r.classNames || [];
+  if (symbolType === "interface") return r.interfaceNames || [];
+  return [
+    ...r.functionNames || [],
+    ...r.classNames || [],
+    ...r.interfaceNames || []
+  ];
+}
+function buildSearchResultMetadata(r) {
+  return {
+    file: r.file,
+    startLine: r.startLine,
+    endLine: r.endLine,
+    type: r.type,
+    language: r.language,
+    symbolName: r.symbolName || void 0,
+    symbolType: r.symbolType,
+    parentClass: r.parentClass || void 0,
+    complexity: r.complexity || void 0,
+    cognitiveComplexity: r.cognitiveComplexity || void 0,
+    parameters: hasValidArrayEntries(r.parameters) ? r.parameters : void 0,
+    signature: r.signature || void 0,
+    imports: hasValidArrayEntries(r.imports) ? r.imports : void 0,
+    // Halstead metrics (v0.19.0) - use explicit null check to preserve valid 0 values
+    halsteadVolume: r.halsteadVolume != null ? r.halsteadVolume : void 0,
+    halsteadDifficulty: r.halsteadDifficulty != null ? r.halsteadDifficulty : void 0,
+    halsteadEffort: r.halsteadEffort != null ? r.halsteadEffort : void 0,
+    halsteadBugs: r.halsteadBugs != null ? r.halsteadBugs : void 0
+  };
+}
 function applyRelevanceBoosting(query, filepath, baseScore) {
   if (!query) {
     return baseScore;
@@ -2790,21 +3414,7 @@ function dbRecordToSearchResult(r, query) {
   const boostedScore = applyRelevanceBoosting(query, r.file, baseScore);
   return {
     content: r.content,
-    metadata: {
-      file: r.file,
-      startLine: r.startLine,
-      endLine: r.endLine,
-      type: r.type,
-      language: r.language,
-      // AST-derived metadata (v0.13.0)
-      symbolName: r.symbolName || void 0,
-      symbolType: r.symbolType,
-      parentClass: r.parentClass || void 0,
-      complexity: r.complexity || void 0,
-      parameters: r.parameters && r.parameters.length > 0 && r.parameters[0] !== "" ? r.parameters : void 0,
-      signature: r.signature || void 0,
-      imports: r.imports && r.imports.length > 0 && r.imports[0] !== "" ? r.imports : void 0
-    },
+    metadata: buildSearchResultMetadata(r),
     score: boostedScore,
     relevance: calculateRelevance(boostedScore)
   };
@@ -2814,10 +3424,8 @@ async function search(table, queryVector, limit = 5, query) {
     throw new DatabaseError("Vector database not initialized");
   }
   try {
-    const results = await table.search(Array.from(queryVector)).limit(limit + 20).execute();
-    const filtered = results.filter(
-      (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
-    ).map((r) => dbRecordToSearchResult(r, query)).sort((a, b) => a.score - b.score).slice(0, limit);
+    const results = await table.search(Array.from(queryVector)).limit(limit + 20).toArray();
+    const filtered = results.filter(isValidRecord).map((r) => dbRecordToSearchResult(r, query)).sort((a, b) => a.score - b.score).slice(0, limit);
     return filtered;
   } catch (error) {
     const errorMsg = String(error);
@@ -2838,10 +3446,8 @@ async function scanWithFilter(table, options) {
   try {
     const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
     const query = table.search(zeroVector).where('file != ""').limit(Math.max(limit * 5, 200));
-    const results = await query.execute();
-    let filtered = results.filter(
-      (r) => r.content && r.content.trim().length > 0 && r.file && r.file.length > 0
-    );
+    const results = await query.toArray();
+    let filtered = results.filter(isValidRecord);
     if (language) {
       filtered = filtered.filter(
         (r) => r.language && r.language.toLowerCase() === language.toLowerCase()
@@ -2853,119 +3459,89 @@ async function scanWithFilter(table, options) {
         (r) => regex.test(r.content) || regex.test(r.file)
       );
     }
-    return filtered.slice(0, limit).map((r) => {
-      const score = 0;
-      return {
-        content: r.content,
-        metadata: {
-          file: r.file,
-          startLine: r.startLine,
-          endLine: r.endLine,
-          type: r.type,
-          language: r.language,
-          // AST-derived metadata (v0.13.0)
-          symbolName: r.symbolName || void 0,
-          symbolType: r.symbolType,
-          parentClass: r.parentClass || void 0,
-          complexity: r.complexity || void 0,
-          parameters: r.parameters && r.parameters.length > 0 && r.parameters[0] !== "" ? r.parameters : void 0,
-          signature: r.signature || void 0,
-          imports: r.imports && r.imports.length > 0 && r.imports[0] !== "" ? r.imports : void 0
-        },
-        score,
-        relevance: calculateRelevance(score)
-      };
-    });
+    return filtered.slice(0, limit).map((r) => ({
+      content: r.content,
+      metadata: buildSearchResultMetadata(r),
+      score: 0,
+      relevance: calculateRelevance(0)
+    }));
   } catch (error) {
     throw wrapError(error, "Failed to scan with filter");
   }
 }
 function matchesSymbolType(record, symbolType, symbols) {
   if (record.symbolType) {
-    if (symbolType === "function") {
-      return record.symbolType === "function" || record.symbolType === "method";
-    } else if (symbolType === "class") {
-      return record.symbolType === "class";
-    } else if (symbolType === "interface") {
-      return record.symbolType === "interface";
-    }
-    return false;
+    return SYMBOL_TYPE_MATCHES[symbolType]?.has(record.symbolType) ?? false;
   }
   return symbols.length > 0 && symbols.some((s) => s.length > 0 && s !== "");
 }
+function matchesSymbolFilter(r, { language, pattern, symbolType }) {
+  if (language && (!r.language || r.language.toLowerCase() !== language.toLowerCase())) {
+    return false;
+  }
+  const symbols = getSymbolsForType(r, symbolType);
+  const astSymbolName = r.symbolName || "";
+  if (symbols.length === 0 && !astSymbolName) {
+    return false;
+  }
+  if (pattern) {
+    const regex = new RegExp(pattern, "i");
+    const nameMatches = symbols.some((s) => regex.test(s)) || regex.test(astSymbolName);
+    if (!nameMatches) return false;
+  }
+  if (symbolType) {
+    return matchesSymbolType(r, symbolType, symbols);
+  }
+  return true;
+}
+function buildLegacySymbols2(r) {
+  return {
+    functions: hasValidArrayEntries(r.functionNames) ? r.functionNames : [],
+    classes: hasValidArrayEntries(r.classNames) ? r.classNames : [],
+    interfaces: hasValidArrayEntries(r.interfaceNames) ? r.interfaceNames : []
+  };
+}
 async function querySymbols(table, options) {
   if (!table) {
     throw new DatabaseError("Vector database not initialized");
   }
   const { language, pattern, symbolType, limit = 50 } = options;
+  const filterOpts = { language, pattern, symbolType };
   try {
     const zeroVector = Array(EMBEDDING_DIMENSION).fill(0);
     const query = table.search(zeroVector).where('file != ""').limit(Math.max(limit * 10, 500));
-    const results = await query.execute();
-    let filtered = results.filter((r) => {
-      if (!r.content || r.content.trim().length === 0) {
-        return false;
-      }
-      if (!r.file || r.file.length === 0) {
-        return false;
-      }
-      if (language && (!r.language || r.language.toLowerCase() !== language.toLowerCase())) {
-        return false;
-      }
-      const symbols = symbolType === "function" ? r.functionNames || [] : symbolType === "class" ? r.classNames || [] : symbolType === "interface" ? r.interfaceNames || [] : [...r.functionNames || [], ...r.classNames || [], ...r.interfaceNames || []];
-      const astSymbolName = r.symbolName || "";
-      if (symbols.length === 0 && !astSymbolName) {
-        return false;
-      }
-      if (pattern) {
-        const regex = new RegExp(pattern, "i");
-        const matchesOldSymbols = symbols.some((s) => regex.test(s));
-        const matchesASTSymbol = regex.test(astSymbolName);
-        const nameMatches = matchesOldSymbols || matchesASTSymbol;
-        if (!nameMatches) return false;
-        if (symbolType) {
-          return matchesSymbolType(r, symbolType, symbols);
-        }
-        return nameMatches;
-      }
-      if (symbolType) {
-        return matchesSymbolType(r, symbolType, symbols);
-      }
-      return true;
-    });
-    return filtered.slice(0, limit).map((r) => {
-      const score = 0;
-      return {
-        content: r.content,
-        metadata: {
-          file: r.file,
-          startLine: r.startLine,
-          endLine: r.endLine,
-          type: r.type,
-          language: r.language,
-          symbols: {
-            functions: r.functionNames && r.functionNames.length > 0 && r.functionNames[0] !== "" ? r.functionNames : [],
-            classes: r.classNames && r.classNames.length > 0 && r.classNames[0] !== "" ? r.classNames : [],
-            interfaces: r.interfaceNames && r.interfaceNames.length > 0 && r.interfaceNames[0] !== "" ? r.interfaceNames : []
-          },
-          // AST-derived metadata (v0.13.0)
-          symbolName: r.symbolName || void 0,
-          symbolType: r.symbolType,
-          parentClass: r.parentClass || void 0,
-          complexity: r.complexity || void 0,
-          parameters: r.parameters && r.parameters.length > 0 && r.parameters[0] !== "" ? r.parameters : void 0,
-          signature: r.signature || void 0,
-          imports: r.imports && r.imports.length > 0 && r.imports[0] !== "" ? r.imports : void 0
-        },
-        score,
-        relevance: calculateRelevance(score)
-      };
-    });
+    const results = await query.toArray();
+    const filtered = results.filter((r) => isValidRecord(r) && matchesSymbolFilter(r, filterOpts));
+    return filtered.slice(0, limit).map((r) => ({
+      content: r.content,
+      metadata: {
+        ...buildSearchResultMetadata(r),
+        symbols: buildLegacySymbols2(r)
+      },
+      score: 0,
+      relevance: calculateRelevance(0)
+    }));
   } catch (error) {
     throw wrapError(error, "Failed to query symbols");
   }
 }
-var PATH_STRATEGY, FILENAME_STRATEGY, FILE_TYPE_STRATEGIES, BOOSTING_COMPOSERS;
+async function scanAll(table, options = {}) {
+  if (!table) {
+    throw new DatabaseError("Vector database not initialized");
+  }
+  try {
+    const totalRows = await table.countRows();
+    const MIN_SCAN_LIMIT = 1e3;
+    const results = await scanWithFilter(table, {
+      ...options,
+      limit: Math.max(totalRows, MIN_SCAN_LIMIT)
+    });
+    return results;
+  } catch (error) {
+    throw wrapError(error, "Failed to scan all chunks");
+  }
+}
+var PATH_STRATEGY, FILENAME_STRATEGY, FILE_TYPE_STRATEGIES, BOOSTING_COMPOSERS, SYMBOL_TYPE_MATCHES;
 var init_query = __esm({
   "src/vectordb/query.ts"() {
     "use strict";
@@ -2986,10 +3562,67 @@ var init_query = __esm({
       ["conceptual" /* CONCEPTUAL */]: new BoostingComposer().addStrategy(PATH_STRATEGY).addStrategy(FILENAME_STRATEGY).addStrategy(FILE_TYPE_STRATEGIES["conceptual" /* CONCEPTUAL */]),
       ["implementation" /* IMPLEMENTATION */]: new BoostingComposer().addStrategy(PATH_STRATEGY).addStrategy(FILENAME_STRATEGY).addStrategy(FILE_TYPE_STRATEGIES["implementation" /* IMPLEMENTATION */])
     };
+    SYMBOL_TYPE_MATCHES = {
+      function: /* @__PURE__ */ new Set(["function", "method"]),
+      class: /* @__PURE__ */ new Set(["class"]),
+      interface: /* @__PURE__ */ new Set(["interface"])
+    };
   }
 });
 
 // src/vectordb/batch-insert.ts
+function transformChunkToRecord(vector, content, metadata) {
+  return {
+    vector: Array.from(vector),
+    content,
+    file: metadata.file,
+    startLine: metadata.startLine,
+    endLine: metadata.endLine,
+    type: metadata.type,
+    language: metadata.language,
+    // Ensure arrays have at least empty string for Arrow type inference
+    functionNames: getNonEmptyArray(metadata.symbols?.functions),
+    classNames: getNonEmptyArray(metadata.symbols?.classes),
+    interfaceNames: getNonEmptyArray(metadata.symbols?.interfaces),
+    // AST-derived metadata (v0.13.0)
+    symbolName: metadata.symbolName || "",
+    symbolType: metadata.symbolType || "",
+    parentClass: metadata.parentClass || "",
+    complexity: metadata.complexity || 0,
+    cognitiveComplexity: metadata.cognitiveComplexity || 0,
+    parameters: getNonEmptyArray(metadata.parameters),
+    signature: metadata.signature || "",
+    imports: getNonEmptyArray(metadata.imports),
+    // Halstead metrics (v0.19.0)
+    halsteadVolume: metadata.halsteadVolume || 0,
+    halsteadDifficulty: metadata.halsteadDifficulty || 0,
+    halsteadEffort: metadata.halsteadEffort || 0,
+    halsteadBugs: metadata.halsteadBugs || 0
+  };
+}
+function getNonEmptyArray(arr) {
+  return arr && arr.length > 0 ? arr : [""];
+}
+function splitBatchInHalf(batch) {
+  const half = Math.floor(batch.vectors.length / 2);
+  return [
+    {
+      vectors: batch.vectors.slice(0, half),
+      metadatas: batch.metadatas.slice(0, half),
+      contents: batch.contents.slice(0, half)
+    },
+    {
+      vectors: batch.vectors.slice(half),
+      metadatas: batch.metadatas.slice(half),
+      contents: batch.contents.slice(half)
+    }
+  ];
+}
+function transformBatchToRecords(batch) {
+  return batch.vectors.map(
+    (vector, i) => transformChunkToRecord(vector, batch.contents[i], batch.metadatas[i])
+  );
+}
 async function insertBatch(db, table, tableName, vectors, metadatas, contents) {
   if (!db) {
     throw new DatabaseError("Vector database not initialized");
@@ -3022,72 +3655,60 @@ async function insertBatch(db, table, tableName, vectors, metadatas, contents) {
 }
 async function insertBatchInternal(db, table, tableName, vectors, metadatas, contents) {
   const queue = [{ vectors, metadatas, contents }];
-  const failedRecords = [];
+  const failedBatches = [];
   let currentTable = table;
+  let lastError;
   while (queue.length > 0) {
     const batch = queue.shift();
-    if (!batch) break;
-    try {
-      const records = batch.vectors.map((vector, i) => ({
-        vector: Array.from(vector),
-        content: batch.contents[i],
-        file: batch.metadatas[i].file,
-        startLine: batch.metadatas[i].startLine,
-        endLine: batch.metadatas[i].endLine,
-        type: batch.metadatas[i].type,
-        language: batch.metadatas[i].language,
-        // Ensure arrays have at least empty string for Arrow type inference
-        functionNames: batch.metadatas[i].symbols?.functions && batch.metadatas[i].symbols.functions.length > 0 ? batch.metadatas[i].symbols.functions : [""],
-        classNames: batch.metadatas[i].symbols?.classes && batch.metadatas[i].symbols.classes.length > 0 ? batch.metadatas[i].symbols.classes : [""],
-        interfaceNames: batch.metadatas[i].symbols?.interfaces && batch.metadatas[i].symbols.interfaces.length > 0 ? batch.metadatas[i].symbols.interfaces : [""],
-        // AST-derived metadata (v0.13.0)
-        symbolName: batch.metadatas[i].symbolName || "",
-        symbolType: batch.metadatas[i].symbolType || "",
-        parentClass: batch.metadatas[i].parentClass || "",
-        complexity: batch.metadatas[i].complexity || 0,
-        parameters: batch.metadatas[i].parameters && batch.metadatas[i].parameters.length > 0 ? batch.metadatas[i].parameters : [""],
-        signature: batch.metadatas[i].signature || "",
-        imports: batch.metadatas[i].imports && batch.metadatas[i].imports.length > 0 ? batch.metadatas[i].imports : [""]
-      }));
-      if (!currentTable) {
-        currentTable = await db.createTable(tableName, records);
-      } else {
-        await currentTable.add(records);
-      }
-    } catch (error) {
-      if (batch.vectors.length > VECTOR_DB_MIN_BATCH_SIZE) {
-        const half = Math.floor(batch.vectors.length / 2);
-        queue.push({
-          vectors: batch.vectors.slice(0, half),
-          metadatas: batch.metadatas.slice(0, half),
-          contents: batch.contents.slice(0, half)
-        });
-        queue.push({
-          vectors: batch.vectors.slice(half),
-          metadatas: batch.metadatas.slice(half),
-          contents: batch.contents.slice(half)
-        });
-      } else {
-        failedRecords.push(batch);
-      }
+    const insertResult = await tryInsertBatch(db, currentTable, tableName, batch);
+    if (insertResult.success) {
+      currentTable = insertResult.table;
+    } else {
+      lastError = insertResult.error;
+      handleBatchFailure(batch, queue, failedBatches);
     }
   }
-  if (failedRecords.length > 0) {
-    const totalFailed = failedRecords.reduce((sum, batch) => sum + batch.vectors.length, 0);
-    throw new DatabaseError(
-      `Failed to insert ${totalFailed} record(s) after retry attempts`,
-      {
-        failedBatches: failedRecords.length,
-        totalRecords: totalFailed,
-        sampleFile: failedRecords[0].metadatas[0].file
-      }
-    );
-  }
+  throwIfBatchesFailed(failedBatches, lastError);
   if (!currentTable) {
     throw new DatabaseError("Failed to create table during batch insert");
   }
   return currentTable;
 }
+async function tryInsertBatch(db, currentTable, tableName, batch) {
+  try {
+    const records = transformBatchToRecords(batch);
+    if (!currentTable) {
+      const newTable = await db.createTable(tableName, records);
+      return { success: true, table: newTable };
+    } else {
+      await currentTable.add(records);
+      return { success: true, table: currentTable };
+    }
+  } catch (error) {
+    return { success: false, table: currentTable, error };
+  }
+}
+function handleBatchFailure(batch, queue, failedBatches) {
+  if (batch.vectors.length > VECTOR_DB_MIN_BATCH_SIZE) {
+    const [firstHalf, secondHalf] = splitBatchInHalf(batch);
+    queue.push(firstHalf, secondHalf);
+  } else {
+    failedBatches.push(batch);
+  }
+}
+function throwIfBatchesFailed(failedBatches, lastError) {
+  if (failedBatches.length === 0) return;
+  const totalFailed = failedBatches.reduce((sum, batch) => sum + batch.vectors.length, 0);
+  throw new DatabaseError(
+    `Failed to insert ${totalFailed} record(s) after retry attempts`,
+    {
+      failedBatches: failedBatches.length,
+      totalRecords: totalFailed,
+      sampleFile: failedBatches[0].metadatas[0].file,
+      lastError: lastError?.message
+    }
+  );
+}
 var init_batch_insert = __esm({
   "src/vectordb/batch-insert.ts"() {
     "use strict";
@@ -3097,7 +3718,9 @@ var init_batch_insert = __esm({
 });
 
 // src/vectordb/maintenance.ts
-async function clear(db, table, tableName) {
+import fs14 from "fs/promises";
+import path15 from "path";
+async function clear(db, table, tableName, dbPath) {
   if (!db) {
     throw new DatabaseError("Vector database not initialized");
   }
@@ -3105,6 +3728,13 @@ async function clear(db, table, tableName) {
     if (table) {
       await db.dropTable(tableName);
     }
+    if (dbPath) {
+      const lanceDir = path15.join(dbPath, `${tableName}.lance`);
+      try {
+        await fs14.rm(lanceDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
   } catch (error) {
     throw wrapError(error, "Failed to clear vector database");
   }
@@ -3152,8 +3782,8 @@ var lancedb_exports = {};
 __export(lancedb_exports, {
   VectorDB: () => VectorDB
 });
-import * as lancedb from "vectordb";
-import path15 from "path";
+import * as lancedb from "@lancedb/lancedb";
+import path16 from "path";
 import os2 from "os";
 import crypto2 from "crypto";
 var VectorDB;
@@ -3174,9 +3804,9 @@ var init_lancedb = __esm({
       lastVersionCheck = 0;
       currentVersion = 0;
       constructor(projectRoot) {
-        const projectName = path15.basename(projectRoot);
+        const projectName = path16.basename(projectRoot);
         const pathHash = crypto2.createHash("md5").update(projectRoot).digest("hex").substring(0, 8);
-        this.dbPath = path15.join(
+        this.dbPath = path16.join(
           os2.homedir(),
           ".lien",
           "indices",
@@ -3244,6 +3874,18 @@ var init_lancedb = __esm({
         }
         return scanWithFilter(this.table, options);
       }
+      /**
+       * Scan all chunks in the database
+       * Fetches total count first, then retrieves all chunks in a single optimized query
+       * @param options - Filter options (language, pattern)
+       * @returns All matching chunks
+       */
+      async scanAll(options = {}) {
+        if (!this.table) {
+          throw new DatabaseError("Vector database not initialized");
+        }
+        return scanAll(this.table, options);
+      }
       async querySymbols(options) {
         if (!this.table) {
           throw new DatabaseError("Vector database not initialized");
@@ -3254,7 +3896,7 @@ var init_lancedb = __esm({
         if (!this.db) {
           throw new DatabaseError("Vector database not initialized");
         }
-        await clear(this.db, this.table, this.tableName);
+        await clear(this.db, this.table, this.tableName, this.dbPath);
         this.table = null;
       }
       async deleteByFile(filepath) {
@@ -3325,7 +3967,7 @@ var init_lancedb = __esm({
           if (count === 0) {
             return false;
           }
-          const sample = await this.table.search(Array(EMBEDDING_DIMENSION).fill(0)).limit(Math.min(count, 5)).execute();
+          const sample = await this.table.search(Array(EMBEDDING_DIMENSION).fill(0)).limit(Math.min(count, 5)).toArray();
           const hasRealData = sample.some(
             (r) => r.content && r.content.trim().length > 0
           );
@@ -3348,8 +3990,8 @@ var manifest_exports = {};
 __export(manifest_exports, {
   ManifestManager: () => ManifestManager
 });
-import fs14 from "fs/promises";
-import path16 from "path";
+import fs15 from "fs/promises";
+import path17 from "path";
 var MANIFEST_FILE, ManifestManager;
 var init_manifest = __esm({
   "src/indexer/manifest.ts"() {
@@ -3371,7 +4013,7 @@ var init_manifest = __esm({
        */
       constructor(indexPath) {
         this.indexPath = indexPath;
-        this.manifestPath = path16.join(indexPath, MANIFEST_FILE);
+        this.manifestPath = path17.join(indexPath, MANIFEST_FILE);
       }
       /**
        * Loads the manifest from disk.
@@ -3384,7 +4026,7 @@ var init_manifest = __esm({
        */
       async load() {
         try {
-          const content = await fs14.readFile(this.manifestPath, "utf-8");
+          const content = await fs15.readFile(this.manifestPath, "utf-8");
           const manifest = JSON.parse(content);
           if (manifest.formatVersion !== INDEX_FORMAT_VERSION) {
             console.error(
@@ -3411,7 +4053,7 @@ var init_manifest = __esm({
        */
       async save(manifest) {
         try {
-          await fs14.mkdir(this.indexPath, { recursive: true });
+          await fs15.mkdir(this.indexPath, { recursive: true });
           const manifestToSave = {
             ...manifest,
             formatVersion: INDEX_FORMAT_VERSION,
@@ -3419,7 +4061,7 @@ var init_manifest = __esm({
             lastIndexed: Date.now()
           };
           const content = JSON.stringify(manifestToSave, null, 2);
-          await fs14.writeFile(this.manifestPath, content, "utf-8");
+          await fs15.writeFile(this.manifestPath, content, "utf-8");
         } catch (error) {
           console.error(`[Lien] Warning: Failed to save manifest: ${error}`);
         }
@@ -3556,7 +4198,7 @@ var init_manifest = __esm({
        */
       async clear() {
         try {
-          await fs14.unlink(this.manifestPath);
+          await fs15.unlink(this.manifestPath);
         } catch (error) {
           if (error.code !== "ENOENT") {
             console.error(`[Lien] Warning: Failed to clear manifest: ${error}`);
@@ -3585,9 +4227,9 @@ var tracker_exports = {};
 __export(tracker_exports, {
   GitStateTracker: () => GitStateTracker
 });
-import fs15 from "fs/promises";
-import path17 from "path";
-var GitStateTracker;
+import fs16 from "fs/promises";
+import path18 from "path";
+var GitStateTracker;
 var init_tracker = __esm({
   "src/git/tracker.ts"() {
     "use strict";
@@ -3598,7 +4240,7 @@ var init_tracker = __esm({
       currentState = null;
       constructor(rootDir, indexPath) {
         this.rootDir = rootDir;
-        this.stateFile = path17.join(indexPath, ".git-state.json");
+        this.stateFile = path18.join(indexPath, ".git-state.json");
       }
       /**
        * Loads the last known git state from disk.
@@ -3606,7 +4248,7 @@ var init_tracker = __esm({
        */
       async loadState() {
         try {
-          const content = await fs15.readFile(this.stateFile, "utf-8");
+          const content = await fs16.readFile(this.stateFile, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -3618,7 +4260,7 @@ var init_tracker = __esm({
       async saveState(state) {
         try {
           const content = JSON.stringify(state, null, 2);
-          await fs15.writeFile(this.stateFile, content, "utf-8");
+          await fs16.writeFile(this.stateFile, content, "utf-8");
         } catch (error) {
           console.error(`[Lien] Warning: Failed to save git state: ${error}`);
         }
@@ -3768,148 +4410,6 @@ var init_tracker = __esm({
   }
 });
 
-// src/indexer/change-detector.ts
-import fs16 from "fs/promises";
-async function detectChanges(rootDir, vectorDB, config) {
-  const manifest = new ManifestManager(vectorDB.dbPath);
-  const savedManifest = await manifest.load();
-  if (!savedManifest) {
-    const allFiles = await getAllFiles(rootDir, config);
-    return {
-      added: allFiles,
-      modified: [],
-      deleted: [],
-      reason: "full"
-    };
-  }
-  const gitAvailable = await isGitAvailable();
-  const isRepo = await isGitRepo(rootDir);
-  if (gitAvailable && isRepo && savedManifest.gitState) {
-    const gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
-    await gitTracker.initialize();
-    const currentState = gitTracker.getState();
-    if (currentState && (currentState.branch !== savedManifest.gitState.branch || currentState.commit !== savedManifest.gitState.commit)) {
-      try {
-        const changedFilesPaths = await getChangedFiles(
-          rootDir,
-          savedManifest.gitState.commit,
-          currentState.commit
-        );
-        const changedFilesSet = new Set(changedFilesPaths);
-        const allFiles = await getAllFiles(rootDir, config);
-        const currentFileSet = new Set(allFiles);
-        const added = [];
-        const modified = [];
-        const deleted = [];
-        for (const filepath of changedFilesPaths) {
-          if (currentFileSet.has(filepath)) {
-            if (savedManifest.files[filepath]) {
-              modified.push(filepath);
-            } else {
-              added.push(filepath);
-            }
-          }
-        }
-        for (const filepath of allFiles) {
-          if (!savedManifest.files[filepath] && !changedFilesSet.has(filepath)) {
-            added.push(filepath);
-          }
-        }
-        for (const filepath of Object.keys(savedManifest.files)) {
-          if (!currentFileSet.has(filepath)) {
-            deleted.push(filepath);
-          }
-        }
-        return {
-          added,
-          modified,
-          deleted,
-          reason: "git-state-changed"
-        };
-      } catch (error) {
-        console.warn(`[Lien] Git diff failed, falling back to full reindex: ${error}`);
-        const allFiles = await getAllFiles(rootDir, config);
-        const currentFileSet = new Set(allFiles);
-        const deleted = [];
-        for (const filepath of Object.keys(savedManifest.files)) {
-          if (!currentFileSet.has(filepath)) {
-            deleted.push(filepath);
-          }
-        }
-        return {
-          added: allFiles,
-          modified: [],
-          deleted,
-          reason: "git-state-changed"
-        };
-      }
-    }
-  }
-  return await mtimeBasedDetection(rootDir, savedManifest, config);
-}
-async function getAllFiles(rootDir, config) {
-  if (isModernConfig(config) && config.frameworks.length > 0) {
-    return await scanCodebaseWithFrameworks(rootDir, config);
-  } else if (isLegacyConfig(config)) {
-    return await scanCodebase({
-      rootDir,
-      includePatterns: config.indexing.include,
-      excludePatterns: config.indexing.exclude
-    });
-  } else {
-    return await scanCodebase({
-      rootDir,
-      includePatterns: [],
-      excludePatterns: []
-    });
-  }
-}
-async function mtimeBasedDetection(rootDir, savedManifest, config) {
-  const added = [];
-  const modified = [];
-  const deleted = [];
-  const currentFiles = await getAllFiles(rootDir, config);
-  const currentFileSet = new Set(currentFiles);
-  const fileStats = /* @__PURE__ */ new Map();
-  for (const filepath of currentFiles) {
-    try {
-      const stats = await fs16.stat(filepath);
-      fileStats.set(filepath, stats.mtimeMs);
-    } catch {
-      continue;
-    }
-  }
-  for (const [filepath, mtime] of fileStats) {
-    const entry = savedManifest.files[filepath];
-    if (!entry) {
-      added.push(filepath);
-    } else if (entry.lastModified < mtime) {
-      modified.push(filepath);
-    }
-  }
-  for (const filepath of Object.keys(savedManifest.files)) {
-    if (!currentFileSet.has(filepath)) {
-      deleted.push(filepath);
-    }
-  }
-  return {
-    added,
-    modified,
-    deleted,
-    reason: "mtime"
-  };
-}
-var init_change_detector = __esm({
-  "src/indexer/change-detector.ts"() {
-    "use strict";
-    init_manifest();
-    init_scanner();
-    init_schema();
-    init_tracker();
-    init_utils();
-  }
-});
-
 // src/utils/result.ts
 function Ok(value) {
   return { ok: true, value };
@@ -3928,6 +4428,21 @@ var init_result = __esm({
 
 // src/indexer/incremental.ts
 import fs17 from "fs/promises";
+import path19 from "path";
+function normalizeToRelativePath(filepath, rootDir) {
+  const root = (rootDir || process.cwd()).replace(/\\/g, "/").replace(/\/$/, "");
+  const normalized = filepath.replace(/\\/g, "/");
+  if (!path19.isAbsolute(filepath)) {
+    return normalized;
+  }
+  if (normalized.startsWith(root + "/")) {
+    return normalized.slice(root.length + 1);
+  }
+  if (normalized.startsWith(root)) {
+    return normalized.slice(root.length);
+  }
+  return path19.relative(root, filepath).replace(/\\/g, "/");
+}
 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;
@@ -3964,61 +4479,63 @@ async function processFileContent(filepath, content, embeddings, config, verbose
 }
 async function indexSingleFile(filepath, vectorDB, embeddings, config, options = {}) {
   const { verbose } = options;
+  const normalizedPath = normalizeToRelativePath(filepath);
   try {
     try {
       await fs17.access(filepath);
     } catch {
       if (verbose) {
-        console.error(`[Lien] File deleted: ${filepath}`);
+        console.error(`[Lien] File deleted: ${normalizedPath}`);
       }
-      await vectorDB.deleteByFile(filepath);
+      await vectorDB.deleteByFile(normalizedPath);
       const manifest2 = new ManifestManager(vectorDB.dbPath);
-      await manifest2.removeFile(filepath);
+      await manifest2.removeFile(normalizedPath);
       return;
     }
     const content = await fs17.readFile(filepath, "utf-8");
-    const result = await processFileContent(filepath, content, embeddings, config, verbose || false);
+    const result = await processFileContent(normalizedPath, content, embeddings, config, verbose || false);
     const stats = await fs17.stat(filepath);
     const manifest = new ManifestManager(vectorDB.dbPath);
     if (result === null) {
-      await vectorDB.deleteByFile(filepath);
-      await manifest.updateFile(filepath, {
-        filepath,
+      await vectorDB.deleteByFile(normalizedPath);
+      await manifest.updateFile(normalizedPath, {
+        filepath: normalizedPath,
         lastModified: stats.mtimeMs,
         chunkCount: 0
       });
       return;
     }
     await vectorDB.updateFile(
-      filepath,
+      normalizedPath,
       result.vectors,
       result.chunks.map((c) => c.metadata),
       result.texts
     );
-    await manifest.updateFile(filepath, {
-      filepath,
+    await manifest.updateFile(normalizedPath, {
+      filepath: normalizedPath,
       lastModified: stats.mtimeMs,
       chunkCount: result.chunkCount
     });
     if (verbose) {
-      console.error(`[Lien] \u2713 Updated ${filepath} (${result.chunkCount} chunks)`);
+      console.error(`[Lien] \u2713 Updated ${normalizedPath} (${result.chunkCount} chunks)`);
     }
   } catch (error) {
-    console.error(`[Lien] \u26A0\uFE0F  Failed to index ${filepath}: ${error}`);
+    console.error(`[Lien] \u26A0\uFE0F  Failed to index ${normalizedPath}: ${error}`);
   }
 }
-async function processSingleFileForIndexing(filepath, embeddings, config, verbose) {
+async function processSingleFileForIndexing(filepath, normalizedPath, embeddings, config, verbose) {
   try {
     const stats = await fs17.stat(filepath);
     const content = await fs17.readFile(filepath, "utf-8");
-    const result = await processFileContent(filepath, content, embeddings, config, verbose);
+    const result = await processFileContent(normalizedPath, content, embeddings, config, verbose);
     return Ok({
-      filepath,
+      filepath: normalizedPath,
+      // Store normalized path
       result,
       mtime: stats.mtimeMs
     });
   } catch (error) {
-    return Err(`Failed to process ${filepath}: ${error}`);
+    return Err(`Failed to process ${normalizedPath}: ${error}`);
   }
 }
 async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, options = {}) {
@@ -4026,17 +4543,18 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
   let processedCount = 0;
   const manifestEntries = [];
   for (const filepath of filepaths) {
-    const result = await processSingleFileForIndexing(filepath, embeddings, config, verbose || false);
+    const normalizedPath = normalizeToRelativePath(filepath);
+    const result = await processSingleFileForIndexing(filepath, normalizedPath, embeddings, config, verbose || false);
     if (isOk(result)) {
-      const { result: processResult, mtime } = result.value;
+      const { filepath: storedPath, result: processResult, mtime } = result.value;
       if (processResult === null) {
         try {
-          await vectorDB.deleteByFile(filepath);
+          await vectorDB.deleteByFile(storedPath);
         } catch (error) {
         }
         const manifest = new ManifestManager(vectorDB.dbPath);
-        await manifest.updateFile(filepath, {
-          filepath,
+        await manifest.updateFile(storedPath, {
+          filepath: storedPath,
           lastModified: mtime,
           chunkCount: 0
         });
@@ -4044,7 +4562,7 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
         continue;
       }
       try {
-        await vectorDB.deleteByFile(filepath);
+        await vectorDB.deleteByFile(storedPath);
       } catch (error) {
       }
       await vectorDB.insertBatch(
@@ -4053,12 +4571,12 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
         processResult.texts
       );
       manifestEntries.push({
-        filepath,
+        filepath: storedPath,
         chunkCount: processResult.chunkCount,
         mtime
       });
       if (verbose) {
-        console.error(`[Lien] \u2713 Updated ${filepath} (${processResult.chunkCount} chunks)`);
+        console.error(`[Lien] \u2713 Updated ${storedPath} (${processResult.chunkCount} chunks)`);
       }
       processedCount++;
     } else {
@@ -4066,12 +4584,12 @@ async function indexMultipleFiles(filepaths, vectorDB, embeddings, config, optio
         console.error(`[Lien] ${result.error}`);
       }
       try {
-        await vectorDB.deleteByFile(filepath);
+        await vectorDB.deleteByFile(normalizedPath);
         const manifest = new ManifestManager(vectorDB.dbPath);
-        await manifest.removeFile(filepath);
+        await manifest.removeFile(normalizedPath);
       } catch (error) {
         if (verbose) {
-          console.error(`[Lien] Note: ${filepath} not in index`);
+          console.error(`[Lien] Note: ${normalizedPath} not in index`);
         }
       }
       processedCount++;
@@ -4101,6 +4619,174 @@ var init_incremental = __esm({
   }
 });
 
+// src/indexer/change-detector.ts
+import fs18 from "fs/promises";
+import path20 from "path";
+async function hasGitStateChanged(rootDir, dbPath, savedGitState) {
+  if (!savedGitState) return { changed: false };
+  const gitAvailable = await isGitAvailable();
+  const isRepo = await isGitRepo(rootDir);
+  if (!gitAvailable || !isRepo) return { changed: false };
+  const gitTracker = new GitStateTracker(rootDir, dbPath);
+  await gitTracker.initialize();
+  const currentState = gitTracker.getState();
+  if (!currentState) return { changed: false };
+  const changed = currentState.branch !== savedGitState.branch || currentState.commit !== savedGitState.commit;
+  return { changed, currentState };
+}
+function categorizeChangedFiles(changedFilesPaths, currentFileSet, normalizedManifestFiles, allFiles) {
+  const changedFilesSet = new Set(changedFilesPaths);
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  for (const filepath of changedFilesPaths) {
+    if (currentFileSet.has(filepath)) {
+      if (normalizedManifestFiles.has(filepath)) {
+        modified.push(filepath);
+      } else {
+        added.push(filepath);
+      }
+    }
+  }
+  for (const filepath of allFiles) {
+    if (!normalizedManifestFiles.has(filepath) && !changedFilesSet.has(filepath)) {
+      added.push(filepath);
+    }
+  }
+  for (const normalizedPath of normalizedManifestFiles) {
+    if (!currentFileSet.has(normalizedPath)) {
+      deleted.push(normalizedPath);
+    }
+  }
+  return { added, modified, deleted };
+}
+function normalizeManifestPaths(manifestFiles, rootDir) {
+  const normalized = /* @__PURE__ */ new Set();
+  for (const filepath of Object.keys(manifestFiles)) {
+    normalized.add(normalizeToRelativePath(filepath, rootDir));
+  }
+  return normalized;
+}
+async function detectGitBasedChanges(rootDir, savedManifest, currentCommit, config) {
+  const changedFilesAbsolute = await getChangedFiles(
+    rootDir,
+    savedManifest.gitState.commit,
+    currentCommit
+  );
+  const changedFilesPaths = changedFilesAbsolute.map((fp) => normalizeToRelativePath(fp, rootDir));
+  const allFiles = await getAllFiles(rootDir, config);
+  const currentFileSet = new Set(allFiles);
+  const normalizedManifestFiles = normalizeManifestPaths(savedManifest.files, rootDir);
+  const { added, modified, deleted } = categorizeChangedFiles(
+    changedFilesPaths,
+    currentFileSet,
+    normalizedManifestFiles,
+    allFiles
+  );
+  return { added, modified, deleted, reason: "git-state-changed" };
+}
+async function fallbackToFullReindex(rootDir, savedManifest, config) {
+  const allFiles = await getAllFiles(rootDir, config);
+  const currentFileSet = new Set(allFiles);
+  const deleted = [];
+  for (const filepath of Object.keys(savedManifest.files)) {
+    const normalizedPath = normalizeToRelativePath(filepath, rootDir);
+    if (!currentFileSet.has(normalizedPath)) {
+      deleted.push(normalizedPath);
+    }
+  }
+  return { added: allFiles, modified: [], deleted, reason: "git-state-changed" };
+}
+async function detectChanges(rootDir, vectorDB, config) {
+  const manifest = new ManifestManager(vectorDB.dbPath);
+  const savedManifest = await manifest.load();
+  if (!savedManifest) {
+    const allFiles = await getAllFiles(rootDir, config);
+    return { added: allFiles, modified: [], deleted: [], reason: "full" };
+  }
+  const gitCheck = await hasGitStateChanged(rootDir, vectorDB.dbPath, savedManifest.gitState);
+  if (gitCheck.changed && gitCheck.currentState) {
+    try {
+      return await detectGitBasedChanges(rootDir, savedManifest, gitCheck.currentState.commit, config);
+    } catch (error) {
+      console.warn(`[Lien] Git diff failed, falling back to full reindex: ${error}`);
+      return await fallbackToFullReindex(rootDir, savedManifest, config);
+    }
+  }
+  return await mtimeBasedDetection(rootDir, savedManifest, config);
+}
+async function getAllFiles(rootDir, config) {
+  let files;
+  if (isModernConfig(config) && config.frameworks.length > 0) {
+    files = await scanCodebaseWithFrameworks(rootDir, config);
+  } else if (isLegacyConfig(config)) {
+    files = await scanCodebase({
+      rootDir,
+      includePatterns: config.indexing.include,
+      excludePatterns: config.indexing.exclude
+    });
+  } else {
+    files = await scanCodebase({
+      rootDir,
+      includePatterns: [],
+      excludePatterns: []
+    });
+  }
+  return files.map((fp) => normalizeToRelativePath(fp, rootDir));
+}
+async function mtimeBasedDetection(rootDir, savedManifest, config) {
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  const currentFiles = await getAllFiles(rootDir, config);
+  const currentFileSet = new Set(currentFiles);
+  const normalizedManifestFiles = /* @__PURE__ */ new Map();
+  for (const [filepath, entry] of Object.entries(savedManifest.files)) {
+    const normalizedPath = normalizeToRelativePath(filepath, rootDir);
+    normalizedManifestFiles.set(normalizedPath, entry);
+  }
+  const fileStats = /* @__PURE__ */ new Map();
+  for (const filepath of currentFiles) {
+    try {
+      const absolutePath = path20.isAbsolute(filepath) ? filepath : path20.join(rootDir, filepath);
+      const stats = await fs18.stat(absolutePath);
+      fileStats.set(filepath, stats.mtimeMs);
+    } catch {
+      continue;
+    }
+  }
+  for (const [filepath, mtime] of fileStats) {
+    const entry = normalizedManifestFiles.get(filepath);
+    if (!entry) {
+      added.push(filepath);
+    } else if (entry.lastModified < mtime) {
+      modified.push(filepath);
+    }
+  }
+  for (const normalizedPath of normalizedManifestFiles.keys()) {
+    if (!currentFileSet.has(normalizedPath)) {
+      deleted.push(normalizedPath);
+    }
+  }
+  return {
+    added,
+    modified,
+    deleted,
+    reason: "mtime"
+  };
+}
+var init_change_detector = __esm({
+  "src/indexer/change-detector.ts"() {
+    "use strict";
+    init_manifest();
+    init_scanner();
+    init_schema();
+    init_tracker();
+    init_utils();
+    init_incremental();
+  }
+});
+
 // src/utils/loading-messages.ts
 function getIndexingMessage() {
   const message = INDEXING_MESSAGES[currentIndexingIndex % INDEXING_MESSAGES.length];
@@ -4281,10 +4967,53 @@ var indexer_exports = {};
 __export(indexer_exports, {
   indexCodebase: () => indexCodebase
 });
-import fs18 from "fs/promises";
+import fs19 from "fs/promises";
 import ora from "ora";
 import chalk5 from "chalk";
 import pLimit from "p-limit";
+function getIndexingConfig(config) {
+  if (isModernConfig(config)) {
+    return {
+      concurrency: config.core.concurrency,
+      embeddingBatchSize: config.core.embeddingBatchSize,
+      chunkSize: config.core.chunkSize,
+      chunkOverlap: config.core.chunkOverlap,
+      useAST: config.chunking.useAST,
+      astFallback: config.chunking.astFallback
+    };
+  }
+  return {
+    concurrency: 4,
+    embeddingBatchSize: 50,
+    chunkSize: 75,
+    chunkOverlap: 10,
+    useAST: true,
+    astFallback: "line-based"
+  };
+}
+async function scanFilesToIndex(rootDir, config) {
+  if (isModernConfig(config) && config.frameworks.length > 0) {
+    return scanCodebaseWithFrameworks(rootDir, config);
+  }
+  if (isLegacyConfig(config)) {
+    return scanCodebase({
+      rootDir,
+      includePatterns: config.indexing.include,
+      excludePatterns: config.indexing.exclude
+    });
+  }
+  return scanCodebase({ rootDir, includePatterns: [], excludePatterns: [] });
+}
+async function processEmbeddingMicroBatches(texts, embeddings) {
+  const results = [];
+  for (let j = 0; j < texts.length; j += EMBEDDING_MICRO_BATCH_SIZE) {
+    const microBatch = texts.slice(j, Math.min(j + EMBEDDING_MICRO_BATCH_SIZE, texts.length));
+    const microResults = await embeddings.embedBatch(microBatch);
+    results.push(...microResults);
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+  return results;
+}
 async function updateGitState(rootDir, vectorDB, manifest) {
   const { isGitAvailable: isGitAvailable2, isGitRepo: isGitRepo2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
   const { GitStateTracker: GitStateTracker2 } = await Promise.resolve().then(() => (init_tracker(), tracker_exports));
@@ -4369,23 +5098,10 @@ async function tryIncrementalIndex(rootDir, vectorDB, config, options, spinner)
   return true;
 }
 async function performFullIndex(rootDir, vectorDB, config, options, spinner) {
+  spinner.text = "Clearing existing index...";
+  await vectorDB.clear();
   spinner.text = "Scanning codebase...";
-  let files;
-  if (isModernConfig(config) && config.frameworks.length > 0) {
-    files = await scanCodebaseWithFrameworks(rootDir, config);
-  } else if (isLegacyConfig(config)) {
-    files = await scanCodebase({
-      rootDir,
-      includePatterns: config.indexing.include,
-      excludePatterns: config.indexing.exclude
-    });
-  } else {
-    files = await scanCodebase({
-      rootDir,
-      includePatterns: [],
-      excludePatterns: []
-    });
-  }
+  const files = await scanFilesToIndex(rootDir, config);
   if (files.length === 0) {
     spinner.fail("No files found to index");
     return;
@@ -4395,14 +5111,13 @@ async function performFullIndex(rootDir, vectorDB, config, options, spinner) {
   const embeddings = new LocalEmbeddings();
   await embeddings.initialize();
   spinner.succeed("Embedding model loaded");
-  const concurrency = isModernConfig(config) ? config.core.concurrency : 4;
-  const embeddingBatchSize = isModernConfig(config) ? config.core.embeddingBatchSize : 50;
+  const indexConfig = getIndexingConfig(config);
   const vectorDBBatchSize = 100;
-  spinner.start(`Processing files with ${concurrency}x concurrency...`);
+  spinner.start(`Processing files with ${indexConfig.concurrency}x concurrency...`);
   const startTime = Date.now();
   let processedChunks = 0;
   const chunkAccumulator = [];
-  const limit = pLimit(concurrency);
+  const limit = pLimit(indexConfig.concurrency);
   const indexedFileEntries = [];
   const progressTracker = new IndexingProgressTracker(files.length, spinner);
   progressTracker.start();
@@ -4418,53 +5133,35 @@ async function performFullIndex(rootDir, vectorDB, config, options, spinner) {
       return processingQueue;
     };
     const doProcessChunks = async () => {
-      if (chunkAccumulator.length === 0) {
-        return;
-      }
+      if (chunkAccumulator.length === 0) return;
       const currentPromise = processingQueue;
       try {
         const toProcess = chunkAccumulator.splice(0, chunkAccumulator.length);
-        for (let i = 0; i < toProcess.length; i += embeddingBatchSize) {
-          const batch = toProcess.slice(i, Math.min(i + embeddingBatchSize, toProcess.length));
-          progressTracker.setMessage(getEmbeddingMessage());
+        for (let i = 0; i < toProcess.length; i += indexConfig.embeddingBatchSize) {
+          const batch = toProcess.slice(i, Math.min(i + indexConfig.embeddingBatchSize, toProcess.length));
           const texts = batch.map((item) => item.content);
-          const embeddingVectors = [];
-          for (let j = 0; j < texts.length; j += EMBEDDING_MICRO_BATCH_SIZE) {
-            const microBatch = texts.slice(j, Math.min(j + EMBEDDING_MICRO_BATCH_SIZE, texts.length));
-            const microResults = await embeddings.embedBatch(microBatch);
-            embeddingVectors.push(...microResults);
-            await new Promise((resolve) => setImmediate(resolve));
-          }
+          progressTracker.setMessage(getEmbeddingMessage());
+          const embeddingVectors = await processEmbeddingMicroBatches(texts, embeddings);
           processedChunks += batch.length;
           progressTracker.setMessage(`Inserting ${batch.length} chunks into vector space...`);
-          await vectorDB.insertBatch(
-            embeddingVectors,
-            batch.map((item) => item.chunk.metadata),
-            texts
-          );
+          await vectorDB.insertBatch(embeddingVectors, batch.map((item) => item.chunk.metadata), texts);
           await new Promise((resolve) => setImmediate(resolve));
         }
         progressTracker.setMessage(getIndexingMessage());
       } finally {
-        if (processingQueue === currentPromise) {
-          processingQueue = null;
-        }
+        if (processingQueue === currentPromise) processingQueue = null;
       }
     };
     const filePromises = files.map(
       (file) => limit(async () => {
         try {
-          const stats = await fs18.stat(file);
-          const content = await fs18.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 stats = await fs19.stat(file);
+          const content = await fs19.readFile(file, "utf-8");
           const chunks = chunkFile(file, content, {
-            chunkSize,
-            chunkOverlap,
-            useAST,
-            astFallback
+            chunkSize: indexConfig.chunkSize,
+            chunkOverlap: indexConfig.chunkOverlap,
+            useAST: indexConfig.useAST,
+            astFallback: indexConfig.astFallback
           });
           if (chunks.length === 0) {
             progressTracker.incrementFiles();
@@ -4529,7 +5226,7 @@ async function performFullIndex(rootDir, vectorDB, config, options, spinner) {
   await writeVersionFile(vectorDB.dbPath);
   const totalTime = ((Date.now() - startTime) / 1e3).toFixed(1);
   spinner.succeed(
-    `Indexed ${progressTracker.getProcessedCount()} files (${processedChunks} chunks) in ${totalTime}s using ${concurrency}x concurrency`
+    `Indexed ${progressTracker.getProcessedCount()} files (${processedChunks} chunks) in ${totalTime}s using ${indexConfig.concurrency}x concurrency`
   );
   console.log(chalk5.dim("\nNext step: Run"), chalk5.bold("lien serve"), chalk5.dim("to start the MCP server"));
 }
@@ -4794,19 +5491,27 @@ async function generateNodeJsConfig(_rootDir, _relativePath) {
       "**/*.mdx"
     ],
     exclude: [
+      // Node.js dependencies (with ** prefix for nested projects)
+      "**/node_modules/**",
       "node_modules/**",
+      // PHP/Composer dependencies (for monorepos with PHP)
+      "**/vendor/**",
+      "vendor/**",
+      // Build outputs
+      "**/dist/**",
       "dist/**",
+      "**/build/**",
       "build/**",
-      "coverage/**",
+      "**/public/build/**",
+      "public/build/**",
+      "out/**",
+      // Framework build caches
       ".next/**",
       ".nuxt/**",
       ".vite/**",
       ".lien/**",
-      "out/**",
-      "*.min.js",
-      "*.min.css",
-      "*.bundle.js",
-      // Test artifacts (source files are indexed, but not output)
+      // Test artifacts
+      "coverage/**",
       "playwright-report/**",
       "test-results/**",
       // Build/generated artifacts
@@ -4815,7 +5520,11 @@ async function generateNodeJsConfig(_rootDir, _relativePath) {
       ".cache/**",
       ".turbo/**",
       ".vercel/**",
-      ".netlify/**"
+      ".netlify/**",
+      // Minified/bundled files
+      "**/*.min.js",
+      "**/*.min.css",
+      "**/*.bundle.js"
     ]
   };
 }
@@ -4909,18 +5618,32 @@ async function generatePhpConfig(_rootDir, _relativePath) {
       "CHANGELOG.md"
     ],
     exclude: [
+      // Composer dependencies (CRITICAL)
+      "**/vendor/**",
       "vendor/**",
+      // Node.js dependencies
+      "**/node_modules/**",
       "node_modules/**",
+      // Build outputs
+      "**/dist/**",
       "dist/**",
+      "**/build/**",
       "build/**",
+      "**/public/build/**",
+      "public/build/**",
+      // Laravel/PHP system directories
       "storage/**",
       "cache/**",
+      "bootstrap/cache/**",
       // Test artifacts
       "coverage/**",
       "test-results/**",
       ".phpunit.cache/**",
       // Build outputs
-      "__generated__/**"
+      "__generated__/**",
+      // Minified files
+      "**/*.min.js",
+      "**/*.min.css"
     ]
   };
 }
@@ -5022,30 +5745,42 @@ async function generateLaravelConfig(_rootDir, _relativePath) {
       "resources/**/*.php",
       "tests/**/*.php",
       "*.php",
-      // Frontend assets (Vue/React/Inertia) - Broadened for flexibility
-      "**/*.js",
-      "**/*.ts",
-      "**/*.jsx",
-      "**/*.tsx",
-      "**/*.vue",
+      // Frontend assets (Vue/React/Inertia) - Scoped to resources/ to avoid build output
+      "resources/**/*.js",
+      "resources/**/*.ts",
+      "resources/**/*.jsx",
+      "resources/**/*.tsx",
+      "resources/**/*.vue",
       // Blade templates
       "resources/views/**/*.blade.php",
       // Documentation
-      "**/*.md",
-      "**/*.mdx",
       "docs/**/*.md",
       "README.md",
       "CHANGELOG.md"
     ],
     exclude: [
+      // Composer dependencies (CRITICAL: exclude before any include patterns)
+      "**/vendor/**",
       "vendor/**",
+      // Build outputs (Vite/Mix compiled assets)
+      "**/public/build/**",
+      "public/build/**",
+      "public/hot",
+      "**/dist/**",
+      "dist/**",
+      "**/build/**",
+      "build/**",
+      // Laravel system directories
       "storage/**",
       "bootstrap/cache/**",
-      "public/**",
+      "public/**/*.js",
+      // Compiled JS in public
+      "public/**/*.css",
+      // Compiled CSS in public
+      // Node.js dependencies
+      "**/node_modules/**",
       "node_modules/**",
-      "dist/**",
-      "build/**",
-      // Test artifacts (source files are indexed, but not output)
+      // Test artifacts
       "playwright-report/**",
       "test-results/**",
       "coverage/**",
@@ -5054,7 +5789,10 @@ async function generateLaravelConfig(_rootDir, _relativePath) {
       // Frontend build outputs
       ".vite/**",
       ".nuxt/**",
-      ".next/**"
+      ".next/**",
+      // Minified files
+      "**/*.min.js",
+      "**/*.min.css"
     ]
   };
 }
@@ -5737,8 +6475,8 @@ async function indexCommand(options) {
 
 // src/cli/serve.ts
 import chalk7 from "chalk";
-import fs19 from "fs/promises";
-import path18 from "path";
+import fs20 from "fs/promises";
+import path21 from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -5822,6 +6560,20 @@ var GetDependentsSchema = z5.object({
   )
 });
 
+// src/mcp/schemas/complexity.schema.ts
+import { z as z6 } from "zod";
+var GetComplexitySchema = z6.object({
+  files: z6.array(z6.string().min(1, "Filepath cannot be empty")).optional().describe(
+    "Specific files to analyze. If omitted, analyzes entire codebase.\n\nExample: ['src/auth.ts', 'src/api/user.ts']"
+  ),
+  top: z6.number().int().min(1, "Top must be at least 1").max(50, "Top cannot exceed 50").default(10).describe(
+    "Return top N most complex functions. Default: 10\n\nUse higher values to see more violations."
+  ),
+  threshold: z6.number().int().min(1, "Threshold must be at least 1").optional().describe(
+    "Only return functions above this complexity threshold.\n\nNote: Violations are first identified using the threshold from lien.config.json (default: 15). This parameter filters those violations to show only items above the specified value. Setting threshold below the config threshold will not show additional functions."
+  )
+});
+
 // src/mcp/tools.ts
 var tools = [
   toMCPToolSchema(
@@ -5915,149 +6667,33 @@ Returns:
 - Risk level (low/medium/high/critical) based on dependent count and complexity
 
 Example: get_dependents({ filepath: "src/utils/validate.ts" })`
-  )
-];
+  ),
+  toMCPToolSchema(
+    GetComplexitySchema,
+    "get_complexity",
+    `Get complexity analysis for files or the entire codebase.
 
-// src/mcp/server.ts
-init_lancedb();
-init_local();
-init_tracker();
-init_incremental();
-init_service();
-init_manifest();
-init_utils();
+Analyzes multiple complexity metrics:
+- **Test paths**: Number of test cases needed for full coverage (cyclomatic)
+- **Mental load**: How hard to follow - penalizes nesting (cognitive)
+- **Time to understand**: Estimated reading time based on Halstead effort
+- **Estimated bugs**: Predicted bug count based on Halstead volume
 
-// src/watcher/index.ts
-init_schema();
-import chokidar from "chokidar";
-var FileWatcher = class {
-  watcher = null;
-  debounceTimers = /* @__PURE__ */ new Map();
-  config;
-  rootDir;
-  onChangeHandler = null;
-  constructor(rootDir, config) {
-    this.rootDir = rootDir;
-    this.config = config;
-  }
-  /**
-   * Starts watching files for changes.
-   * 
-   * @param handler - Callback function called when files change
-   */
-  async start(handler) {
-    if (this.watcher) {
-      throw new Error("File watcher is already running");
-    }
-    this.onChangeHandler = handler;
-    let includePatterns;
-    let excludePatterns;
-    if (isLegacyConfig(this.config)) {
-      includePatterns = this.config.indexing.include;
-      excludePatterns = this.config.indexing.exclude;
-    } else if (isModernConfig(this.config)) {
-      includePatterns = this.config.frameworks.flatMap((f) => f.config.include);
-      excludePatterns = this.config.frameworks.flatMap((f) => f.config.exclude);
-    } else {
-      includePatterns = ["**/*"];
-      excludePatterns = [];
-    }
-    this.watcher = chokidar.watch(includePatterns, {
-      cwd: this.rootDir,
-      ignored: excludePatterns,
-      persistent: true,
-      ignoreInitial: true,
-      // Don't trigger for existing files
-      awaitWriteFinish: {
-        stabilityThreshold: 500,
-        // Wait 500ms for file to stop changing
-        pollInterval: 100
-      },
-      // Performance optimizations
-      usePolling: false,
-      interval: 100,
-      binaryInterval: 300
-    });
-    this.watcher.on("add", (filepath) => this.handleChange("add", filepath)).on("change", (filepath) => this.handleChange("change", filepath)).on("unlink", (filepath) => this.handleChange("unlink", filepath)).on("error", (error) => {
-      console.error(`[Lien] File watcher error: ${error}`);
-    });
-    await new Promise((resolve) => {
-      this.watcher.on("ready", () => {
-        resolve();
-      });
-    });
-  }
-  /**
-   * Handles a file change event with debouncing.
-   * Debouncing prevents rapid reindexing when files are saved multiple times quickly.
-   */
-  handleChange(type, filepath) {
-    const existingTimer = this.debounceTimers.get(filepath);
-    if (existingTimer) {
-      clearTimeout(existingTimer);
-    }
-    const timer = setTimeout(() => {
-      this.debounceTimers.delete(filepath);
-      if (this.onChangeHandler) {
-        const absolutePath = filepath.startsWith("/") ? filepath : `${this.rootDir}/${filepath}`;
-        try {
-          const result = this.onChangeHandler({
-            type,
-            filepath: absolutePath
-          });
-          if (result instanceof Promise) {
-            result.catch((error) => {
-              console.error(`[Lien] Error handling file change: ${error}`);
-            });
-          }
-        } catch (error) {
-          console.error(`[Lien] Error handling file change: ${error}`);
-        }
-      }
-    }, this.config.fileWatching.debounceMs);
-    this.debounceTimers.set(filepath, timer);
-  }
-  /**
-   * Stops the file watcher and cleans up resources.
-   */
-  async stop() {
-    if (!this.watcher) {
-      return;
-    }
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.debounceTimers.clear();
-    await this.watcher.close();
-    this.watcher = null;
-    this.onChangeHandler = null;
-  }
-  /**
-   * Gets the list of files currently being watched.
-   */
-  getWatchedFiles() {
-    if (!this.watcher) {
-      return [];
-    }
-    const watched = this.watcher.getWatched();
-    const files = [];
-    for (const [dir, filenames] of Object.entries(watched)) {
-      for (const filename of filenames) {
-        files.push(`${dir}/${filename}`);
-      }
-    }
-    return files;
-  }
-  /**
-   * Checks if the watcher is currently running.
-   */
-  isRunning() {
-    return this.watcher !== null;
-  }
-};
+Use for tech debt analysis and refactoring prioritization:
+- "What are the most complex functions?"
+- "Show me tech debt hotspots"
+- "What should I refactor?"
 
-// src/mcp/server.ts
-init_constants();
+Examples:
+  get_complexity({ top: 10 })
+  get_complexity({ files: ["src/auth.ts", "src/api/user.ts"] })
+  get_complexity({ threshold: 15 })
+
+Returns violations with metricType ('cyclomatic', 'cognitive', 'halstead_effort',
+or 'halstead_bugs'), risk levels, and dependent counts.
+Human-readable output: "23 (needs ~23 tests)", "\u{1F9E0} 45", "~2h 30m", "2.27 bugs".`
+  )
+];
 
 // src/mcp/utils/tool-wrapper.ts
 init_errors();
@@ -6114,9 +6750,47 @@ function wrapToolHandler(schema, handler) {
   };
 }
 
+// src/mcp/handlers/semantic-search.ts
+async function handleSemanticSearch(args, ctx) {
+  const { vectorDB, embeddings, log, checkAndReconnect, getIndexMetadata } = ctx;
+  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);
+}
+
+// src/mcp/handlers/find-similar.ts
+async function handleFindSimilar(args, ctx) {
+  const { vectorDB, embeddings, log, checkAndReconnect, getIndexMetadata } = ctx;
+  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);
+}
+
 // src/mcp/utils/path-matching.ts
-function normalizePath(path19, workspaceRoot) {
-  let normalized = path19.replace(/['"]/g, "").trim().replace(/\\/g, "/");
+function normalizePath(path23, workspaceRoot) {
+  let normalized = path23.replace(/['"]/g, "").trim().replace(/\\/g, "/");
   normalized = normalized.replace(/\.(ts|tsx|js|jsx)$/, "");
   if (normalized.startsWith(workspaceRoot + "/")) {
     normalized = normalized.substring(workspaceRoot.length + 1);
@@ -6158,17 +6832,165 @@ function isTestFile2(filepath) {
   return /\.(test|spec)\.[^/]+$/.test(filepath) || /(^|[/\\])(test|tests|__tests__)[/\\]/.test(filepath);
 }
 
-// src/mcp/server.ts
-init_errors();
-var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname3(__filename4);
-var require4 = createRequire3(import.meta.url);
-var packageJson3;
-try {
-  packageJson3 = require4(join3(__dirname4, "../package.json"));
-} catch {
-  packageJson3 = require4(join3(__dirname4, "../../package.json"));
+// src/mcp/handlers/get-files-context.ts
+var SCAN_LIMIT = 1e4;
+async function handleGetFilesContext(args, ctx) {
+  const { vectorDB, embeddings, log, checkAndReconnect, getIndexMetadata } = ctx;
+  return await wrapToolHandler(
+    GetFilesContextSchema,
+    async (validatedArgs) => {
+      const filepaths = Array.isArray(validatedArgs.filepaths) ? validatedArgs.filepaths : [validatedArgs.filepaths];
+      const isSingleFile = !Array.isArray(validatedArgs.filepaths);
+      log(`Getting context for: ${filepaths.join(", ")}`);
+      await checkAndReconnect();
+      const workspaceRoot = process.cwd().replace(/\\/g, "/");
+      const fileEmbeddings = await Promise.all(filepaths.map((fp) => embeddings.embed(fp)));
+      const allFileSearches = await Promise.all(
+        fileEmbeddings.map(
+          (embedding, i) => vectorDB.search(embedding, 50, filepaths[i])
+        )
+      );
+      const fileChunksMap = filepaths.map((filepath, i) => {
+        const allResults = allFileSearches[i];
+        const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
+        return allResults.filter((r) => {
+          const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
+          return chunkCanonical === targetCanonical;
+        });
+      });
+      let relatedChunksMap = [];
+      if (validatedArgs.includeRelated) {
+        const filesWithChunks = fileChunksMap.map((chunks, i) => ({ chunks, filepath: filepaths[i], index: i })).filter(({ chunks }) => chunks.length > 0);
+        if (filesWithChunks.length > 0) {
+          const relatedEmbeddings = await Promise.all(
+            filesWithChunks.map(({ chunks }) => embeddings.embed(chunks[0].content))
+          );
+          const relatedSearches = await Promise.all(
+            relatedEmbeddings.map(
+              (embedding, i) => vectorDB.search(embedding, 5, filesWithChunks[i].chunks[0].content)
+            )
+          );
+          relatedChunksMap = Array.from({ length: filepaths.length }, () => []);
+          filesWithChunks.forEach(({ filepath, index }, i) => {
+            const related = relatedSearches[i];
+            const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
+            relatedChunksMap[index] = related.filter((r) => {
+              const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
+              return chunkCanonical !== targetCanonical;
+            });
+          });
+        }
+      }
+      const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
+      if (allChunks.length === SCAN_LIMIT) {
+        log(`Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`, "warning");
+      }
+      const pathCache = /* @__PURE__ */ new Map();
+      const normalizePathCached = (path23) => {
+        if (pathCache.has(path23)) return pathCache.get(path23);
+        const normalized = normalizePath(path23, workspaceRoot);
+        pathCache.set(path23, normalized);
+        return normalized;
+      };
+      const testAssociationsMap = filepaths.map((filepath) => {
+        const normalizedTarget = normalizePathCached(filepath);
+        const testFiles = /* @__PURE__ */ new Set();
+        for (const chunk of allChunks) {
+          const chunkFile2 = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+          if (!isTestFile2(chunkFile2)) continue;
+          const imports = chunk.metadata.imports || [];
+          for (const imp of imports) {
+            const normalizedImport = normalizePathCached(imp);
+            if (matchesFile(normalizedImport, normalizedTarget)) {
+              testFiles.add(chunkFile2);
+              break;
+            }
+          }
+        }
+        return Array.from(testFiles);
+      });
+      const filesData = {};
+      filepaths.forEach((filepath, i) => {
+        const fileChunks = fileChunksMap[i];
+        const relatedChunks = relatedChunksMap[i] || [];
+        const seenChunks = /* @__PURE__ */ new Set();
+        const dedupedChunks = [...fileChunks, ...relatedChunks].filter((chunk) => {
+          const canonicalFile = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+          const chunkId = `${canonicalFile}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+          if (seenChunks.has(chunkId)) return false;
+          seenChunks.add(chunkId);
+          return true;
+        });
+        filesData[filepath] = {
+          chunks: dedupedChunks,
+          testAssociations: testAssociationsMap[i]
+        };
+      });
+      log(`Found ${Object.values(filesData).reduce((sum, f) => sum + f.chunks.length, 0)} total chunks`);
+      if (isSingleFile) {
+        const filepath = filepaths[0];
+        return {
+          indexInfo: getIndexMetadata(),
+          file: filepath,
+          chunks: filesData[filepath].chunks,
+          testAssociations: filesData[filepath].testAssociations
+        };
+      } else {
+        return {
+          indexInfo: getIndexMetadata(),
+          files: filesData
+        };
+      }
+    }
+  )(args);
+}
+
+// src/mcp/handlers/list-functions.ts
+async function handleListFunctions(args, ctx) {
+  const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
+  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);
 }
+
+// src/mcp/handlers/get-dependents.ts
 var DEPENDENT_COUNT_THRESHOLDS = {
   LOW: 5,
   // Few dependents, safe to change
@@ -6193,559 +7015,1053 @@ var COMPLEXITY_THRESHOLDS = {
   MEDIUM_MAX: 15
   // Occasional branching
 };
-var SCAN_LIMIT = 1e4;
-async function startMCPServer(options) {
-  const { rootDir, verbose, watch } = options;
-  const log = (message) => {
-    if (verbose) {
-      console.error(`[Lien MCP] ${message}`);
+var SCAN_LIMIT2 = 1e4;
+var RISK_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
+function buildImportIndex(allChunks, normalizePathCached) {
+  const importIndex = /* @__PURE__ */ new Map();
+  for (const chunk of allChunks) {
+    const imports = chunk.metadata.imports || [];
+    for (const imp of imports) {
+      const normalizedImport = normalizePathCached(imp);
+      if (!importIndex.has(normalizedImport)) {
+        importIndex.set(normalizedImport, []);
+      }
+      importIndex.get(normalizedImport).push(chunk);
+    }
+  }
+  return importIndex;
+}
+function findDependentChunks(importIndex, normalizedTarget) {
+  const dependentChunks = [];
+  const seenChunkIds = /* @__PURE__ */ new Set();
+  const addChunk = (chunk) => {
+    const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+    if (!seenChunkIds.has(chunkId)) {
+      dependentChunks.push(chunk);
+      seenChunkIds.add(chunkId);
     }
   };
-  log("Initializing MCP server...");
-  const embeddings = new LocalEmbeddings();
-  const vectorDB = new VectorDB(rootDir);
-  try {
-    log("Loading embedding model...");
-    await embeddings.initialize();
-    log("Loading vector database...");
-    await vectorDB.initialize();
-    log("Embeddings and vector DB ready");
-  } catch (error) {
-    console.error(`Failed to initialize: ${error}`);
-    process.exit(1);
+  if (importIndex.has(normalizedTarget)) {
+    for (const chunk of importIndex.get(normalizedTarget)) {
+      addChunk(chunk);
+    }
   }
-  const server = new Server(
-    {
-      name: "lien",
-      version: packageJson3.version
-    },
-    {
-      capabilities: {
-        tools: {}
+  for (const [normalizedImport, chunks] of importIndex.entries()) {
+    if (normalizedImport !== normalizedTarget && matchesFile(normalizedImport, normalizedTarget)) {
+      for (const chunk of chunks) {
+        addChunk(chunk);
       }
     }
-  );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools
-  }));
-  const checkAndReconnect = async () => {
+  }
+  return dependentChunks;
+}
+function calculateFileComplexities(chunksByFile) {
+  const fileComplexities = [];
+  for (const [filepath, chunks] of chunksByFile.entries()) {
+    const complexities = chunks.map((c) => c.metadata.complexity).filter((c) => typeof c === "number" && c > 0);
+    if (complexities.length > 0) {
+      const sum = complexities.reduce((a, b) => a + b, 0);
+      fileComplexities.push({
+        filepath,
+        avgComplexity: Math.round(sum / complexities.length * 10) / 10,
+        maxComplexity: Math.max(...complexities),
+        complexityScore: sum,
+        chunksWithComplexity: complexities.length
+      });
+    }
+  }
+  return fileComplexities;
+}
+function calculateOverallComplexityMetrics(fileComplexities) {
+  if (fileComplexities.length === 0) {
+    return {
+      averageComplexity: 0,
+      maxComplexity: 0,
+      filesWithComplexityData: 0,
+      highComplexityDependents: [],
+      complexityRiskBoost: "low"
+    };
+  }
+  const allAvgs = fileComplexities.map((f) => f.avgComplexity);
+  const allMaxes = fileComplexities.map((f) => f.maxComplexity);
+  const totalAvg = allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length;
+  const globalMax = Math.max(...allMaxes);
+  const highComplexityDependents = fileComplexities.filter((f) => f.maxComplexity > COMPLEXITY_THRESHOLDS.HIGH_COMPLEXITY_DEPENDENT).sort((a, b) => b.maxComplexity - a.maxComplexity).slice(0, 5).map((f) => ({ filepath: f.filepath, maxComplexity: f.maxComplexity, avgComplexity: f.avgComplexity }));
+  const complexityRiskBoost = calculateComplexityRiskBoost(totalAvg, globalMax);
+  return {
+    averageComplexity: Math.round(totalAvg * 10) / 10,
+    maxComplexity: globalMax,
+    filesWithComplexityData: fileComplexities.length,
+    highComplexityDependents,
+    complexityRiskBoost
+  };
+}
+function calculateComplexityRiskBoost(avgComplexity, maxComplexity) {
+  if (avgComplexity > COMPLEXITY_THRESHOLDS.CRITICAL_AVG || maxComplexity > COMPLEXITY_THRESHOLDS.CRITICAL_MAX) {
+    return "critical";
+  }
+  if (avgComplexity > COMPLEXITY_THRESHOLDS.HIGH_AVG || maxComplexity > COMPLEXITY_THRESHOLDS.HIGH_MAX) {
+    return "high";
+  }
+  if (avgComplexity > COMPLEXITY_THRESHOLDS.MEDIUM_AVG || maxComplexity > COMPLEXITY_THRESHOLDS.MEDIUM_MAX) {
+    return "medium";
+  }
+  return "low";
+}
+function calculateRiskLevel(dependentCount, complexityRiskBoost) {
+  let riskLevel = dependentCount === 0 ? "low" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.LOW ? "low" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM ? "medium" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.HIGH ? "high" : "critical";
+  if (RISK_ORDER[complexityRiskBoost] > RISK_ORDER[riskLevel]) {
+    riskLevel = complexityRiskBoost;
+  }
+  return riskLevel;
+}
+async function handleGetDependents(args, ctx) {
+  const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
+  return await wrapToolHandler(
+    GetDependentsSchema,
+    async (validatedArgs) => {
+      log(`Finding dependents of: ${validatedArgs.filepath}`);
+      await checkAndReconnect();
+      const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT2 });
+      const hitLimit = allChunks.length === SCAN_LIMIT2;
+      if (hitLimit) {
+        log(`Scanned ${SCAN_LIMIT2} chunks (limit reached). Results may be incomplete.`, "warning");
+      }
+      log(`Scanning ${allChunks.length} chunks for imports...`);
+      const workspaceRoot = process.cwd().replace(/\\/g, "/");
+      const pathCache = /* @__PURE__ */ new Map();
+      const normalizePathCached = (path23) => {
+        if (!pathCache.has(path23)) pathCache.set(path23, normalizePath(path23, workspaceRoot));
+        return pathCache.get(path23);
+      };
+      const importIndex = buildImportIndex(allChunks, normalizePathCached);
+      const normalizedTarget = normalizePathCached(validatedArgs.filepath);
+      const dependentChunks = findDependentChunks(importIndex, normalizedTarget);
+      const chunksByFile = /* @__PURE__ */ new Map();
+      for (const chunk of dependentChunks) {
+        const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+        const existing = chunksByFile.get(canonical) || [];
+        existing.push(chunk);
+        chunksByFile.set(canonical, existing);
+      }
+      const fileComplexities = calculateFileComplexities(chunksByFile);
+      const complexityMetrics = calculateOverallComplexityMetrics(fileComplexities);
+      const uniqueFiles = Array.from(chunksByFile.keys()).map((filepath) => ({
+        filepath,
+        isTestFile: isTestFile2(filepath)
+      }));
+      const riskLevel = calculateRiskLevel(uniqueFiles.length, complexityMetrics.complexityRiskBoost);
+      log(`Found ${uniqueFiles.length} dependent files (risk: ${riskLevel}${complexityMetrics.filesWithComplexityData > 0 ? ", complexity-boosted" : ""})`);
+      return {
+        indexInfo: getIndexMetadata(),
+        filepath: validatedArgs.filepath,
+        dependentCount: uniqueFiles.length,
+        riskLevel,
+        dependents: uniqueFiles,
+        complexityMetrics,
+        note: hitLimit ? `Warning: Scanned ${SCAN_LIMIT2} chunks (limit reached). Results may be incomplete.` : void 0
+      };
+    }
+  )(args);
+}
+
+// src/mcp/handlers/get-complexity.ts
+import collect from "collect.js";
+
+// src/insights/types.ts
+var RISK_ORDER2 = { low: 0, medium: 1, high: 2, critical: 3 };
+
+// src/indexer/dependency-analyzer.ts
+var DEPENDENT_COUNT_THRESHOLDS2 = {
+  LOW: 5,
+  // Few dependents, safe to change
+  MEDIUM: 15,
+  // Moderate impact, review dependents
+  HIGH: 30
+  // High impact, careful planning needed
+};
+var COMPLEXITY_THRESHOLDS2 = {
+  HIGH_COMPLEXITY_DEPENDENT: 10,
+  // Individual file is complex
+  CRITICAL_AVG: 15,
+  // Average complexity indicates systemic complexity
+  CRITICAL_MAX: 25,
+  // Peak complexity indicates hotspot
+  HIGH_AVG: 10,
+  // Moderately complex on average
+  HIGH_MAX: 20,
+  // Some complex functions exist
+  MEDIUM_AVG: 6,
+  // Slightly above simple code
+  MEDIUM_MAX: 15
+  // Occasional branching
+};
+function createPathNormalizer(workspaceRoot) {
+  const cache = /* @__PURE__ */ new Map();
+  return (path23) => {
+    const cached = cache.get(path23);
+    if (cached !== void 0) return cached;
+    const normalized = normalizePath(path23, workspaceRoot);
+    cache.set(path23, normalized);
+    return normalized;
+  };
+}
+function buildImportIndex2(chunks, normalizePathCached) {
+  const importIndex = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const imports = chunk.metadata.imports || [];
+    for (const imp of imports) {
+      const normalizedImport = normalizePathCached(imp);
+      let chunkList = importIndex.get(normalizedImport);
+      if (!chunkList) {
+        chunkList = [];
+        importIndex.set(normalizedImport, chunkList);
+      }
+      chunkList.push(chunk);
+    }
+  }
+  return importIndex;
+}
+function findDependentChunks2(normalizedTarget, importIndex) {
+  const dependentChunks = [];
+  const seenChunkIds = /* @__PURE__ */ new Set();
+  const addChunk = (chunk) => {
+    const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+    if (!seenChunkIds.has(chunkId)) {
+      dependentChunks.push(chunk);
+      seenChunkIds.add(chunkId);
+    }
+  };
+  const directMatches = importIndex.get(normalizedTarget);
+  if (directMatches) {
+    for (const chunk of directMatches) {
+      addChunk(chunk);
+    }
+  }
+  for (const [normalizedImport, chunks] of importIndex.entries()) {
+    if (normalizedImport !== normalizedTarget && matchesFile(normalizedImport, normalizedTarget)) {
+      for (const chunk of chunks) {
+        addChunk(chunk);
+      }
+    }
+  }
+  return dependentChunks;
+}
+function groupChunksByFile(chunks, workspaceRoot) {
+  const chunksByFile = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+    let existing = chunksByFile.get(canonical);
+    if (!existing) {
+      existing = [];
+      chunksByFile.set(canonical, existing);
+    }
+    existing.push(chunk);
+  }
+  return chunksByFile;
+}
+function calculateFileComplexities2(chunksByFile) {
+  const fileComplexities = [];
+  for (const [filepath, chunks] of chunksByFile.entries()) {
+    const complexities = chunks.map((c) => c.metadata.complexity).filter((c) => typeof c === "number" && c > 0);
+    if (complexities.length > 0) {
+      const sum = complexities.reduce((a, b) => a + b, 0);
+      const avg = sum / complexities.length;
+      const max = Math.max(...complexities);
+      fileComplexities.push({
+        filepath,
+        avgComplexity: Math.round(avg * 10) / 10,
+        maxComplexity: max,
+        complexityScore: sum,
+        chunksWithComplexity: complexities.length
+      });
+    }
+  }
+  return fileComplexities;
+}
+function calculateOverallComplexityMetrics2(fileComplexities) {
+  if (fileComplexities.length === 0) {
+    return void 0;
+  }
+  const allAvgs = fileComplexities.map((f) => f.avgComplexity);
+  const allMaxes = fileComplexities.map((f) => f.maxComplexity);
+  const totalAvg = allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length;
+  const globalMax = Math.max(...allMaxes);
+  const highComplexityDependents = fileComplexities.filter((f) => f.maxComplexity > COMPLEXITY_THRESHOLDS2.HIGH_COMPLEXITY_DEPENDENT).sort((a, b) => b.maxComplexity - a.maxComplexity).slice(0, 5).map((f) => ({
+    filepath: f.filepath,
+    maxComplexity: f.maxComplexity,
+    avgComplexity: f.avgComplexity
+  }));
+  const complexityRiskBoost = calculateComplexityRiskBoost2(totalAvg, globalMax);
+  return {
+    averageComplexity: Math.round(totalAvg * 10) / 10,
+    maxComplexity: globalMax,
+    filesWithComplexityData: fileComplexities.length,
+    highComplexityDependents,
+    complexityRiskBoost
+  };
+}
+function calculateComplexityRiskBoost2(avgComplexity, maxComplexity) {
+  if (avgComplexity > COMPLEXITY_THRESHOLDS2.CRITICAL_AVG || maxComplexity > COMPLEXITY_THRESHOLDS2.CRITICAL_MAX) {
+    return "critical";
+  }
+  if (avgComplexity > COMPLEXITY_THRESHOLDS2.HIGH_AVG || maxComplexity > COMPLEXITY_THRESHOLDS2.HIGH_MAX) {
+    return "high";
+  }
+  if (avgComplexity > COMPLEXITY_THRESHOLDS2.MEDIUM_AVG || maxComplexity > COMPLEXITY_THRESHOLDS2.MEDIUM_MAX) {
+    return "medium";
+  }
+  return "low";
+}
+function calculateRiskLevelFromCount(count) {
+  if (count <= DEPENDENT_COUNT_THRESHOLDS2.LOW) {
+    return "low";
+  }
+  if (count <= DEPENDENT_COUNT_THRESHOLDS2.MEDIUM) {
+    return "medium";
+  }
+  if (count <= DEPENDENT_COUNT_THRESHOLDS2.HIGH) {
+    return "high";
+  }
+  return "critical";
+}
+function analyzeDependencies(targetFilepath, allChunks, workspaceRoot) {
+  const normalizePathCached = createPathNormalizer(workspaceRoot);
+  const importIndex = buildImportIndex2(allChunks, normalizePathCached);
+  const normalizedTarget = normalizePathCached(targetFilepath);
+  const dependentChunks = findDependentChunks2(normalizedTarget, importIndex);
+  const chunksByFile = groupChunksByFile(dependentChunks, workspaceRoot);
+  const fileComplexities = calculateFileComplexities2(chunksByFile);
+  const complexityMetrics = calculateOverallComplexityMetrics2(fileComplexities);
+  const dependents = Array.from(chunksByFile.keys()).map((filepath) => ({
+    filepath,
+    isTestFile: isTestFile2(filepath)
+  }));
+  let riskLevel = calculateRiskLevelFromCount(dependents.length);
+  if (complexityMetrics?.complexityRiskBoost) {
+    if (RISK_ORDER2[complexityMetrics.complexityRiskBoost] > RISK_ORDER2[riskLevel]) {
+      riskLevel = complexityMetrics.complexityRiskBoost;
+    }
+  }
+  return {
+    dependents,
+    dependentCount: dependents.length,
+    riskLevel,
+    complexityMetrics
+  };
+}
+
+// src/insights/complexity-analyzer.ts
+var SEVERITY = { warning: 1, error: 2 };
+var ComplexityAnalyzer = class {
+  constructor(vectorDB, config) {
+    this.vectorDB = vectorDB;
+    this.config = config;
+  }
+  /**
+   * Analyze complexity of codebase or specific files
+   * @param files - Optional list of specific files to analyze
+   * @returns Complexity report with violations and summary
+   */
+  async analyze(files) {
+    const allChunks = await this.vectorDB.scanAll();
+    const chunks = files ? allChunks.filter((c) => this.matchesAnyFile(c.metadata.file, files)) : allChunks;
+    const violations = this.findViolations(chunks);
+    const report = this.buildReport(violations, chunks);
+    this.enrichWithDependencies(report, allChunks);
+    return report;
+  }
+  /**
+   * Normalize a file path to a consistent relative format
+   * Converts absolute paths to relative paths from workspace root
+   */
+  normalizeFilePath(filepath) {
+    const workspaceRoot = process.cwd();
+    const normalized = filepath.replace(/\\/g, "/");
+    const normalizedRoot = workspaceRoot.replace(/\\/g, "/");
+    if (normalized.startsWith(normalizedRoot + "/")) {
+      return normalized.slice(normalizedRoot.length + 1);
+    }
+    if (normalized.startsWith(normalizedRoot)) {
+      return normalized.slice(normalizedRoot.length);
+    }
+    return normalized;
+  }
+  /**
+   * Check if a chunk's file matches any of the target files
+   * Uses exact match or suffix matching to avoid unintended matches
+   */
+  matchesAnyFile(chunkFile2, targetFiles) {
+    const normalizedChunkFile = chunkFile2.replace(/\\/g, "/");
+    return targetFiles.some((target) => {
+      const normalizedTarget = target.replace(/\\/g, "/");
+      return normalizedChunkFile === normalizedTarget || normalizedChunkFile.endsWith("/" + normalizedTarget);
+    });
+  }
+  /**
+   * Create a violation if complexity exceeds threshold
+   */
+  createViolation(metadata, complexity, baseThreshold, metricType) {
+    const warningThreshold = baseThreshold * SEVERITY.warning;
+    const errorThreshold = baseThreshold * SEVERITY.error;
+    if (complexity < warningThreshold) return null;
+    const violationSeverity = complexity >= errorThreshold ? "error" : "warning";
+    const effectiveThreshold = violationSeverity === "error" ? errorThreshold : warningThreshold;
+    const message = metricType === "cyclomatic" ? `Needs ~${complexity} test cases for full coverage (threshold: ${Math.round(effectiveThreshold)})` : `Mental load ${complexity} exceeds threshold ${Math.round(effectiveThreshold)} (hard to follow)`;
+    return {
+      filepath: metadata.file,
+      startLine: metadata.startLine,
+      endLine: metadata.endLine,
+      symbolName: metadata.symbolName || "unknown",
+      symbolType: metadata.symbolType,
+      language: metadata.language,
+      complexity,
+      threshold: Math.round(effectiveThreshold),
+      severity: violationSeverity,
+      message,
+      metricType
+    };
+  }
+  /**
+   * Deduplicate and filter chunks to only function/method types.
+   * Handles potential index duplicates by tracking file+line ranges.
+   */
+  getUniqueFunctionChunks(chunks) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const { metadata } of chunks) {
+      if (metadata.symbolType !== "function" && metadata.symbolType !== "method") continue;
+      const key = `${metadata.file}:${metadata.startLine}-${metadata.endLine}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      result.push(metadata);
+    }
+    return result;
+  }
+  /**
+   * Convert Halstead effort to time in minutes.
+   * Formula: Time (seconds) = Effort / 18 (Stroud number for mental discrimination)
+   *          Time (minutes) = Effort / (18 * 60) = Effort / 1080
+   */
+  effortToMinutes(effort) {
+    return effort / 1080;
+  }
+  /**
+   * Format minutes as human-readable time (e.g., "2h 30m" or "45m")
+   */
+  formatTime(minutes) {
+    if (minutes >= 60) {
+      const hours = Math.floor(minutes / 60);
+      const mins = Math.round(minutes % 60);
+      return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+    }
+    return `${Math.round(minutes)}m`;
+  }
+  /**
+   * Create a Halstead violation if metrics exceed thresholds
+   */
+  createHalsteadViolation(metadata, metricValue, threshold, metricType) {
+    const warningThreshold = threshold * SEVERITY.warning;
+    const errorThreshold = threshold * SEVERITY.error;
+    if (metricValue < warningThreshold) return null;
+    const violationSeverity = metricValue >= errorThreshold ? "error" : "warning";
+    const effectiveThreshold = violationSeverity === "error" ? errorThreshold : warningThreshold;
+    let message;
+    if (metricType === "halstead_effort") {
+      const timeMinutes = this.effortToMinutes(metricValue);
+      const thresholdMinutes = this.effortToMinutes(effectiveThreshold);
+      message = `Time to understand ~${this.formatTime(timeMinutes)} exceeds threshold ${this.formatTime(thresholdMinutes)}`;
+    } else {
+      message = `Estimated bugs ${metricValue.toFixed(2)} exceeds threshold ${effectiveThreshold.toFixed(1)}`;
+    }
+    const halsteadDetails = {
+      volume: metadata.halsteadVolume || 0,
+      difficulty: metadata.halsteadDifficulty || 0,
+      effort: metadata.halsteadEffort || 0,
+      bugs: metadata.halsteadBugs || 0
+    };
+    let complexity;
+    let displayThreshold;
+    if (metricType === "halstead_effort") {
+      complexity = Math.round(this.effortToMinutes(metricValue));
+      displayThreshold = Math.round(this.effortToMinutes(effectiveThreshold));
+    } else {
+      complexity = metricValue;
+      displayThreshold = effectiveThreshold;
+    }
+    return {
+      filepath: metadata.file,
+      startLine: metadata.startLine,
+      endLine: metadata.endLine,
+      symbolName: metadata.symbolName || "unknown",
+      symbolType: metadata.symbolType,
+      language: metadata.language,
+      complexity,
+      threshold: displayThreshold,
+      severity: violationSeverity,
+      message,
+      metricType,
+      halsteadDetails
+    };
+  }
+  /**
+   * Check complexity metrics and create violations for a single chunk.
+   */
+  checkChunkComplexity(metadata, thresholds) {
+    const violations = [];
+    if (metadata.complexity) {
+      const v = this.createViolation(metadata, metadata.complexity, thresholds.testPaths, "cyclomatic");
+      if (v) violations.push(v);
+    }
+    if (metadata.cognitiveComplexity) {
+      const v = this.createViolation(metadata, metadata.cognitiveComplexity, thresholds.mentalLoad, "cognitive");
+      if (v) violations.push(v);
+    }
+    if (thresholds.halsteadEffort && metadata.halsteadEffort) {
+      const v = this.createHalsteadViolation(metadata, metadata.halsteadEffort, thresholds.halsteadEffort, "halstead_effort");
+      if (v) violations.push(v);
+    }
+    if (thresholds.estimatedBugs && metadata.halsteadBugs) {
+      const v = this.createHalsteadViolation(metadata, metadata.halsteadBugs, thresholds.estimatedBugs, "halstead_bugs");
+      if (v) violations.push(v);
+    }
+    return violations;
+  }
+  /**
+   * Convert time in minutes to Halstead effort.
+   * This is the inverse of effortToMinutes().
+   * Formula: Time (seconds) = Effort / 18 (Stroud number)
+   *          So: Effort = Time (minutes) * 60 * 18 = Time * 1080
+   */
+  minutesToEffort(minutes) {
+    return minutes * 1080;
+  }
+  /**
+   * Find all complexity violations based on thresholds.
+   * Checks cyclomatic, cognitive, and Halstead complexity.
+   */
+  findViolations(chunks) {
+    const configThresholds = this.config.complexity?.thresholds;
+    const halsteadEffort = configThresholds?.timeToUnderstandMinutes ? this.minutesToEffort(configThresholds.timeToUnderstandMinutes) : this.minutesToEffort(60);
+    const thresholds = {
+      testPaths: configThresholds?.testPaths ?? 15,
+      mentalLoad: configThresholds?.mentalLoad ?? 15,
+      halsteadEffort,
+      // Converted from minutes to effort internally (see above)
+      estimatedBugs: configThresholds?.estimatedBugs ?? 1.5
+      // Direct decimal value (no conversion needed)
+    };
+    const functionChunks = this.getUniqueFunctionChunks(chunks);
+    return functionChunks.flatMap(
+      (metadata) => this.checkChunkComplexity(metadata, thresholds)
+    );
+  }
+  /**
+   * Build the final report with summary and per-file data
+   */
+  buildReport(violations, allChunks) {
+    const fileViolationsMap = /* @__PURE__ */ new Map();
+    for (const violation of violations) {
+      const normalizedPath = this.normalizeFilePath(violation.filepath);
+      violation.filepath = normalizedPath;
+      const existing = fileViolationsMap.get(normalizedPath) || [];
+      existing.push(violation);
+      fileViolationsMap.set(normalizedPath, existing);
+    }
+    const analyzedFiles = new Set(allChunks.map((c) => this.normalizeFilePath(c.metadata.file)));
+    const files = {};
+    for (const filepath of analyzedFiles) {
+      const fileViolations = fileViolationsMap.get(filepath) || [];
+      files[filepath] = {
+        violations: fileViolations,
+        dependents: [],
+        // Will be enriched later if needed
+        testAssociations: [],
+        // Will be enriched later if needed
+        riskLevel: this.calculateRiskLevel(fileViolations)
+      };
+    }
+    const errorCount = violations.filter((v) => v.severity === "error").length;
+    const warningCount = violations.filter((v) => v.severity === "warning").length;
+    const complexityValues = allChunks.filter((c) => c.metadata.complexity !== void 0 && c.metadata.complexity > 0).map((c) => c.metadata.complexity);
+    const avgComplexity = complexityValues.length > 0 ? complexityValues.reduce((sum, val) => sum + val, 0) / complexityValues.length : 0;
+    const maxComplexity = complexityValues.length > 0 ? Math.max(...complexityValues) : 0;
+    return {
+      summary: {
+        filesAnalyzed: analyzedFiles.size,
+        totalViolations: violations.length,
+        bySeverity: { error: errorCount, warning: warningCount },
+        avgComplexity: Math.round(avgComplexity * 10) / 10,
+        // Round to 1 decimal
+        maxComplexity
+      },
+      files
+    };
+  }
+  /**
+   * Calculate risk level based on violations
+   */
+  calculateRiskLevel(violations) {
+    if (violations.length === 0) return "low";
+    const hasErrors = violations.some((v) => v.severity === "error");
+    const errorCount = violations.filter((v) => v.severity === "error").length;
+    if (errorCount >= 3) return "critical";
+    if (hasErrors) return "high";
+    if (violations.length >= 3) return "medium";
+    return "low";
+  }
+  /**
+   * Enrich files with violations with dependency data
+   * This adds:
+   * - List of dependent files (who imports this?)
+   * - Boosted risk level based on dependents + complexity
+   */
+  enrichWithDependencies(report, allChunks) {
+    const workspaceRoot = process.cwd();
+    const filesWithViolations = Object.entries(report.files).filter(([_, data]) => data.violations.length > 0).map(([filepath, _]) => filepath);
+    for (const filepath of filesWithViolations) {
+      const fileData = report.files[filepath];
+      const depAnalysis = analyzeDependencies(filepath, allChunks, workspaceRoot);
+      fileData.dependents = depAnalysis.dependents.map((d) => d.filepath);
+      fileData.dependentCount = depAnalysis.dependentCount;
+      if (RISK_ORDER2[depAnalysis.riskLevel] > RISK_ORDER2[fileData.riskLevel]) {
+        fileData.riskLevel = depAnalysis.riskLevel;
+      }
+      if (depAnalysis.complexityMetrics) {
+        fileData.dependentComplexityMetrics = {
+          averageComplexity: depAnalysis.complexityMetrics.averageComplexity,
+          maxComplexity: depAnalysis.complexityMetrics.maxComplexity,
+          filesWithComplexityData: depAnalysis.complexityMetrics.filesWithComplexityData
+        };
+      }
+    }
+  }
+};
+
+// src/mcp/handlers/get-complexity.ts
+function transformViolation(v, fileData) {
+  return {
+    filepath: v.filepath,
+    symbolName: v.symbolName,
+    symbolType: v.symbolType,
+    startLine: v.startLine,
+    endLine: v.endLine,
+    complexity: v.complexity,
+    metricType: v.metricType,
+    threshold: v.threshold,
+    severity: v.severity,
+    language: v.language,
+    message: v.message,
+    dependentCount: fileData.dependentCount || 0,
+    riskLevel: fileData.riskLevel,
+    ...v.halsteadDetails && { halsteadDetails: v.halsteadDetails }
+  };
+}
+async function handleGetComplexity(args, ctx) {
+  const { vectorDB, config, log, checkAndReconnect, getIndexMetadata } = ctx;
+  return await wrapToolHandler(
+    GetComplexitySchema,
+    async (validatedArgs) => {
+      log("Analyzing complexity...");
+      await checkAndReconnect();
+      const analyzer = new ComplexityAnalyzer(vectorDB, config);
+      const report = await analyzer.analyze(validatedArgs.files);
+      log(`Analyzed ${report.summary.filesAnalyzed} files`);
+      const allViolations = collect(Object.entries(report.files)).flatMap(
+        ([, fileData]) => fileData.violations.map((v) => transformViolation(v, fileData))
+      ).sortByDesc("complexity").all();
+      const violations = validatedArgs.threshold !== void 0 ? allViolations.filter((v) => v.complexity >= validatedArgs.threshold) : allViolations;
+      const topViolations = violations.slice(0, validatedArgs.top);
+      const bySeverity = collect(violations).countBy("severity").all();
+      return {
+        indexInfo: getIndexMetadata(),
+        summary: {
+          filesAnalyzed: report.summary.filesAnalyzed,
+          avgComplexity: report.summary.avgComplexity,
+          maxComplexity: report.summary.maxComplexity,
+          violationCount: violations.length,
+          bySeverity: {
+            error: bySeverity["error"] || 0,
+            warning: bySeverity["warning"] || 0
+          }
+        },
+        violations: topViolations
+      };
+    }
+  )(args);
+}
+
+// src/mcp/handlers/index.ts
+var toolHandlers = {
+  "semantic_search": handleSemanticSearch,
+  "find_similar": handleFindSimilar,
+  "get_files_context": handleGetFilesContext,
+  "list_functions": handleListFunctions,
+  "get_dependents": handleGetDependents,
+  "get_complexity": handleGetComplexity
+};
+
+// src/mcp/server.ts
+init_lancedb();
+init_local();
+init_tracker();
+init_incremental();
+init_service();
+init_manifest();
+init_utils();
+
+// src/watcher/index.ts
+init_schema();
+import chokidar from "chokidar";
+var FileWatcher = class {
+  watcher = null;
+  debounceTimers = /* @__PURE__ */ new Map();
+  config;
+  rootDir;
+  onChangeHandler = null;
+  constructor(rootDir, config) {
+    this.rootDir = rootDir;
+    this.config = config;
+  }
+  /**
+   * Starts watching files for changes.
+   * 
+   * @param handler - Callback function called when files change
+   */
+  async start(handler) {
+    if (this.watcher) {
+      throw new Error("File watcher is already running");
+    }
+    this.onChangeHandler = handler;
+    let includePatterns;
+    let excludePatterns;
+    if (isLegacyConfig(this.config)) {
+      includePatterns = this.config.indexing.include;
+      excludePatterns = this.config.indexing.exclude;
+    } else if (isModernConfig(this.config)) {
+      includePatterns = this.config.frameworks.flatMap((f) => f.config.include);
+      excludePatterns = this.config.frameworks.flatMap((f) => f.config.exclude);
+    } else {
+      includePatterns = ["**/*"];
+      excludePatterns = [];
+    }
+    this.watcher = chokidar.watch(includePatterns, {
+      cwd: this.rootDir,
+      ignored: excludePatterns,
+      persistent: true,
+      ignoreInitial: true,
+      // Don't trigger for existing files
+      awaitWriteFinish: {
+        stabilityThreshold: 500,
+        // Wait 500ms for file to stop changing
+        pollInterval: 100
+      },
+      // Performance optimizations
+      usePolling: false,
+      interval: 100,
+      binaryInterval: 300
+    });
+    this.watcher.on("add", (filepath) => this.handleChange("add", filepath)).on("change", (filepath) => this.handleChange("change", filepath)).on("unlink", (filepath) => this.handleChange("unlink", filepath)).on("error", (error) => {
+      console.error(`[Lien] File watcher error: ${error}`);
+    });
+    await new Promise((resolve) => {
+      this.watcher.on("ready", () => {
+        resolve();
+      });
+    });
+  }
+  /**
+   * Handles a file change event with debouncing.
+   * Debouncing prevents rapid reindexing when files are saved multiple times quickly.
+   */
+  handleChange(type, filepath) {
+    const existingTimer = this.debounceTimers.get(filepath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(filepath);
+      if (this.onChangeHandler) {
+        const absolutePath = filepath.startsWith("/") ? filepath : `${this.rootDir}/${filepath}`;
+        try {
+          const result = this.onChangeHandler({
+            type,
+            filepath: absolutePath
+          });
+          if (result instanceof Promise) {
+            result.catch((error) => {
+              console.error(`[Lien] Error handling file change: ${error}`);
+            });
+          }
+        } catch (error) {
+          console.error(`[Lien] Error handling file change: ${error}`);
+        }
+      }
+    }, this.config.fileWatching.debounceMs);
+    this.debounceTimers.set(filepath, timer);
+  }
+  /**
+   * Stops the file watcher and cleans up resources.
+   */
+  async stop() {
+    if (!this.watcher) {
+      return;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+    await this.watcher.close();
+    this.watcher = null;
+    this.onChangeHandler = null;
+  }
+  /**
+   * Gets the list of files currently being watched.
+   */
+  getWatchedFiles() {
+    if (!this.watcher) {
+      return [];
+    }
+    const watched = this.watcher.getWatched();
+    const files = [];
+    for (const [dir, filenames] of Object.entries(watched)) {
+      for (const filename of filenames) {
+        files.push(`${dir}/${filename}`);
+      }
+    }
+    return files;
+  }
+  /**
+   * Checks if the watcher is currently running.
+   */
+  isRunning() {
+    return this.watcher !== null;
+  }
+};
+
+// src/mcp/server.ts
+init_constants();
+init_errors();
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname3(__filename4);
+var require4 = createRequire3(import.meta.url);
+var packageJson3;
+try {
+  packageJson3 = require4(join3(__dirname4, "../package.json"));
+} catch {
+  packageJson3 = require4(join3(__dirname4, "../../package.json"));
+}
+async function initializeDatabase(rootDir, log) {
+  const embeddings = new LocalEmbeddings();
+  const vectorDB = new VectorDB(rootDir);
+  log("Loading embedding model...");
+  await embeddings.initialize();
+  log("Loading vector database...");
+  await vectorDB.initialize();
+  log("Embeddings and vector DB ready");
+  return { embeddings, vectorDB };
+}
+async function handleAutoIndexing(vectorDB, config, rootDir, log) {
+  const hasIndex = await vectorDB.hasData();
+  if (!hasIndex && config.mcp.autoIndexOnFirstRun) {
+    log("\u{1F4E6} No index found - running initial indexing...");
+    log("\u23F1\uFE0F  This may take 5-20 minutes depending on project size");
     try {
-      const versionChanged = await vectorDB.checkVersion();
-      if (versionChanged) {
-        log("Index version changed, reconnecting to database...");
-        await vectorDB.reconnect();
-        log("Reconnected to updated index");
+      const { indexCodebase: indexCodebase2 } = await Promise.resolve().then(() => (init_indexer(), indexer_exports));
+      await indexCodebase2({ rootDir, verbose: true });
+      log("\u2705 Initial indexing complete!");
+    } catch (error) {
+      log(`\u26A0\uFE0F  Initial indexing failed: ${error}`, "warning");
+      log("You can manually run: lien index", "warning");
+    }
+  } else if (!hasIndex) {
+    log("\u26A0\uFE0F  No index found. Auto-indexing is disabled in config.", "warning");
+    log('Run "lien index" to index your codebase.', "warning");
+  }
+}
+async function setupGitDetection(config, rootDir, vectorDB, embeddings, verbose, log) {
+  if (!config.gitDetection.enabled) {
+    log("Git detection disabled by configuration");
+    return { gitTracker: null, gitPollInterval: null };
+  }
+  const gitAvailable = await isGitAvailable();
+  const isRepo = await isGitRepo(rootDir);
+  if (!gitAvailable) {
+    log("Git not available - git detection disabled");
+    return { gitTracker: null, gitPollInterval: null };
+  }
+  if (!isRepo) {
+    log("Not a git repository - git detection disabled");
+    return { gitTracker: null, gitPollInterval: null };
+  }
+  log("\u2713 Detected git repository");
+  const gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
+  try {
+    log("Checking for git changes...");
+    const changedFiles = await gitTracker.initialize();
+    if (changedFiles && changedFiles.length > 0) {
+      log(`\u{1F33F} Git changes detected: ${changedFiles.length} files changed`);
+      const count = await indexMultipleFiles(changedFiles, vectorDB, embeddings, config, { verbose });
+      log(`\u2713 Reindexed ${count} files`);
+    } else {
+      log("\u2713 Index is up to date with git state");
+    }
+  } catch (error) {
+    log(`Failed to check git state on startup: ${error}`, "warning");
+  }
+  log(`\u2713 Git detection enabled (checking every ${config.gitDetection.pollIntervalMs / 1e3}s)`);
+  const gitPollInterval = setInterval(async () => {
+    try {
+      const changedFiles = await gitTracker.detectChanges();
+      if (changedFiles && changedFiles.length > 0) {
+        log(`\u{1F33F} Git change detected: ${changedFiles.length} files changed`);
+        indexMultipleFiles(changedFiles, vectorDB, embeddings, config, { verbose }).then((count) => log(`\u2713 Background reindex complete: ${count} files`)).catch((error) => log(`Background reindex failed: ${error}`, "warning"));
       }
     } catch (error) {
-      log(`Version check failed: ${error}`);
+      log(`Git detection check failed: ${error}`, "warning");
     }
-  };
-  const getIndexMetadata = () => ({
-    indexVersion: vectorDB.getCurrentVersion(),
-    indexDate: vectorDB.getVersionDate()
-  });
-  const versionCheckInterval = setInterval(async () => {
-    await checkAndReconnect();
-  }, VERSION_CHECK_INTERVAL_MS);
+  }, config.gitDetection.pollIntervalMs);
+  return { gitTracker, gitPollInterval };
+}
+async function setupFileWatching(watch, config, rootDir, vectorDB, embeddings, verbose, log) {
+  const fileWatchingEnabled = watch !== void 0 ? watch : config.fileWatching.enabled;
+  if (!fileWatchingEnabled) return null;
+  log("\u{1F440} Starting file watcher...");
+  const fileWatcher = new FileWatcher(rootDir, config);
+  try {
+    await fileWatcher.start(async (event) => {
+      const { type, filepath } = event;
+      if (type === "unlink") {
+        log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
+        try {
+          await vectorDB.deleteByFile(filepath);
+          const manifest = new ManifestManager(vectorDB.dbPath);
+          await manifest.removeFile(filepath);
+          log(`\u2713 Removed ${filepath} from index`);
+        } catch (error) {
+          log(`Failed to remove ${filepath}: ${error}`, "warning");
+        }
+      } else {
+        const action = type === "add" ? "added" : "changed";
+        log(`\u{1F4DD} File ${action}: ${filepath}`);
+        indexSingleFile(filepath, vectorDB, embeddings, config, { verbose }).catch((error) => log(`Failed to reindex ${filepath}: ${error}`, "warning"));
+      }
+    });
+    log(`\u2713 File watching enabled (watching ${fileWatcher.getWatchedFiles().length} files)`);
+    return fileWatcher;
+  } catch (error) {
+    log(`Failed to start file watcher: ${error}`, "warning");
+    return null;
+  }
+}
+function registerToolCallHandler(server, toolContext, log) {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     log(`Handling tool call: ${name}`);
+    const handler = toolHandlers[name];
+    if (!handler) {
+      const error = new LienError(
+        `Unknown tool: ${name}`,
+        "INVALID_INPUT" /* INVALID_INPUT */,
+        { requestedTool: name, availableTools: tools.map((t) => t.name) },
+        "medium",
+        false,
+        false
+      );
+      return { isError: true, content: [{ type: "text", text: JSON.stringify(error.toJSON(), null, 2) }] };
+    }
     try {
-      switch (name) {
-        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_files_context":
-          return await wrapToolHandler(
-            GetFilesContextSchema,
-            async (validatedArgs) => {
-              const filepaths = Array.isArray(validatedArgs.filepaths) ? validatedArgs.filepaths : [validatedArgs.filepaths];
-              const isSingleFile = !Array.isArray(validatedArgs.filepaths);
-              log(`Getting context for: ${filepaths.join(", ")}`);
-              await checkAndReconnect();
-              const workspaceRoot = process.cwd().replace(/\\/g, "/");
-              const fileEmbeddings = await Promise.all(filepaths.map((fp) => embeddings.embed(fp)));
-              const allFileSearches = await Promise.all(
-                fileEmbeddings.map(
-                  (embedding, i) => vectorDB.search(embedding, 50, filepaths[i])
-                )
-              );
-              const fileChunksMap = filepaths.map((filepath, i) => {
-                const allResults = allFileSearches[i];
-                const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
-                return allResults.filter((r) => {
-                  const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
-                  return chunkCanonical === targetCanonical;
-                });
-              });
-              let relatedChunksMap = [];
-              if (validatedArgs.includeRelated) {
-                const filesWithChunks = fileChunksMap.map((chunks, i) => ({ chunks, filepath: filepaths[i], index: i })).filter(({ chunks }) => chunks.length > 0);
-                if (filesWithChunks.length > 0) {
-                  const relatedEmbeddings = await Promise.all(
-                    filesWithChunks.map(({ chunks }) => embeddings.embed(chunks[0].content))
-                  );
-                  const relatedSearches = await Promise.all(
-                    relatedEmbeddings.map(
-                      (embedding, i) => vectorDB.search(embedding, 5, filesWithChunks[i].chunks[0].content)
-                    )
-                  );
-                  relatedChunksMap = Array.from({ length: filepaths.length }, () => []);
-                  filesWithChunks.forEach(({ filepath, index }, i) => {
-                    const related = relatedSearches[i];
-                    const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
-                    relatedChunksMap[index] = related.filter((r) => {
-                      const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
-                      return chunkCanonical !== targetCanonical;
-                    });
-                  });
-                }
-              }
-              const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
-              if (allChunks.length === SCAN_LIMIT) {
-                log(`WARNING: Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`);
-              }
-              const pathCache = /* @__PURE__ */ new Map();
-              const normalizePathCached = (path19) => {
-                if (pathCache.has(path19)) return pathCache.get(path19);
-                const normalized = normalizePath(path19, workspaceRoot);
-                pathCache.set(path19, normalized);
-                return normalized;
-              };
-              const testAssociationsMap = filepaths.map((filepath) => {
-                const normalizedTarget = normalizePathCached(filepath);
-                const testFiles = /* @__PURE__ */ new Set();
-                for (const chunk of allChunks) {
-                  const chunkFile2 = getCanonicalPath(chunk.metadata.file, workspaceRoot);
-                  if (!isTestFile2(chunkFile2)) continue;
-                  const imports = chunk.metadata.imports || [];
-                  for (const imp of imports) {
-                    const normalizedImport = normalizePathCached(imp);
-                    if (matchesFile(normalizedImport, normalizedTarget)) {
-                      testFiles.add(chunkFile2);
-                      break;
-                    }
-                  }
-                }
-                return Array.from(testFiles);
-              });
-              const filesData = {};
-              filepaths.forEach((filepath, i) => {
-                const fileChunks = fileChunksMap[i];
-                const relatedChunks = relatedChunksMap[i] || [];
-                const seenChunks = /* @__PURE__ */ new Set();
-                const dedupedChunks = [...fileChunks, ...relatedChunks].filter((chunk) => {
-                  const canonicalFile = getCanonicalPath(chunk.metadata.file, workspaceRoot);
-                  const chunkId = `${canonicalFile}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
-                  if (seenChunks.has(chunkId)) return false;
-                  seenChunks.add(chunkId);
-                  return true;
-                });
-                filesData[filepath] = {
-                  chunks: dedupedChunks,
-                  testAssociations: testAssociationsMap[i]
-                };
-              });
-              log(`Found ${Object.values(filesData).reduce((sum, f) => sum + f.chunks.length, 0)} total chunks`);
-              if (isSingleFile) {
-                const filepath = filepaths[0];
-                return {
-                  indexInfo: getIndexMetadata(),
-                  file: filepath,
-                  chunks: filesData[filepath].chunks,
-                  testAssociations: filesData[filepath].testAssociations
-                };
-              } else {
-                return {
-                  indexInfo: getIndexMetadata(),
-                  files: filesData
-                };
-              }
-            }
-          )(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);
-        case "get_dependents":
-          return await wrapToolHandler(
-            GetDependentsSchema,
-            async (validatedArgs) => {
-              log(`Finding dependents of: ${validatedArgs.filepath}`);
-              await checkAndReconnect();
-              const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
-              if (allChunks.length === SCAN_LIMIT) {
-                log(`WARNING: Scanned ${SCAN_LIMIT} chunks (limit reached). Results may be incomplete for large codebases.`);
-              }
-              log(`Scanning ${allChunks.length} chunks for imports...`);
-              const workspaceRoot = process.cwd().replace(/\\/g, "/");
-              const pathCache = /* @__PURE__ */ new Map();
-              const normalizePathCached = (path19) => {
-                if (pathCache.has(path19)) return pathCache.get(path19);
-                const normalized = normalizePath(path19, workspaceRoot);
-                pathCache.set(path19, normalized);
-                return normalized;
-              };
-              const importIndex = /* @__PURE__ */ new Map();
-              for (const chunk of allChunks) {
-                const imports = chunk.metadata.imports || [];
-                for (const imp of imports) {
-                  const normalizedImport = normalizePathCached(imp);
-                  if (!importIndex.has(normalizedImport)) {
-                    importIndex.set(normalizedImport, []);
-                  }
-                  importIndex.get(normalizedImport).push(chunk);
-                }
-              }
-              const normalizedTarget = normalizePathCached(validatedArgs.filepath);
-              const dependentChunks = [];
-              const seenChunkIds = /* @__PURE__ */ new Set();
-              if (importIndex.has(normalizedTarget)) {
-                for (const chunk of importIndex.get(normalizedTarget)) {
-                  const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
-                  if (!seenChunkIds.has(chunkId)) {
-                    dependentChunks.push(chunk);
-                    seenChunkIds.add(chunkId);
-                  }
-                }
-              }
-              for (const [normalizedImport, chunks] of importIndex.entries()) {
-                if (normalizedImport !== normalizedTarget && matchesFile(normalizedImport, normalizedTarget)) {
-                  for (const chunk of chunks) {
-                    const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
-                    if (!seenChunkIds.has(chunkId)) {
-                      dependentChunks.push(chunk);
-                      seenChunkIds.add(chunkId);
-                    }
-                  }
-                }
-              }
-              const chunksByFile = /* @__PURE__ */ new Map();
-              for (const chunk of dependentChunks) {
-                const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
-                const existing = chunksByFile.get(canonical) || [];
-                existing.push(chunk);
-                chunksByFile.set(canonical, existing);
-              }
-              const fileComplexities = [];
-              for (const [filepath, chunks] of chunksByFile.entries()) {
-                const complexities = chunks.map((c) => c.metadata.complexity).filter((c) => typeof c === "number" && c > 0);
-                if (complexities.length > 0) {
-                  const sum = complexities.reduce((a, b) => a + b, 0);
-                  const avg = sum / complexities.length;
-                  const max = Math.max(...complexities);
-                  fileComplexities.push({
-                    filepath,
-                    avgComplexity: Math.round(avg * 10) / 10,
-                    // Round to 1 decimal
-                    maxComplexity: max,
-                    complexityScore: sum,
-                    chunksWithComplexity: complexities.length
-                  });
-                }
-              }
-              let complexityMetrics;
-              if (fileComplexities.length > 0) {
-                const allAvgs = fileComplexities.map((f) => f.avgComplexity);
-                const allMaxes = fileComplexities.map((f) => f.maxComplexity);
-                const totalAvg = allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length;
-                const globalMax = Math.max(...allMaxes);
-                const highComplexityDependents = fileComplexities.filter((f) => f.maxComplexity > COMPLEXITY_THRESHOLDS.HIGH_COMPLEXITY_DEPENDENT).sort((a, b) => b.maxComplexity - a.maxComplexity).slice(0, 5).map((f) => ({
-                  filepath: f.filepath,
-                  maxComplexity: f.maxComplexity,
-                  avgComplexity: f.avgComplexity
-                }));
-                let complexityRiskBoost = "low";
-                if (totalAvg > COMPLEXITY_THRESHOLDS.CRITICAL_AVG || globalMax > COMPLEXITY_THRESHOLDS.CRITICAL_MAX) {
-                  complexityRiskBoost = "critical";
-                } else if (totalAvg > COMPLEXITY_THRESHOLDS.HIGH_AVG || globalMax > COMPLEXITY_THRESHOLDS.HIGH_MAX) {
-                  complexityRiskBoost = "high";
-                } else if (totalAvg > COMPLEXITY_THRESHOLDS.MEDIUM_AVG || globalMax > COMPLEXITY_THRESHOLDS.MEDIUM_MAX) {
-                  complexityRiskBoost = "medium";
-                }
-                complexityMetrics = {
-                  averageComplexity: Math.round(totalAvg * 10) / 10,
-                  maxComplexity: globalMax,
-                  filesWithComplexityData: fileComplexities.length,
-                  highComplexityDependents,
-                  complexityRiskBoost
-                };
-              } else {
-                complexityMetrics = {
-                  averageComplexity: 0,
-                  maxComplexity: 0,
-                  filesWithComplexityData: 0,
-                  highComplexityDependents: [],
-                  complexityRiskBoost: "low"
-                };
-              }
-              const uniqueFiles = Array.from(chunksByFile.keys()).map((filepath) => ({
-                filepath,
-                isTestFile: isTestFile2(filepath)
-              }));
-              const count = uniqueFiles.length;
-              let riskLevel = count === 0 ? "low" : count <= DEPENDENT_COUNT_THRESHOLDS.LOW ? "low" : count <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM ? "medium" : count <= DEPENDENT_COUNT_THRESHOLDS.HIGH ? "high" : "critical";
-              const RISK_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
-              if (RISK_ORDER[complexityMetrics.complexityRiskBoost] > RISK_ORDER[riskLevel]) {
-                riskLevel = complexityMetrics.complexityRiskBoost;
-              }
-              log(`Found ${count} dependent files (risk: ${riskLevel}${complexityMetrics.filesWithComplexityData > 0 ? ", complexity-boosted" : ""})`);
-              let note;
-              if (allChunks.length === SCAN_LIMIT) {
-                note = `Warning: Scanned ${SCAN_LIMIT} chunks (limit reached). Results may be incomplete for large codebases. Some dependents might not be listed.`;
-              }
-              return {
-                indexInfo: getIndexMetadata(),
-                filepath: validatedArgs.filepath,
-                dependentCount: count,
-                riskLevel,
-                dependents: uniqueFiles,
-                complexityMetrics,
-                note
-              };
-            }
-          )(args);
-        default:
-          throw new LienError(
-            `Unknown tool: ${name}`,
-            "INVALID_INPUT" /* INVALID_INPUT */,
-            { requestedTool: name, availableTools: tools.map((t) => t.name) },
-            "medium",
-            false,
-            false
-          );
-      }
+      return await handler(args, toolContext);
     } catch (error) {
       if (error instanceof LienError) {
-        return {
-          isError: true,
-          content: [{
-            type: "text",
-            text: JSON.stringify(error.toJSON(), null, 2)
-          }]
-        };
+        return { isError: true, content: [{ type: "text", 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)
+          text: JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error", code: "INTERNAL_ERROR" /* INTERNAL_ERROR */, tool: name }, null, 2)
         }]
       };
     }
   });
-  const config = await configService.load(rootDir);
-  const hasIndex = await vectorDB.hasData();
-  if (!hasIndex && config.mcp.autoIndexOnFirstRun) {
-    log("\u{1F4E6} No index found - running initial indexing...");
-    log("\u23F1\uFE0F  This may take 5-20 minutes depending on project size");
-    try {
-      const { indexCodebase: indexCodebase2 } = await Promise.resolve().then(() => (init_indexer(), indexer_exports));
-      await indexCodebase2({ rootDir, verbose: true });
-      log("\u2705 Initial indexing complete!");
-    } catch (error) {
-      log(`\u26A0\uFE0F  Initial indexing failed: ${error}`);
-      log("You can manually run: lien index");
+}
+async function startMCPServer(options) {
+  const { rootDir, verbose, watch } = options;
+  const earlyLog = (message, level = "info") => {
+    if (verbose || level === "warning" || level === "error") {
+      console.error(`[Lien MCP] [${level}] ${message}`);
     }
-  } else if (!hasIndex) {
-    log("\u26A0\uFE0F  No index found. Auto-indexing is disabled in config.");
-    log('Run "lien index" to index your codebase.');
-  }
-  let gitTracker = null;
-  let gitPollInterval = null;
-  let fileWatcher = null;
-  if (config.gitDetection.enabled) {
-    const gitAvailable = await isGitAvailable();
-    const isRepo = await isGitRepo(rootDir);
-    if (gitAvailable && isRepo) {
-      log("\u2713 Detected git repository");
-      gitTracker = new GitStateTracker(rootDir, vectorDB.dbPath);
-      try {
-        log("Checking for git changes...");
-        const changedFiles = await gitTracker.initialize();
-        if (changedFiles && changedFiles.length > 0) {
-          log(`\u{1F33F} Git changes detected: ${changedFiles.length} files changed`);
-          log("Reindexing changed files...");
-          const count = await indexMultipleFiles(
-            changedFiles,
-            vectorDB,
-            embeddings,
-            config,
-            { verbose }
-          );
-          log(`\u2713 Reindexed ${count} files`);
-        } else {
-          log("\u2713 Index is up to date with git state");
-        }
-      } catch (error) {
-        log(`Warning: Failed to check git state on startup: ${error}`);
-      }
-      log(`\u2713 Git detection enabled (checking every ${config.gitDetection.pollIntervalMs / 1e3}s)`);
-      gitPollInterval = setInterval(async () => {
-        try {
-          const changedFiles = await gitTracker.detectChanges();
-          if (changedFiles && changedFiles.length > 0) {
-            log(`\u{1F33F} Git change detected: ${changedFiles.length} files changed`);
-            log("Reindexing in background...");
-            indexMultipleFiles(
-              changedFiles,
-              vectorDB,
-              embeddings,
-              config,
-              { verbose }
-            ).then((count) => {
-              log(`\u2713 Background reindex complete: ${count} files`);
-            }).catch((error) => {
-              log(`Warning: Background reindex failed: ${error}`);
-            });
-          }
-        } catch (error) {
-          log(`Warning: Git detection check failed: ${error}`);
-        }
-      }, config.gitDetection.pollIntervalMs);
-    } else {
-      if (!gitAvailable) {
-        log("Git not available - git detection disabled");
-      } else if (!isRepo) {
-        log("Not a git repository - git detection disabled");
-      }
+  };
+  earlyLog("Initializing MCP server...");
+  const { embeddings, vectorDB } = await initializeDatabase(rootDir, earlyLog).catch((error) => {
+    console.error(`Failed to initialize: ${error}`);
+    process.exit(1);
+  });
+  const server = new Server(
+    { name: "lien", version: packageJson3.version },
+    { capabilities: { tools: {}, logging: {} } }
+  );
+  const log = (message, level = "info") => {
+    if (verbose || level === "warning" || level === "error") {
+      server.sendLoggingMessage({
+        level,
+        logger: "lien",
+        data: message
+      }).catch(() => {
+        console.error(`[Lien MCP] [${level}] ${message}`);
+      });
     }
-  } else {
-    log("Git detection disabled by configuration");
-  }
-  const fileWatchingEnabled = watch !== void 0 ? watch : config.fileWatching.enabled;
-  if (fileWatchingEnabled) {
-    log("\u{1F440} Starting file watcher...");
-    fileWatcher = new FileWatcher(rootDir, config);
+  };
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+  const checkAndReconnect = async () => {
     try {
-      await fileWatcher.start(async (event) => {
-        const { type, filepath } = event;
-        if (type === "unlink") {
-          log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
-          try {
-            await vectorDB.deleteByFile(filepath);
-            const manifest = new ManifestManager(vectorDB.dbPath);
-            await manifest.removeFile(filepath);
-            log(`\u2713 Removed ${filepath} from index`);
-          } catch (error) {
-            log(`Warning: Failed to remove ${filepath}: ${error}`);
-          }
-        } else {
-          const action = type === "add" ? "added" : "changed";
-          log(`\u{1F4DD} File ${action}: ${filepath}`);
-          indexSingleFile(filepath, vectorDB, embeddings, config, { verbose }).catch((error) => {
-            log(`Warning: Failed to reindex ${filepath}: ${error}`);
-          });
-        }
-      });
-      const watchedCount = fileWatcher.getWatchedFiles().length;
-      log(`\u2713 File watching enabled (watching ${watchedCount} files)`);
+      if (await vectorDB.checkVersion()) {
+        log("Index version changed, reconnecting...");
+        await vectorDB.reconnect();
+      }
     } catch (error) {
-      log(`Warning: Failed to start file watcher: ${error}`);
-      fileWatcher = null;
+      log(`Version check failed: ${error}`, "warning");
     }
-  }
+  };
+  const getIndexMetadata = () => ({
+    indexVersion: vectorDB.getCurrentVersion(),
+    indexDate: vectorDB.getVersionDate()
+  });
+  const versionCheckInterval = setInterval(checkAndReconnect, VERSION_CHECK_INTERVAL_MS);
+  const config = await configService.load(rootDir);
+  const toolContext = { vectorDB, embeddings, config, rootDir, log, checkAndReconnect, getIndexMetadata };
+  registerToolCallHandler(server, toolContext, log);
+  await handleAutoIndexing(vectorDB, config, rootDir, log);
+  const { gitPollInterval } = await setupGitDetection(config, rootDir, vectorDB, embeddings, verbose, log);
+  const fileWatcher = await setupFileWatching(watch, config, rootDir, vectorDB, embeddings, verbose, log);
   const cleanup = async () => {
     log("Shutting down MCP server...");
     clearInterval(versionCheckInterval);
-    if (gitPollInterval) {
-      clearInterval(gitPollInterval);
-    }
-    if (fileWatcher) {
-      await fileWatcher.stop();
-    }
+    if (gitPollInterval) clearInterval(gitPollInterval);
+    if (fileWatcher) await fileWatcher.stop();
     process.exit(0);
   };
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   const transport = new StdioServerTransport();
   transport.onclose = () => {
-    log("Transport closed, parent process likely terminated");
+    log("Transport closed");
     cleanup().catch(() => process.exit(0));
   };
-  transport.onerror = (error) => {
-    log(`Transport error: ${error}`);
-  };
+  transport.onerror = (error) => log(`Transport error: ${error}`);
   await server.connect(transport);
   log("MCP server started and listening on stdio");
 }
 
 // src/cli/serve.ts
 async function serveCommand(options) {
-  const rootDir = options.root ? path18.resolve(options.root) : process.cwd();
+  const rootDir = options.root ? path21.resolve(options.root) : process.cwd();
   try {
     if (options.root) {
       try {
-        const stats = await fs19.stat(rootDir);
+        const stats = await fs20.stat(rootDir);
         if (!stats.isDirectory()) {
           console.error(chalk7.red(`Error: --root path is not a directory: ${rootDir}`));
           process.exit(1);
@@ -6784,6 +8100,370 @@ async function serveCommand(options) {
   }
 }
 
+// src/cli/complexity.ts
+init_lancedb();
+init_service();
+import chalk9 from "chalk";
+import fs21 from "fs";
+import path22 from "path";
+
+// src/insights/formatters/text.ts
+import chalk8 from "chalk";
+function getMetricLabel(metricType) {
+  switch (metricType) {
+    case "cognitive":
+      return "\u{1F9E0} Mental load";
+    case "cyclomatic":
+      return "\u{1F500} Test paths";
+    case "halstead_effort":
+      return "\u23F1\uFE0F Time to understand";
+    case "halstead_bugs":
+      return "\u{1F41B} Estimated bugs";
+    default:
+      return "Complexity";
+  }
+}
+function effortToMinutes(effort) {
+  return effort / 1080;
+}
+function formatTime(minutes) {
+  if (minutes >= 60) {
+    const hours = Math.floor(minutes / 60);
+    const mins = Math.round(minutes % 60);
+    return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+  }
+  return `${Math.round(minutes)}m`;
+}
+function formatHalsteadDetails(violation) {
+  if (!violation.halsteadDetails) return [];
+  const { volume, difficulty, effort, bugs } = violation.halsteadDetails;
+  const timeStr = formatTime(effortToMinutes(effort));
+  return [
+    chalk8.dim(`    \u{1F4CA}  Volume: ${Math.round(volume).toLocaleString()}, Difficulty: ${difficulty.toFixed(1)}`),
+    chalk8.dim(`    \u23F1\uFE0F  Time: ~${timeStr}, Est. bugs: ${bugs.toFixed(2)}`)
+  ];
+}
+var metricFormatters = {
+  halstead_effort: (val, thresh) => ({
+    // val/thresh are already in minutes (human-scale)
+    complexity: "~" + formatTime(val),
+    threshold: formatTime(thresh)
+  }),
+  halstead_bugs: (val, thresh) => ({
+    complexity: val.toFixed(2),
+    threshold: thresh.toFixed(1)
+  }),
+  cyclomatic: (val, thresh) => ({
+    complexity: `${val} (needs ~${val} tests)`,
+    threshold: thresh.toString()
+  })
+};
+var defaultFormatter = (val, thresh) => ({
+  complexity: val.toString(),
+  threshold: thresh.toString()
+});
+function formatSymbolDisplay(violation, isBold) {
+  const display = ["function", "method"].includes(violation.symbolType) ? `${violation.symbolName}()` : violation.symbolName;
+  return isBold ? chalk8.bold(display) : display;
+}
+function formatDependencyInfo(fileData) {
+  const depCount = fileData.dependentCount ?? fileData.dependents.length;
+  if (depCount === 0) return [];
+  const lines = [chalk8.dim(`    \u{1F4E6}  Imported by ${depCount} file${depCount !== 1 ? "s" : ""}`)];
+  if (fileData.dependentComplexityMetrics) {
+    const { averageComplexity, maxComplexity } = fileData.dependentComplexityMetrics;
+    lines.push(chalk8.dim(`    - Dependent avg complexity: ${averageComplexity}, max: ${maxComplexity}`));
+  }
+  return lines;
+}
+function formatPercentageOver(complexity, threshold) {
+  if (threshold <= 0) return "N/A (invalid threshold)";
+  return `${Math.round((complexity - threshold) / threshold * 100)}% over threshold`;
+}
+function formatViolation(violation, fileData, colorFn, isBold) {
+  const symbolText = formatSymbolDisplay(violation, isBold);
+  const metricLabel = getMetricLabel(violation.metricType);
+  const formatter = metricFormatters[violation.metricType] || defaultFormatter;
+  const { complexity: complexityDisplay, threshold: thresholdDisplay } = formatter(violation.complexity, violation.threshold);
+  return [
+    colorFn(`  ${violation.file}:${violation.startLine}`) + chalk8.dim(" - ") + symbolText,
+    chalk8.dim(`    ${metricLabel}: ${complexityDisplay} (threshold: ${thresholdDisplay})`),
+    chalk8.dim(`    \u2B06\uFE0F  ${formatPercentageOver(violation.complexity, violation.threshold)}`),
+    ...formatHalsteadDetails(violation),
+    ...formatDependencyInfo(fileData),
+    chalk8.dim(`    \u26A0\uFE0F  Risk: ${fileData.riskLevel.toUpperCase()}`),
+    ""
+  ];
+}
+function formatTextReport(report) {
+  const lines = [];
+  lines.push(chalk8.bold("\u{1F50D} Complexity Analysis\n"));
+  lines.push(chalk8.bold("Summary:"));
+  lines.push(chalk8.dim("  Files analyzed: ") + report.summary.filesAnalyzed.toString());
+  const errorText = `${report.summary.bySeverity.error} error${report.summary.bySeverity.error !== 1 ? "s" : ""}`;
+  const warningText = `${report.summary.bySeverity.warning} warning${report.summary.bySeverity.warning !== 1 ? "s" : ""}`;
+  lines.push(chalk8.dim("  Violations: ") + `${report.summary.totalViolations} (${errorText}, ${warningText})`);
+  lines.push(chalk8.dim("  Average complexity: ") + report.summary.avgComplexity.toString());
+  lines.push(chalk8.dim("  Max complexity: ") + report.summary.maxComplexity.toString());
+  lines.push("");
+  const filesWithViolations = Object.entries(report.files).filter(([_, data]) => data.violations.length > 0).sort((a, b) => b[1].violations.length - a[1].violations.length);
+  if (filesWithViolations.length === 0) {
+    lines.push(chalk8.green("\u2713 No violations found!"));
+    return lines.join("\n");
+  }
+  const errors = filesWithViolations.flatMap(
+    ([file, data]) => data.violations.filter((v) => v.severity === "error").map((v) => ({ file, ...v }))
+  );
+  if (errors.length > 0) {
+    lines.push(chalk8.red.bold("\u274C Errors:\n"));
+    for (const error of errors) {
+      lines.push(...formatViolation(error, report.files[error.file], chalk8.red, true));
+    }
+  }
+  const warnings = filesWithViolations.flatMap(
+    ([file, data]) => data.violations.filter((v) => v.severity === "warning").map((v) => ({ file, ...v }))
+  );
+  if (warnings.length > 0) {
+    lines.push(chalk8.yellow.bold("\u26A0\uFE0F  Warnings:\n"));
+    for (const warning of warnings) {
+      lines.push(...formatViolation(warning, report.files[warning.file], chalk8.yellow, false));
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/insights/formatters/json.ts
+function formatJsonReport(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+// src/insights/formatters/sarif.ts
+function getRuleId(metricType) {
+  switch (metricType) {
+    case "cognitive":
+      return "lien/high-cognitive-complexity";
+    case "cyclomatic":
+      return "lien/high-cyclomatic-complexity";
+    case "halstead_effort":
+      return "lien/high-halstead-effort";
+    case "halstead_bugs":
+      return "lien/high-estimated-bugs";
+    default:
+      return "lien/high-complexity";
+  }
+}
+function formatSarifReport(report) {
+  const rules = [
+    {
+      id: "lien/high-cyclomatic-complexity",
+      shortDescription: {
+        text: "Too many test paths"
+      },
+      fullDescription: {
+        text: "Function or method requires too many test cases to achieve full branch coverage. Each decision point (if, switch, loop) adds a path that needs testing."
+      },
+      help: {
+        text: "Consider refactoring by extracting methods, using early returns, or simplifying conditional logic to reduce the number of test paths."
+      }
+    },
+    {
+      id: "lien/high-cognitive-complexity",
+      shortDescription: {
+        text: "High mental load"
+      },
+      fullDescription: {
+        text: "Function or method has high mental load (deeply nested or hard to follow), requiring too much mental effort to understand and maintain."
+      },
+      help: {
+        text: "Consider flattening nested conditionals, extracting helper functions, or using guard clauses to reduce mental load."
+      }
+    },
+    {
+      id: "lien/high-halstead-effort",
+      shortDescription: {
+        text: "Long time to understand"
+      },
+      fullDescription: {
+        text: "Function or method takes too long to understand, based on Halstead metrics (operators and operands count)."
+      },
+      help: {
+        text: "Consider simplifying expressions, reducing variable count, or breaking into smaller functions."
+      }
+    },
+    {
+      id: "lien/high-estimated-bugs",
+      shortDescription: {
+        text: "High estimated bug count"
+      },
+      fullDescription: {
+        text: "Function or method is likely to contain bugs based on Halstead metrics (Volume / 3000), which estimates bug count from code complexity."
+      },
+      help: {
+        text: "Consider simplifying the function, breaking into smaller units, or adding thorough test coverage."
+      }
+    }
+  ];
+  const results = [];
+  for (const [filepath, fileData] of Object.entries(report.files)) {
+    for (const violation of fileData.violations) {
+      const ruleId = getRuleId(violation.metricType);
+      results.push({
+        ruleId,
+        level: violation.severity,
+        message: {
+          text: `${violation.symbolName}: ${violation.message}`
+        },
+        locations: [
+          {
+            physicalLocation: {
+              artifactLocation: {
+                uri: filepath
+              },
+              region: {
+                startLine: violation.startLine,
+                endLine: violation.endLine
+              }
+            }
+          }
+        ]
+      });
+    }
+  }
+  const sarifReport = {
+    $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "Lien Complexity Analyzer",
+            version: "1.0.0",
+            informationUri: "https://github.com/liendev/lien",
+            rules
+          }
+        },
+        results
+      }
+    ]
+  };
+  return JSON.stringify(sarifReport, null, 2);
+}
+
+// src/insights/formatters/index.ts
+function formatReport(report, format) {
+  switch (format) {
+    case "json":
+      return formatJsonReport(report);
+    case "sarif":
+      return formatSarifReport(report);
+    case "text":
+    default:
+      return formatTextReport(report);
+  }
+}
+
+// src/cli/complexity.ts
+var VALID_FAIL_ON = ["error", "warning"];
+var VALID_FORMATS = ["text", "json", "sarif"];
+function validateFailOn(failOn) {
+  if (failOn && !VALID_FAIL_ON.includes(failOn)) {
+    console.error(chalk9.red(`Error: Invalid --fail-on value "${failOn}". Must be either 'error' or 'warning'`));
+    process.exit(1);
+  }
+}
+function validateFormat(format) {
+  if (!VALID_FORMATS.includes(format)) {
+    console.error(chalk9.red(`Error: Invalid --format value "${format}". Must be one of: text, json, sarif`));
+    process.exit(1);
+  }
+}
+function validateFilesExist(files, rootDir) {
+  if (!files || files.length === 0) return;
+  const missingFiles = files.filter((file) => {
+    const fullPath = path22.isAbsolute(file) ? file : path22.join(rootDir, file);
+    return !fs21.existsSync(fullPath);
+  });
+  if (missingFiles.length > 0) {
+    console.error(chalk9.red(`Error: File${missingFiles.length > 1 ? "s" : ""} not found:`));
+    missingFiles.forEach((file) => console.error(chalk9.red(`  - ${file}`)));
+    process.exit(1);
+  }
+}
+function parseThresholdValue(value, flagName) {
+  if (!value) return null;
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    console.error(chalk9.red(`Error: Invalid ${flagName} value "${value}". Must be a number`));
+    process.exit(1);
+  }
+  if (parsed <= 0) {
+    console.error(chalk9.red(`Error: Invalid ${flagName} value "${value}". Must be a positive number`));
+    process.exit(1);
+  }
+  return parsed;
+}
+function parseThresholdOverrides(options) {
+  const baseThreshold = parseThresholdValue(options.threshold, "--threshold");
+  const cyclomaticOverride = parseThresholdValue(options.cyclomaticThreshold, "--cyclomatic-threshold");
+  const cognitiveOverride = parseThresholdValue(options.cognitiveThreshold, "--cognitive-threshold");
+  return {
+    // Specific flags take precedence over --threshold
+    cyclomatic: cyclomaticOverride ?? baseThreshold,
+    cognitive: cognitiveOverride ?? baseThreshold
+  };
+}
+function applyThresholdOverrides(config, overrides) {
+  if (overrides.cyclomatic === null && overrides.cognitive === null) return;
+  const cfg = config;
+  if (!cfg.complexity) {
+    cfg.complexity = {
+      enabled: true,
+      thresholds: { testPaths: 15, mentalLoad: 15 }
+    };
+  } else if (!cfg.complexity.thresholds) {
+    cfg.complexity.thresholds = { testPaths: 15, mentalLoad: 15 };
+  }
+  if (overrides.cyclomatic !== null) {
+    cfg.complexity.thresholds.testPaths = overrides.cyclomatic;
+  }
+  if (overrides.cognitive !== null) {
+    cfg.complexity.thresholds.mentalLoad = overrides.cognitive;
+  }
+}
+async function ensureIndexExists(vectorDB) {
+  try {
+    await vectorDB.scanWithFilter({ limit: 1 });
+  } catch {
+    console.error(chalk9.red("Error: Index not found"));
+    console.log(chalk9.yellow("\nRun"), chalk9.bold("lien index"), chalk9.yellow("to index your codebase first"));
+    process.exit(1);
+  }
+}
+async function complexityCommand(options) {
+  const rootDir = process.cwd();
+  try {
+    validateFailOn(options.failOn);
+    validateFormat(options.format);
+    validateFilesExist(options.files, rootDir);
+    const thresholdOverrides = parseThresholdOverrides(options);
+    const config = await configService.load(rootDir);
+    const vectorDB = new VectorDB(rootDir);
+    await vectorDB.initialize();
+    await ensureIndexExists(vectorDB);
+    applyThresholdOverrides(config, thresholdOverrides);
+    const analyzer = new ComplexityAnalyzer(vectorDB, config);
+    const report = await analyzer.analyze(options.files);
+    console.log(formatReport(report, options.format));
+    if (options.failOn) {
+      const hasViolations = options.failOn === "error" ? report.summary.bySeverity.error > 0 : report.summary.totalViolations > 0;
+      if (hasViolations) process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk9.red("Error analyzing complexity:"), error);
+    process.exit(1);
+  }
+}
+
 // src/cli/index.ts
 var __filename5 = fileURLToPath5(import.meta.url);
 var __dirname5 = dirname4(__filename5);
@@ -6800,6 +8480,7 @@ program.command("init").description("Initialize Lien in the current directory").
 program.command("index").description("Index the codebase for semantic search").option("-f, --force", "Force full reindex (skip incremental)").option("-w, --watch", "Watch for changes and re-index automatically").option("-v, --verbose", "Show detailed logging during indexing").action(indexCommand);
 program.command("serve").description("Start the MCP server for Cursor integration").option("-p, --port <port>", "Port number (for future use)", "7133").option("--no-watch", "Disable file watching for this session").option("-w, --watch", "[DEPRECATED] File watching is now enabled by default").option("-r, --root <path>", "Root directory to serve (defaults to current directory)").action(serveCommand);
 program.command("status").description("Show indexing status and statistics").action(statusCommand);
+program.command("complexity").description("Analyze code complexity").option("--files <paths...>", "Specific files to analyze").option("--format <type>", "Output format: text, json, sarif", "text").option("--threshold <n>", "Override both complexity thresholds (cyclomatic & cognitive)").option("--cyclomatic-threshold <n>", "Override cyclomatic complexity threshold only").option("--cognitive-threshold <n>", "Override cognitive complexity threshold only").option("--fail-on <severity>", "Exit 1 if violations: error, warning").action(complexityCommand);
 
 // src/index.ts
 program.parse();