@liendev/parser 0.39.0

package/dist/ast/chunker.d.ts

@@ -0,0 +1,30 @@
+import type { ASTChunk } from './types.js';
+export interface ASTChunkOptions {
+    maxChunkSize?: number;
+    minChunkSize?: number;
+    repoId?: string;
+    orgId?: string;
+}
+/**
+ * Chunk a file using AST-based semantic boundaries
+ *
+ * Uses Tree-sitter to parse code into an AST and extract semantic chunks
+ * (functions, classes, methods) that respect code structure.
+ *
+ * **Known Limitations:**
+ * - Tree-sitter may fail with "Invalid argument" error on very large files (1000+ lines)
+ * - When this occurs, Lien automatically falls back to line-based chunking
+ * - Configure fallback behavior via `chunking.astFallback` ('line-based' or 'error')
+ *
+ * @param filepath - Path to the file
+ * @param content - File content
+ * @param options - Chunking options
+ * @returns Array of AST-aware chunks
+ * @throws Error if AST parsing fails and astFallback is 'error'
+ */
+export declare function chunkByAST(filepath: string, content: string, options?: ASTChunkOptions): ASTChunk[];
+/**
+ * Check if AST chunking should be used for a file
+ */
+export declare function shouldUseAST(filepath: string): boolean;
+//# sourceMappingURL=chunker.d.ts.map

package/dist/ast/chunker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/ast/chunker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAqB,MAAM,YAAY,CAAC;AAY9D,MAAM,WAAW,eAAe;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAwGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,eAAoB,GAC5B,QAAQ,EAAE,CA0CZ;AA+SD;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEtD"}

package/dist/ast/chunker.js

@@ -0,0 +1,310 @@
+import { parseAST, detectLanguage, isASTSupported } from './parser.js';
+import { extractSymbolInfo, extractImports, extractImportedSymbols, extractExports, extractCallSites, } from './symbols.js';
+import { calculateCognitiveComplexity, calculateHalstead } from './complexity/index.js';
+import { getTraverser } from './traversers/index.js';
+/**
+ * Validate language support and parse the file.
+ * @throws Error if language not supported or parsing fails
+ */
+function parseAndValidate(filepath, content) {
+    const language = detectLanguage(filepath);
+    if (!language) {
+        throw new Error(`Unsupported language for file: ${filepath}`);
+    }
+    const parseResult = parseAST(content, language);
+    if (!parseResult.tree) {
+        throw new Error(`Failed to parse ${filepath}: ${parseResult.error}`);
+    }
+    return { language, rootNode: parseResult.tree.rootNode };
+}
+/**
+ * Prepare AST context by extracting imports, exports, and symbols.
+ */
+function prepareASTContext(content, rootNode, language) {
+    return {
+        lines: content.split('\n'),
+        fileImports: extractImports(rootNode, language),
+        importedSymbols: extractImportedSymbols(rootNode, language),
+        fileExports: extractExports(rootNode, language),
+        traverser: getTraverser(language),
+    };
+}
+/**
+ * Process a single top-level node into a chunk.
+ */
+function processTopLevelNode(node, filepath, content, context, language, tenantContext) {
+    const { lines, fileImports, fileExports, importedSymbols, traverser } = context;
+    // For variable declarations, try to find the function inside
+    let actualNode = node;
+    if (traverser.isDeclarationWithFunction(node)) {
+        const declInfo = traverser.findFunctionInDeclaration(node);
+        if (declInfo.functionNode) {
+            actualNode = declInfo.functionNode;
+        }
+    }
+    // For methods, find the parent container name (e.g., class name)
+    const parentClassName = traverser.findParentContainerName(actualNode);
+    const symbolInfo = extractSymbolInfo(actualNode, content, parentClassName, language);
+    const nodeContent = getNodeContent(node, lines);
+    return createChunk(filepath, node, nodeContent, symbolInfo, fileImports, language, tenantContext, fileExports, importedSymbols);
+}
+/**
+ * Process all top-level nodes into chunks.
+ */
+function processTopLevelNodes(topLevelNodes, filepath, content, context, language, tenantContext) {
+    return topLevelNodes.map(node => processTopLevelNode(node, filepath, content, context, language, tenantContext));
+}
+/**
+ * Chunk a file using AST-based semantic boundaries
+ *
+ * Uses Tree-sitter to parse code into an AST and extract semantic chunks
+ * (functions, classes, methods) that respect code structure.
+ *
+ * **Known Limitations:**
+ * - Tree-sitter may fail with "Invalid argument" error on very large files (1000+ lines)
+ * - When this occurs, Lien automatically falls back to line-based chunking
+ * - Configure fallback behavior via `chunking.astFallback` ('line-based' or 'error')
+ *
+ * @param filepath - Path to the file
+ * @param content - File content
+ * @param options - Chunking options
+ * @returns Array of AST-aware chunks
+ * @throws Error if AST parsing fails and astFallback is 'error'
+ */
+export function chunkByAST(filepath, content, options = {}) {
+    const { minChunkSize = 5, repoId, orgId } = options;
+    const tenantContext = { repoId, orgId };
+    // Parse and validate
+    const { language, rootNode } = parseAndValidate(filepath, content);
+    // Prepare context
+    const context = prepareASTContext(content, rootNode, language);
+    // Find and process top-level nodes
+    const topLevelNodes = findTopLevelNodes(rootNode, context.traverser);
+    const topLevelChunks = processTopLevelNodes(topLevelNodes, filepath, content, context, language, tenantContext);
+    // Extract uncovered code (imports, exports, top-level statements)
+    const coveredRanges = topLevelNodes.map(n => ({
+        start: n.startPosition.row,
+        end: n.endPosition.row,
+    }));
+    const uncoveredChunks = extractUncoveredCode(context.lines, coveredRanges, filepath, minChunkSize, context.fileImports, language, tenantContext, context.fileExports, context.importedSymbols);
+    // Combine and sort by line number
+    return [...topLevelChunks, ...uncoveredChunks].sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+}
+/** Check if node is a function-containing declaration at top level */
+function isFunctionDeclaration(node, depth, traverser) {
+    if (depth !== 0 || !traverser.isDeclarationWithFunction(node))
+        return false;
+    return traverser.findFunctionInDeclaration(node).hasFunction;
+}
+/** Check if node is a target type at valid depth */
+function isTargetNode(node, depth, traverser) {
+    return depth <= 1 && traverser.targetNodeTypes.includes(node.type);
+}
+/**
+ * Find all top-level nodes that should become chunks
+ *
+ * Uses a language-specific traverser to handle different AST structures.
+ * This function is now language-agnostic - all language-specific logic
+ * is delegated to the traverser.
+ *
+ * @param rootNode - Root AST node
+ * @param traverser - Language-specific traverser
+ * @returns Array of nodes to extract as chunks
+ */
+function findTopLevelNodes(rootNode, traverser) {
+    const nodes = [];
+    function traverse(node, depth) {
+        // Capture function declarations and target nodes
+        if (isFunctionDeclaration(node, depth, traverser) || isTargetNode(node, depth, traverser)) {
+            nodes.push(node);
+            return;
+        }
+        // Handle containers - emit the container itself AND traverse body for children
+        if (traverser.shouldExtractChildren(node)) {
+            nodes.push(node);
+            const body = traverser.getContainerBody(node);
+            if (body)
+                traverse(body, depth + 1);
+            return;
+        }
+        // Traverse children of traversable nodes
+        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);
+    return nodes;
+}
+/**
+ * Extract content for a specific AST node
+ */
+function getNodeContent(node, lines) {
+    const startLine = node.startPosition.row;
+    const endLine = node.endPosition.row;
+    return lines.slice(startLine, endLine + 1).join('\n');
+}
+/** Maps symbol types to legacy symbol array keys */
+const SYMBOL_TYPE_TO_ARRAY = {
+    function: 'functions',
+    method: 'functions',
+    class: 'classes',
+    interface: 'interfaces',
+};
+/** Symbol types that have meaningful complexity metrics */
+const COMPLEXITY_SYMBOL_TYPES = new Set(['function', 'method']);
+/**
+ * Build legacy symbols object for backward compatibility
+ */
+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;
+}
+/**
+ * Determine chunk type from symbol info
+ */
+function getChunkType(symbolInfo) {
+    if (!symbolInfo)
+        return 'block';
+    return symbolInfo.type === 'class' ? 'class' : 'function';
+}
+/**
+ * Create a chunk from an AST node
+ */
+function createChunk(filepath, node, content, symbolInfo, imports, language, tenantContext, fileExports, importedSymbols) {
+    const symbols = buildLegacySymbols(symbolInfo);
+    const shouldCalcComplexity = symbolInfo?.type && COMPLEXITY_SYMBOL_TYPES.has(symbolInfo.type);
+    // Calculate complexity metrics only for functions and methods
+    const cognitiveComplexity = shouldCalcComplexity ? calculateCognitiveComplexity(node) : undefined;
+    // Calculate Halstead metrics only for functions and methods
+    const halstead = shouldCalcComplexity ? calculateHalstead(node, language) : undefined;
+    // Extract call sites for functions and methods
+    const callSites = shouldCalcComplexity ? extractCallSites(node, language) : undefined;
+    return {
+        content,
+        metadata: {
+            file: filepath,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            type: getChunkType(symbolInfo),
+            language,
+            symbols,
+            symbolName: symbolInfo?.name,
+            symbolType: symbolInfo?.type,
+            parentClass: symbolInfo?.parentClass,
+            complexity: symbolInfo?.complexity,
+            cognitiveComplexity,
+            parameters: symbolInfo?.parameters,
+            signature: symbolInfo?.signature,
+            returnType: symbolInfo?.returnType,
+            imports,
+            // Symbol-level dependency tracking
+            // NOTE: `exports` and `importedSymbols` are file-level concepts, but we deliberately
+            // attach them to every chunk from the same file (including "uncovered" chunks).
+            // This duplicates some metadata, but greatly simplifies dependency analysis,
+            // since consumers can inspect a single chunk in isolation without additional lookups.
+            // This increases storage overhead but is acceptable given typical file sizes and chunk counts.
+            ...(fileExports && fileExports.length > 0 && { exports: fileExports }),
+            ...(importedSymbols && Object.keys(importedSymbols).length > 0 && { importedSymbols }),
+            ...(callSites && callSites.length > 0 && { callSites }),
+            // Halstead metrics
+            halsteadVolume: halstead?.volume,
+            halsteadDifficulty: halstead?.difficulty,
+            halsteadEffort: halstead?.effort,
+            halsteadBugs: halstead?.bugs,
+            // Multi-tenant fields
+            ...(tenantContext?.repoId && { repoId: tenantContext.repoId }),
+            ...(tenantContext?.orgId && { orgId: tenantContext.orgId }),
+        },
+    };
+}
+/**
+ * Find gaps between covered ranges (uncovered code)
+ */
+function findUncoveredRanges(coveredRanges, totalLines) {
+    const uncoveredRanges = [];
+    let currentStart = 0;
+    // Sort covered ranges
+    const sortedRanges = [...coveredRanges].sort((a, b) => a.start - b.start);
+    for (const range of sortedRanges) {
+        if (currentStart < range.start) {
+            // There's a gap before this range
+            uncoveredRanges.push({
+                start: currentStart,
+                end: range.start - 1,
+            });
+        }
+        currentStart = range.end + 1;
+    }
+    // Handle remaining code after last covered range
+    if (currentStart < totalLines) {
+        uncoveredRanges.push({
+            start: currentStart,
+            end: totalLines - 1,
+        });
+    }
+    return uncoveredRanges;
+}
+/**
+ * Create a chunk from a line range
+ */
+function createChunkFromRange(range, lines, filepath, language, imports, tenantContext, fileExports, importedSymbols) {
+    const uncoveredLines = lines.slice(range.start, range.end + 1);
+    const content = uncoveredLines.join('\n').trim();
+    return {
+        content,
+        metadata: {
+            file: filepath,
+            startLine: range.start + 1,
+            endLine: range.end + 1,
+            type: 'block',
+            language,
+            // Empty symbols for uncovered code (imports, exports, etc.)
+            symbols: { functions: [], classes: [], interfaces: [] },
+            imports,
+            // Symbol-level dependency tracking
+            ...(fileExports && fileExports.length > 0 && { exports: fileExports }),
+            ...(importedSymbols && Object.keys(importedSymbols).length > 0 && { importedSymbols }),
+            // Multi-tenant fields
+            ...(tenantContext?.repoId && { repoId: tenantContext.repoId }),
+            ...(tenantContext?.orgId && { orgId: tenantContext.orgId }),
+        },
+    };
+}
+/**
+ * Validate that a chunk meets the minimum size requirements
+ */
+function isValidChunk(chunk, minChunkSize) {
+    const lineCount = chunk.metadata.endLine - chunk.metadata.startLine + 1;
+    return chunk.content.length > 0 && lineCount >= minChunkSize;
+}
+/**
+ * Extract code that wasn't covered by function/class chunks
+ * (imports, exports, top-level statements)
+ */
+function extractUncoveredCode(lines, coveredRanges, filepath, minChunkSize, imports, language, tenantContext, fileExports, importedSymbols) {
+    const uncoveredRanges = findUncoveredRanges(coveredRanges, lines.length);
+    const hasExports = fileExports && fileExports.length > 0;
+    return uncoveredRanges
+        .map(range => createChunkFromRange(range, lines, filepath, language, imports, tenantContext, fileExports, importedSymbols))
+        .filter(chunk => (hasExports ? chunk.content.length > 0 : isValidChunk(chunk, minChunkSize)));
+}
+/**
+ * Check if AST chunking should be used for a file
+ */
+export function shouldUseAST(filepath) {
+    return isASTSupported(filepath);
+}
+//# sourceMappingURL=chunker.js.map

package/dist/ast/chunker.js.map

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

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

@@ -0,0 +1,16 @@
+import type Parser from 'tree-sitter';
+/**
+ * Calculate cognitive complexity of a function
+ *
+ * Based on SonarSource's Cognitive Complexity specification:
+ * - +1 for each break from linear flow (if, for, while, catch, etc.)
+ * - +1 for each nesting level when inside a control structure
+ * - +1 for each logical operator sequence break (a && b || c)
+ *
+ * @see https://www.sonarsource.com/docs/CognitiveComplexity.pdf
+ *
+ * @param node - AST node to analyze (typically a function/method)
+ * @returns Cognitive complexity score (minimum 0)
+ */
+export declare function calculateCognitiveComplexity(node: Parser.SyntaxNode): number;
+//# sourceMappingURL=cognitive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cognitive.d.ts","sourceRoot":"","sources":["../../../src/ast/complexity/cognitive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AA8HtC;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAsC5E"}

package/dist/ast/complexity/cognitive.js

@@ -0,0 +1,137 @@
+import { getAllLanguages } from '../languages/registry.js';
+/**
+ * Lazily-built union sets from all language definitions.
+ */
+let nestingTypesCache = null;
+let nonNestingTypesCache = null;
+let lambdaTypesCache = null;
+function getNestingTypes() {
+    if (!nestingTypesCache) {
+        nestingTypesCache = new Set();
+        for (const lang of getAllLanguages()) {
+            for (const type of lang.complexity.nestingTypes) {
+                nestingTypesCache.add(type);
+            }
+        }
+    }
+    return nestingTypesCache;
+}
+function getNonNestingTypes() {
+    if (!nonNestingTypesCache) {
+        nonNestingTypesCache = new Set();
+        for (const lang of getAllLanguages()) {
+            for (const type of lang.complexity.nonNestingTypes) {
+                nonNestingTypesCache.add(type);
+            }
+        }
+    }
+    return nonNestingTypesCache;
+}
+function getLambdaTypes() {
+    if (!lambdaTypesCache) {
+        lambdaTypesCache = new Set();
+        for (const lang of getAllLanguages()) {
+            for (const type of lang.complexity.lambdaTypes) {
+                lambdaTypesCache.add(type);
+            }
+        }
+    }
+    return lambdaTypesCache;
+}
+/**
+ * Check if node is a logical operator and return normalized form
+ */
+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;
+}
+/**
+ * Determine nesting level for a child node based on SonarSource spec.
+ */
+function getChildNestingLevel(parent, child, currentLevel, nonNestingTypes) {
+    const isCondition = parent.childForFieldName('condition') === child;
+    const isNonNestingChild = nonNestingTypes.has(child.type);
+    return !isCondition && !isNonNestingChild ? currentLevel + 1 : currentLevel;
+}
+/**
+ * Get complexity increment for nested lambda (only adds if already nested)
+ */
+function getNestedLambdaIncrement(nodeType, nestingLevel, lambdaTypes) {
+    return lambdaTypes.has(nodeType) && nestingLevel > 0 ? 1 : 0;
+}
+/** Traverse logical operator children, passing the operator type */
+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);
+    }
+}
+/** Traverse nesting type children with proper nesting level adjustment */
+function traverseNestingChildren(n, level, nonNestingTypes, ctx) {
+    for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child)
+            ctx.traverse(child, getChildNestingLevel(n, child, level, nonNestingTypes), null);
+    }
+}
+/** Traverse all children at specified level */
+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);
+    }
+}
+/**
+ * Calculate cognitive complexity of a function
+ *
+ * Based on SonarSource's Cognitive Complexity specification:
+ * - +1 for each break from linear flow (if, for, while, catch, etc.)
+ * - +1 for each nesting level when inside a control structure
+ * - +1 for each logical operator sequence break (a && b || c)
+ *
+ * @see https://www.sonarsource.com/docs/CognitiveComplexity.pdf
+ *
+ * @param node - AST node to analyze (typically a function/method)
+ * @returns Cognitive complexity score (minimum 0)
+ */
+export function calculateCognitiveComplexity(node) {
+    let complexity = 0;
+    const ctx = { traverse };
+    const nestingTypes = getNestingTypes();
+    const nonNestingTypes = getNonNestingTypes();
+    const lambdaTypes = getLambdaTypes();
+    function traverse(n, nestingLevel, lastLogicalOp) {
+        const logicalOp = getLogicalOperator(n);
+        if (logicalOp) {
+            complexity += lastLogicalOp !== logicalOp ? 1 : 0;
+            traverseLogicalChildren(n, nestingLevel, logicalOp, ctx);
+            return;
+        }
+        if (nestingTypes.has(n.type)) {
+            complexity += 1 + nestingLevel;
+            traverseNestingChildren(n, nestingLevel, nonNestingTypes, ctx);
+            return;
+        }
+        if (nonNestingTypes.has(n.type)) {
+            complexity += 1;
+            traverseAllChildren(n, nestingLevel + 1, ctx);
+            return;
+        }
+        complexity += getNestedLambdaIncrement(n.type, nestingLevel, lambdaTypes);
+        traverseAllChildren(n, nestingLevel, ctx);
+    }
+    traverse(node, 0, null);
+    return complexity;
+}
+//# sourceMappingURL=cognitive.js.map

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

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

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

@@ -0,0 +1,12 @@
+import type Parser from 'tree-sitter';
+/**
+ * Calculate cyclomatic complexity of a function
+ *
+ * Complexity = 1 (base) + number of decision points
+ * Decision points: if, while, do...while, for, for...in, for...of, foreach, case, catch, &&, ||, ?:
+ *
+ * @param node - AST node to analyze (typically a function/method)
+ * @returns Cyclomatic complexity score (minimum 1)
+ */
+export declare function calculateComplexity(node: Parser.SyntaxNode): number;
+//# sourceMappingURL=cyclomatic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cyclomatic.d.ts","sourceRoot":"","sources":["../../../src/ast/complexity/cyclomatic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAsBtC;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CA0BnE"}

package/dist/ast/complexity/cyclomatic.js

@@ -0,0 +1,54 @@
+import { getAllLanguages } from '../languages/registry.js';
+/**
+ * Build the union set of decision point node types from all language definitions.
+ * Lazily initialized on first use.
+ */
+let decisionPointsCache = null;
+function getDecisionPoints() {
+    if (!decisionPointsCache) {
+        const set = new Set();
+        for (const lang of getAllLanguages()) {
+            for (const type of lang.complexity.decisionPoints) {
+                set.add(type);
+            }
+        }
+        decisionPointsCache = set;
+    }
+    return decisionPointsCache;
+}
+/**
+ * Calculate cyclomatic complexity of a function
+ *
+ * Complexity = 1 (base) + number of decision points
+ * Decision points: if, while, do...while, for, for...in, for...of, foreach, case, catch, &&, ||, ?:
+ *
+ * @param node - AST node to analyze (typically a function/method)
+ * @returns Cyclomatic complexity score (minimum 1)
+ */
+export function calculateComplexity(node) {
+    let complexity = 1; // Base complexity
+    const decisionPoints = getDecisionPoints();
+    function traverse(n) {
+        if (decisionPoints.has(n.type)) {
+            // For binary expressions, only count && and ||
+            if (n.type === 'binary_expression') {
+                const operator = n.childForFieldName('operator');
+                if (operator && (operator.text === '&&' || operator.text === '||')) {
+                    complexity++;
+                }
+            }
+            else {
+                complexity++;
+            }
+        }
+        // Traverse children
+        for (let i = 0; i < n.namedChildCount; i++) {
+            const child = n.namedChild(i);
+            if (child)
+                traverse(child);
+        }
+    }
+    traverse(node);
+    return complexity;
+}
+//# sourceMappingURL=cyclomatic.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cyclomatic.js","sourceRoot":"","sources":["../../../src/ast/complexity/cyclomatic.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;GAGG;AACH,IAAI,mBAAmB,GAAuB,IAAI,CAAC;AAEnD,SAAS,iBAAiB;IACxB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;QAC9B,KAAK,MAAM,IAAI,IAAI,eAAe,EAAE,EAAE,CAAC;YACrC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;gBAClD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAChB,CAAC;QACH,CAAC;QACD,mBAAmB,GAAG,GAAG,CAAC;IAC5B,CAAC;IACD,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAuB;IACzD,IAAI,UAAU,GAAG,CAAC,CAAC,CAAC,kBAAkB;IACtC,MAAM,cAAc,GAAG,iBAAiB,EAAE,CAAC;IAE3C,SAAS,QAAQ,CAAC,CAAoB;QACpC,IAAI,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,+CAA+C;YAC/C,IAAI,CAAC,CAAC,IAAI,KAAK,mBAAmB,EAAE,CAAC;gBACnC,MAAM,QAAQ,GAAG,CAAC,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;gBACjD,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;oBACnE,UAAU,EAAE,CAAC;gBACf,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,UAAU,EAAE,CAAC;YACf,CAAC;QACH,CAAC;QAED,oBAAoB;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,KAAK,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC9B,IAAI,KAAK;gBAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED,QAAQ,CAAC,IAAI,CAAC,CAAC;IACf,OAAO,UAAU,CAAC;AACpB,CAAC"}

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

@@ -0,0 +1,56 @@
+import type Parser from 'tree-sitter';
+import type { SupportedLanguage } from '../languages/registry.js';
+/** Raw Halstead counts from AST */
+export interface HalsteadCounts {
+    n1: number;
+    n2: number;
+    N1: number;
+    N2: number;
+    operators: Map<string, number>;
+    operands: Map<string, number>;
+}
+/** Calculated Halstead metrics */
+export interface HalsteadMetrics {
+    vocabulary: number;
+    length: number;
+    volume: number;
+    difficulty: number;
+    effort: number;
+    time: number;
+    bugs: number;
+}
+/**
+ * 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 declare function countHalstead(node: Parser.SyntaxNode, language: SupportedLanguage): HalsteadCounts;
+/**
+ * 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 declare function calculateHalsteadMetrics(counts: HalsteadCounts): HalsteadMetrics;
+/**
+ * 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 declare function calculateHalstead(node: Parser.SyntaxNode, language: SupportedLanguage): HalsteadMetrics;
+//# sourceMappingURL=halstead.d.ts.map