code-auditor-mcp 3.4.12 → 3.4.13

package/dist/analyzers/universal/UniversalDocumentationAnalyzer.js

@@ -55,12 +55,20 @@ const HEADER_SKIP_GLOBS_DEFAULT = [
     '**/*.config.*',
     '**/*.d.ts',
 ];
+/**
+ * Languages whose documentation convention uses JSDoc @param/@returns tags.
+ * Other languages (e.g. Go) document parameters and return values in prose
+ * godoc comments, so the tag-based checks do not apply to them.
+ */
+const JSDOC_LANGUAGES = new Set(['typescript', 'javascript']);
+/**
+ * Universal documentation analyzer.
+ */
 export class UniversalDocumentationAnalyzer extends UniversalAnalyzer {
     name = 'documentation';
     description = 'Analyzes documentation quality across the codebase';
     category = 'documentation';
     async analyzeAST(ast, adapter, config, sourceCode) {
-        const violations = [];
         const finalConfig = { ...DEFAULT_DOCUMENTATION_CONFIG, ...config };
         // Resolve scope: "public" is post-spec-17 default
         const scope = finalConfig.scope ?? 'public';
@@ -68,392 +76,458 @@ export class UniversalDocumentationAnalyzer extends UniversalAnalyzer {
         const fileHeaders = finalConfig.fileHeaders ?? finalConfig.requireFileDocs ?? false;
         // Check if file is exempt (name-based patterns)
         if (this.isExempt(ast.filePath, finalConfig.exemptPatterns)) {
-            return violations;
+            return [];
         }
+        const violations = [];
         // File-level documentation header check — R1.5 (defaults OFF)
-        if (fileHeaders) {
-            const skipGlobs = finalConfig.headerSkipGlobs ?? HEADER_SKIP_GLOBS_DEFAULT;
-            if (!this.matchesAnyGlob(ast.filePath, skipGlobs)) {
-                const fileDoc = this.getFileDocumentation(ast, adapter);
-                if (!fileDoc || fileDoc.length < finalConfig.minDescriptionLength) {
-                    violations.push(this.createViolation(ast.filePath, { line: 1, column: 1 }, 'File lacks proper documentation header', 'suggestion', 'file-documentation'));
-                }
-            }
-        }
+        violations.push(...checkFileHeader(ast, adapter, finalConfig, fileHeaders));
+        // Per-file scan context for the section analyzers below (Spec 34 bundling).
+        const scan = { adapter, sourceCode, config: finalConfig, scope };
         // Function documentation — R1.1 through R1.4, R1.6
         if (finalConfig.requireFunctionDocs) {
-            const functions = adapter.extractFunctions(ast);
-            const docsMinLines = finalConfig.docsMinLines ?? 5;
-            for (const func of functions) {
-                // Find the AST node for this function
-                const node = this.findNodeByLocation(ast.root, func.location.start);
-                // R1.1 — Skip anonymous/inline callables
-                if (node && this.isAnonymousOrCallback(node, adapter)) {
-                    continue;
-                }
-                // R1.2 — Scope filter (public API surface only)
-                if (scope === 'public') {
-                    if (!func.isExported) {
-                        // If not exported and not a public method of exported class, skip
-                        if (!func.isMethod) {
-                            // Named function decl nested inside another function — skip at default scope
-                            if (node && this.isNestedFunction(node, adapter)) {
-                                continue;
-                            }
-                            // Non-exported top-level function — skip
-                            continue;
-                        }
-                        // It's a method — check visibility
-                        if (node && this.isNonPublicMethod(node, adapter, sourceCode)) {
-                            continue;
-                        }
-                        // Check if the enclosing class is exported
-                        if (node && !this.isMethodOfExportedClass(node, adapter, ast)) {
-                            continue;
-                        }
-                    }
-                }
-                // R1.3 — Minimum-size gate
-                const bodyLines = (func.location.end.line - func.location.start.line) + 1;
-                if (bodyLines < docsMinLines) {
-                    continue;
-                }
-                const doc = func.jsDoc || '';
-                // R1.6 — Audience-reason message
-                if (!doc || doc.length < finalConfig.minDescriptionLength) {
-                    const reason = func.isExported
-                        ? `exported function '${func.name}' lacks proper documentation`
-                        : func.isMethod && func.className
-                            ? `public method '${func.className}.${func.name}' lacks proper documentation`
-                            : `function '${func.name}' lacks proper documentation`;
-                    violations.push(this.createViolation(ast.filePath, func.location.start, reason, 'suggestion', 'function-documentation', undefined, func.name));
-                }
-                else {
-                    // Param docs
-                    if (finalConfig.requireParamDocs && func.parameters.length > 0) {
-                        const missingParamDocs = this.checkParameterDocumentation(doc, func.parameters.map(p => p.name));
-                        for (const param of missingParamDocs) {
-                            violations.push(this.createViolation(ast.filePath, func.location.start, `Function '${func.name}' missing documentation for parameter '${param}'`, 'suggestion', 'parameter-documentation', undefined, func.name));
-                        }
-                    }
-                    // Return docs
-                    if (finalConfig.requireReturnDocs &&
-                        func.returnType &&
-                        func.returnType !== 'void' &&
-                        !this.hasReturnDocumentation(doc)) {
-                        violations.push(this.createViolation(ast.filePath, func.location.start, `Function '${func.name}' missing return value documentation`, 'suggestion', 'return-documentation', undefined, func.name));
-                    }
-                }
-            }
+            violations.push(...analyzeFunctionDocumentation(ast, scan));
         }
         // Class documentation
         if (finalConfig.requireClassDocs) {
-            const classes = adapter.extractClasses(ast);
-            for (const cls of classes) {
-                // Scope filter for classes
-                if (scope === 'public' && !cls.isExported) {
-                    continue;
-                }
-                const doc = cls.jsDoc || '';
-                if (!doc || doc.length < finalConfig.minDescriptionLength) {
-                    violations.push(this.createViolation(ast.filePath, cls.location.start, `Class '${cls.name}' lacks proper documentation`, 'suggestion', 'class-documentation', undefined, cls.name));
-                }
-                // Method documentation
-                if (finalConfig.requireFunctionDocs) {
-                    for (const method of cls.methods) {
-                        // Method scope filter
-                        if (scope === 'public') {
-                            const methodNode = this.findNodeByLocation(ast.root, method.location.start);
-                            if (methodNode && this.isNonPublicMethod(methodNode, adapter, sourceCode)) {
-                                continue;
-                            }
-                        }
-                        const methodDoc = method.jsDoc || '';
-                        if (!methodDoc || methodDoc.length < finalConfig.minDescriptionLength) {
-                            violations.push(this.createViolation(ast.filePath, method.location.start, `public method '${cls.name}.${method.name}' lacks proper documentation`, 'suggestion', 'method-documentation', undefined, `${cls.name}.${method.name}`));
-                        }
-                    }
-                }
-            }
+            violations.push(...analyzeClassDocumentation(ast, scan));
         }
         return violations;
     }
-    // ---------------------------------------------------------------------------
-    // R1.1 — Anonymous / inline callable detection
-    // ---------------------------------------------------------------------------
     /**
-     * Returns true if the node is an anonymous arrow/function expression used as:
-     * (a) a call argument (any callee — no name whitelist)
-     * (b) a JSX attribute value
-     * (c) an object-literal property value or array element passed as an argument
-     * (d) an IIFE
+     * Check if a name or path matches any exempt regex patterns.
      */
-    isAnonymousOrCallback(node, adapter) {
-        const nodeType = adapter.getNodeType(node);
-        const parent = adapter.getParent(node);
-        if (!parent)
-            return false;
-        const parentType = adapter.getNodeType(parent);
-        // Arrow functions and function expressions
-        if (nodeType === 'arrow_function' ||
-            nodeType === 'function_expression' ||
-            nodeType === 'generator_function_expression') {
-            // (a) Call argument — parent is 'arguments' (args to any call expression)
-            if (parentType === 'arguments') {
-                return true;
-            }
-            // (b) JSX attribute value (event handlers, render props)
-            if (parentType === 'jsx_expression' ||
-                parentType === 'jsx_attribute' ||
-                parentType === 'jsx_self_closing_element' ||
-                parentType === 'jsx_opening_element') {
-                return true;
-            }
-            // (c) Object literal property value in call arguments
-            // chain: arrow → pair → object → arguments → call_expression
-            if (parentType === 'pair') {
-                const gp = adapter.getParent(parent);
-                if (gp) {
-                    const gpType = adapter.getNodeType(gp);
-                    if (gpType === 'object' || gpType === 'object_pattern') {
-                        const ggp = adapter.getParent(gp);
-                        if (ggp && adapter.getNodeType(ggp) === 'arguments') {
-                            return true;
-                        }
-                    }
-                }
-            }
-            // (c) Array element in call arguments
-            if (parentType === 'array') {
-                const gp = adapter.getParent(parent);
-                if (gp && adapter.getNodeType(gp) === 'arguments') {
-                    return true;
-                }
-            }
-            // (d) IIFE — the function is the callee of a call expression
-            if (parentType === 'call_expression') {
-                // Check if this node is in the function/callee position (not in arguments)
-                const fnChild = this.getFirstChildOfType(parent, [
-                    'arrow_function',
-                    'function_expression',
-                    'function',
-                    'identifier',
-                    'member_expression',
-                    'call_expression',
-                ]);
-                if (fnChild) {
-                    // If the first function-ish child is at the same location, this IS the callee
-                    if (fnChild.location.start.line === node.location.start.line &&
-                        fnChild.location.start.column === node.location.start.column) {
-                        return true;
-                    }
-                }
-            }
-        }
+    isExempt(name, patterns) {
+        return patterns.some(pattern => {
+            const regex = new RegExp(pattern, 'i');
+            return regex.test(name);
+        });
+    }
+}
+function makeViolation(file, location, message, classification) {
+    const v = {
+        file,
+        line: location.line,
+        column: location.column,
+        severity: classification.severity,
+        message,
+        rule: classification.rule,
+        analyzer: 'documentation'
+    };
+    if (classification.symbol)
+        v.functionName = classification.symbol;
+    return v;
+}
+/** R1.5 — file-level documentation header check (defaults OFF). */
+function checkFileHeader(ast, adapter, config, fileHeaders) {
+    const violations = [];
+    if (!fileHeaders)
+        return violations;
+    const skipGlobs = config.headerSkipGlobs ?? HEADER_SKIP_GLOBS_DEFAULT;
+    if (matchesAnyGlob(ast.filePath, skipGlobs))
+        return violations;
+    const fileDoc = getFileDocumentation(ast, adapter);
+    if (!fileDoc || fileDoc.length < config.minDescriptionLength) {
+        violations.push(makeViolation(ast.filePath, { line: 1, column: 1 }, 'File lacks proper documentation header', { severity: 'suggestion', rule: 'file-documentation' }));
+    }
+    return violations;
+}
+/** R1.1 + R1.2 — true when a function should be skipped before doc checks. */
+function shouldSkipFunction(node, func, scan, ast) {
+    const { adapter, sourceCode, scope } = scan;
+    // R1.1 — Skip anonymous/inline callables
+    if (node && isAnonymousOrCallback(node, adapter)) {
+        return true;
+    }
+    // R1.2 — Scope filter (public API surface only)
+    if (scope !== 'public' || func.isExported) {
         return false;
     }
-    /**
-     * Returns true if a function_declaration node is nested inside another function/method
-     * (a helper by construction — R1.1).
-     */
-    isNestedFunction(node, adapter) {
-        const nodeType = adapter.getNodeType(node);
-        if (nodeType !== 'function_declaration' && nodeType !== 'generator_function_declaration') {
-            return false;
+    if (!func.isMethod) {
+        // Named function decl nested inside another function — skip at default scope
+        if (node && isNestedFunction(node, adapter)) {
+            return true;
+        }
+        // Non-exported top-level function — skip
+        return true;
+    }
+    // It's a method — check visibility
+    if (node && isNonPublicMethod(node, adapter, sourceCode)) {
+        return true;
+    }
+    // Check if the enclosing class is exported
+    return !!(node && !isMethodOfExportedClass(node, adapter, ast));
+}
+/** R1.4/R1.6 — emit function/parameter/return documentation violations for one function. */
+function checkFunctionDocumentation(ast, adapter, config, func) {
+    const violations = [];
+    const doc = func.jsDoc || '';
+    if (!doc || doc.length < config.minDescriptionLength) {
+        // Methods lacking any documentation are reported by the class loop as
+        // method-documentation — skip here so a public method is not
+        // double-reported as both function-documentation and method-documentation.
+        if (func.isMethod) {
+            return violations;
+        }
+        // R1.6 — Audience-reason message
+        const reason = func.isExported
+            ? `exported function '${func.name}' lacks proper documentation`
+            : `function '${func.name}' lacks proper documentation`;
+        violations.push(makeViolation(ast.filePath, func.location.start, reason, { severity: 'suggestion', rule: 'function-documentation', symbol: func.name }));
+        return violations;
+    }
+    return checkFunctionDocTags(ast.filePath, adapter, config, func);
+}
+/** R1 — parameter and return documentation (JSDoc tags, JSDoc languages only). */
+function checkFunctionDocTags(file, adapter, config, func) {
+    const violations = [];
+    const doc = func.jsDoc || '';
+    // Param docs — JSDoc @param tags only apply to JSDoc languages.
+    const checkJsDocTags = JSDOC_LANGUAGES.has(adapter.name);
+    if (checkJsDocTags && config.requireParamDocs && func.parameters.length > 0) {
+        const missingParamDocs = checkParameterDocumentation(doc, func.parameters.map(p => p.name));
+        for (const param of missingParamDocs) {
+            violations.push(makeViolation(file, func.location.start, `Function '${func.name}' missing documentation for parameter '${param}'`, { severity: 'suggestion', rule: 'parameter-documentation', symbol: func.name }));
         }
-        let current = adapter.getParent(node);
-        while (current) {
-            const type = adapter.getNodeType(current);
-            // Skip enclosing blocks/statement blocks
-            if (type === 'statement_block' ||
-                type === 'block' ||
-                type === 'program' ||
-                type === 'export_statement') {
-                current = adapter.getParent(current);
+    }
+    // Return docs — JSDoc @returns tags only apply to JSDoc languages.
+    if (checkJsDocTags &&
+        config.requireReturnDocs &&
+        func.returnType &&
+        func.returnType !== 'void' &&
+        !hasReturnDocumentation(doc)) {
+        violations.push(makeViolation(file, func.location.start, `Function '${func.name}' missing return value documentation`, { severity: 'suggestion', rule: 'return-documentation', symbol: func.name }));
+    }
+    return violations;
+}
+/** R1.1–R1.4, R1.6 — function/parameter/return documentation. */
+function analyzeFunctionDocumentation(ast, scan) {
+    const { adapter, config } = scan;
+    const violations = [];
+    const functions = adapter.extractFunctions(ast);
+    const docsMinLines = config.docsMinLines ?? 5;
+    for (const func of functions) {
+        // Find the AST node for this function
+        const node = findNodeByLocation(ast.root, func.location.start);
+        if (shouldSkipFunction(node, func, scan, ast)) {
+            continue;
+        }
+        // R1.3 — Minimum-size gate
+        const bodyLines = (func.location.end.line - func.location.start.line) + 1;
+        if (bodyLines < docsMinLines) {
+            continue;
+        }
+        violations.push(...checkFunctionDocumentation(ast, adapter, config, func));
+    }
+    return violations;
+}
+/** Class + method documentation. */
+function analyzeClassDocumentation(ast, scan) {
+    const { adapter, config, scope } = scan;
+    const violations = [];
+    const classes = adapter.extractClasses(ast);
+    for (const cls of classes) {
+        // Scope filter for classes
+        if (scope === 'public' && !cls.isExported) {
+            continue;
+        }
+        const doc = cls.jsDoc || '';
+        if (!doc || doc.length < config.minDescriptionLength) {
+            violations.push(makeViolation(ast.filePath, cls.location.start, `Class '${cls.name}' lacks proper documentation`, { severity: 'suggestion', rule: 'class-documentation', symbol: cls.name }));
+        }
+        // Method documentation
+        violations.push(...checkClassMethodDocumentation(ast, cls, scan));
+    }
+    return violations;
+}
+/** R1.2 — method-documentation for each public method of a class. */
+function checkClassMethodDocumentation(ast, cls, scan) {
+    const { adapter, config, sourceCode, scope } = scan;
+    const violations = [];
+    if (!config.requireFunctionDocs)
+        return violations;
+    for (const method of cls.methods) {
+        // Method scope filter
+        if (scope === 'public') {
+            const methodNode = findNodeByLocation(ast.root, method.location.start);
+            if (methodNode && isNonPublicMethod(methodNode, adapter, sourceCode)) {
                 continue;
             }
-            // Found enclosing function or method → this is nested
-            if (adapter.isFunction(current) || adapter.isMethod(current)) {
-                return true;
-            }
-            // Hit something else (class body, module, etc.) → not nested in a function
-            break;
         }
+        const methodDoc = method.jsDoc || '';
+        if (!methodDoc || methodDoc.length < config.minDescriptionLength) {
+            violations.push(makeViolation(ast.filePath, method.location.start, `public method '${cls.name}.${method.name}' lacks proper documentation`, { severity: 'suggestion', rule: 'method-documentation', symbol: `${cls.name}.${method.name}` }));
+        }
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
+// R1.1 — Anonymous / inline callable detection
+// ---------------------------------------------------------------------------
+/**
+ * Returns true if the node is an anonymous arrow/function expression used as:
+ * (a) a call argument (any callee — no name whitelist)
+ * (b) a JSX attribute value
+ * (c) an object-literal property value or array element passed as an argument
+ * (d) an IIFE
+ */
+function isAnonymousOrCallback(node, adapter) {
+    const nodeType = adapter.getNodeType(node);
+    const parent = adapter.getParent(node);
+    if (!parent)
         return false;
+    const parentType = adapter.getNodeType(parent);
+    // Arrow functions and function expressions
+    if (nodeType === 'arrow_function' ||
+        nodeType === 'function_expression' ||
+        nodeType === 'generator_function_expression') {
+        // (a)/(c) Call argument — direct, or via object/array literal container.
+        if (isInlineInCallArguments(parent, adapter))
+            return true;
+        // (b) JSX attribute value (event handlers, render props)
+        if (isJsxAttributeValue(parentType))
+            return true;
+        // (d) IIFE — the function is the callee of a call expression
+        if (parentType === 'call_expression' && isIifeCallee(node, parent, adapter))
+            return true;
     }
-    // ---------------------------------------------------------------------------
-    // R1.2 — Method visibility helpers
-    // ---------------------------------------------------------------------------
-    /**
-     * A method is non-public if it is private, protected, #-named, or _-prefixed.
-     */
-    isNonPublicMethod(node, adapter, sourceCode) {
-        const type = adapter.getNodeType(node);
-        if (type !== 'method_definition' && type !== 'public_field_definition') {
-            return false;
+    return false;
+}
+/** (a)/(c) — true when `parent` positions the inline callable as a call argument. */
+function isInlineInCallArguments(parent, adapter) {
+    const parentType = adapter.getNodeType(parent);
+    if (parentType === 'arguments')
+        return true;
+    // Object literal property value in call arguments: arrow → pair → object → arguments
+    if (parentType === 'pair') {
+        const gp = adapter.getParent(parent);
+        if (gp && (adapter.getNodeType(gp) === 'object' || adapter.getNodeType(gp) === 'object_pattern')) {
+            const ggp = adapter.getParent(gp);
+            return !!(ggp && adapter.getNodeType(ggp) === 'arguments');
         }
-        // Check for tree-sitter accessibility modifiers in children
-        if (node.children) {
-            for (const child of node.children) {
-                const childType = adapter.getNodeType(child);
-                if (childType === 'accessibility_modifier' ||
-                    childType === 'private' ||
-                    childType === 'protected') {
-                    const text = adapter.getNodeText(child, sourceCode).trim();
-                    if (text === 'private' || text === 'protected') {
-                        return true;
-                    }
-                }
-            }
+    }
+    // Array element in call arguments: arrow → array → arguments
+    if (parentType === 'array') {
+        const gp = adapter.getParent(parent);
+        return !!(gp && adapter.getNodeType(gp) === 'arguments');
+    }
+    return false;
+}
+/** (b) — true when the parent type is a JSX attribute/expression value. */
+function isJsxAttributeValue(parentType) {
+    return (parentType === 'jsx_expression' ||
+        parentType === 'jsx_attribute' ||
+        parentType === 'jsx_self_closing_element' ||
+        parentType === 'jsx_opening_element');
+}
+/** (d) — true when `node` is the callee (not an argument) of the call expression. */
+function isIifeCallee(node, parent, adapter) {
+    const fnChild = getFirstChildOfType(parent, [
+        'arrow_function',
+        'function_expression',
+        'function',
+        'identifier',
+        'member_expression',
+        'call_expression',
+    ]);
+    if (!fnChild)
+        return false;
+    return (fnChild.location.start.line === node.location.start.line &&
+        fnChild.location.start.column === node.location.start.column);
+}
+/**
+ * Returns true if a function_declaration node is nested inside another function/method
+ * (a helper by construction — R1.1).
+ */
+function isNestedFunction(node, adapter) {
+    const nodeType = adapter.getNodeType(node);
+    if (nodeType !== 'function_declaration' && nodeType !== 'generator_function_declaration') {
+        return false;
+    }
+    let current = adapter.getParent(node);
+    while (current) {
+        const type = adapter.getNodeType(current);
+        // Skip enclosing blocks/statement blocks
+        if (type === 'statement_block' ||
+            type === 'block' ||
+            type === 'program' ||
+            type === 'export_statement') {
+            current = adapter.getParent(current);
+            continue;
         }
-        // Check property/method name for #-prefix (JS private) or _-prefix (convention)
-        const propName = this.getMethodName(node, adapter, sourceCode);
-        if (propName && (propName.startsWith('#') || propName.startsWith('_'))) {
+        // Found enclosing function or method → this is nested
+        if (adapter.isFunction(current) || adapter.isMethod(current)) {
             return true;
         }
+        // Hit something else (class body, module, etc.) → not nested in a function
+        break;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// R1.2 — Method visibility helpers
+// ---------------------------------------------------------------------------
+/**
+ * A method is non-public if it is private, protected, #-named, or _-prefixed.
+ */
+function isNonPublicMethod(node, adapter, sourceCode) {
+    const type = adapter.getNodeType(node);
+    if (type !== 'method_definition' && type !== 'public_field_definition') {
         return false;
     }
-    /**
-     * Check if a method's enclosing class is exported.
-     */
-    isMethodOfExportedClass(node, adapter, ast) {
-        let current = adapter.getParent(node);
-        while (current) {
-            if (adapter.isClass(current)) {
-                // Check export by looking at parent of class node
-                const classParent = adapter.getParent(current);
-                if (classParent) {
-                    const classParentType = adapter.getNodeType(classParent);
-                    if (classParentType === 'export_statement') {
-                        return true;
-                    }
-                    // Also check if class declaration itself has export modifier
-                    const siblings = adapter.getChildren(classParent);
-                    for (const sib of siblings) {
-                        if (adapter.getNodeType(sib) === 'export' || adapter.getNodeType(sib) === 'export_statement') {
-                            // Verify this export wraps our class
-                            const exportChildren = adapter.getChildren(sib);
-                            for (const ec of exportChildren) {
-                                if (adapter.getNodeType(ec) === 'class_declaration' &&
-                                    ec.location.start.line === current.location.start.line) {
-                                    return true;
-                                }
-                            }
-                        }
-                    }
+    // Check for tree-sitter accessibility modifiers in children
+    if (node.children) {
+        for (const child of node.children) {
+            const childType = adapter.getNodeType(child);
+            if (childType === 'accessibility_modifier' ||
+                childType === 'private' ||
+                childType === 'protected') {
+                const text = adapter.getNodeText(child, sourceCode).trim();
+                if (text === 'private' || text === 'protected') {
+                    return true;
                 }
-                // Use extractClasses to check isExported
-                break;
             }
-            current = adapter.getParent(current);
         }
-        // Fallback: check extractClasses for isExported
-        const classes = adapter.extractClasses(ast);
-        for (const cls of classes) {
-            // Find the class containing this method
-            if (node.location.start.line >= cls.location.start.line &&
-                node.location.start.line <= cls.location.end.line &&
-                cls.isExported) {
+    }
+    // Check property/method name for #-prefix (JS private) or _-prefix (convention)
+    const propName = getMethodName(node, adapter, sourceCode);
+    if (propName && (propName.startsWith('#') || propName.startsWith('_'))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a method's enclosing class is exported.
+ */
+function isMethodOfExportedClass(node, adapter, ast) {
+    let current = adapter.getParent(node);
+    while (current) {
+        if (adapter.isClass(current)) {
+            if (isClassDirectlyExported(current, adapter))
                 return true;
-            }
+            break;
         }
-        return false;
+        current = adapter.getParent(current);
     }
-    // ---------------------------------------------------------------------------
-    // Utility helpers
-    // ---------------------------------------------------------------------------
-    /**
-     * Check if a file path matches any picomatch glob pattern.
-     */
-    matchesAnyGlob(filePath, globs) {
-        for (const glob of globs) {
-            if (picomatch.isMatch(filePath, glob)) {
+    // Fallback: check extractClasses for isExported
+    const classes = adapter.extractClasses(ast);
+    for (const cls of classes) {
+        // Find the class containing this method
+        if (node.location.start.line >= cls.location.start.line &&
+            node.location.start.line <= cls.location.end.line &&
+            cls.isExported) {
+            return true;
+        }
+    }
+    return false;
+}
+/** True when the class declaration node is directly wrapped in an export. */
+function isClassDirectlyExported(classNode, adapter) {
+    const classParent = adapter.getParent(classNode);
+    if (!classParent)
+        return false;
+    if (adapter.getNodeType(classParent) === 'export_statement')
+        return true;
+    // Also check if the class declaration itself has an export modifier.
+    const siblings = adapter.getChildren(classParent);
+    for (const sib of siblings) {
+        const sibType = adapter.getNodeType(sib);
+        if (sibType !== 'export' && sibType !== 'export_statement')
+            continue;
+        const exportChildren = adapter.getChildren(sib);
+        for (const ec of exportChildren) {
+            if (adapter.getNodeType(ec) === 'class_declaration' &&
+                ec.location.start.line === classNode.location.start.line) {
                 return true;
             }
         }
-        return false;
-    }
-    /**
-     * Check if a name or path matches any exempt regex patterns.
-     */
-    isExempt(name, patterns) {
-        return patterns.some(pattern => {
-            const regex = new RegExp(pattern, 'i');
-            return regex.test(name);
-        });
     }
-    /**
-     * Get the name of a method definition node.
-     */
-    getMethodName(node, adapter, sourceCode) {
-        if (node.children) {
-            for (const child of node.children) {
-                const type = adapter.getNodeType(child);
-                if (type === 'property_identifier' || type === 'identifier') {
-                    return adapter.getNodeText(child, sourceCode).trim();
-                }
-            }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Utility helpers
+// ---------------------------------------------------------------------------
+/**
+ * Check if a file path matches any picomatch glob pattern.
+ */
+function matchesAnyGlob(filePath, globs) {
+    for (const glob of globs) {
+        if (picomatch.isMatch(filePath, glob)) {
+            return true;
         }
-        return null;
     }
-    /**
-     * Get the first child node matching one of the given types.
-     */
-    getFirstChildOfType(node, types) {
-        if (!node.children)
-            return null;
+    return false;
+}
+/**
+ * Get the name of a method definition node.
+ */
+function getMethodName(node, adapter, sourceCode) {
+    if (node.children) {
         for (const child of node.children) {
-            if (types.includes(child.type)) {
-                return child;
+            const type = adapter.getNodeType(child);
+            if (type === 'property_identifier' || type === 'identifier') {
+                return adapter.getNodeText(child, sourceCode).trim();
             }
         }
-        return null;
     }
-    /**
-     * Get file-level documentation (usually at the top).
-     */
-    getFileDocumentation(ast, adapter) {
-        const firstChild = ast.root.children?.[0];
-        if (firstChild) {
-            return adapter.getDocumentation(firstChild);
-        }
+    return null;
+}
+/**
+ * Get the first child node matching one of the given types.
+ */
+function getFirstChildOfType(node, types) {
+    if (!node.children)
         return null;
-    }
-    /**
-     * Find a node by its location via BFS.
-     */
-    findNodeByLocation(root, location) {
-        const queue = [root];
-        while (queue.length > 0) {
-            const node = queue.shift();
-            if (node.location.start.line === location.line &&
-                node.location.start.column === location.column) {
-                return node;
-            }
-            if (node.children) {
-                queue.push(...node.children);
-            }
+    for (const child of node.children) {
+        if (types.includes(child.type)) {
+            return child;
         }
-        return null;
     }
-    /**
-     * Check which parameters are missing documentation.
-     */
-    checkParameterDocumentation(doc, paramNames) {
-        const missingParams = [];
-        for (const param of paramNames) {
-            const paramRegex = new RegExp(`@param\\s+(?:\\{[^}]+\\}\\s+)?${param}\\b`, 'i');
-            if (!paramRegex.test(doc)) {
-                missingParams.push(param);
-            }
+    return null;
+}
+/**
+ * Get file-level documentation (usually at the top).
+ */
+function getFileDocumentation(ast, adapter) {
+    const firstChild = ast.root.children?.[0];
+    if (firstChild) {
+        return adapter.getDocumentation(firstChild);
+    }
+    return null;
+}
+/**
+ * Find a node by its location via BFS.
+ */
+function findNodeByLocation(root, location) {
+    const queue = [root];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (node.location.start.line === location.line &&
+            node.location.start.column === location.column) {
+            return node;
+        }
+        if (node.children) {
+            queue.push(...node.children);
         }
-        return missingParams;
     }
-    /**
-     * Check if documentation contains return value documentation.
-     */
-    hasReturnDocumentation(doc) {
-        return /@returns?\b/i.test(doc);
+    return null;
+}
+/**
+ * Check which parameters are missing documentation.
+ */
+function checkParameterDocumentation(doc, paramNames) {
+    const missingParams = [];
+    for (const param of paramNames) {
+        const paramRegex = new RegExp(`@param\\s+(?:\\{[^}]+\\}\\s+)?${param}\\b`, 'i');
+        if (!paramRegex.test(doc)) {
+            missingParams.push(param);
+        }
     }
+    return missingParams;
+}
+/**
+ * Check if documentation contains return value documentation.
+ */
+function hasReturnDocumentation(doc) {
+    return /@returns?\b/i.test(doc);
 }
 //# sourceMappingURL=UniversalDocumentationAnalyzer.js.map