code-auditor-mcp 3.4.12 → 3.4.13

package/dist/analyzers/universal/UniversalConventionsAnalyzer.js

@@ -14,6 +14,7 @@
  */
 import * as path from 'path';
 import { UniversalAnalyzer } from '../../languages/UniversalAnalyzer.js';
+import { withRuleTiming } from '../ruleTiming.js';
 import { makeVisitorStatus } from '../../pipeline.js';
 import { detectCase, detectErrorHandlingShape, detectExportForm, parseFileImports, hasNonLatinChars, } from '../../conventions/conventionMiner.js';
 // ---------------------------------------------------------------------------
@@ -28,6 +29,9 @@ export const DEFAULT_CONVENTIONS_CONFIG = {
 // ---------------------------------------------------------------------------
 // Analyzer
 // ---------------------------------------------------------------------------
+/**
+ * Universal conventions analyzer.
+ */
 export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
     name = 'conventions';
     description = 'Mines codebase conventions and flags deviations at suggestion severity';
@@ -35,53 +39,70 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
     /**
      * Full override: query conventions from the DB and emit violations per domain.
      * The base-class per-file AST loop is bypassed.
+     * @param config
+     * @param files
+     * @param options
+     * @returns
      */
     async analyze(files, config = {}, options = {}) {
         const startTime = Date.now();
         const violations = [];
         const indexHandle = config.indexHandle;
         if (!indexHandle) {
-            return {
-                violations: [],
-                errors: [{ file: '', error: 'No index handle available — code index not open' }],
-                status: makeVisitorStatus(0),
-                executionTime: Date.now() - startTime,
-                analyzerName: this.name,
-                metrics: { filesAnalyzed: 0, totalViolations: 0, executionTime: Date.now() - startTime },
-            };
+            return this.makeResult([], 0, startTime, [
+                { file: '', error: 'No index handle available — code index not open' },
+            ]);
         }
         // Query all conventions
         const conventions = indexHandle.query('SELECT * FROM conventions ORDER BY domain, directory');
         if (conventions.length === 0) {
-            return {
-                violations: [],
-                errors: [],
-                status: makeVisitorStatus(files.length),
-                executionTime: Date.now() - startTime,
-                analyzerName: this.name,
-                metrics: { filesAnalyzed: files.length, totalViolations: 0, executionTime: Date.now() - startTime },
-            };
+            return this.makeResult([], files.length, startTime);
         }
-        // Extract project root, source map, and exports map from config
+        // Extract project root, on-demand source reader, and exports map from config
         const projectRoot = config.projectRoot;
-        const sourceMap = config.sourceMap;
+        const readSource = config.readSource;
         // B2: exportsMap comes from function-index visitor facts (AST-extracted)
         const exportsMap = config.exportsMap;
-        // Group conventions by domain for efficient detection
-        const byDomain = new Map();
-        for (const c of conventions) {
-            const list = byDomain.get(c.domain) ?? [];
-            list.push(c);
-            byDomain.set(c.domain, list);
-        }
         // Detect violations per domain
+        const byDomain = groupConventionsByDomain(conventions);
+        const scanCtx = { projectRoot, readSource, exportsMap };
+        violations.push(...this.detectPerDomain(byDomain, indexHandle, scanCtx));
+        // Count unique files that conventions apply to (from the function index)
+        const uniqueFiles = countUniqueFiles(indexHandle, projectRoot);
+        return this.makeResult(violations, uniqueFiles, startTime);
+    }
+    /** Build a standard AnalyzerResult with shared metrics and timing fields. */
+    makeResult(violations, filesAnalyzed, startTime, errors = []) {
+        return {
+            violations,
+            errors,
+            status: makeVisitorStatus(filesAnalyzed),
+            executionTime: Date.now() - startTime,
+            analyzerName: this.name,
+            metrics: {
+                filesAnalyzed,
+                totalViolations: violations.length,
+                executionTime: Date.now() - startTime,
+            },
+        };
+    }
+    /** No-op — all detection is DB-based. */
+    async analyzeAST() {
+        return [];
+    }
+    /**
+     * Dispatch each convention domain to its detector.
+     */
+    detectPerDomain(byDomain, indexHandle, scanCtx) {
+        const { projectRoot, readSource, exportsMap } = scanCtx;
+        const violations = [];
         for (const [domain, domainConventions] of byDomain) {
             switch (domain) {
                 case 'usage-pair':
                     violations.push(...this.detectUsagePairViolations(indexHandle, domainConventions));
                     break;
                 case 'import-form':
-                    violations.push(...this.detectImportFormViolations(indexHandle, domainConventions, projectRoot, sourceMap));
+                    violations.push(...this.detectImportFormViolations(indexHandle, domainConventions, projectRoot, readSource));
                     break;
                 case 'error-handling':
                     violations.push(...this.detectErrorHandlingViolations(indexHandle, domainConventions));
@@ -94,28 +115,7 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
                     break;
             }
         }
-        // Count unique files that conventions apply to (from the function index)
-        const resolvedProjectRoot = projectRoot ? path.resolve(projectRoot) : undefined;
-        const fileRows = indexHandle.query(resolvedProjectRoot
-            ? 'SELECT COUNT(DISTINCT file_path) as cnt FROM functions WHERE file_path LIKE ?'
-            : 'SELECT COUNT(DISTINCT file_path) as cnt FROM functions', resolvedProjectRoot ? [resolvedProjectRoot + '%'] : []);
-        const uniqueFiles = fileRows[0]?.cnt ?? 0;
-        return {
-            violations,
-            errors: [],
-            status: makeVisitorStatus(uniqueFiles),
-            executionTime: Date.now() - startTime,
-            analyzerName: this.name,
-            metrics: {
-                filesAnalyzed: uniqueFiles,
-                totalViolations: violations.length,
-                executionTime: Date.now() - startTime,
-            },
-        };
-    }
-    /** No-op — all detection is DB-based. */
-    async analyzeAST() {
-        return [];
+        return violations;
     }
     // ── Usage-Pair Detection ──────────────────────────────────────────────
     /**
@@ -124,60 +124,20 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
      */
     detectUsagePairViolations(indexHandle, conventions) {
         const violations = [];
-        // Query all function calls once
+        // Query all function calls once and index both directions
         const allCalls = indexHandle.query('SELECT caller_id, callee_name FROM function_calls');
-        // Build callerId → Set<calleeName>
-        const callerCalls = new Map();
-        for (const fc of allCalls) {
-            if (!callerCalls.has(fc.caller_id))
-                callerCalls.set(fc.caller_id, new Set());
-            callerCalls.get(fc.caller_id).add(fc.callee_name);
-        }
-        // antecedentName → Set<callerId>
-        const antecedentCallers = new Map();
-        for (const fc of allCalls) {
-            if (!antecedentCallers.has(fc.callee_name)) {
-                antecedentCallers.set(fc.callee_name, new Set());
-            }
-            antecedentCallers.get(fc.callee_name).add(fc.caller_id);
-        }
+        const { callerCalls, antecedentCallers } = buildCallMaps(allCalls);
         // Query all functions for file/line info
         const funcRows = indexHandle.query('SELECT id, name, file_path, line_number FROM functions');
-        const funcById = new Map();
-        for (const f of funcRows) {
-            funcById.set(f.id, f);
-        }
+        const funcById = buildFuncById(funcRows);
+        const ctx = {
+            antecedentCallers,
+            callerCalls,
+            funcById,
+            analyzerName: this.name,
+        };
         for (const conv of conventions) {
-            if (!conv.antecedent || !conv.consequent)
-                continue;
-            const antecedent = conv.antecedent;
-            const consequent = conv.consequent;
-            const callerIds = antecedentCallers.get(antecedent);
-            if (!callerIds || callerIds.size === 0)
-                continue;
-            for (const cid of callerIds) {
-                const callSet = callerCalls.get(cid);
-                if (!callSet || !callSet.has(consequent)) {
-                    const func = funcById.get(cid);
-                    if (!func)
-                        continue;
-                    const exemplarRef = conv.exemplar_file
-                        ? ` (exemplar: ${conv.exemplar_file}${conv.exemplar_line ? `:${conv.exemplar_line}` : ''})`
-                        : '';
-                    const pct = Math.round(conv.confidence * 100);
-                    violations.push({
-                        file: func.file_path,
-                        line: func.line_number,
-                        column: 1,
-                        severity: 'suggestion',
-                        message: `${pct}% of \`${antecedent}\` callers also call \`${consequent}\` — ` +
-                            `this function calls \`${antecedent}\` without \`${consequent}\`${exemplarRef}`,
-                        rule: 'conventions/usage-pair',
-                        analyzer: this.name,
-                        functionName: func.name,
-                    });
-                }
-            }
+            violations.push(...withRuleTiming('conventions/usage-pair', () => detectUsagePairForConvention(conv, ctx)));
         }
         return violations;
     }
@@ -186,28 +146,10 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
      * For each import-form convention (source → dominantForm in directory),
      * find imports of that source that use a minority form.
      */
-    detectImportFormViolations(indexHandle, conventions, projectRoot, sourceMap) {
+    detectImportFormViolations(indexHandle, conventions, projectRoot, readSource) {
         const violations = [];
-        // Use directory-key → Map<source, ImportConv>
-        const dirImports = new Map();
-        for (const conv of conventions) {
-            const dir = conv.directory ?? '.';
-            const source = conv.antecedent;
-            if (!source)
-                continue;
-            const form = conv.consequent;
-            if (!form)
-                continue;
-            if (!dirImports.has(dir))
-                dirImports.set(dir, new Map());
-            dirImports.get(dir).set(source, {
-                source,
-                form,
-                confidence: conv.confidence,
-                exemplar_file: conv.exemplar_file,
-                exemplar_line: conv.exemplar_line,
-            });
-        }
+        // Build directory → Map<source, ImportConv>
+        const dirImports = buildDirImports(conventions);
         // Get unique file paths
         const fileRows = indexHandle.query('SELECT DISTINCT file_path FROM functions WHERE file_path IS NOT NULL');
         const seenFiles = new Set();
@@ -220,36 +162,10 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
             if (!importConvs)
                 continue;
             const fullPath = projectRoot ? path.join(projectRoot, fp) : fp;
-            let content = sourceMap?.get(fullPath);
+            const content = readSource?.(fullPath);
             if (content === undefined)
                 continue;
-            const imports = parseFileImports(content);
-            for (const imp of imports) {
-                const conv = importConvs.get(imp.source);
-                if (!conv || imp.form === conv.form)
-                    continue;
-                const pct = Math.round(conv.confidence * 100);
-                const exemplarRef = conv.exemplar_file
-                    ? ` (exemplar: ${conv.exemplar_file}${conv.exemplar_line ? `:${conv.exemplar_line}` : ''})`
-                    : '';
-                violations.push({
-                    file: fp,
-                    line: imp.line,
-                    column: 1,
-                    severity: 'suggestion',
-                    message: `${pct}% of imports of \`${imp.source}\` in \`${directory}/\` ` +
-                        `use ${conv.form} import — this file uses ${imp.form}${exemplarRef}`,
-                    rule: 'conventions/import-form',
-                    analyzer: this.name,
-                    details: {
-                        source: imp.source,
-                        directory,
-                        conventionForm: conv.form,
-                        actualForm: imp.form,
-                        localNames: imp.localNames,
-                    },
-                });
-            }
+            violations.push(...detectImportFormForFile(fp, content, importConvs, this.name));
         }
         return violations;
     }
@@ -263,55 +179,14 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
     detectErrorHandlingViolations(indexHandle, conventions) {
         const violations = [];
         // directory → dominantShape
-        const dirShapes = new Map();
-        for (const conv of conventions) {
-            const dir = conv.directory ?? '.';
-            const shape = conv.pattern;
-            if (!shape)
-                continue;
-            dirShapes.set(dir, {
-                shape,
-                confidence: conv.confidence,
-                exemplar_file: conv.exemplar_file,
-                exemplar_line: conv.exemplar_line,
-            });
-        }
+        const dirShapes = buildDirShapes(conventions);
         const rows = indexHandle.query(`SELECT id, name, file_path, line_number, metadata_json
          FROM functions
          WHERE metadata_json IS NOT NULL`);
         for (const row of rows) {
-            const directory = path.dirname(row.file_path) || '.';
-            const conv = dirShapes.get(directory);
-            if (!conv)
-                continue;
-            let metadata;
-            try {
-                metadata = JSON.parse(row.metadata_json);
-            }
-            catch {
-                continue;
-            }
-            const body = metadata.body;
-            const shape = detectErrorHandlingShape(body);
-            if (!shape)
-                continue; // no error handling → skip
-            if (shape === conv.shape)
-                continue; // matches convention
-            const pct = Math.round(conv.confidence * 100);
-            const exemplarRef = conv.exemplar_file
-                ? ` (exemplar: ${conv.exemplar_file}${conv.exemplar_line ? `:${conv.exemplar_line}` : ''})`
-                : '';
-            violations.push({
-                file: row.file_path,
-                line: row.line_number,
-                column: 1,
-                severity: 'suggestion',
-                message: `${pct}% of error-handling functions in \`${directory}/\` use ` +
-                    `\`${conv.shape}\` — this function uses \`${shape}\`${exemplarRef}`,
-                rule: 'conventions/error-handling',
-                analyzer: this.name,
-                functionName: row.name,
-            });
+            const violation = detectErrorHandlingForRow(row, dirShapes, this.name);
+            if (violation)
+                violations.push(violation);
         }
         return violations;
     }
@@ -323,49 +198,14 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
     detectExportShapeViolations(indexHandle, conventions, exportsMap) {
         const violations = [];
         // directory → dominantForm
-        const dirForms = new Map();
-        for (const conv of conventions) {
-            const dir = conv.directory ?? '.';
-            const form = conv.pattern;
-            if (!form)
-                continue;
-            dirForms.set(dir, {
-                form,
-                confidence: conv.confidence,
-                exemplar_file: conv.exemplar_file,
-                exemplar_line: conv.exemplar_line,
-            });
-        }
+        const dirForms = buildDirForms(conventions);
         const rows = indexHandle.query(`SELECT id, name, file_path, line_number, is_exported
          FROM functions
          WHERE is_exported = 1`);
         for (const row of rows) {
-            const directory = path.dirname(row.file_path) || '.';
-            const conv = dirForms.get(directory);
-            if (!conv)
-                continue;
-            // B2: Use AST-extracted ExportInfo[] from function-index facts
-            const fileExports = exportsMap?.get(row.file_path);
-            if (!fileExports)
-                continue;
-            const form = detectExportForm(row.name, fileExports);
-            if (!form || form === conv.form)
-                continue;
-            const pct = Math.round(conv.confidence * 100);
-            const exemplarRef = conv.exemplar_file
-                ? ` (exemplar: ${conv.exemplar_file}${conv.exemplar_line ? `:${conv.exemplar_line}` : ''})`
-                : '';
-            violations.push({
-                file: row.file_path,
-                line: row.line_number,
-                column: 1,
-                severity: 'suggestion',
-                message: `${pct}% of exports in \`${directory}/\` use ${conv.form} export — ` +
-                    `\`${row.name}\` uses ${form}${exemplarRef}`,
-                rule: 'conventions/export-shape',
-                analyzer: this.name,
-                functionName: row.name,
-            });
+            const violation = detectExportShapeForRow(row, dirForms, exportsMap, this.name);
+            if (violation)
+                violations.push(violation);
         }
         return violations;
     }
@@ -378,69 +218,308 @@ export class UniversalConventionsAnalyzer extends UniversalAnalyzer {
     detectNamingViolations(indexHandle, conventions) {
         const violations = [];
         // directory → kind → convention
-        const dirKindCases = new Map();
-        for (const conv of conventions) {
-            const dir = conv.directory ?? '.';
-            const casing = conv.pattern;
-            if (!casing)
-                continue;
-            const kind = conv.export_kind ?? 'function';
-            if (!dirKindCases.has(dir))
-                dirKindCases.set(dir, new Map());
-            dirKindCases.get(dir).set(kind, {
-                casing,
-                confidence: conv.confidence,
-                exemplar_file: conv.exemplar_file,
-                exemplar_line: conv.exemplar_line,
-                kind,
-            });
-        }
+        const dirKindCases = buildDirKindCases(conventions);
         const rows = indexHandle.query(`SELECT id, name, file_path, line_number, is_exported, entity_type, component_type
          FROM functions
          WHERE is_exported = 1`);
         for (const row of rows) {
-            const directory = path.dirname(row.file_path) || '.';
-            // Classify into export kind (same logic as mineNaming)
-            let rowKind;
-            if (row.entity_type === 'component' || row.component_type !== null) {
-                rowKind = 'react-component';
-            }
-            else if (/^use[A-Z]/.test(row.name)) {
-                rowKind = 'hook';
-            }
-            else {
-                rowKind = 'function';
-            }
-            const kindConvs = dirKindCases.get(directory);
-            if (!kindConvs)
-                continue;
-            // Try exact kind match first, fall back to 'function' for backward compat
-            const conv = kindConvs.get(rowKind);
-            if (!conv)
-                continue;
-            // Non-Latin skip (Spec 21 R5.4)
-            if (hasNonLatinChars(row.name))
-                continue;
-            const casing = detectCase(row.name);
-            if (!casing || casing === conv.casing)
+            const violation = detectNamingForRow(row, dirKindCases, this.name);
+            if (violation)
+                violations.push(violation);
+        }
+        return violations;
+    }
+}
+/** Build the `(exemplar: file:line)` suffix shared across convention messages. */
+function exemplarRef(conv) {
+    return conv.exemplar_file
+        ? ` (exemplar: ${conv.exemplar_file}${conv.exemplar_line ? `:${conv.exemplar_line}` : ''})`
+        : '';
+}
+/** Group convention rows by their `domain` field. */
+function groupConventionsByDomain(conventions) {
+    const byDomain = new Map();
+    for (const conv of conventions) {
+        const list = byDomain.get(conv.domain);
+        if (list)
+            list.push(conv);
+        else
+            byDomain.set(conv.domain, [conv]);
+    }
+    return byDomain;
+}
+/** Count distinct file paths in the function index (files conventions apply to). */
+function countUniqueFiles(indexHandle, projectRoot) {
+    const rows = indexHandle.query('SELECT DISTINCT file_path FROM functions WHERE file_path IS NOT NULL');
+    return rows.length;
+}
+/** Index call rows in both directions: caller→callees and callee→callers. */
+function buildCallMaps(allCalls) {
+    const callerCalls = new Map();
+    const antecedentCallers = new Map();
+    for (const call of allCalls) {
+        const callees = callerCalls.get(call.caller_id);
+        if (callees)
+            callees.add(call.callee_name);
+        else
+            callerCalls.set(call.caller_id, new Set([call.callee_name]));
+        const callers = antecedentCallers.get(call.callee_name);
+        if (callers)
+            callers.add(call.caller_id);
+        else
+            antecedentCallers.set(call.callee_name, new Set([call.caller_id]));
+    }
+    return { callerCalls, antecedentCallers };
+}
+/** Index function rows by id for caller→function lookups. */
+function buildFuncById(funcRows) {
+    const map = new Map();
+    for (const row of funcRows)
+        map.set(row.id, row);
+    return map;
+}
+/** Emit usage-pair violations for a single convention row. */
+function detectUsagePairForConvention(conv, ctx) {
+    const violations = [];
+    if (!conv.antecedent || !conv.consequent)
+        return violations;
+    const antecedent = conv.antecedent;
+    const consequent = conv.consequent;
+    const callerIds = ctx.antecedentCallers.get(antecedent);
+    if (!callerIds || callerIds.size === 0)
+        return violations;
+    for (const cid of callerIds) {
+        const callSet = ctx.callerCalls.get(cid);
+        if (!callSet || !callSet.has(consequent)) {
+            const func = ctx.funcById.get(cid);
+            if (!func)
                 continue;
             const pct = Math.round(conv.confidence * 100);
-            const exemplarRef = conv.exemplar_file
-                ? ` (exemplar: ${conv.exemplar_file}${conv.exemplar_line ? `:${conv.exemplar_line}` : ''})`
-                : '';
             violations.push({
-                file: row.file_path,
-                line: row.line_number,
+                file: func.file_path,
+                line: func.line_number,
                 column: 1,
                 severity: 'suggestion',
-                message: `${pct}% of ${conv.kind} exports in \`${directory}/\` use ${conv.casing} — ` +
-                    `\`${row.name}\` uses ${casing}${exemplarRef}`,
-                rule: 'conventions/naming',
-                analyzer: this.name,
-                functionName: row.name,
+                message: `${pct}% of \`${antecedent}\` callers also call \`${consequent}\` — ` +
+                    `this function calls \`${antecedent}\` without \`${consequent}\`${exemplarRef(conv)}`,
+                rule: 'conventions/usage-pair',
+                analyzer: ctx.analyzerName,
+                functionName: func.name,
+                resolution: {
+                    action: 'call-companion',
+                    summary: `Add a call to the companion function \`${consequent}\` in \`${func.name}\` — ${pct}% of \`${antecedent}\` callers also call it.`,
+                    symbols: [consequent, antecedent],
+                    files: [func.file_path],
+                    lines: [func.line_number],
+                },
             });
         }
-        return violations;
     }
+    return violations;
+}
+/** Build directory → Map<source, ImportConv> from import-form convention rows. */
+function buildDirImports(conventions) {
+    const dirImports = new Map();
+    for (const conv of conventions) {
+        const dir = conv.directory ?? '.';
+        const source = conv.antecedent;
+        if (!source)
+            continue;
+        const form = conv.consequent;
+        if (!form)
+            continue;
+        if (!dirImports.has(dir))
+            dirImports.set(dir, new Map());
+        dirImports.get(dir).set(source, {
+            source,
+            form,
+            confidence: conv.confidence,
+            exemplar_file: conv.exemplar_file,
+            exemplar_line: conv.exemplar_line,
+        });
+    }
+    return dirImports;
+}
+/** Detect import-form violations within one file's parsed imports. */
+function detectImportFormForFile(fp, content, importConvs, analyzerName) {
+    const violations = [];
+    const directory = path.dirname(fp) || '.';
+    const imports = parseFileImports(content);
+    for (const imp of imports) {
+        const conv = importConvs.get(imp.source);
+        if (!conv || imp.form === conv.form)
+            continue;
+        const pct = Math.round(conv.confidence * 100);
+        violations.push({
+            file: fp,
+            line: imp.line,
+            column: 1,
+            severity: 'suggestion',
+            message: `${pct}% of imports of \`${imp.source}\` in \`${directory}/\` ` +
+                `use ${conv.form} import — this file uses ${imp.form}${exemplarRef(conv)}`,
+            rule: 'conventions/import-form',
+            analyzer: analyzerName,
+            details: {
+                source: imp.source,
+                directory,
+                conventionForm: conv.form,
+                actualForm: imp.form,
+                localNames: imp.localNames,
+            },
+        });
+    }
+    return violations;
+}
+/** Build directory → dominant error-handling shape from convention rows. */
+function buildDirShapes(conventions) {
+    const dirShapes = new Map();
+    for (const conv of conventions) {
+        const dir = conv.directory ?? '.';
+        const shape = conv.pattern;
+        if (!shape)
+            continue;
+        dirShapes.set(dir, {
+            shape,
+            confidence: conv.confidence,
+            exemplar_file: conv.exemplar_file,
+            exemplar_line: conv.exemplar_line,
+        });
+    }
+    return dirShapes;
+}
+/** Detect an error-handling-shape deviation for one function row, if any. */
+function detectErrorHandlingForRow(row, dirShapes, analyzerName) {
+    const directory = path.dirname(row.file_path) || '.';
+    const conv = dirShapes.get(directory);
+    if (!conv)
+        return null;
+    let metadata;
+    try {
+        metadata = JSON.parse(row.metadata_json);
+    }
+    catch {
+        return null;
+    }
+    const body = metadata.body;
+    const shape = detectErrorHandlingShape(body);
+    if (!shape)
+        return null; // no error handling → skip
+    if (shape === conv.shape)
+        return null; // matches convention
+    const pct = Math.round(conv.confidence * 100);
+    return {
+        file: row.file_path,
+        line: row.line_number,
+        column: 1,
+        severity: 'suggestion',
+        message: `${pct}% of error-handling functions in \`${directory}/\` use ` +
+            `\`${conv.shape}\` — this function uses \`${shape}\`${exemplarRef(conv)}`,
+        rule: 'conventions/error-handling',
+        analyzer: analyzerName,
+        functionName: row.name,
+    };
+}
+/** Build directory → dominant export form from convention rows. */
+function buildDirForms(conventions) {
+    const dirForms = new Map();
+    for (const conv of conventions) {
+        const dir = conv.directory ?? '.';
+        const form = conv.pattern;
+        if (!form)
+            continue;
+        dirForms.set(dir, {
+            form,
+            confidence: conv.confidence,
+            exemplar_file: conv.exemplar_file,
+            exemplar_line: conv.exemplar_line,
+        });
+    }
+    return dirForms;
+}
+/** Detect an export-shape deviation for one function row, if any. */
+function detectExportShapeForRow(row, dirForms, exportsMap, analyzerName) {
+    const directory = path.dirname(row.file_path) || '.';
+    const conv = dirForms.get(directory);
+    if (!conv)
+        return null;
+    // B2: Use AST-extracted ExportInfo[] from function-index facts
+    const fileExports = exportsMap?.get(row.file_path);
+    if (!fileExports)
+        return null;
+    const form = detectExportForm(row.name, fileExports);
+    if (!form || form === conv.form)
+        return null;
+    const pct = Math.round(conv.confidence * 100);
+    return {
+        file: row.file_path,
+        line: row.line_number,
+        column: 1,
+        severity: 'suggestion',
+        message: `${pct}% of exports in \`${directory}/\` use ${conv.form} export — ` +
+            `\`${row.name}\` uses ${form}${exemplarRef(conv)}`,
+        rule: 'conventions/export-shape',
+        analyzer: analyzerName,
+        functionName: row.name,
+    };
+}
+/** Build directory → kind → convention from naming convention rows. */
+function buildDirKindCases(conventions) {
+    const dirKindCases = new Map();
+    for (const conv of conventions) {
+        const dir = conv.directory ?? '.';
+        const casing = conv.pattern;
+        if (!casing)
+            continue;
+        const kind = conv.export_kind ?? 'function';
+        if (!dirKindCases.has(dir))
+            dirKindCases.set(dir, new Map());
+        dirKindCases.get(dir).set(kind, {
+            casing,
+            confidence: conv.confidence,
+            exemplar_file: conv.exemplar_file,
+            exemplar_line: conv.exemplar_line,
+            kind,
+        });
+    }
+    return dirKindCases;
+}
+/** Classify an exported function into a naming kind (same logic as mineNaming). */
+function classifyExportKind(row) {
+    if (row.entity_type === 'component' || row.component_type !== null) {
+        return 'react-component';
+    }
+    if (/^use[A-Z]/.test(row.name)) {
+        return 'hook';
+    }
+    return 'function';
+}
+/** Detect a naming-casing deviation for one function row, if any. */
+function detectNamingForRow(row, dirKindCases, analyzerName) {
+    const directory = path.dirname(row.file_path) || '.';
+    const kindConvs = dirKindCases.get(directory);
+    if (!kindConvs)
+        return null;
+    const rowKind = classifyExportKind(row);
+    const conv = kindConvs.get(rowKind);
+    if (!conv)
+        return null;
+    // Non-Latin skip (Spec 21 R5.4)
+    if (hasNonLatinChars(row.name))
+        return null;
+    const casing = detectCase(row.name);
+    if (!casing || casing === conv.casing)
+        return null;
+    const pct = Math.round(conv.confidence * 100);
+    return {
+        file: row.file_path,
+        line: row.line_number,
+        column: 1,
+        severity: 'suggestion',
+        message: `${pct}% of ${conv.kind} exports in \`${directory}/\` use ${conv.casing} — ` +
+            `\`${row.name}\` uses ${casing}${exemplarRef(conv)}`,
+        rule: 'conventions/naming',
+        analyzer: analyzerName,
+        functionName: row.name,
+    };
 }
 //# sourceMappingURL=UniversalConventionsAnalyzer.js.map