@liendev/lien 0.14.0 → 0.15.1

package/dist/index.js

@@ -161,7 +161,7 @@ function migrateConfig(oldConfig) {
       path: ".",
       enabled: true,
       config: {
-        include: oldConfig.indexing.include ?? ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        include: oldConfig.indexing.include ?? ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
         exclude: oldConfig.indexing.exclude ?? [
           "**/node_modules/**",
           "**/dist/**",
@@ -181,7 +181,7 @@ function migrateConfig(oldConfig) {
       path: ".",
       enabled: true,
       config: {
-        include: ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        include: ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
         exclude: [
           "**/node_modules/**",
           "**/dist/**",
@@ -1030,7 +1030,7 @@ async function scanCodebase(options) {
     ".lien/**",
     ...excludePatterns
   ]);
-  const patterns = includePatterns.length > 0 ? includePatterns : ["**/*.{ts,tsx,js,jsx,py,go,rs,java,cpp,c,h,md,mdx}"];
+  const patterns = includePatterns.length > 0 ? includePatterns : ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,cpp,c,cs,h,md,mdx}"];
   const allFiles = [];
   for (const pattern of patterns) {
     const files = await glob(pattern, {
@@ -1388,6 +1388,7 @@ import Parser from "tree-sitter";
 import TypeScript from "tree-sitter-typescript";
 import JavaScript from "tree-sitter-javascript";
 import PHPParser from "tree-sitter-php";
+import Python from "tree-sitter-python";
 import { extname } from "path";
 function getParser(language) {
   if (!parserCache.has(language)) {
@@ -1414,6 +1415,8 @@ function detectLanguage2(filePath) {
       return "javascript";
     case "php":
       return "php";
+    case "py":
+      return "python";
     default:
       return null;
   }
@@ -1447,8 +1450,9 @@ var init_parser = __esm({
     languageConfig = {
       typescript: TypeScript.typescript,
       javascript: JavaScript,
-      php: PHPParser.php
+      php: PHPParser.php,
       // Note: tree-sitter-php exports both 'php' (mixed HTML/PHP) and 'php_only'
+      python: Python
     };
   }
 });
@@ -1524,7 +1528,35 @@ function extractInterfaceInfo(node, _content, _parentClass) {
     signature: `interface ${nameNode.text}`
   };
 }
-function extractSymbolInfo(node, content, parentClass) {
+function extractPythonFunctionInfo(node, content, parentClass) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: nameNode.text,
+    type: parentClass ? "method" : "function",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    parentClass,
+    signature: extractSignature(node, content),
+    parameters: extractParameters(node, content),
+    complexity: calculateComplexity(node)
+  };
+}
+function extractPythonClassInfo(node, _content, _parentClass) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: nameNode.text,
+    type: "class",
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    signature: `class ${nameNode.text}`
+  };
+}
+function extractSymbolInfo(node, content, parentClass, language) {
+  if (node.type === "function_definition" && language === "python") {
+    return extractPythonFunctionInfo(node, content, parentClass);
+  }
   const extractor = symbolExtractors[node.type];
   return extractor ? extractor(node, content, parentClass) : null;
 }
@@ -1563,23 +1595,39 @@ function extractReturnType(node, _content) {
 function calculateComplexity(node) {
   let complexity = 1;
   const decisionPoints = [
-    // TypeScript/JavaScript
+    // Common across languages (TypeScript/JavaScript/Python/PHP)
     "if_statement",
+    // if conditions
     "while_statement",
-    "do_statement",
-    // do...while loops
+    // while loops
     "for_statement",
-    "for_in_statement",
-    "for_of_statement",
-    // for...of loops
+    // for loops
     "switch_case",
+    // switch/case statements
     "catch_clause",
+    // try/catch error handling
     "ternary_expression",
+    // Ternary operator (a ? b : c)
     "binary_expression",
-    // For && and ||
-    // PHP
-    "foreach_statement"
+    // 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)) {
@@ -1608,7 +1656,13 @@ function extractImports(rootNode) {
       if (sourceNode) {
         const importPath = sourceNode.text.replace(/['"]/g, "");
         imports.push(importPath);
+      } else {
+        const importText = node.text.split("\n")[0];
+        imports.push(importText);
       }
+    } else if (node.type === "import_from_statement") {
+      const importText = node.text.split("\n")[0];
+      imports.push(importText);
     }
     if (node === rootNode) {
       for (let i = 0; i < node.namedChildCount; i++) {
@@ -1635,9 +1689,16 @@ var init_symbols = __esm({
       "interface_declaration": extractInterfaceInfo,
       // PHP
       "function_definition": extractFunctionInfo,
-      // PHP functions
-      "method_declaration": extractMethodInfo
+      // PHP functions (Python handled via language check in extractSymbolInfo)
+      "method_declaration": extractMethodInfo,
       // PHP methods
+      // Python
+      "async_function_definition": extractPythonFunctionInfo,
+      // Python async functions
+      "class_definition": extractPythonClassInfo
+      // Python classes
+      // Note: Python regular functions use 'function_definition' (same as PHP)
+      // They are dispatched to extractPythonFunctionInfo via language check in extractSymbolInfo()
     };
   }
 });
@@ -1795,6 +1856,69 @@ var init_php = __esm({
   }
 });
 
+// src/indexer/ast/traversers/python.ts
+var PythonTraverser;
+var init_python = __esm({
+  "src/indexer/ast/traversers/python.ts"() {
+    "use strict";
+    PythonTraverser = class {
+      targetNodeTypes = [
+        "function_definition",
+        "async_function_definition"
+      ];
+      containerTypes = [
+        "class_definition"
+        // We extract methods, not the class itself
+      ];
+      declarationTypes = [
+        // Python doesn't have const/let/var declarations like JS/TS
+        // Functions are always defined with 'def' or 'async def'
+      ];
+      functionTypes = [
+        "function_definition",
+        "async_function_definition"
+      ];
+      shouldExtractChildren(node) {
+        return this.containerTypes.includes(node.type);
+      }
+      isDeclarationWithFunction(_node) {
+        return false;
+      }
+      getContainerBody(node) {
+        if (node.type === "class_definition") {
+          return node.childForFieldName("body");
+        }
+        return null;
+      }
+      shouldTraverseChildren(node) {
+        return node.type === "module" || // Top-level Python file
+        node.type === "block";
+      }
+      findParentContainerName(node) {
+        let current = node.parent;
+        while (current) {
+          if (current.type === "class_definition") {
+            const nameNode = current.childForFieldName("name");
+            return nameNode?.text;
+          }
+          current = current.parent;
+        }
+        return void 0;
+      }
+      /**
+       * Python doesn't have this pattern (const x = () => {})
+       * Functions are always defined with 'def' or 'async def'
+       */
+      findFunctionInDeclaration(_node) {
+        return {
+          hasFunction: false,
+          functionNode: null
+        };
+      }
+    };
+  }
+});
+
 // src/indexer/ast/traversers/index.ts
 function getTraverser(language) {
   const traverser = traverserRegistry[language];
@@ -1809,10 +1933,12 @@ var init_traversers = __esm({
     "use strict";
     init_typescript();
     init_php();
+    init_python();
     traverserRegistry = {
       typescript: new TypeScriptTraverser(),
       javascript: new JavaScriptTraverser(),
-      php: new PHPTraverser()
+      php: new PHPTraverser(),
+      python: new PythonTraverser()
     };
   }
 });
@@ -1843,7 +1969,7 @@ function chunkByAST(filepath, content, options = {}) {
       }
     }
     const parentClassName = traverser.findParentContainerName(actualNode);
-    const symbolInfo = extractSymbolInfo(actualNode, content, parentClassName);
+    const symbolInfo = extractSymbolInfo(actualNode, content, parentClassName, language);
     const nodeContent = getNodeContent(node, lines);
     chunks.push(createChunk(filepath, node, nodeContent, symbolInfo, fileImports, language));
   }
@@ -4926,7 +5052,7 @@ async function createNewConfig(rootDir, options) {
       path: ".",
       enabled: true,
       config: {
-        include: ["**/*.{ts,tsx,js,jsx,py,go,rs,java,c,cpp,cs}"],
+        include: ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
         exclude: [
           "**/node_modules/**",
           "**/dist/**",
@@ -5304,22 +5430,48 @@ var tools = [
   toMCPToolSchema(
     SemanticSearchSchema,
     "semantic_search",
-    "Search the codebase semantically for relevant code using natural language. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+    `Search codebase by MEANING, not text. USE THIS INSTEAD OF grep/ripgrep for finding implementations, features, or understanding how code works.
+
+Examples:
+- "Where is authentication handled?" \u2192 semantic_search({ query: "handles user authentication" })
+- "How does payment work?" \u2192 semantic_search({ query: "processes payment transactions" })
+
+Use natural language describing what the code DOES, not function names. For exact string matching, use grep instead.
+
+Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) for each match.`
   ),
   toMCPToolSchema(
     FindSimilarSchema,
     "find_similar",
-    "Find code similar to a given code snippet. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+    `Find code structurally similar to a given snippet. Use for:
+- Ensuring consistency when adding new code
+- Finding duplicate implementations
+- Refactoring similar patterns together
+
+Provide at least 10 characters of code to match against. Results include a relevance category for each match.`
   ),
   toMCPToolSchema(
     GetFileContextSchema,
     "get_file_context",
-    "Get all chunks and related context for a specific file. Results include a relevance category (highly_relevant, relevant, loosely_related, not_relevant) based on semantic similarity."
+    `Get full context for a file including related code and dependencies.
+
+IMPORTANT: Call this BEFORE editing any file to understand:
+- What the file does
+- What depends on it
+- Related test files (via testAssociations)
+
+Results include a relevance category for each related chunk. Typical flow: semantic_search \u2192 find file \u2192 get_file_context \u2192 make changes.`
   ),
   toMCPToolSchema(
     ListFunctionsSchema,
     "list_functions",
-    "List functions, classes, and interfaces by name pattern and language"
+    `Fast symbol lookup by naming pattern. Use when searching by NAME, not behavior.
+
+Examples:
+- "Show all controllers" \u2192 list_functions({ pattern: ".*Controller.*" })
+- "Find service classes" \u2192 list_functions({ pattern: ".*Service$" })
+
+10x faster than semantic_search for structural/architectural queries. Use semantic_search instead when searching by what code DOES.`
   )
 ];