code-auditor-mcp 4.1.1 → 5.0.2

package/dist/functionScanner.js

@@ -8,6 +8,7 @@
  * and adapterBridge utilities. The old `import * as ts from 'typescript'` is removed.
  */
 import { discoverFiles, getLanguageFromPath } from './utils/fileDiscovery.js';
+import { errorMessage } from './utils/errorMessage.js';
 import { findNodesByKind, getNodeText, getLineAndColumn, getImports, getImportsDetailed, extractIdentifierUsage, getReExports } from './utils/astUtils.js';
 import { parseFile, walkAST, hasModifier, isExported, calculateComplexity } from './languages/adapterBridge.js';
 import { isReactComponent, detectComponentType, getComponentName, extractHooks, extractPropTypes } from './utils/reactDetection.js';
@@ -27,6 +28,10 @@ function isVariableDecl(type) {
 }
 /**
  * Scan directory for functions
+ *
+ * @param dirPath - Directory to scan for TS/JS files.
+ * @param options - Scan options (extensions, includes/excludes, unused-import config).
+ * @returns Function metadata for every function found in the directory.
  */
 export async function scanDirectoryForFunctions(dirPath, options) {
     const functions = [];
@@ -54,11 +59,15 @@ export async function scanDirectoryForFunctions(dirPath, options) {
         return functions;
     }
     catch (error) {
-        throw new Error(`Failed to scan directory: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw new Error(`Failed to scan directory: ${errorMessage(error)}`);
     }
 }
 /**
  * Extract functions from a single file (convenience wrapper that reads the file).
+ *
+ * @param filePath - Path of the file to read and extract from.
+ * @param options - Optional unused-import config forwarded to extraction.
+ * @returns Function metadata for the file's functions.
  */
 export async function extractFunctionsFromFile(filePath, options) {
     const content = await readFile(filePath, 'utf-8');
@@ -67,6 +76,11 @@ export async function extractFunctionsFromFile(filePath, options) {
 /**
  * Extract functions from source content (no file I/O — usable by both the
  * audit runner and the index sync path).
+ *
+ * @param content - Source text to parse and extract from.
+ * @param filePath - Path used to resolve the language and relative imports.
+ * @param options - Optional unused-import config.
+ * @returns Function metadata extracted from the source.
  */
 export function extractFunctionsFromSource(content, filePath, options) {
     const functions = [];
@@ -90,88 +104,88 @@ export function extractFunctionsFromSource(content, filePath, options) {
     const fileUsageMap = extractIdentifierUsage(root, content, importNames);
     // Track re-exports - these imports are used even if not referenced in code
     const reExports = getReExports(root, content);
-    for (const reExport of reExports) {
-        // Find imports that match re-exported names
-        for (const imp of detailedImports) {
-            if (imp.importedName === reExport.name ||
-                (reExport.name === '*' && imp.modulePath === reExport.module)) {
-                // Mark this import as used for re-export
-                if (!fileUsageMap.has(imp.localName)) {
-                    fileUsageMap.set(imp.localName, {
-                        usageType: 'reexport',
-                        usageCount: 1,
-                        lineNumbers: []
-                    });
-                }
-                else {
-                    const usage = fileUsageMap.get(imp.localName);
-                    if (usage.usageType !== 'reexport') {
-                        usage.usageType = 'reexport';
-                    }
-                }
-            }
-        }
-    }
-    // Find all function declarations
-    const functionDeclarations = findNodesByKind(root, 'function_declaration');
-    for (const func of functionDeclarations) {
-        const nameNode = findChildOfType(func, 'identifier');
-        if (!nameNode)
-            continue;
-        const { line } = getLineAndColumn(func);
-        const endLine = func.location?.end?.line ?? line;
-        // Extract function calls
-        const body = findChildOfType(func, 'statement_block');
+    markReExports(fileUsageMap, reExports, detailedImports);
+    // ── Shared extraction for the three function-like scans ────────────────
+    // Function declarations, arrow functions, and class methods repeat the same
+    // call-extraction + import-usage + unused-import + parameter-count derivation
+    // and the same record push; only the label and kind-specific metadata vary.
+    const deriveFunctionData = (node) => {
+        const body = findChildOfType(node, 'statement_block');
         const functionCalls = body ? extractFunctionCalls(body, content, importMap) : [];
         const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
-        // Track which imports this function uses
-        const functionUsageMap = extractIdentifierUsage(func, content, importNames);
+        const functionUsageMap = extractIdentifierUsage(node, content, importNames);
         const usedImports = Array.from(functionUsageMap.keys());
-        // Apply unused imports configuration
         const config = options?.unusedImportsConfig;
-        let unusedImports = detailedImports
+        const unusedImports = detailedImports
             .filter(imp => {
-            // Skip side-effect imports - they're never "unused"
+            // Skip side-effect imports - they're never "unused".
             if (imp.importType === 'side-effect')
                 return false;
-            // Check if import is used in this function OR at module level
+            // Used in this function OR at module level.
             if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
                 return false;
-            // Apply type-only configuration
+            // Apply type-only configuration.
             if (!config?.includeTypeOnlyImports && imp.isTypeOnly)
                 return false;
-            // Apply ignore patterns
+            // Apply ignore patterns.
             if (config?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
                 return false;
             return true;
         })
             .map(imp => imp.localName);
-        // Get parameter count from formal_parameters
-        const params = findChildOfType(func, 'formal_parameters');
-        const paramCount = params?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
+        const params = findChildOfType(node, 'formal_parameters');
+        const parameterCount = params?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter').length ?? 0;
+        return {
+            body,
+            functionCalls: normalizedCalls,
+            usedImports,
+            unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
+            parameterCount,
+        };
+    };
+    const pushScannedFunction = (opts) => {
+        const { name, line, endLine, node, kind, purpose, context, extraMetadata } = opts;
+        const d = deriveFunctionData(node);
         functions.push({
-            name: getNodeText(nameNode, content),
+            name,
             filePath,
             lineNumber: line,
             startLine: line,
             endLine,
             language: getLanguageFromPath(filePath),
             dependencies,
-            purpose: `Function ${getNodeText(nameNode, content)} implementation`,
-            context: `Located in ${path.basename(filePath)}`,
-            body: body ? getNodeText(body, content) : undefined,
+            purpose,
+            context,
+            body: d.body ? getNodeText(d.body, content) : undefined,
             metadata: {
-                kind: 'function',
-                isAsync: hasModifier(func, 'async'),
-                isExported: isExported(func),
-                parameterCount: paramCount,
-                functionCalls: normalizedCalls,
-                usedImports,
-                unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                complexity: calculateComplexity(func),
+                kind,
+                ...extraMetadata,
+                parameterCount: d.parameterCount,
+                functionCalls: d.functionCalls,
+                usedImports: d.usedImports,
+                unusedImports: d.unusedImports,
+                complexity: calculateComplexity(node),
                 dependencies
             }
         });
+    };
+    // Find all function declarations
+    const functionDeclarations = findNodesByKind(root, 'function_declaration');
+    for (const func of functionDeclarations) {
+        const nameNode = findChildOfType(func, 'identifier');
+        if (!nameNode)
+            continue;
+        const { line } = getLineAndColumn(func);
+        const name = getNodeText(nameNode, content);
+        pushScannedFunction({
+            name, line,
+            endLine: func.location?.end?.line ?? line,
+            node: func,
+            kind: 'function',
+            purpose: `Function ${name} implementation`,
+            context: `Located in ${path.basename(filePath)}`,
+            extraMetadata: { isAsync: hasModifier(func, 'async'), isExported: isExported(func) },
+        });
     }
     // Find arrow functions assigned to variables
     const varStmts = [
@@ -187,53 +201,15 @@ export function extractFunctionsFromSource(content, filePath, options) {
             if (!nameNode || !arrowFunc)
                 continue;
             const { line } = getLineAndColumn(varDecl);
-            const endLine = arrowFunc.location?.end?.line ?? line;
-            // Extract function calls
-            const body = findChildOfType(arrowFunc, 'statement_block');
-            const functionCalls = body ? extractFunctionCalls(body, content, importMap) : [];
-            const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
-            // Track which imports this function uses
-            const functionUsageMap = extractIdentifierUsage(arrowFunc, content, importNames);
-            const usedImports = Array.from(functionUsageMap.keys());
-            // Apply unused imports configuration
-            const fConfig = options?.unusedImportsConfig;
-            let unusedImports = detailedImports
-                .filter(imp => {
-                if (imp.importType === 'side-effect')
-                    return false;
-                if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
-                    return false;
-                if (!fConfig?.includeTypeOnlyImports && imp.isTypeOnly)
-                    return false;
-                if (fConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
-                    return false;
-                return true;
-            })
-                .map(imp => imp.localName);
-            const arrowParams = findChildOfType(arrowFunc, 'formal_parameters');
-            const arrowParamCount = arrowParams?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
-            functions.push({
-                name: getNodeText(nameNode, content),
-                filePath,
-                lineNumber: line,
-                startLine: line,
-                endLine,
-                language: getLanguageFromPath(filePath),
-                dependencies,
-                purpose: `Arrow function ${getNodeText(nameNode, content)}`,
+            const name = getNodeText(nameNode, content);
+            pushScannedFunction({
+                name, line,
+                endLine: arrowFunc.location?.end?.line ?? line,
+                node: arrowFunc,
+                kind: 'arrow',
+                purpose: `Arrow function ${name}`,
                 context: `Defined in ${path.basename(filePath)}`,
-                body: body ? getNodeText(body, content) : undefined,
-                metadata: {
-                    kind: 'arrow',
-                    isAsync: hasModifier(arrowFunc, 'async'),
-                    isExported: isExported(varStmt),
-                    parameterCount: arrowParamCount,
-                    functionCalls: normalizedCalls,
-                    usedImports,
-                    unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                    complexity: calculateComplexity(arrowFunc),
-                    dependencies
-                }
+                extraMetadata: { isAsync: hasModifier(arrowFunc, 'async'), isExported: isExported(varStmt) },
             });
         }
     }
@@ -249,189 +225,197 @@ export function extractFunctionsFromSource(content, filePath, options) {
             if (!methodNameNode)
                 continue;
             const { line } = getLineAndColumn(method);
-            const endLine = method.location?.end?.line ?? line;
-            // Extract function calls
-            const body = findChildOfType(method, 'statement_block');
-            const functionCalls = body ? extractFunctionCalls(body, content, importMap) : [];
-            const normalizedCalls = functionCalls.map(call => normalizeCallTarget(call.callee, filePath, localFunctions));
-            // Track which imports this method uses
-            const functionUsageMap = extractIdentifierUsage(method, content, importNames);
-            const usedImports = Array.from(functionUsageMap.keys());
-            // Apply unused imports configuration
-            const mConfig = options?.unusedImportsConfig;
-            let unusedImports = detailedImports
-                .filter(imp => {
-                if (imp.importType === 'side-effect')
-                    return false;
-                if (functionUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
-                    return false;
-                if (!mConfig?.includeTypeOnlyImports && imp.isTypeOnly)
-                    return false;
-                if (mConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
-                    return false;
-                return true;
-            })
-                .map(imp => imp.localName);
-            const methodParams = findChildOfType(method, 'formal_parameters');
-            const methodParamCount = methodParams?.children?.filter(c => c.type === 'required_parameter' || c.type === 'optional_parameter' || c.type === 'rest_parameter').length ?? 0;
-            functions.push({
-                name: `${className}.${getNodeText(methodNameNode, content)}`,
-                filePath,
-                lineNumber: line,
-                startLine: line,
-                endLine,
-                language: getLanguageFromPath(filePath),
-                dependencies,
-                purpose: `Method ${getNodeText(methodNameNode, content)} of class ${className}`,
+            const methodName = getNodeText(methodNameNode, content);
+            pushScannedFunction({
+                name: `${className}.${methodName}`,
+                line,
+                endLine: method.location?.end?.line ?? line,
+                node: method,
+                kind: 'method',
+                purpose: `Method ${methodName} of class ${className}`,
                 context: `Class method in ${path.basename(filePath)}`,
-                body: body ? getNodeText(body, content) : undefined,
-                metadata: {
-                    kind: 'method',
+                extraMetadata: {
                     className,
                     isAsync: hasModifier(method, 'async'),
                     isStatic: hasModifier(method, 'static'),
-                    isPrivate: hasModifier(method, 'private'),
-                    parameterCount: methodParamCount,
-                    functionCalls: normalizedCalls,
-                    usedImports,
-                    unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                    complexity: calculateComplexity(method),
-                    dependencies
-                }
+                    isPrivate: hasModifier(method, 'private')
+                },
             });
         }
     }
     // Check if this is a React file and scan for components
     if (filePath.endsWith('.tsx') || filePath.endsWith('.jsx') ||
         (filePath.endsWith('.js') && dependencies.includes('react'))) {
-        // Walk all nodes for React components
-        walkAST(root, (node) => {
-            if (!isReactComponent(node, content))
-                return;
-            const componentType = detectComponentType(node, content);
-            if (!componentType)
-                return;
-            const componentName = getComponentName(node, content);
-            const { line } = getLineAndColumn(node);
-            const endLine = node.location?.end?.line ?? line;
-            // Determine which node to use for prop extraction
-            // For arrow functions, use the parent variable declarator
-            let nodeForProps = node;
-            if (node.type === 'arrow_function' &&
-                node.parent && (node.parent.type === 'variable_declarator' ||
-                isVariableDecl(node.parent.type))) {
-                nodeForProps = node.parent;
-            }
-            // Track which imports this component uses
-            const componentUsageMap = extractIdentifierUsage(node, content, importNames);
-            const usedImports = Array.from(componentUsageMap.keys());
-            // Apply unused imports configuration
-            const cConfig = options?.unusedImportsConfig;
-            let unusedImports = detailedImports
-                .filter(imp => {
-                if (imp.importType === 'side-effect')
-                    return false;
-                if (componentUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
-                    return false;
-                if (!cConfig?.includeTypeOnlyImports && imp.isTypeOnly)
-                    return false;
-                if (cConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
-                    return false;
-                return true;
-            })
-                .map(imp => imp.localName);
-            // Check if we already indexed this as a regular function
-            const existingFunc = functions.find(f => f.name === componentName && f.lineNumber === line);
-            if (existingFunc) {
-                // Update the existing function with component metadata
-                existingFunc.purpose = `React ${componentType} component`;
-                existingFunc.body = getComponentBody(node, content);
-                existingFunc.metadata = {
-                    ...existingFunc.metadata,
-                    entityType: 'component',
-                    componentType,
-                    props: extractPropTypes(nodeForProps, content),
-                    hooks: extractHooks(node, content),
-                    jsxElements: extractJSXElements(node, content),
-                    isExported: isComponentExported(node),
-                    complexity: calculateComplexity(node),
-                };
-            }
-            else {
-                // Add new component
-                functions.push({
-                    name: componentName,
-                    filePath,
-                    lineNumber: line,
-                    startLine: line,
-                    endLine,
-                    language: getLanguageFromPath(filePath),
-                    dependencies,
-                    purpose: `React ${componentType} component`,
-                    context: `Located in ${path.basename(filePath)}`,
-                    body: getComponentBody(node, content),
-                    metadata: {
-                        entityType: 'component',
-                        componentType,
-                        props: extractPropTypes(nodeForProps, content),
-                        hooks: extractHooks(node, content),
-                        jsxElements: extractJSXElements(node, content),
-                        isExported: isComponentExported(node),
-                        complexity: calculateComplexity(node),
-                        usedImports,
-                        unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
-                        calledBy: [],
-                        dependencies
-                    }
-                });
-            }
-        });
+        scanReactComponents(functions, { root, content, filePath, dependencies, importNames, detailedImports, fileUsageMap, options });
     }
     // Add file-level unused import analysis if configured
     if (options?.unusedImportsConfig?.checkLevel === 'file' && functions.length > 0) {
-        // Get all imports used across all functions in the file
-        const allUsedImports = new Set();
-        for (const func of functions) {
-            if (func.metadata?.usedImports) {
-                for (const imp of func.metadata.usedImports) {
-                    allUsedImports.add(imp);
+        scanFileLevelUnusedImports(functions, detailedImports, filePath, dependencies, options.unusedImportsConfig);
+    }
+    return functions;
+}
+/**
+ * Mark imports that match re-exported names as used (reexport). Mutates the
+ * file-level usage map in place.
+ */
+function markReExports(fileUsageMap, reExports, detailedImports) {
+    for (const reExport of reExports) {
+        // Find imports that match re-exported names
+        for (const imp of detailedImports) {
+            if (imp.importedName === reExport.name ||
+                (reExport.name === '*' && imp.modulePath === reExport.module)) {
+                // Mark this import as used for re-export
+                if (!fileUsageMap.has(imp.localName)) {
+                    fileUsageMap.set(imp.localName, {
+                        usageType: 'reexport',
+                        usageCount: 1,
+                        lineNumbers: []
+                    });
+                }
+                else {
+                    const usage = fileUsageMap.get(imp.localName);
+                    if (usage.usageType !== 'reexport') {
+                        usage.usageType = 'reexport';
+                    }
                 }
             }
         }
-        // Calculate file-level unused imports
-        const flConfig = options.unusedImportsConfig;
-        const fileUnusedImports = detailedImports
+    }
+}
+/**
+ * Scan a React file for components, folding each into the functions list
+ * (updating an existing function when the component was already indexed as a
+ * regular function, otherwise appending a new entry).
+ */
+function scanReactComponents(functions, ctx) {
+    const { root, content, filePath, dependencies, importNames, detailedImports, fileUsageMap, options } = ctx;
+    // Walk all nodes for React components
+    walkAST(root, (node) => {
+        if (!isReactComponent(node, content))
+            return;
+        const componentType = detectComponentType(node, content);
+        if (!componentType)
+            return;
+        const componentName = getComponentName(node, content);
+        const { line } = getLineAndColumn(node);
+        const endLine = node.location?.end?.line ?? line;
+        // Determine which node to use for prop extraction
+        // For arrow functions, use the parent variable declarator
+        let nodeForProps = node;
+        if (node.type === 'arrow_function' &&
+            node.parent && (node.parent.type === 'variable_declarator' ||
+            isVariableDecl(node.parent.type))) {
+            nodeForProps = node.parent;
+        }
+        // Track which imports this component uses
+        const componentUsageMap = extractIdentifierUsage(node, content, importNames);
+        const usedImports = Array.from(componentUsageMap.keys());
+        // Apply unused imports configuration
+        const cConfig = options?.unusedImportsConfig;
+        let unusedImports = detailedImports
             .filter(imp => {
-            if (allUsedImports.has(imp.localName))
+            if (imp.importType === 'side-effect')
+                return false;
+            if (componentUsageMap.has(imp.localName) || fileUsageMap.has(imp.localName))
                 return false;
-            if (!flConfig?.includeTypeOnlyImports && imp.isTypeOnly)
+            if (!cConfig?.includeTypeOnlyImports && imp.isTypeOnly)
                 return false;
-            if (flConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
+            if (cConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
                 return false;
             return true;
         })
             .map(imp => imp.localName);
-        // Add a special file-level entry if there are unused imports
-        if (fileUnusedImports.length > 0) {
+        // Check if we already indexed this as a regular function
+        const existingFunc = functions.find(f => f.name === componentName && f.lineNumber === line);
+        if (existingFunc) {
+            // Update the existing function with component metadata
+            existingFunc.purpose = `React ${componentType} component`;
+            existingFunc.body = getComponentBody(node, content);
+            existingFunc.metadata = {
+                ...existingFunc.metadata,
+                entityType: 'component',
+                componentType,
+                props: extractPropTypes(nodeForProps, content),
+                hooks: extractHooks(node, content),
+                jsxElements: extractJSXElements(node, content),
+                isExported: isComponentExported(node),
+                complexity: calculateComplexity(node),
+            };
+        }
+        else {
+            // Add new component
             functions.push({
-                name: `[File-Level Analysis] ${path.basename(filePath)}`,
+                name: componentName,
                 filePath,
-                lineNumber: 1,
+                lineNumber: line,
+                startLine: line,
+                endLine,
                 language: getLanguageFromPath(filePath),
                 dependencies,
-                purpose: 'File-level unused imports analysis',
-                context: `File ${path.basename(filePath)} has unused imports at the file level`,
+                purpose: `React ${componentType} component`,
+                context: `Located in ${path.basename(filePath)}`,
+                body: getComponentBody(node, content),
                 metadata: {
-                    kind: 'file-analysis',
-                    unusedImports: fileUnusedImports,
-                    totalImports: detailedImports.length,
-                    usedImportsCount: allUsedImports.size,
+                    entityType: 'component',
+                    componentType,
+                    props: extractPropTypes(nodeForProps, content),
+                    hooks: extractHooks(node, content),
+                    jsxElements: extractJSXElements(node, content),
+                    isExported: isComponentExported(node),
+                    complexity: calculateComplexity(node),
+                    usedImports,
+                    unusedImports: unusedImports.length > 0 ? unusedImports : undefined,
+                    calledBy: [],
                     dependencies
                 }
             });
         }
+    });
+}
+/**
+ * Append a file-level unused-imports analysis entry when configured.
+ */
+function scanFileLevelUnusedImports(functions, detailedImports, filePath, dependencies, flConfig) {
+    // Get all imports used across all functions in the file
+    const allUsedImports = new Set();
+    for (const func of functions) {
+        if (func.metadata?.usedImports) {
+            for (const imp of func.metadata.usedImports) {
+                allUsedImports.add(imp);
+            }
+        }
+    }
+    // Calculate file-level unused imports
+    const fileUnusedImports = detailedImports
+        .filter(imp => {
+        if (allUsedImports.has(imp.localName))
+            return false;
+        if (!flConfig?.includeTypeOnlyImports && imp.isTypeOnly)
+            return false;
+        if (flConfig?.ignorePatterns?.some(pattern => imp.localName.match(new RegExp(pattern))))
+            return false;
+        return true;
+    })
+        .map(imp => imp.localName);
+    // Add a special file-level entry if there are unused imports
+    if (fileUnusedImports.length > 0) {
+        functions.push({
+            name: `[File-Level Analysis] ${path.basename(filePath)}`,
+            filePath,
+            lineNumber: 1,
+            language: getLanguageFromPath(filePath),
+            dependencies,
+            purpose: 'File-level unused imports analysis',
+            context: `File ${path.basename(filePath)} has unused imports at the file level`,
+            metadata: {
+                kind: 'file-analysis',
+                unusedImports: fileUnusedImports,
+                totalImports: detailedImports.length,
+                usedImportsCount: allUsedImports.size,
+                dependencies
+            }
+        });
     }
-    return functions;
 }
 // ---------------------------------------------------------------------------
 // Helper functions for React component extraction
@@ -440,7 +424,7 @@ function extractJSXElements(node, content) {
     const elements = new Set();
     walkAST(node, (child) => {
         if (child.type === 'jsx_element') {
-            const openTag = findChildOfType(child, 'open_tag');
+            const openTag = findChildOfType(child, 'jsx_opening_element');
             if (openTag) {
                 const tagNameNode = openTag.children?.find(c => c.type === 'identifier' || c.type === 'member_expression');
                 if (tagNameNode) {
@@ -475,7 +459,7 @@ function isComponentExported(node) {
     // Check if parent is an export statement
     let parent = node.parent;
     while (parent) {
-        if (parent.type === 'export_statement' || parent.type === 'export_declaration') {
+        if (parent.type === 'export_statement') {
             return true;
         }
         parent = parent.parent;
@@ -484,6 +468,15 @@ function isComponentExported(node) {
 }
 // Aliases for MCP server compatibility
 export const scanFunctionsInFile = extractFunctionsFromFile;
+/**
+ * Scan a directory for functions using a compatibility-friendly option shape.
+ * Delegates to {@link scanDirectoryForFunctions}, translating `recursive` and
+ * `fileTypes` into its include-path and extension options.
+ *
+ * @param dirPath - Directory to scan.
+ * @param options - Optional recursion toggle and file-type filter.
+ * @returns Function metadata for every function found.
+ */
 export async function scanFunctionsInDirectory(dirPath, options) {
     return scanDirectoryForFunctions(dirPath, {
         fileExtensions: options?.fileTypes,
@@ -494,10 +487,19 @@ export async function scanFunctionsInDirectory(dirPath, options) {
  * Function Scanner class for compatibility
  */
 export class FunctionScanner {
-    async scanFunctions(content, filePath, language) {
+    /**
+     * Extract functions from source content via the shared extraction path.
+     *
+     * @param content - Source text to parse and extract from.
+     * @param filePath - Path used to resolve the language.
+     * @returns Function metadata for the source's functions.
+     */
+    async scanFunctions(content, filePath) {
         // Delegate to the shared extraction logic — this ensures the index sync
         // path produces the same relational data (functionCalls, usedImports,
-        // complexity, etc.) as the audit runner path.
+        // complexity, etc.) as the audit runner path. Language is resolved inside
+        // extractFunctionsFromSource via getLanguageFromPath (the same selector
+        // the pipeline uses) — there is no separate language argument to drift.
         return extractFunctionsFromSource(content, filePath);
     }
 }