code-auditor-mcp 3.4.9 → 3.4.11

package/dist/pipelineAdapters.js

@@ -0,0 +1,1146 @@
+/**
+ * Pipeline adapter factories (Spec 24).
+ *
+ * Each factory converts an existing analyzer into a Stage2Visitor,
+ * Stage3Reducer, or Stage4Reducer for the pipeline. Lazy-loads analyzer
+ * classes via dynamic import() to avoid circular dependency issues.
+ *
+ * Key patterns:
+ *   - Per-file (solid, data-access, doc, schema): wrap analyzeAST()
+ *   - DRY: wraps analyzeAST(), accumulates dryPairs internally →
+ *     factory returns { visitor, getDryPairs } for post-pipeline extraction
+ *   - React: wraps scanFile() per file, accumulates scan results →
+ *     factory returns { visitor, finalizeCrossComponent }
+ *   - DB-based (styles, conventions, cross-domain): reducers call
+ *     analyzer.analyze([]) with rawDb injected through config
+ *   - Invariants: Stage 3 reducer — receives full file list, runs rule engine
+ */
+import { createHash } from 'crypto';
+import path from 'path';
+import { RULE_REGISTRY } from './analyzers/ruleRegistry.js';
+import { walkAST, isExported, getLineAndColumn, calculateComplexity, getFunctionBody, } from './languages/adapterBridge.js';
+import { buildImportMap, extractFunctionCalls, } from './utils/dependencyExtractor.js';
+import { isReactComponent, detectComponentType, getComponentName, } from './utils/reactDetection.js';
+import { ALL_EXTENSIONS } from './utils/fileDiscovery.js';
+// ── Rule ID helpers ──────────────────────────────────────────────────────────
+function getRuleIdsFor(name) {
+    return Object.entries(RULE_REGISTRY)
+        .filter(([, entry]) => entry.analyzer === name)
+        .map(([id]) => id);
+}
+// ── Lazy import singleton ────────────────────────────────────────────────────
+function lazySingleton(loader) {
+    let promise = null;
+    return () => {
+        if (!promise)
+            promise = loader();
+        return promise;
+    };
+}
+// ── File-sources infrastructure visitor ──────────────────────────────────────
+/**
+ * Infrastructure visitor that records every file's source code so Stage 3
+ * reducers can access it without calling readFileSync(). Always registered;
+ * declares all known extensions so it covers both parsed and raw tuples.
+ */
+export function createFileSourcesVisitor() {
+    return {
+        name: 'file-sources',
+        stage: 'visitor',
+        extensions: ALL_EXTENSIONS,
+        getRuleIds: () => [],
+        async visit(_ast, _adapter, context, sourceCode) {
+            return {
+                violations: [],
+                facts: { [context.filePath]: sourceCode },
+            };
+        },
+        defaultConfig: {},
+        description: 'Records every file source for Stage 3 reducers (infrastructure)',
+        category: 'infrastructure',
+    };
+}
+// ── SOLID visitor ────────────────────────────────────────────────────────────
+export function createSolidVisitor() {
+    const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalSOLIDAnalyzer.js').then((m) => new m.UniversalSOLIDAnalyzer()));
+    return {
+        name: 'solid',
+        stage: 'visitor',
+        getRuleIds: () => getRuleIdsFor('solid'),
+        async visit(ast, adapter, context, sourceCode) {
+            const a = await getAnalyzer();
+            const violations = await a.analyzeAST(ast, adapter, context.config, sourceCode);
+            return {
+                violations,
+                facts: {},
+            };
+        },
+        defaultConfig: {},
+        description: 'Detects violations of SOLID principles',
+        category: 'architecture',
+    };
+}
+export function createDryVisitor(fullFunctionIndex) {
+    const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalDRYAnalyzer.js').then((m) => new m.UniversalDRYAnalyzer()));
+    const visitor = {
+        name: 'dry',
+        stage: 'visitor',
+        getRuleIds: () => getRuleIdsFor('dry'),
+        async visit(ast, adapter, context, sourceCode) {
+            const a = await getAnalyzer();
+            const config = fullFunctionIndex
+                ? { ...context.config, fullFunctionIndex }
+                : context.config;
+            const violations = await a.analyzeAST(ast, adapter, config, sourceCode);
+            return { violations, facts: {} };
+        },
+        defaultConfig: {},
+        description: 'Detects code duplication across the codebase',
+        category: 'maintainability',
+    };
+    return {
+        visitor,
+        getDryPairs: async () => {
+            try {
+                const a = await getAnalyzer();
+                return a.dryPairs ?? [];
+            }
+            catch {
+                return [];
+            }
+        },
+    };
+}
+// ── Data-Access visitor ──────────────────────────────────────────────────────
+export function createDataAccessVisitor() {
+    const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalDataAccessAnalyzer.js').then((m) => new m.UniversalDataAccessAnalyzer()));
+    return {
+        name: 'data-access',
+        stage: 'visitor',
+        getRuleIds: () => getRuleIdsFor('data-access'),
+        async visit(ast, adapter, context, sourceCode) {
+            const a = await getAnalyzer();
+            const violations = await a.analyzeAST(ast, adapter, context.config, sourceCode);
+            return { violations, facts: {} };
+        },
+        defaultConfig: {},
+        description: 'Analyzes database access patterns and data layer interactions',
+        category: 'security',
+    };
+}
+// ── Documentation visitor ────────────────────────────────────────────────────
+export function createDocumentationVisitor() {
+    const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalDocumentationAnalyzer.js').then((m) => new m.UniversalDocumentationAnalyzer()));
+    return {
+        name: 'documentation',
+        stage: 'visitor',
+        getRuleIds: () => getRuleIdsFor('documentation'),
+        async visit(ast, adapter, context, sourceCode) {
+            const a = await getAnalyzer();
+            const violations = await a.analyzeAST(ast, adapter, context.config, sourceCode);
+            return { violations, facts: {} };
+        },
+        defaultConfig: {},
+        description: 'Checks documentation completeness',
+        category: 'style',
+    };
+}
+// ── Function-Index visitor (infrastructure) ──────────────────────────────────
+// Always-on Stage 2 visitor that populates the `functions` table with
+// per-file definitions so the conventions and cross-domain reducers have data
+// to mine — even on a cold run with no prior `index sync`.
+// The function_calls table is rebuilt post-pipeline after functions rows have
+// their auto-increment IDs assigned.
+function getLanguageFromPath(filePath) {
+    const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
+    switch (ext) {
+        case '.ts':
+        case '.tsx':
+            return 'typescript';
+        case '.js':
+        case '.jsx':
+            return 'javascript';
+        default:
+            return 'unknown';
+    }
+}
+function computeContentHash(body, signature) {
+    const normalized = (body ?? '').replace(/\s+/g, ' ').trim() + '|' + (signature ?? '').trim();
+    return createHash('sha256').update(normalized).digest('hex');
+}
+/** Raw text from an ASTNode (tree-sitter node stored on `.raw`). */
+function rawText(node) {
+    return node.raw?.text ?? '';
+}
+export function createFunctionIndexVisitor() {
+    return {
+        name: 'function-index',
+        stage: 'visitor',
+        getRuleIds: () => [],
+        async visit(ast, _adapter, context, sourceCode) {
+            const root = ast.root;
+            const filePath = context.filePath;
+            if (!filePath)
+                return { violations: [], facts: {} };
+            const indexFacts = [];
+            // Only index TS/JS files
+            const lang = getLanguageFromPath(filePath);
+            if (lang === 'unknown')
+                return { violations: [], facts: {} };
+            // Clear existing entries for this file
+            indexFacts.push({
+                table: 'functions',
+                data: { _action: 'clear-by-file', file_path: filePath },
+            });
+            // Build import map once per file for resolving call targets
+            const importMap = buildImportMap(root);
+            // Collect function-like nodes in two passes:
+            //  1) function_declaration + method_definition nodes
+            //  2) arrow functions assigned to variables (variable_declarator children)
+            const fnEntries = [];
+            // Pass 1 — named function declarations and methods
+            walkAST(root, (node) => {
+                if (node.type === 'function_declaration') {
+                    const nameNode = node.children?.find((c) => c.type === 'identifier');
+                    if (!nameNode)
+                        return;
+                    const name = rawText(nameNode);
+                    if (!name)
+                        return;
+                    const { line } = getLineAndColumn(node);
+                    const raw = node.raw;
+                    const endLine = line + (raw?.endPosition?.row ?? raw?.startPosition?.row ?? 0) - (raw?.startPosition?.row ?? line) + 1;
+                    const body = getFunctionBody(node, sourceCode);
+                    const calls = extractFunctionCalls(node, sourceCode, importMap);
+                    const callNames = [...new Set(calls.map((c) => c.callee))];
+                    fnEntries.push({
+                        name,
+                        line,
+                        endLine,
+                        entityType: 'function',
+                        componentType: null,
+                        isExported: isExported(node),
+                        complexity: calculateComplexity(node),
+                        body,
+                        functionCalls: callNames,
+                    });
+                }
+                // Class methods
+                if (node.type === 'method_definition') {
+                    const nameNode = node.children?.find((c) => c.type === 'identifier');
+                    if (!nameNode)
+                        return;
+                    const methodName = rawText(nameNode);
+                    if (!methodName)
+                        return;
+                    // Walk up to find class name
+                    let parent = node.parent;
+                    let className = 'AnonymousClass';
+                    while (parent) {
+                        if (parent.type === 'class_declaration') {
+                            const cn = parent.children?.find((c) => c.type === 'identifier');
+                            if (cn)
+                                className = rawText(cn);
+                            break;
+                        }
+                        parent = parent.parent;
+                    }
+                    const { line } = getLineAndColumn(node);
+                    const raw = node.raw;
+                    const endLine = line + (raw?.endPosition?.row ?? raw?.startPosition?.row ?? 0) - (raw?.startPosition?.row ?? line) + 1;
+                    const body = getFunctionBody(node, sourceCode);
+                    const calls = extractFunctionCalls(node, sourceCode, importMap);
+                    const callNames = [...new Set(calls.map((c) => c.callee))];
+                    fnEntries.push({
+                        name: `${className}.${methodName}`,
+                        line,
+                        endLine,
+                        entityType: 'method',
+                        componentType: null,
+                        isExported: isExported(node),
+                        complexity: calculateComplexity(node),
+                        body,
+                        functionCalls: callNames,
+                    });
+                }
+            });
+            // Pass 2 — arrow functions assigned to variables
+            walkAST(root, (node) => {
+                if (node.type !== 'variable_declarator')
+                    return;
+                const nameNode = node.children?.find((c) => c.type === 'identifier');
+                const arrowFunc = node.children?.find((c) => c.type === 'arrow_function');
+                if (!nameNode || !arrowFunc)
+                    return;
+                const name = rawText(nameNode);
+                if (!name)
+                    return;
+                // Don't duplicate if already covered as function_declaration
+                // (shouldn't happen — function_declaration is a different node type)
+                const { line } = getLineAndColumn(arrowFunc);
+                const raw = arrowFunc.raw;
+                const endLine = line + (raw?.endPosition?.row ?? raw?.startPosition?.row ?? 0) - (raw?.startPosition?.row ?? line) + 1;
+                const body = getFunctionBody(arrowFunc, sourceCode);
+                const calls = extractFunctionCalls(arrowFunc, sourceCode, importMap);
+                const callNames = [...new Set(calls.map((c) => c.callee))];
+                fnEntries.push({
+                    name,
+                    line,
+                    endLine,
+                    entityType: 'function',
+                    componentType: null,
+                    isExported: isExported(node),
+                    complexity: calculateComplexity(arrowFunc),
+                    body,
+                    functionCalls: callNames,
+                });
+            });
+            // Pass 3 — React component detection
+            // Detect JSX-returning functions to set entity_type='component' and
+            // component_type, matching what functionScanner's deepSync produces.
+            // The convention miner's classifyExportKind() uses these columns to
+            // partition naming conventions.
+            const hasReactImport = [...importMap.values()].some((v) => v.modulePath === 'react');
+            if (filePath.endsWith('.tsx') ||
+                filePath.endsWith('.jsx') ||
+                (filePath.endsWith('.js') && hasReactImport)) {
+                walkAST(root, (node) => {
+                    if (!isReactComponent(node))
+                        return;
+                    const ct = detectComponentType(node);
+                    if (!ct)
+                        return;
+                    const cName = getComponentName(node);
+                    if (!cName || cName === 'AnonymousComponent')
+                        return;
+                    const existing = fnEntries.find((f) => f.name === cName);
+                    if (existing) {
+                        // Upgrade existing function_declaration or arrow-function entry
+                        existing.entityType = 'component';
+                        existing.componentType = ct;
+                    }
+                    else {
+                        // New entry — class component, function_expression, or memo/forwardRef
+                        // wrapper not already captured by passes 1 or 2.
+                        const { line } = getLineAndColumn(node);
+                        const raw = node.raw;
+                        const endLine = line +
+                            (raw?.endPosition?.row ?? raw?.startPosition?.row ?? 0) -
+                            (raw?.startPosition?.row ?? line) +
+                            1;
+                        const body = getFunctionBody(node, sourceCode);
+                        fnEntries.push({
+                            name: cName,
+                            line,
+                            endLine,
+                            entityType: 'component',
+                            componentType: ct,
+                            isExported: isExported(node),
+                            complexity: calculateComplexity(node),
+                            body,
+                            functionCalls: [],
+                        });
+                    }
+                });
+            }
+            // Build IndexFactsEntry for each function
+            for (const fn of fnEntries) {
+                const metadata = {
+                    entityType: fn.entityType,
+                    isExported: fn.isExported,
+                    complexity: fn.complexity,
+                    functionCalls: fn.functionCalls,
+                    body: fn.body,
+                };
+                const contentHash = computeContentHash(fn.body, '');
+                const now = new Date().toISOString();
+                indexFacts.push({
+                    table: 'functions',
+                    data: {
+                        name: fn.name,
+                        file_path: filePath,
+                        line_number: fn.line,
+                        start_line: fn.line,
+                        end_line: fn.endLine,
+                        language: lang,
+                        entity_type: fn.entityType,
+                        component_type: fn.componentType,
+                        signature: '',
+                        return_type: null,
+                        complexity: fn.complexity,
+                        is_exported: fn.isExported ? 1 : 0,
+                        has_jsdoc: 0,
+                        jsdoc_description: '',
+                        parameters: null,
+                        body: fn.body ?? null,
+                        content_hash: contentHash,
+                        last_modified: now,
+                        metadata_json: JSON.stringify(metadata),
+                    },
+                    conflictKey: 'name, file_path, line_number',
+                });
+            }
+            // ── Extract imports and exports from AST for downstream consumers ──
+            // B1: Replaces regex-based extractImports()/extractExportedSymbols() in
+            // ruleEngine.ts.  Also consumed by conventions (B2: detectExportForm).
+            const langAdapter = _adapter;
+            const langAst = ast;
+            // Static imports via the adapter's canonical extractImports()
+            const staticImportInfos = langAdapter.extractImports(langAst);
+            const staticImports = staticImportInfos.map((imp) => ({
+                moduleSpecifier: imp.source,
+                isStatic: true,
+                isDynamic: false,
+                isRequire: false,
+                line: imp.location.start.line,
+            }));
+            // Dynamic import() and require() — first attempt with pure NodePattern
+            // Plan note: import keyword is an anonymous tree-sitter node, so
+            // hasChild cannot see it.  We use `custom` with raw node access.
+            const dynamicCallNodes = langAdapter.findNodes(langAst, {
+                type: 'call_expression',
+                custom: (node) => {
+                    const raw = node.raw;
+                    const fn = raw?.firstChild;
+                    return (fn?.type === 'import') ||
+                        (fn?.type === 'identifier' && fn.text === 'require');
+                },
+            });
+            const dynamicImports = [];
+            for (const node of dynamicCallNodes) {
+                const raw = node.raw;
+                const fn = raw?.firstChild;
+                const isImport = fn?.type === 'import';
+                const isRequire = !isImport && (fn?.type === 'identifier' && fn.text === 'require');
+                // Walk the raw tree to find the string argument
+                const argsNode = raw?.children?.find((c) => c.type === 'arguments');
+                const stringNode = argsNode?.children?.find((c) => c.type === 'string');
+                if (stringNode) {
+                    const text = stringNode.text;
+                    if (text.length >= 2) {
+                        dynamicImports.push({
+                            moduleSpecifier: text.slice(1, -1), // strip quotes
+                            isStatic: false,
+                            isDynamic: isImport,
+                            isRequire,
+                            line: node.location.start.line,
+                        });
+                    }
+                }
+            }
+            // Exports via the adapter's canonical extractExports()
+            // Returns ExportInfo[] with isDefault — used by both invariants and conventions (B2)
+            const exportInfos = langAdapter.extractExports(langAst);
+            return {
+                violations: [],
+                facts: {
+                    [filePath]: {
+                        imports: [...staticImports, ...dynamicImports],
+                        exports: exportInfos,
+                    },
+                },
+                indexFacts,
+            };
+        },
+        defaultConfig: {},
+        description: 'Indexes function definitions and extracts imports/exports for downstream analyzers',
+        category: 'infrastructure',
+    };
+}
+export function createReactVisitor() {
+    const scanResults = [];
+    const visitor = {
+        name: 'react',
+        stage: 'visitor',
+        getRuleIds: () => getRuleIdsFor('react'),
+        async visit(_ast, _adapter, context, _sourceCode) {
+            const filePath = context.filePath;
+            if (!filePath)
+                return { violations: [], facts: {} };
+            try {
+                const { scanFile } = await import('./componentScanner.js');
+                const { analyzeComponent: analyzeComp, DEFAULT_REACT_CONFIG } = await import('./analyzers/reactAnalyzer.js');
+                // Merge with defaults so partial configs get all required fields
+                const cfg = { ...DEFAULT_REACT_CONFIG, ...context.config };
+                const sr = await scanFile(filePath, {
+                    includeTests: false,
+                    includeStories: false,
+                    extractProps: true,
+                    extractHooks: cfg.checkHooksRules,
+                    extractImports: true,
+                    detectComplexity: true,
+                });
+                scanResults.push(sr);
+                if (sr.parseErrors && sr.parseErrors.length > 0) {
+                    return { violations: [], facts: {} };
+                }
+                // Per-component checks — same logic as reactAnalyzer.analyze()
+                const violations = [];
+                for (const comp of sr.components ?? []) {
+                    violations.push(...analyzeComp(comp, cfg, sr));
+                }
+                return { violations, facts: {} };
+            }
+            catch {
+                return { violations: [], facts: {} };
+            }
+        },
+        defaultConfig: {},
+        description: 'Analyzes React components for best practices and performance',
+        category: 'frontend',
+    };
+    return {
+        visitor,
+        finalizeCrossComponent: async (config) => {
+            if (scanResults.length === 0)
+                return [];
+            const violations = [];
+            try {
+                const { checkCircularDependencies, checkErrorBoundaryUsage, checkRawElements, } = await import('./analyzers/reactAnalyzer.js');
+                // Build component tree and check for circular dependencies
+                const { buildComponentTree } = await import('./componentScanner.js');
+                const tree = buildComponentTree(scanResults);
+                violations.push(...checkCircularDependencies(tree));
+                // Check for missing error boundaries
+                if (config.requireErrorBoundaries !== false) {
+                    violations.push(...checkErrorBoundaryUsage(scanResults));
+                }
+                // Check for raw element usage (Spec 10 R4)
+                if (config.rawElementCheck !== false) {
+                    violations.push(...checkRawElements(scanResults, config));
+                }
+            }
+            catch {
+                // Cross-component checks are advisory
+            }
+            return violations;
+        },
+    };
+}
+// ── Styles reducer (stage 3) ─────────────────────────────────────────────────
+// ── Styles CSS visitor (Spec 26 Phase 2) ───────────────────────────────────────
+/**
+ * Styles CSS visitor — extracts declarations, tokens, and class usage from
+ * tree-sitter-css parsed ASTs. Replaces the regex-based CSS extraction in
+ * styleExtractor.ts for .css files only.
+ *
+ * tree-sitter-css is NOT an SCSS grammar — .scss files stay on the regex path.
+ */
+export function createStylesCssVisitor() {
+    return {
+        name: 'styles-css',
+        stage: 'visitor',
+        extensions: ['.css'],
+        getRuleIds: () => [],
+        async visit(ast, adapter, context, sourceCode) {
+            // Lazy-load to avoid circular dependency issues at module load time
+            const { extractDeclarationsFromCSSAst, extractTokensFromCSSAst, extractClassUsageFromCSSAst } = await import('./styles/cssAstExtractor.js');
+            const cssAst = ast;
+            const cssAdapter = adapter;
+            const filePath = context.filePath;
+            return {
+                violations: [],
+                facts: {
+                    [filePath]: {
+                        declarations: extractDeclarationsFromCSSAst(cssAst, cssAdapter, filePath, sourceCode),
+                        tokens: extractTokensFromCSSAst(cssAst, cssAdapter, filePath),
+                        classUsage: extractClassUsageFromCSSAst(cssAst, cssAdapter, filePath),
+                    },
+                },
+            };
+        },
+        defaultConfig: {},
+        description: 'Extracts CSS declarations from tree-sitter-css ASTs (.css only)',
+        category: 'style',
+    };
+}
+/**
+ * Styles reducer — runs all style detectors on existing style_* tables.
+ * Uses the analyzer.analyze([]) pattern: passes an empty file list so the
+ * analyzer skips file iteration and only queries the DB.
+ *
+ * Spec 26 Phase 2: CSS facts from the styles-css visitor are inserted into
+ * the DB before the analyzer runs. For .css files, the AST extraction replaces
+ * the regex-based styleIndexer path (which now skips .css files).
+ */
+export function createStylesReducer() {
+    return {
+        name: 'styles',
+        stage: 'reducer',
+        consumes: [],
+        getRuleIds: () => getRuleIdsFor('styles'),
+        async reduce(_allFacts, context) {
+            if (!context.indexHandle)
+                return { violations: [], facts: {} };
+            try {
+                // ── Insert CSS visitor facts into style_* tables ──────────────────────
+                const cssFacts = _allFacts['styles-css'];
+                if (cssFacts) {
+                    const run = context.indexHandle.run.bind(context.indexHandle);
+                    for (const [filePath, facts] of Object.entries(cssFacts)) {
+                        // Delete old entries for this file (replaces the styleIndexer path)
+                        run('DELETE FROM style_declarations WHERE file_path = ?', [filePath]);
+                        run('DELETE FROM style_tokens WHERE file_path = ?', [filePath]);
+                        run('DELETE FROM style_class_usage WHERE file_path = ?', [filePath]);
+                        // Compute content hash for the file
+                        const contentStr = JSON.stringify({ declarations: facts.declarations.length, tokens: facts.tokens.length, classUsage: facts.classUsage.length });
+                        const contentHash = createHash('sha256').update(contentStr).digest('hex').slice(0, 16);
+                        // Insert declarations
+                        for (const decl of facts.declarations) {
+                            run('INSERT INTO style_declarations (property, raw_value, normalized_value, mechanism, file_path, line, context, variant_context, token_ref, content_hash) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [decl.property, decl.rawValue, JSON.stringify(decl.normalizedValue), decl.mechanism, decl.filePath, decl.line, decl.context, decl.variantContext, decl.tokenRef, contentHash]);
+                        }
+                        // Insert tokens
+                        for (const tok of facts.tokens) {
+                            run('INSERT INTO style_tokens (name, value, file_path, mechanism) VALUES (?, ?, ?, ?)', [tok.name, tok.value, tok.filePath, tok.mechanism]);
+                        }
+                        // Insert class usage
+                        for (const cu of facts.classUsage) {
+                            run('INSERT INTO style_class_usage (class_name, file_path, line, mechanism, unresolvable) VALUES (?, ?, ?, ?, ?)', [cu.className, cu.filePath, cu.line, cu.mechanism, cu.unresolvable ? 1 : 0]);
+                        }
+                    }
+                }
+                // ── Run the analyzer (queries the now-populated style_* tables) ───────
+                const { UniversalStylesAnalyzer } = await import('./analyzers/universal/UniversalStylesAnalyzer.js');
+                const analyzer = new UniversalStylesAnalyzer();
+                const result = await analyzer.analyze([], { ...context.config, indexHandle: context.indexHandle });
+                const factsConsumed = context.indexHandle.count('style_declarations')
+                    + context.indexHandle.count('style_tokens')
+                    + context.indexHandle.count('style_class_usage');
+                return { violations: result.violations ?? [], facts: {}, factsConsumed };
+            }
+            catch {
+                return { violations: [], facts: {} };
+            }
+        },
+        defaultConfig: {},
+        description: 'Detects style fragmentation, value drift, token bypass, and z-index sprawl',
+        category: 'style',
+    };
+}
+// ── Conventions reducer (stage 3) ────────────────────────────────────────────
+/**
+ * Conventions reducer — queries conventions table and flags deviations
+ * (usage-pair, import-form, error-handling, export-shape, naming).
+ * Uses analyzer.analyze([]) with rawDb injected.
+ */
+export function createConventionsReducer() {
+    return {
+        name: 'conventions',
+        stage: 'reducer',
+        consumes: [],
+        getRuleIds: () => getRuleIdsFor('conventions'),
+        async reduce(_allFacts, context) {
+            if (!context.indexHandle)
+                return { violations: [], facts: {} };
+            try {
+                const { UniversalConventionsAnalyzer } = await import('./analyzers/universal/UniversalConventionsAnalyzer.js');
+                const analyzer = new UniversalConventionsAnalyzer();
+                // Extract per-file source map from the file-sources infrastructure visitor
+                const fileSources = _allFacts['file-sources'];
+                const sourceMap = fileSources
+                    ? new Map(Object.entries(fileSources))
+                    : undefined;
+                // B2: Build exports map from function-index visitor facts (AST-extracted)
+                const functionIndexFacts = _allFacts['function-index'];
+                const exportsMap = functionIndexFacts
+                    ? new Map(Object.entries(functionIndexFacts)
+                        .filter(([, data]) => data?.exports?.length)
+                        .map(([filePath, data]) => [filePath, data.exports]))
+                    : undefined;
+                const config = { ...context.config, indexHandle: context.indexHandle, projectRoot: context.projectRoot, sourceMap, exportsMap };
+                const result = await analyzer.analyze([], config);
+                const factsConsumed = context.indexHandle.count('conventions');
+                return { violations: result.violations ?? [], facts: {}, factsConsumed };
+            }
+            catch {
+                return { violations: [], facts: {} };
+            }
+        },
+        defaultConfig: {},
+        description: 'Mines codebase conventions and flags deviations',
+        category: 'style',
+    };
+}
+// ── Cross-Domain reducer (stage 4) ───────────────────────────────────────────
+/**
+ * Cross-domain reducer — runs written-never-read, read-never-written,
+ * transaction-boundary risk, validation-bypass, and uncovered-risk detectors.
+ * Uses analyzer.analyze([]) with rawDb injected.
+ */
+export function createCrossDomainReducer() {
+    return {
+        name: 'cross-domain',
+        stage: 'derivedReducer',
+        consumes: [],
+        getRuleIds: () => getRuleIdsFor('cross-domain'),
+        async reduce(_allFacts, context) {
+            if (!context.indexHandle)
+                return { violations: [], facts: {} };
+            try {
+                const { CrossDomainAnalyzer } = await import('./analyzers/crossDomain/CrossDomainAnalyzer.js');
+                const analyzer = new CrossDomainAnalyzer();
+                const config = { ...context.config, indexHandle: context.indexHandle, projectRoot: context.projectRoot };
+                const result = await analyzer.analyze([], config);
+                // Count DB rows consumed across primary cross-domain tables
+                let factsConsumed = 0;
+                try {
+                    factsConsumed += context.indexHandle.count('schema_usage');
+                }
+                catch { /* table may not exist */ }
+                try {
+                    factsConsumed += context.indexHandle.count('indexed_functions');
+                }
+                catch { /* table may not exist */ }
+                return { violations: result.violations ?? [], facts: {}, factsConsumed };
+            }
+            catch (e) {
+                console.error('[cross-domain reducer] error:', e.message);
+                return { violations: [], facts: {} };
+            }
+        },
+        defaultConfig: {},
+        description: 'Detects cross-domain issues (schema lifecycle, validation bypass, coverage gaps)',
+        category: 'architecture',
+    };
+}
+// ── Invariants reducer (stage 3) ──────────────────────────────────────────────
+/**
+ * Invariants reducer — enforces user-defined invariant rules from .codeauditor.json.
+ * Receives the full file list via context.files and runs the rule engine across
+ * all files at once (call-constraint rules inherently need cross-file scope).
+ */
+export function createInvariantsReducer() {
+    return {
+        name: 'invariants',
+        stage: 'reducer',
+        consumes: [],
+        getRuleIds: () => getRuleIdsFor('invariants'),
+        async reduce(_allFacts, context) {
+            try {
+                const { analyzeInvariants } = await import('./analyzers/invariantsAnalyzer.js');
+                // Full file list is in _infra.files (merged into context.config via pipeline)
+                const files = context.config.files ?? [];
+                // Extract per-file source map from the file-sources infrastructure visitor
+                const fileSources = _allFacts['file-sources'];
+                const sourceMap = fileSources
+                    ? new Map(Object.entries(fileSources))
+                    : undefined;
+                const knownFiles = sourceMap
+                    ? new Set(sourceMap.keys())
+                    : undefined;
+                // B1: Build fileData from the function-index visitor's AST-extracted
+                // imports/exports — replaces regex-based extractImports/extractExportedSymbols
+                const functionIndexFacts = _allFacts['function-index'];
+                let fileData;
+                if (functionIndexFacts) {
+                    fileData = new Map();
+                    const projectRoot = context.projectRoot;
+                    for (const [filePath, data] of Object.entries(functionIndexFacts)) {
+                        if (data && (data.imports || data.exports)) {
+                            // Normalize absolute paths to project-relative (matching checkRules normalization)
+                            const normalized = path.isAbsolute(filePath)
+                                ? path.relative(projectRoot, filePath)
+                                : filePath;
+                            fileData.set(normalized, {
+                                imports: (data.imports || []).map((imp) => ({
+                                    moduleSpecifier: imp.moduleSpecifier,
+                                    isStatic: imp.isStatic,
+                                    isDynamic: imp.isDynamic,
+                                    isRequire: imp.isRequire,
+                                    line: imp.line,
+                                })),
+                                exports: (data.exports || []).map((exp) => ({
+                                    name: exp.name,
+                                    line: exp.location?.start?.line ?? 0,
+                                })),
+                            });
+                        }
+                    }
+                }
+                const result = await analyzeInvariants(files, { ...context.config, sourceMap, knownFiles, fileData }, { projectRoot: context.projectRoot, indexHandle: context.indexHandle });
+                return {
+                    violations: result.violations ?? [],
+                    facts: {},
+                    factsConsumed: files.length,
+                };
+            }
+            catch {
+                return { violations: [], facts: {} };
+            }
+        },
+        defaultConfig: {},
+        description: 'Enforces custom invariant rules (import bans, call constraints, module boundaries, naming)',
+        category: 'architecture',
+    };
+}
+// ── Schema visitors and reducer (Task #41 Part A) ──────────────────────────
+// Need provenance for per-file gate + reference extraction
+let _provenanceModule = null;
+async function _getProvenanceModule() {
+    if (!_provenanceModule) {
+        _provenanceModule = await import('./analyzers/provenance.js');
+    }
+    return _provenanceModule;
+}
+/**
+ * Schema SQL visitor (.sql files) — extracts raw DDL source for the Stage 3
+ * reducer to replay into the known-tables catalog.
+ */
+export function createSchemaSqlVisitor() {
+    return {
+        name: 'schema-sql',
+        stage: 'visitor',
+        extensions: ['.sql'],
+        getRuleIds: () => [],
+        async visit(_ast, _adapter, context, sourceCode) {
+            return {
+                violations: [],
+                facts: { [context.filePath]: { ddlSource: sourceCode } },
+            };
+        },
+        defaultConfig: {},
+        description: 'Captures SQL DDL source for known-table catalog',
+        category: 'database',
+    };
+}
+/**
+ * Schema code visitor (.ts/.tsx/.js/.jsx) — per-file analysis for naming conventions,
+ * query patterns, SQL injection, table references, and ORM table extraction.
+ */
+export function createSchemaCodeVisitor() {
+    const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalSchemaAnalyzer.js').then((m) => ({
+        analyzer: new m.UniversalSchemaAnalyzer(),
+        defaults: m.DEFAULT_SCHEMA_CONFIG,
+    })));
+    return {
+        name: 'schema-code',
+        stage: 'visitor',
+        extensions: ['.ts', '.tsx', '.js', '.jsx'],
+        getRuleIds: () => getRuleIdsFor('schema'),
+        async visit(ast, adapter, context, sourceCode) {
+            const { analyzer: a, defaults } = await getAnalyzer();
+            const pm = await _getProvenanceModule();
+            const violations = [];
+            const indexFacts = [];
+            // Extract ORM table names (Drizzle) from source
+            const ormTables = [];
+            const drizzleRe = /(?:pgTable|mysqlTable|sqliteTable)\s*\(\s*['"]([^'"]+)['"]/g;
+            let dm;
+            while ((dm = drizzleRe.exec(sourceCode)) !== null) {
+                ormTables.push(dm[1]);
+            }
+            // Extract DDL from sql.exec(...) string literals inside Durable Object classes.
+            // These are CREATE TABLE / DROP TABLE statements at runtime that migration
+            // discovery never sees.  Extracting them completes the authoritative catalog
+            // so unknown-table doesn't false-positive on DO-local tables.
+            const doDDL = [];
+            const doTemplateDDL = /`([^`]*(?:CREATE|DROP|ALTER)\s+(?:TABLE|VIRTUAL\s+TABLE)\s+[^`]+)`/gis;
+            const doStringDDL = /(["'])((?:\s*(?:CREATE|DROP|ALTER)\s+(?:TABLE|VIRTUAL\s+TABLE)\s+[^"']+))\1/gis;
+            let ddlMatch;
+            while ((ddlMatch = doTemplateDDL.exec(sourceCode)) !== null) {
+                const sql = ddlMatch[1].trim();
+                if (sql)
+                    doDDL.push(sql);
+            }
+            while ((ddlMatch = doStringDDL.exec(sourceCode)) !== null) {
+                const sql = ddlMatch[2].trim();
+                if (sql)
+                    doDDL.push(sql);
+            }
+            // Build provenance context for this file — defaults from DEFAULT_SCHEMA_CONFIG
+            const schemaConfig = (context.config ?? {});
+            const detectionMode = schemaConfig.detection?.mode ?? 'hybrid';
+            const provenanceContext = pm.buildProvenanceContext(ast, adapter, sourceCode, {
+                mode: detectionMode,
+                dbReceiverNames: schemaConfig.dbReceiverNames ?? defaults.dbReceiverNames,
+                dbBindingNames: schemaConfig.dbBindingNames ?? defaults.dbBindingNames,
+                dbCallMethods: schemaConfig.dbCallMethods ?? defaults.dbCallMethods,
+            });
+            // File gate — skip files without DB usage
+            if (!a.passesFileGate(context.filePath, sourceCode, schemaConfig, provenanceContext)) {
+                const facts = { [context.filePath]: { tableRefs: [], ormTables } };
+                if (doDDL.length > 0)
+                    facts[context.filePath].ddlSource = doDDL.join(';\n');
+                return { violations: [], facts };
+            }
+            // Build known-tables set from schemas config (pre-pipeline + DB-loaded schemas)
+            const schemas = schemaConfig.schemas ?? [];
+            const knownTablesArr = schemaConfig.knownTables ?? [];
+            const allTables = new Set();
+            for (const t of knownTablesArr)
+                allTables.add(t);
+            for (const schema of schemas) {
+                for (const table of (schema.tables ?? [])) {
+                    allTables.add(table.name);
+                }
+            }
+            // Find table references (per-file, uses allTables for short-id false-positive filtering)
+            const tableRefs = a.findTableReferences(ast, adapter, sourceCode, schemaConfig, provenanceContext, allTables);
+            // Record schema usage → emit as indexFacts via the shared instance
+            a.recordTableUsage(ast, adapter, context.filePath, tableRefs);
+            const pending = a.getPendingSchemaRecords();
+            // Emit clear-by-file + per-usage index facts
+            if (pending.clearFiles.length > 0) {
+                for (const filePath of pending.clearFiles) {
+                    indexFacts.push({ table: 'schema_usage', data: { _action: 'clear-by-file', file_path: filePath } });
+                }
+            }
+            for (const usage of pending.usages) {
+                indexFacts.push({
+                    table: 'schema_usage',
+                    data: {
+                        file_path: usage.filePath,
+                        table_name: usage.tableName,
+                        function_name: usage.functionName,
+                        usage_type: usage.usageType,
+                        line: usage.line,
+                        column: usage.column,
+                        raw_query: usage.rawQuery,
+                    },
+                });
+            }
+            // Check naming conventions
+            if (schemaConfig.checkNamingConventions !== false) {
+                violations.push(...a.checkNamingConventions(tableRefs, context.filePath));
+            }
+            // Check query patterns
+            if (schemaConfig.validateQueryPatterns !== false) {
+                violations.push(...a.checkQueryPatterns(ast, adapter, sourceCode, schemaConfig));
+            }
+            // Check SQL injection
+            violations.push(...a.checkSQLInjection(ast, adapter, sourceCode));
+            // Emit facts for the Stage 3 reducer
+            const fileFacts = {
+                tableRefs: tableRefs.map((r) => ({
+                    table: r.table,
+                    type: r.type,
+                    line: r.location.line,
+                    column: r.location.column,
+                    context: r.context,
+                })),
+                ormTables,
+            };
+            if (doDDL.length > 0)
+                fileFacts.ddlSource = doDDL.join(';\n');
+            return {
+                violations,
+                facts: { [context.filePath]: fileFacts },
+                indexFacts: indexFacts.length > 0 ? indexFacts : undefined,
+            };
+        },
+        defaultConfig: {},
+        description: 'Per-file schema analysis: naming conventions, query patterns, SQL injection, table references',
+        category: 'database',
+    };
+}
+/**
+ * Schema Prisma visitor (.prisma files) — extracts model names for known-table catalog.
+ */
+export function createSchemaPrismaVisitor() {
+    return {
+        name: 'schema-prisma',
+        stage: 'visitor',
+        extensions: ['.prisma'],
+        getRuleIds: () => [],
+        async visit(_ast, _adapter, context, sourceCode) {
+            const models = [];
+            const modelRe = /model\s+(\w+)\s*\{/g;
+            let m;
+            while ((m = modelRe.exec(sourceCode)) !== null) {
+                models.push(m[1]);
+            }
+            return {
+                violations: [],
+                facts: { [context.filePath]: { prismaModels: models } },
+            };
+        },
+        defaultConfig: {},
+        description: 'Extracts Prisma model names for known-table catalog',
+        category: 'database',
+    };
+}
+/**
+ * Schema JSON visitor (.json files) — parses JSON for the Stage 3 reducer to validate.
+ */
+export function createSchemaJsonVisitor() {
+    return {
+        name: 'schema-json',
+        stage: 'visitor',
+        extensions: ['.json'],
+        getRuleIds: () => [],
+        async visit(_ast, _adapter, context, sourceCode) {
+            let parsed = null;
+            try {
+                parsed = JSON.parse(sourceCode);
+            }
+            catch {
+                // Invalid JSON — skip
+            }
+            return {
+                violations: [],
+                facts: { [context.filePath]: { jsonParsed: parsed, jsonRaw: sourceCode } },
+            };
+        },
+        defaultConfig: {},
+        description: 'Parses JSON files for schema validation',
+        category: 'database',
+    };
+}
+/**
+ * Schema Stage 3 reducer — cross-file unknown-table detection and JSON schema validation.
+ *
+ * Consumes facts from schema-sql, schema-code, schema-prisma, and schema-json visitors.
+ * Builds the complete known-tables catalog and checks all table references against it.
+ */
+export function createSchemaReducer() {
+    const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalSchemaAnalyzer.js').then((m) => ({
+        analyzer: new m.UniversalSchemaAnalyzer(),
+        defaults: m.DEFAULT_SCHEMA_CONFIG,
+    })));
+    return {
+        name: 'schema',
+        stage: 'reducer',
+        consumes: [],
+        getRuleIds: () => getRuleIdsFor('schema'),
+        async reduce(allFacts, context) {
+            const { analyzer: a } = await getAnalyzer();
+            const violations = [];
+            const schemaConfig = (context.config ?? {});
+            // allFacts is keyed by visitor name, each value is { [filePath]: { ...per-file facts } }
+            // Flatten to per-file iteration helpers.
+            const perFile = function* () {
+                for (const [, visitorFacts] of Object.entries(allFacts)) {
+                    if (typeof visitorFacts === 'object' && visitorFacts !== null) {
+                        for (const [filePath, fact] of Object.entries(visitorFacts)) {
+                            if (typeof fact === 'object' && fact !== null) {
+                                yield [filePath, fact];
+                            }
+                        }
+                    }
+                }
+            };
+            // ── 1. Build known-tables catalog ──────────────────────────────────────
+            const knownTables = new Set();
+            // 1a. SQL DDL replay — collect all .sql file facts, sort by numeric prefix, replay
+            const sqlFiles = [];
+            for (const [filePath, fact] of perFile()) {
+                if ('ddlSource' in fact) {
+                    sqlFiles.push({ filePath, source: fact.ddlSource });
+                }
+            }
+            // Sort by numeric prefix in basename: "009_something" < "0010_rename"
+            // Falls back to localeCompare for non-numeric-prefixed names.
+            const numericPrefix = (p) => {
+                const base = p.split('/').pop() ?? p;
+                const m = base.match(/^(\d+)/);
+                return m ? parseInt(m[1], 10) : 0;
+            };
+            sqlFiles.sort((a, b) => {
+                const na = numericPrefix(a.filePath);
+                const nb = numericPrefix(b.filePath);
+                if (na !== nb)
+                    return na - nb;
+                return a.filePath.localeCompare(b.filePath);
+            });
+            for (const sqlFile of sqlFiles) {
+                a.processMigrationSource(sqlFile.source, knownTables);
+            }
+            // 1b. ORM tables from code files
+            for (const [, fact] of perFile()) {
+                const ormTables = fact.ormTables ?? [];
+                for (const t of ormTables)
+                    knownTables.add(t);
+            }
+            // 1c. Prisma models
+            for (const [, fact] of perFile()) {
+                const prismaModels = fact.prismaModels ?? [];
+                for (const m of prismaModels)
+                    knownTables.add(m);
+            }
+            // ── 2. Unknown-table detection ────────────────────────────────────────
+            //
+            // Fail-open guardrail: we can only accuse when the table catalog is
+            // built from authoritative sources.  Empty catalog → cannot accuse.
+            //
+            // Authoritative sources (independent of query sites, not circular):
+            //   • SQL migration files via schema-sql     (step 1a)
+            //   • ORM model definitions via schema-code  (step 1b)
+            //   • Prisma schemas via schema-prisma       (step 1c)
+            //
+            // External config tables (schemas from CodeIndexDB, wrangler.toml
+            // pre-discovered tables) are added as a bonus but are not required.
+            //
+            // NOT authoritative: tables inferred from query-text alone.  Those
+            // never enter the catalog (table refs are for checking, not building).
+            // Merge external tables from config (bonus, not required).
+            const externalKnownTables = schemaConfig.knownTables ?? [];
+            for (const t of externalKnownTables)
+                knownTables.add(t);
+            if (knownTables.size > 0) {
+                // Collect all table references across all files
+                const allTableRefs = [];
+                for (const [filePath, fact] of perFile()) {
+                    const refs = fact.tableRefs ?? [];
+                    for (const ref of refs) {
+                        allTableRefs.push({ file: filePath, ...ref });
+                    }
+                }
+                // 10:1 fail-open ratio guard
+                const unknownRefs = allTableRefs.filter(ref => !knownTables.has(ref.table));
+                if (unknownRefs.length / Math.max(knownTables.size, 1) <= 10) {
+                    for (const ref of unknownRefs) {
+                        const suggestions = a.getNearestTableSuggestions(ref.table, knownTables, 2);
+                        const msg = suggestions.length > 0
+                            ? `Reference to unknown table '${ref.table}' (${ref.type}). Did you mean: ${suggestions.join(', ')}?`
+                            : `Reference to unknown table '${ref.table}' (${ref.type})`;
+                        violations.push({
+                            file: ref.file,
+                            line: ref.line,
+                            column: ref.column,
+                            severity: 'suggestion',
+                            message: msg,
+                            rule: 'unknown-table',
+                            analyzer: 'schema',
+                            symbol: ref.table,
+                        });
+                    }
+                }
+            }
+            // ── 3. JSON schema validation ──────────────────────────────────────────
+            if (schemaConfig.validateJsonSchemas !== false) {
+                try {
+                    // Build content Map from json facts for the refactored analyzeJsonSchemas
+                    const jsonContents = new Map();
+                    let jsonFactCount = 0;
+                    for (const [filePath, fact] of perFile()) {
+                        if ('jsonParsed' in fact) {
+                            jsonFactCount++;
+                            const raw = (fact.jsonParsed ?? null);
+                            // parsed is the result of JSON.parse: null on failure, or the
+                            // deserialized value. Only accept objects as usable parsed content.
+                            const parsed = raw !== null && typeof raw === 'object' ? raw : null;
+                            jsonContents.set(filePath, {
+                                parsed,
+                                raw: (fact.jsonRaw ?? fact.sourceCode ?? ''),
+                            });
+                        }
+                    }
+                    const jsonResult = a.analyzeJsonSchemas(jsonContents, schemaConfig);
+                    violations.push(...(jsonResult?.violations ?? []));
+                }
+                catch (e) {
+                    // JSON schema validation is best-effort (non-fatal)
+                }
+            }
+            return {
+                violations,
+                facts: {},
+                factsConsumed: [...perFile()].length,
+            };
+        },
+        defaultConfig: {},
+        description: 'Cross-file schema analysis: unknown-table detection and JSON schema validation',
+        category: 'database',
+    };
+}
+//# sourceMappingURL=pipelineAdapters.js.map