autosnippet 3.2.6 → 3.2.8

package/lib/core/ast/lang-java.js

@@ -6,6 +6,8 @@
  * 模式: Singleton, Builder, Factory, DI, Stream Pipeline
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+
 function walkJava(root, ctx) {
   _walkJavaNode(root, ctx, null);
 }
@@ -16,9 +18,29 @@ function _walkJavaNode(node, ctx, parentClassName) {
 
     switch (child.type) {
       case 'import_declaration': {
+        const isStatic = child.namedChildren.some((c) => c.text === 'static');
         const path = child.namedChildren.find((c) => c.type === 'scoped_identifier');
         if (path) {
-          ctx.imports.push(path.text);
+          const fullPath = path.text; // e.g. com.example.MyClass or com.example.MyClass.myMethod
+          const segments = fullPath.split('.');
+          const lastName = segments[segments.length - 1];
+          // Java wildcard: import com.example.* 
+          const isWildcard = child.text.includes('.*');
+          if (isWildcard) {
+            ctx.imports.push(
+              new ImportRecord(fullPath, { symbols: ['*'], kind: 'namespace' })
+            );
+          } else if (isStatic) {
+            // static import: import static com.example.MyClass.method
+            ctx.imports.push(
+              new ImportRecord(fullPath, { symbols: [lastName], kind: 'named', isTypeOnly: false })
+            );
+          } else {
+            // regular: import com.example.MyClass
+            ctx.imports.push(
+              new ImportRecord(fullPath, { symbols: [lastName], alias: lastName, kind: 'named' })
+            );
+          }
         }
         break;
       }
@@ -255,6 +277,22 @@ function _parseJavaField(node, className) {
     .filter((c) => c.type === 'marker_annotation' || c.type === 'annotation')
     .map((a) => a.text);
 
+  // Phase 5.3: Extract field type for DI resolution
+  // field_declaration: [modifiers] type_identifier variable_declarator
+  let typeAnnotation = null;
+  const typeNode = node.namedChildren.find(
+    (c) =>
+      c.type === 'type_identifier' ||
+      c.type === 'generic_type' ||
+      c.type === 'scoped_type_identifier'
+  );
+  if (typeNode) {
+    // Strip generics: List<User> → List, Repository<User, Long> → Repository
+    const text = typeNode.text;
+    const bracketIdx = text.indexOf('<');
+    typeAnnotation = bracketIdx > 0 ? text.slice(0, bracketIdx) : text;
+  }
+
   return {
     name,
     className,
@@ -262,6 +300,7 @@ function _parseJavaField(node, className) {
     isFinal,
     isPrivate,
     annotations,
+    typeAnnotation,
     line: node.startPosition.row + 1,
   };
 }
@@ -413,6 +452,170 @@ function _maxNesting(node, depth) {
   return max;
 }
 
+// ── Java Call Site 提取 (Phase 5) ─────────────────────────────
+
+/**
+ * 从 Java AST root 提取所有调用点
+ * 遍历 method_declaration / constructor_declaration 中的 block → method_invocation / object_creation_expression
+ */
+function extractCallSitesJava(root, ctx, _lang) {
+  const scopes = _collectJavaScopes(root);
+  for (const scope of scopes) {
+    _extractJavaCallSitesFromBody(scope.body, scope.className, scope.methodName, ctx);
+  }
+}
+
+/**
+ * 递归收集 Java 中所有方法体作用域
+ */
+function _collectJavaScopes(root) {
+  const scopes = [];
+
+  function visit(node, className) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+
+      if (child.type === 'class_declaration' || child.type === 'enum_declaration' || child.type === 'record_declaration') {
+        const name = child.namedChildren.find((c) => c.type === 'identifier')?.text;
+        const body = child.namedChildren.find((c) => c.type === 'class_body' || c.type === 'enum_body');
+        if (body) {
+          visit(body, name || className);
+        }
+      } else if (child.type === 'interface_declaration') {
+        const name = child.namedChildren.find((c) => c.type === 'identifier')?.text;
+        const body = child.namedChildren.find((c) => c.type === 'interface_body');
+        if (body) {
+          visit(body, name || className);
+        }
+      } else if (child.type === 'method_declaration' || child.type === 'constructor_declaration') {
+        const name = child.namedChildren.find((c) => c.type === 'identifier')?.text || '<init>';
+        const body = child.namedChildren.find((c) => c.type === 'block');
+        if (body) {
+          scopes.push({ body, className, methodName: name });
+        }
+      }
+    }
+  }
+
+  visit(root, null);
+  return scopes;
+}
+
+/**
+ * 从 Java method body 中递归提取调用点
+ */
+function _extractJavaCallSitesFromBody(bodyNode, className, methodName, ctx) {
+  if (!bodyNode) return;
+
+  const JAVA_NOISE = new Set([
+    'System', 'Math', 'String', 'Integer', 'Long', 'Double', 'Float',
+    'Boolean', 'Character', 'Byte', 'Short', 'Arrays', 'Collections',
+    'Objects', 'Optional', 'Stream', 'Collectors', 'List', 'Map', 'Set',
+  ]);
+
+  function walk(node) {
+    if (!node || node.type === 'ERROR' || node.isMissing) return;
+
+    if (node.type === 'method_invocation') {
+      // obj.method(args) or method(args)
+      // In Java tree-sitter: namedChildren = [object?, name(identifier), argument_list]
+      // The method name is the LAST identifier before argument_list
+      const identifiers = node.namedChildren.filter((c) => c.type === 'identifier');
+      const args = node.namedChildren.find((c) => c.type === 'argument_list');
+      const argCount = args ? args.namedChildCount : 0;
+
+      let callee, receiver = null, receiverType = null, callType;
+
+      if (identifiers.length >= 2) {
+        // obj.method() — first identifier is receiver, last is method name
+        const objectNode = identifiers[0];
+        const methodNode = identifiers[identifiers.length - 1];
+        receiver = objectNode.text?.slice(0, 80);
+        callee = methodNode.text;
+        callType = 'method';
+
+        // Check known noise
+        if (receiver && JAVA_NOISE.has(receiver.split('.')[0])) {
+          receiverType = receiver;
+          callType = 'static';
+        }
+      } else if (identifiers.length === 1) {
+        // Could be: unqualified method(args) or receiver is an expression
+        const objectNode = node.namedChildren[0];
+        if (objectNode && objectNode.type !== 'identifier' && objectNode.type !== 'argument_list') {
+          // Expression receiver: e.g. getService().doWork() or super.method()
+          receiver = objectNode.text?.slice(0, 80);
+          callee = identifiers[0].text;
+          callType = 'method';
+          // super.xxx() → CHA 解析到父类
+          if (receiver === 'super') {
+            callType = 'super';
+            receiverType = className;
+          }
+        } else {
+          callee = identifiers[0].text;
+          callType = 'function'; // unqualified method call within same class
+        }
+      } else {
+        callee = node.text?.split('(')[0]?.slice(0, 80) || 'unknown';
+        callType = 'function';
+      }
+
+      ctx.callSites.push({
+        callee,
+        callerMethod: methodName,
+        callerClass: className,
+        callType,
+        receiver,
+        receiverType,
+        argCount,
+        line: node.startPosition.row + 1,
+        isAwait: false,
+      });
+
+      // walk arguments for nested calls
+      if (args) walkChildren(args);
+      return;
+    }
+
+    if (node.type === 'object_creation_expression') {
+      // new ClassName(args)
+      const typeNode = node.namedChildren.find(
+        (c) => c.type === 'type_identifier' || c.type === 'generic_type' || c.type === 'scoped_type_identifier'
+      );
+      const args = node.namedChildren.find((c) => c.type === 'argument_list');
+      const argCount = args ? args.namedChildCount : 0;
+
+      const typeName = typeNode?.text || 'Unknown';
+
+      ctx.callSites.push({
+        callee: typeName,
+        callerMethod: methodName,
+        callerClass: className,
+        callType: 'constructor',
+        receiver: null,
+        receiverType: typeName,
+        argCount,
+        line: node.startPosition.row + 1,
+        isAwait: false,
+      });
+
+      if (args) walkChildren(args);
+      return;
+    }
+
+    walkChildren(node);
+  }
+
+  function walkChildren(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      walk(node.namedChild(i));
+    }
+  }
+
+  walk(bodyNode);
+}
+
 // ── 插件导出 ──
 
 let _grammar = null;
@@ -427,5 +630,6 @@ export const plugin = {
   getGrammar,
   walk: walkJava,
   detectPatterns: detectJavaPatterns,
+  extractCallSites: extractCallSitesJava,
   extensions: ['.java'],
 };

package/lib/core/ast/lang-kotlin.js

@@ -6,6 +6,8 @@
  * 模式: Singleton (object), Factory (companion), DSL, Flow, Sealed
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+
 function walkKotlin(root, ctx) {
   _walkKtNode(root, ctx, null);
 }
@@ -21,7 +23,28 @@ function _walkKtNode(node, ctx, parentClassName) {
           (c) => c.type === 'identifier' || c.type === 'user_type'
         );
         if (id) {
-          ctx.imports.push(id.text);
+          const fullPath = id.text; // e.g. com.example.MyClass or com.example.myFunc
+          const segments = fullPath.split('.');
+          const lastName = segments[segments.length - 1];
+          // Kotlin: import com.example.* (wildcard)
+          const isWildcard = child.text.includes('.*');
+          // Kotlin: import com.example.MyClass as Alias
+          const aliasNode = child.namedChildren.find((c) => c.type === 'import_alias');
+          const alias = aliasNode?.namedChildren?.find((c) => c.type === 'type_identifier' || c.type === 'simple_identifier')?.text;
+
+          if (isWildcard) {
+            ctx.imports.push(
+              new ImportRecord(fullPath, { symbols: ['*'], kind: 'namespace' })
+            );
+          } else {
+            ctx.imports.push(
+              new ImportRecord(fullPath, {
+                symbols: [lastName],
+                alias: alias || lastName,
+                kind: 'named',
+              })
+            );
+          }
         }
         break;
       }
@@ -29,6 +52,11 @@ function _walkKtNode(node, ctx, parentClassName) {
       case 'class_declaration': {
         const classInfo = _parseKtClass(child);
         ctx.classes.push(classInfo);
+
+        // Phase 5.3: Extract primary constructor parameter properties (Kotlin DI pattern)
+        // class UserService(private val repo: UserRepo) → property { name: 'repo', typeAnnotation: 'UserRepo' }
+        _extractKtConstructorProperties(child, ctx, classInfo.name);
+
         const body = child.namedChildren.find((c) => c.type === 'class_body');
         if (body) {
           _walkKtClassBody(body, ctx, classInfo.name);
@@ -107,6 +135,8 @@ function _walkKtClassBody(body, ctx, className) {
         const inner = _parseKtClass(child);
         inner.outerClass = className;
         ctx.classes.push(inner);
+        // Phase 5.3: Extract primary constructor params for inner classes too
+        _extractKtConstructorProperties(child, ctx, inner.name);
         const innerBody = child.namedChildren.find((c) => c.type === 'class_body');
         if (innerBody) {
           _walkKtClassBody(innerBody, ctx, inner.name);
@@ -246,6 +276,50 @@ function _parseKtProperty(node, className) {
   const isLazy = node.text.includes('by lazy');
   const isLateinit = node.text.includes('lateinit');
 
+  // Phase 5.3: Extract property type for DI resolution
+  // Kotlin property types can be in variable_declaration or directly on the node:
+  //   val userRepo: UserRepo  →  variable_declaration { simple_identifier, user_type }
+  //   lateinit var service: UserService  →  user_type directly on property_declaration
+  let typeAnnotation = null;
+
+  // 1. Try from variable_declaration child
+  const varDecl = node.namedChildren.find((c) => c.type === 'variable_declaration');
+  if (varDecl) {
+    const typeNode = varDecl.namedChildren.find(
+      (c) => c.type === 'user_type' || c.type === 'nullable_type'
+    );
+    if (typeNode) {
+      typeAnnotation = _extractKtTypeName(typeNode);
+    }
+  }
+
+  // 2. Fallback: try direct children (lateinit var patterns)
+  if (!typeAnnotation) {
+    const typeNode = node.namedChildren.find(
+      (c) => c.type === 'user_type' || c.type === 'nullable_type'
+    );
+    if (typeNode) {
+      typeAnnotation = _extractKtTypeName(typeNode);
+    }
+  }
+
+  // Phase 5.3: Extract annotations on property (e.g. @Inject, @Autowired)
+  const annotations = [];
+  for (const child of node.namedChildren) {
+    if (child.type === 'annotation' || child.type === 'single_annotation') {
+      annotations.push(child.text);
+    }
+  }
+  // Also check modifiers block
+  const modifiers = node.namedChildren.find((c) => c.type === 'modifiers');
+  if (modifiers) {
+    for (const child of modifiers.namedChildren) {
+      if (child.type === 'annotation' || child.type === 'single_annotation') {
+        annotations.push(child.text);
+      }
+    }
+  }
+
   return {
     name,
     className,
@@ -253,10 +327,105 @@ function _parseKtProperty(node, className) {
     isMutable: isVar,
     isLazy,
     isLateinit,
+    typeAnnotation,
+    annotations: annotations.length > 0 ? annotations : undefined,
     line: node.startPosition.row + 1,
   };
 }
 
+/**
+ * Phase 5.3: Extract Kotlin primary constructor parameter properties
+ *
+ * Kotlin constructors: class Svc(private val repo: UserRepo, val logger: Logger)
+ * Each val/var parameter in a primary_constructor becomes a class property.
+ *
+ * AST: class_declaration → primary_constructor → class_parameter[]
+ * Each class_parameter may contain: modifiers, val/var keyword, simple_identifier, user_type
+ *
+ * @param {object} classNode — class_declaration AST node
+ * @param {object} ctx — walker context
+ * @param {string} className
+ */
+function _extractKtConstructorProperties(classNode, ctx, className) {
+  const primaryCtor = classNode.namedChildren.find(
+    (c) => c.type === 'primary_constructor'
+  );
+  if (!primaryCtor) return;
+
+  for (const param of primaryCtor.namedChildren) {
+    if (param.type !== 'class_parameter') continue;
+
+    // Only val/var params become properties
+    const text = param.text;
+    const isVal = text.includes('val ');
+    const isVar = text.includes('var ');
+    if (!isVal && !isVar) continue;
+
+    const name = param.namedChildren.find(
+      (c) => c.type === 'simple_identifier'
+    )?.text;
+    if (!name) continue;
+
+    // Extract type annotation
+    let typeAnnotation = null;
+    const typeNode = param.namedChildren.find(
+      (c) => c.type === 'user_type' || c.type === 'nullable_type'
+    );
+    if (typeNode) {
+      typeAnnotation = _extractKtTypeName(typeNode);
+    }
+
+    // Extract annotations (e.g. @Inject)
+    const annotations = [];
+    for (const child of param.namedChildren) {
+      if (child.type === 'annotation' || child.type === 'single_annotation' || child.type === 'modifiers') {
+        if (child.type === 'modifiers') {
+          for (const mod of child.namedChildren) {
+            if (mod.type === 'annotation' || mod.type === 'single_annotation') {
+              annotations.push(mod.text);
+            }
+          }
+        } else {
+          annotations.push(child.text);
+        }
+      }
+    }
+
+    ctx.properties.push({
+      name,
+      className,
+      isConstant: isVal,
+      isMutable: isVar,
+      isLazy: false,
+      isLateinit: false,
+      isConstructorParam: true,
+      typeAnnotation,
+      annotations: annotations.length > 0 ? annotations : undefined,
+      line: param.startPosition.row + 1,
+    });
+  }
+}
+
+/**
+ * Phase 5.3: Extract Kotlin type name from user_type or nullable_type node
+ * Strips generics and nullable marker
+ */
+function _extractKtTypeName(typeNode) {
+  if (typeNode.type === 'nullable_type') {
+    const inner = typeNode.namedChildren.find((c) => c.type === 'user_type');
+    if (inner) {
+      const text = inner.text;
+      const bracketIdx = text.indexOf('<');
+      return bracketIdx > 0 ? text.slice(0, bracketIdx) : text;
+    }
+    return null;
+  }
+  // user_type
+  const text = typeNode.text;
+  const bracketIdx = text.indexOf('<');
+  return bracketIdx > 0 ? text.slice(0, bracketIdx) : text;
+}
+
 function _collectTypeRefs(node) {
   const refs = [];
   function walk(n) {
@@ -401,6 +570,165 @@ function _maxNesting(node, depth) {
   return max;
 }
 
+// ── Kotlin Call Site 提取 (Phase 5) ──────────────────────────
+
+/**
+ * 从 Kotlin AST root 提取所有调用点
+ */
+function extractCallSitesKotlin(root, ctx, _lang) {
+  const scopes = _collectKtScopes(root);
+  for (const scope of scopes) {
+    _extractKtCallSitesFromBody(scope.body, scope.className, scope.methodName, ctx);
+  }
+}
+
+/**
+ * 递归收集 Kotlin 中所有函数体作用域
+ */
+function _collectKtScopes(root) {
+  const scopes = [];
+
+  function visit(node, className) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+
+      if (child.type === 'class_declaration' || child.type === 'object_declaration') {
+        const name = child.namedChildren.find(
+          (c) => c.type === 'type_identifier' || c.type === 'simple_identifier'
+        )?.text;
+        const body = child.namedChildren.find((c) => c.type === 'class_body');
+        if (body) {
+          visit(body, name || className);
+        }
+      } else if (child.type === 'companion_object') {
+        const body = child.namedChildren.find((c) => c.type === 'class_body');
+        if (body) {
+          visit(body, className);
+        }
+      } else if (child.type === 'function_declaration') {
+        const name = child.namedChildren.find((c) => c.type === 'simple_identifier')?.text || 'unknown';
+        const body = child.namedChildren.find((c) => c.type === 'function_body' || c.type === 'block');
+        if (body) {
+          scopes.push({ body, className, methodName: name });
+        }
+      } else if (child.type === 'property_declaration') {
+        // property with getter/setter or initializer with lambda
+        const getter = child.namedChildren.find((c) => c.type === 'getter');
+        const setter = child.namedChildren.find((c) => c.type === 'setter');
+        const propName = child.namedChildren.find((c) => c.type === 'simple_identifier' || c.type === 'variable_declaration')?.text;
+        if (getter) {
+          const body = getter.namedChildren.find((c) => c.type === 'function_body' || c.type === 'block');
+          if (body) scopes.push({ body, className, methodName: `get_${propName || 'prop'}` });
+        }
+        if (setter) {
+          const body = setter.namedChildren.find((c) => c.type === 'function_body' || c.type === 'block');
+          if (body) scopes.push({ body, className, methodName: `set_${propName || 'prop'}` });
+        }
+      }
+    }
+  }
+
+  visit(root, null);
+  return scopes;
+}
+
+/**
+ * 从 Kotlin function body 中递归提取调用点
+ */
+function _extractKtCallSitesFromBody(bodyNode, className, methodName, ctx) {
+  if (!bodyNode) return;
+
+  const KT_NOISE = new Set([
+    'println', 'print', 'require', 'check', 'error', 'TODO',
+    'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf',
+    'arrayOf', 'intArrayOf', 'emptyList', 'emptyMap', 'emptySet',
+    'lazy', 'repeat', 'run', 'let', 'also', 'apply', 'with',
+  ]);
+
+  function walk(node) {
+    if (!node || node.type === 'ERROR' || node.isMissing) return;
+
+    if (node.type === 'call_expression') {
+      const func = node.namedChildren[0];
+      if (!func) { walkChildren(node); return; }
+
+      let callee, receiver = null, receiverType = null, callType;
+
+      if (func.type === 'navigation_expression') {
+        // obj.method() or Pkg.func()
+        const parts = func.text.split('.');
+        if (parts.length >= 2) {
+          receiver = parts.slice(0, -1).join('.');
+          callee = parts[parts.length - 1];
+          if (receiver === 'this' || receiver === 'self') {
+            receiverType = className;
+            callType = 'method';
+          } else if (receiver === 'super') {
+            receiverType = className;
+            callType = 'super';
+          } else if (/^[A-Z]/.test(receiver)) {
+            receiverType = receiver;
+            callType = 'static';
+          } else {
+            callType = 'method';
+            receiverType = null;
+          }
+        } else {
+          callee = func.text;
+          callType = 'function';
+        }
+      } else if (func.type === 'simple_identifier') {
+        callee = func.text;
+        if (KT_NOISE.has(callee)) {
+          walkChildren(node);
+          return;
+        }
+        // PascalCase → constructor
+        callType = /^[A-Z]/.test(callee) ? 'constructor' : 'function';
+        if (callType === 'constructor') {
+          receiverType = callee;
+        }
+      } else {
+        callee = func.text?.slice(0, 80) || 'unknown';
+        callType = 'function';
+      }
+
+      // 计算参数数量
+      const valueArgs = node.namedChildren.find((c) => c.type === 'call_suffix' || c.type === 'value_arguments');
+      const argCount = valueArgs ? valueArgs.namedChildCount : 0;
+
+      ctx.callSites.push({
+        callee,
+        callerMethod: methodName,
+        callerClass: className,
+        callType,
+        receiver,
+        receiverType,
+        argCount,
+        line: node.startPosition.row + 1,
+        isAwait: false,
+      });
+
+      // walk arguments for nested calls
+      if (valueArgs) walkChildren(valueArgs);
+      // also check trailing lambda
+      const lambda = node.namedChildren.find((c) => c.type === 'annotated_lambda' || c.type === 'lambda_literal');
+      if (lambda) walkChildren(lambda);
+      return;
+    }
+
+    walkChildren(node);
+  }
+
+  function walkChildren(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      walk(node.namedChild(i));
+    }
+  }
+
+  walk(bodyNode);
+}
+
 // ── 插件导出 ──
 
 let _grammar = null;
@@ -415,5 +743,6 @@ export const plugin = {
   getGrammar,
   walk: walkKotlin,
   detectPatterns: detectKtPatterns,
+  extractCallSites: extractCallSitesKotlin,
   extensions: ['.kt', '.kts'],
 };

package/lib/core/ast/lang-python.js

@@ -4,8 +4,13 @@
  *
  * 提取: class, function, import, decorator, docstring, module-level assignments
  * 模式: Singleton, Factory, Context Manager, Decorator pattern, Data Class
+ *
+ * Phase 5: 新增 ImportRecord 结构化导入 + extractCallSites 调用点提取
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+import { extractCallSitesPython } from '../analysis/CallSiteExtractor.js';
+
 function walkPython(root, ctx) {
   _walkPyNode(root, ctx, null);
 }
@@ -18,7 +23,14 @@ function _walkPyNode(node, ctx, parentClassName) {
       case 'import_statement': {
         const modNode = child.namedChildren.find((c) => c.type === 'dotted_name');
         if (modNode) {
-          ctx.imports.push(modNode.text);
+          // import mod / import mod as alias
+          const aliasNode = child.namedChildren.find((c) => c.type === 'aliased_import');
+          const alias = aliasNode?.namedChildren?.find((c) => c.type === 'identifier')?.text || null;
+          ctx.imports.push(new ImportRecord(modNode.text, {
+            symbols: ['*'],
+            alias: alias || modNode.text.split('.').pop(),
+            kind: 'namespace',
+          }));
         }
         break;
       }
@@ -28,7 +40,23 @@ function _walkPyNode(node, ctx, parentClassName) {
           (c) => c.type === 'dotted_name' || c.type === 'relative_import'
         );
         if (modNode) {
-          ctx.imports.push(modNode.text);
+          const importPath = modNode.text;
+          // from mod import A, B, C
+          const importedNames = [];
+          for (const c of child.namedChildren) {
+            if (c.type === 'dotted_name' && c !== modNode) {
+              importedNames.push(c.text);
+            } else if (c.type === 'aliased_import') {
+              const nameNode = c.namedChildren.find((n) => n.type === 'dotted_name' || n.type === 'identifier');
+              if (nameNode) importedNames.push(nameNode.text);
+            } else if (c.type === 'wildcard_import') {
+              importedNames.push('*');
+            }
+          }
+          ctx.imports.push(new ImportRecord(importPath, {
+            symbols: importedNames.length > 0 ? importedNames : [],
+            kind: importedNames.includes('*') ? 'namespace' : 'named',
+          }));
         }
         break;
       }
@@ -363,5 +391,6 @@ export const plugin = {
   getGrammar,
   walk: walkPython,
   detectPatterns: detectPyPatterns,
+  extractCallSites: extractCallSitesPython,
   extensions: ['.py'],
 };