@liendev/parser 0.39.0

package/dist/ast/complexity/halstead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"halstead.d.ts","sourceRoot":"","sources":["../../../src/ast/complexity/halstead.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAQlE,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,kCAAkC;AAClC,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AA6HD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,CAAC,UAAU,EACvB,QAAQ,EAAE,iBAAiB,GAC1B,cAAc,CAkChB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,cAAc,GAAG,eAAe,CAsBhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,CAAC,UAAU,EACvB,QAAQ,EAAE,iBAAiB,GAC1B,eAAe,CAGjB"}

package/dist/ast/complexity/halstead.js

@@ -0,0 +1,196 @@
+import { getLanguage } from '../languages/registry.js';
+/**
+ * AST node types that represent operators (language-agnostic).
+ * These are the tree-sitter node types, not the text content.
+ */
+const OPERATOR_NODE_TYPES = 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',
+]);
+/**
+ * AST node types that represent operands.
+ */
+const OPERAND_NODE_TYPES = 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',
+]);
+/**
+ * Resolve operator sets for a language once, to avoid repeated lookups.
+ */
+function resolveOperators(language) {
+    const def = getLanguage(language);
+    return { symbols: def.complexity.operatorSymbols, keywords: def.complexity.operatorKeywords };
+}
+/**
+ * Check if a node represents an operator
+ */
+function isOperator(node, ops) {
+    const nodeType = node.type;
+    const nodeText = node.text;
+    // Check if it's an operator node type
+    if (OPERATOR_NODE_TYPES.has(nodeType)) {
+        return true;
+    }
+    // Check if it's an operator symbol or keyword
+    return ops.symbols.has(nodeText) || ops.keywords.has(nodeText);
+}
+/**
+ * Check if a node represents an operand
+ */
+function isOperand(node) {
+    return OPERAND_NODE_TYPES.has(node.type);
+}
+/**
+ * Get the canonical key for an operator (for counting distinct operators)
+ */
+function getOperatorKey(node) {
+    // For complex expressions, use the operator type
+    if (OPERATOR_NODE_TYPES.has(node.type)) {
+        // For binary/unary expressions, extract the actual operator
+        const operator = node.childForFieldName('operator');
+        if (operator) {
+            return operator.text;
+        }
+        return node.type;
+    }
+    return node.text;
+}
+/**
+ * Get the canonical key for an operand (for counting distinct operands)
+ */
+function getOperandKey(node) {
+    return node.text;
+}
+/**
+ * Sum all values in a map
+ */
+function sumValues(map) {
+    let sum = 0;
+    for (const count of map.values()) {
+        sum += count;
+    }
+    return sum;
+}
+/**
+ * Count operators and operands in an AST node
+ *
+ * @param node - AST node to analyze (typically a function/method)
+ * @param language - Programming language for language-specific handling
+ * @returns HalsteadCounts with raw operator/operand counts
+ */
+export function countHalstead(node, language) {
+    const operators = new Map();
+    const operands = new Map();
+    const ops = resolveOperators(language);
+    function traverse(n) {
+        // Check if this is an operator
+        if (isOperator(n, ops)) {
+            const key = getOperatorKey(n);
+            operators.set(key, (operators.get(key) || 0) + 1);
+        }
+        // Check if this is an operand
+        if (isOperand(n)) {
+            const key = getOperandKey(n);
+            operands.set(key, (operands.get(key) || 0) + 1);
+        }
+        // Recurse into children
+        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,
+    };
+}
+/**
+ * Calculate derived Halstead metrics from raw counts
+ *
+ * Formulas based on Maurice Halstead's "Elements of Software Science" (1977):
+ * - Vocabulary (n) = n1 + n2
+ * - Length (N) = N1 + N2
+ * - Volume (V) = N × log₂(n) - size of implementation
+ * - Difficulty (D) = (n1/2) × (N2/n2) - error-proneness
+ * - Effort (E) = D × V - mental effort required
+ * - Time (T) = E / 18 - seconds to understand (Stroud number)
+ * - Bugs (B) = E^(2/3) / 3000 - estimated delivered bugs (effort-based variant)
+ *
+ * @param counts - Raw Halstead counts from countHalstead()
+ * @returns Calculated HalsteadMetrics
+ */
+export function calculateHalsteadMetrics(counts) {
+    const { n1, n2, N1, N2 } = counts;
+    const vocabulary = n1 + n2;
+    const length = N1 + N2;
+    // Avoid log(0) and division by zero
+    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; // Stroud number (18 mental discriminations per second)
+    const bugs = Math.pow(effort, 2 / 3) / 3000;
+    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 * 1000) / 1000,
+    };
+}
+/**
+ * Calculate Halstead metrics for an AST node in one call
+ *
+ * Convenience function that combines countHalstead and calculateHalsteadMetrics.
+ *
+ * @param node - AST node to analyze
+ * @param language - Programming language
+ * @returns Calculated HalsteadMetrics
+ */
+export function calculateHalstead(node, language) {
+    const counts = countHalstead(node, language);
+    return calculateHalsteadMetrics(counts);
+}
+//# sourceMappingURL=halstead.js.map

package/dist/ast/complexity/halstead.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"halstead.js","sourceRoot":"","sources":["../../../src/ast/complexity/halstead.ts"],"names":[],"mappings":"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"}

package/dist/ast/complexity/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Complexity metrics module
+ *
+ * This module provides various code complexity metrics:
+ * - Cyclomatic complexity: Counts decision points (branches) in code
+ * - Cognitive complexity: Measures mental effort to understand code (SonarSource spec)
+ * - Halstead metrics: Measures complexity based on operators/operands
+ */
+export { calculateComplexity } from './cyclomatic.js';
+export { calculateCognitiveComplexity } from './cognitive.js';
+export { countHalstead, calculateHalsteadMetrics, calculateHalstead } from './halstead.js';
+export type { HalsteadCounts, HalsteadMetrics } from './halstead.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/complexity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ast/complexity/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC3F,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/ast/complexity/index.js

@@ -0,0 +1,12 @@
+/**
+ * Complexity metrics module
+ *
+ * This module provides various code complexity metrics:
+ * - Cyclomatic complexity: Counts decision points (branches) in code
+ * - Cognitive complexity: Measures mental effort to understand code (SonarSource spec)
+ * - Halstead metrics: Measures complexity based on operators/operands
+ */
+export { calculateComplexity } from './cyclomatic.js';
+export { calculateCognitiveComplexity } from './cognitive.js';
+export { countHalstead, calculateHalsteadMetrics, calculateHalstead } from './halstead.js';
+//# sourceMappingURL=index.js.map

package/dist/ast/complexity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/ast/complexity/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC"}

package/dist/ast/extractors/index.d.ts

@@ -0,0 +1,35 @@
+import type { SupportedLanguage } from '../types.js';
+import type { LanguageExportExtractor, LanguageImportExtractor, LanguageSymbolExtractor } from './types.js';
+export type { LanguageExportExtractor, LanguageImportExtractor, LanguageSymbolExtractor, } from './types.js';
+/**
+ * Get the export extractor for a specific language.
+ * Delegates to the language registry.
+ *
+ * @param language - Programming language
+ * @returns Language-specific export extractor
+ */
+export declare function getExtractor(language: SupportedLanguage): LanguageExportExtractor;
+/**
+ * Get the import extractor for a specific language.
+ * Delegates to the language registry.
+ *
+ * @param language - Programming language
+ * @returns Language-specific import extractor, or undefined if not implemented
+ */
+export declare function getImportExtractor(language: SupportedLanguage): LanguageImportExtractor | undefined;
+/**
+ * Get the symbol extractor for a specific language.
+ * Delegates to the language registry.
+ *
+ * @param language - Programming language
+ * @returns Language-specific symbol extractor, or undefined if not implemented
+ */
+export declare function getSymbolExtractor(language: SupportedLanguage): LanguageSymbolExtractor | undefined;
+/**
+ * Check if a language has an export extractor implementation
+ *
+ * @param language - Programming language
+ * @returns True if extractor exists
+ */
+export declare function hasExtractor(language: string): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/extractors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ast/extractors/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EACV,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,iBAAiB,GAAG,uBAAuB,CAEjF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,GAC1B,uBAAuB,GAAG,SAAS,CAErC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,GAC1B,uBAAuB,GAAG,SAAS,CAErC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEtD"}

package/dist/ast/extractors/index.js

@@ -0,0 +1,41 @@
+import { getLanguage, languageExists } from '../languages/registry.js';
+/**
+ * Get the export extractor for a specific language.
+ * Delegates to the language registry.
+ *
+ * @param language - Programming language
+ * @returns Language-specific export extractor
+ */
+export function getExtractor(language) {
+    return getLanguage(language).exportExtractor;
+}
+/**
+ * Get the import extractor for a specific language.
+ * Delegates to the language registry.
+ *
+ * @param language - Programming language
+ * @returns Language-specific import extractor, or undefined if not implemented
+ */
+export function getImportExtractor(language) {
+    return getLanguage(language).importExtractor;
+}
+/**
+ * Get the symbol extractor for a specific language.
+ * Delegates to the language registry.
+ *
+ * @param language - Programming language
+ * @returns Language-specific symbol extractor, or undefined if not implemented
+ */
+export function getSymbolExtractor(language) {
+    return getLanguage(language).symbolExtractor;
+}
+/**
+ * Check if a language has an export extractor implementation
+ *
+ * @param language - Programming language
+ * @returns True if extractor exists
+ */
+export function hasExtractor(language) {
+    return languageExists(language);
+}
+//# sourceMappingURL=index.js.map

package/dist/ast/extractors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/ast/extractors/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAQvE;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,QAA2B;IACtD,OAAO,WAAW,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC;AAC/C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,QAA2B;IAE3B,OAAO,WAAW,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC;AAC/C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,QAA2B;IAE3B,OAAO,WAAW,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,QAAgB;IAC3C,OAAO,cAAc,CAAC,QAAQ,CAAC,CAAC;AAClC,CAAC"}

package/dist/ast/extractors/symbol-helpers.d.ts

@@ -0,0 +1,20 @@
+import type Parser from 'tree-sitter';
+/**
+ * Extract function/method signature
+ */
+export declare function extractSignature(node: Parser.SyntaxNode, content: string): string;
+/**
+ * Extract parameter list from function node
+ *
+ * Note: The `_content` parameter is unused in this function, but is kept for API consistency
+ * with other extract functions (e.g., extractSignature).
+ */
+export declare function extractParameters(node: Parser.SyntaxNode, _content: string): string[];
+/**
+ * Extract return type from function node (TypeScript)
+ *
+ * Note: The `_content` parameter is unused in this function, but is kept for API consistency
+ * with other extract functions (e.g., extractSignature).
+ */
+export declare function extractReturnType(node: Parser.SyntaxNode, _content: string): string | undefined;
+//# sourceMappingURL=symbol-helpers.d.ts.map

package/dist/ast/extractors/symbol-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-helpers.d.ts","sourceRoot":"","sources":["../../../src/ast/extractors/symbol-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA0BjF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBrF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK/F"}

package/dist/ast/extractors/symbol-helpers.js

@@ -0,0 +1,58 @@
+/**
+ * Extract function/method signature
+ */
+export function extractSignature(node, content) {
+    // Get the first line of the function (up to opening brace or arrow)
+    const startLine = node.startPosition.row;
+    const lines = content.split('\n');
+    let signature = lines[startLine] || '';
+    // If signature spans multiple lines, try to get up to the opening brace
+    let currentLine = startLine;
+    while (currentLine < node.endPosition.row &&
+        !signature.includes('{') &&
+        !signature.includes('=>')) {
+        currentLine++;
+        signature += ' ' + (lines[currentLine] || '');
+    }
+    // Clean up signature
+    signature = signature.split('{')[0].split('=>')[0].trim();
+    // Limit length
+    if (signature.length > 200) {
+        signature = signature.substring(0, 197) + '...';
+    }
+    return signature;
+}
+/**
+ * Extract parameter list from function node
+ *
+ * Note: The `_content` parameter is unused in this function, but is kept for API consistency
+ * with other extract functions (e.g., extractSignature).
+ */
+export function extractParameters(node, _content) {
+    const parameters = [];
+    // Find parameters node
+    const paramsNode = node.childForFieldName('parameters');
+    if (!paramsNode)
+        return parameters;
+    // Traverse parameter nodes
+    for (let i = 0; i < paramsNode.namedChildCount; i++) {
+        const param = paramsNode.namedChild(i);
+        if (param && param.text.trim()) {
+            parameters.push(param.text);
+        }
+    }
+    return parameters;
+}
+/**
+ * Extract return type from function node (TypeScript)
+ *
+ * Note: The `_content` parameter is unused in this function, but is kept for API consistency
+ * with other extract functions (e.g., extractSignature).
+ */
+export function extractReturnType(node, _content) {
+    const returnTypeNode = node.childForFieldName('return_type');
+    if (!returnTypeNode)
+        return undefined;
+    return returnTypeNode.text;
+}
+//# sourceMappingURL=symbol-helpers.js.map

package/dist/ast/extractors/symbol-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-helpers.js","sourceRoot":"","sources":["../../../src/ast/extractors/symbol-helpers.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAuB,EAAE,OAAe;IACvE,oEAAoE;IACpE,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;IACzC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAEvC,wEAAwE;IACxE,IAAI,WAAW,GAAG,SAAS,CAAC;IAC5B,OACE,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG;QAClC,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;QACxB,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EACzB,CAAC;QACD,WAAW,EAAE,CAAC;QACd,SAAS,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;IAChD,CAAC;IAED,qBAAqB;IACrB,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAE1D,eAAe;IACf,IAAI,SAAS,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;QAC3B,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC;IAClD,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAuB,EAAE,QAAgB;IACzE,MAAM,UAAU,GAAa,EAAE,CAAC;IAEhC,uBAAuB;IACvB,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACxD,IAAI,CAAC,UAAU;QAAE,OAAO,UAAU,CAAC;IAEnC,2BAA2B;IAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACvC,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;YAC/B,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAuB,EAAE,QAAgB;IACzE,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC;IAC7D,IAAI,CAAC,cAAc;QAAE,OAAO,SAAS,CAAC;IAEtC,OAAO,cAAc,CAAC,IAAI,CAAC;AAC7B,CAAC"}

package/dist/ast/extractors/types.d.ts

@@ -0,0 +1,108 @@
+import type Parser from 'tree-sitter';
+import type { SymbolInfo } from '../types.js';
+/**
+ * Language-specific symbol extraction strategy
+ *
+ * Each language has different AST node types for functions, classes, and methods.
+ * This interface allows language-specific symbol extraction while keeping the
+ * core chunking logic language-agnostic.
+ */
+export interface LanguageSymbolExtractor {
+    /** AST node types this extractor can handle for symbol extraction */
+    readonly symbolNodeTypes: string[];
+    /** Extract symbol info (name, type, signature, etc.) from an AST node */
+    extractSymbol(node: Parser.SyntaxNode, content: string, parentClass?: string): SymbolInfo | null;
+    /** Extract symbol name and line from a call expression node */
+    extractCallSite(node: Parser.SyntaxNode): {
+        symbol: string;
+        line: number;
+        key: string;
+    } | null;
+}
+/**
+ * Language-specific export extraction strategy
+ *
+ * Each language has different export semantics:
+ * - JavaScript/TypeScript: Explicit export statements
+ * - PHP: All top-level declarations are implicitly exported
+ * - Python: All module-level declarations are implicitly exported
+ *
+ * This interface allows us to implement language-specific export extraction
+ * while keeping the core symbol extraction logic language-agnostic.
+ *
+ * @example JavaScript/TypeScript
+ * ```typescript
+ * export function validateEmail() {}  // Explicit export
+ * export { foo, bar }                 // Named exports
+ * export default App                  // Default export
+ * ```
+ *
+ * @example PHP
+ * ```php
+ * class User {}        // Implicitly exported
+ * function helper() {} // Implicitly exported
+ * ```
+ *
+ * @example Python
+ * ```python
+ * class User:          # Implicitly exported
+ *     pass
+ * def helper():        # Implicitly exported
+ *     pass
+ * ```
+ */
+export interface LanguageExportExtractor {
+    /**
+     * Extract exported symbol names from an AST root node
+     *
+     * For JavaScript/TypeScript: Processes explicit export statements
+     * For PHP/Python: Processes top-level declarations (implicitly exported)
+     *
+     * @param rootNode - AST root node (typically 'program' or similar)
+     * @returns Array of exported symbol names (deduplicated)
+     *
+     * @example
+     * ```typescript
+     * // For: export { foo, bar }; export default App;
+     * extractExports(rootNode) // => ['foo', 'bar', 'default']
+     * ```
+     */
+    extractExports(rootNode: Parser.SyntaxNode): string[];
+}
+/**
+ * Language-specific import extraction strategy
+ *
+ * Each language has different import semantics:
+ * - JavaScript/TypeScript: import/export statements with source paths
+ * - PHP: namespace use declarations
+ * - Python: import/from...import statements with dotted paths
+ * - Rust: use declarations with crate/self/super paths
+ *
+ * This interface allows language-specific import extraction while
+ * keeping the core symbol extraction logic language-agnostic.
+ */
+export interface LanguageImportExtractor {
+    /**
+     * AST node types that represent import statements in this language.
+     * Used to identify which top-level nodes to process.
+     */
+    readonly importNodeTypes: string[];
+    /**
+     * Extract the import path from an import node for the imports list.
+     *
+     * @param node - AST node matching one of importNodeTypes
+     * @returns The import path string, or null to skip
+     */
+    extractImportPath(node: Parser.SyntaxNode): string | null;
+    /**
+     * Extract imported symbols mapped to their source path.
+     *
+     * @param node - AST node matching one of importNodeTypes
+     * @returns Object with importPath and symbols, or null to skip
+     */
+    processImportSymbols(node: Parser.SyntaxNode): {
+        importPath: string;
+        symbols: string[];
+    } | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ast/extractors/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ast/extractors/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAEnC,yEAAyE;IACzE,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IAEjG,+DAA+D;IAC/D,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAChG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE,CAAC;CACvD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAEnC;;;;;OAKG;IACH,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;IAE1D;;;;;OAKG;IACH,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;CACjG"}

package/dist/ast/extractors/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/ast/extractors/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/ast/extractors/types.ts"],"names":[],"mappings":""}