code-auditor-mcp 3.4.9 → 3.4.11

package/dist/pipeline.js.bak

@@ -0,0 +1,465 @@
+/**
+ * Pipeline execution engine (Spec 24).
+ *
+ * Four sequential stages:
+ *   1. Traverse + Parse — one walk, one parse per file
+ *   2. Per-file visitors — each AST → all visitors in parallel
+ *   3. Corpus reducers — accumulated facts → cross-file analysis
+ *   4. Derived reducers — stage 2+3 facts → cross-domain analysis
+ *
+ * Stage position IS the dependency declaration — no topological sort needed.
+ */
+import { readFile } from 'fs/promises';
+import { performance } from 'perf_hooks';
+import { AuditAbortedError, } from './types.js';
+import { LanguageRegistry } from './languages/LanguageRegistry.js';
+import { discoverFiles } from './utils/fileDiscovery.js';
+import { resolvePathProfile } from './config/pathProfiles.js';
+import { validateFactsDependencies } from './pipelineTypes.js';
+// ── Stage 1: Traverse + Parse ──────────────────────────────────────────────
+async function runStage1(config) {
+    const t0 = performance.now();
+    let readMs = 0;
+    let parseMs = 0;
+    // Discover files (or use explicit)
+    const projectRoot = config.projectRoot;
+    let files;
+    if (config.explicitFiles && config.explicitFiles.length > 0) {
+        files = config.explicitFiles;
+    }
+    else {
+        files = await discoverFiles(projectRoot, {
+            excludeDirs: ['node_modules', '.next', 'dist', 'build', '.git', 'coverage', '.turbo'],
+        });
+    }
+    // Group by language adapter
+    const registry = LanguageRegistry.getInstance();
+    const groups = new Map();
+    const orphans = [];
+    for (const file of files) {
+        const adapter = registry.getAdapterForFile(file);
+        if (adapter) {
+            const list = groups.get(adapter) ?? [];
+            list.push(file);
+            groups.set(adapter, list);
+        }
+        else {
+            orphans.push(file);
+        }
+    }
+    // Parse each file once
+    const tuples = [];
+    let parsed = 0;
+    for (const [adapter, adapterFiles] of groups) {
+        for (const file of adapterFiles) {
+            // Check abort
+            if (config.abortSignal?.aborted) {
+                throw new AuditAbortedError('Audit aborted during stage 1');
+            }
+            try {
+                const r0 = performance.now();
+                const content = await readFile(file, 'utf-8');
+                readMs += performance.now() - r0;
+                const p0 = performance.now();
+                const ast = await adapter.parse(file, content);
+                parseMs += performance.now() - p0;
+                tuples.push({
+                    file,
+                    ast,
+                    adapter,
+                    sourceCode: content,
+                });
+                parsed++;
+            }
+            catch (err) {
+                // File read/parse errors — skip this file
+                // Individual files that fail to parse don't abort the entire run
+                if (config.progressCallback) {
+                    config.progressCallback({
+                        current: parsed,
+                        total: files.length,
+                        analyzer: 'pipeline',
+                        phase: 'stage1',
+                        file,
+                        message: `Skipped: ${err.message}`,
+                    });
+                }
+            }
+        }
+    }
+    const duration = performance.now() - t0;
+    // Log orphan files (no matching language adapter)
+    const orphanCount = orphans.length;
+    if (orphanCount > 0 && config.progressCallback) {
+        config.progressCallback({
+            current: orphanCount,
+            total: orphans.length,
+            analyzer: 'pipeline',
+            phase: 'stage1',
+            message: `${orphanCount} file(s) skipped (no language adapter)`,
+        });
+    }
+    return {
+        tuples,
+        fileCount: tuples.length + orphanCount,
+        parseDurationMs: duration,
+        readDurationMs: readMs,
+    };
+}
+// ── Stage 2: Per-file visitors ─────────────────────────────────────────────
+async function runStage2(tuples, visitors, config) {
+    const t0 = performance.now();
+    const visitorResults = new Map();
+    const allFacts = new Map();
+    const indexFacts = [];
+    const timingMap = new Map();
+    const errors = new Map();
+    // Initialize per-visitor state
+    for (const visitor of visitors) {
+        visitorResults.set(visitor.name, {
+            violations: [],
+            filesProcessed: 0,
+            status: { status: 'ran', filesProcessed: 0 },
+            executionTime: 0,
+            analyzerName: visitor.name,
+        });
+        allFacts.set(visitor.name, {});
+        timingMap.set(visitor.name, 0);
+        errors.set(visitor.name, []);
+    }
+    const projectRoot = config.projectRoot;
+    const pathProfiles = config.config?.pathProfiles;
+    const rawConfig = config.config ?? {};
+    const severityOverrides = rawConfig.severityOverrides ?? {};
+    // Iterate tuples
+    for (let i = 0; i < tuples.length; i++) {
+        const tuple = tuples[i];
+        // Check abort
+        if (config.abortSignal?.aborted) {
+            throw new AuditAbortedError('Audit aborted during stage 2');
+        }
+        // Progress
+        if (config.progressCallback && i % 10 === 0) {
+            config.progressCallback({
+                current: i,
+                total: tuples.length,
+                analyzer: 'pipeline',
+                phase: 'stage2',
+                file: tuple.file,
+            });
+        }
+        // Resolve path profiles for this file
+        let fileConfig = rawConfig;
+        let fileProfileNames = [];
+        let fileSeverityCap;
+        if (pathProfiles && pathProfiles.length > 0) {
+            const resolved = resolvePathProfile(tuple.file, projectRoot, pathProfiles);
+            if (Object.keys(resolved.overrides).length > 0) {
+                fileConfig = { ...rawConfig, ...resolved.overrides };
+            }
+            fileProfileNames = resolved.matchedProfileNames;
+            fileSeverityCap = resolved.severityCap;
+        }
+        const visitorContext = {
+            projectRoot,
+            config: fileConfig,
+            abortSignal: config.abortSignal,
+        };
+        // Fan out to all visitors for this file
+        for (const visitor of visitors) {
+            try {
+                const v0 = performance.now();
+                const result = await visitor.visit(tuple.ast, tuple.adapter, visitorContext, tuple.sourceCode);
+                const vMs = performance.now() - v0;
+                // Accumulate timing
+                timingMap.set(visitor.name, (timingMap.get(visitor.name) ?? 0) + vMs);
+                // Attach profile, severity overrides, analyzer name
+                const severityOrder = ['suggestion', 'warning', 'critical'];
+                const processedViolations = result.violations
+                    .map((v) => ({
+                    ...v,
+                    analyzer: v.analyzer ?? visitor.name,
+                    profile: fileProfileNames.length > 0
+                        ? fileProfileNames[fileProfileNames.length - 1]
+                        : v.profile,
+                    severity: severityOverrides[v.rule] ?? v.severity,
+                }))
+                    // Filter out violations whose severity was overridden to 'off' (Spec-11 R5)
+                    .filter((v) => v.severity !== 'off')
+                    // Apply severity cap from path profiles (Spec-20)
+                    // Applied AFTER severityOverrides so path-level caps beat global promotions
+                    .map((v) => {
+                    if (fileSeverityCap) {
+                        const capIndex = severityOrder.indexOf(fileSeverityCap);
+                        if (capIndex >= 0 && severityOrder.indexOf(v.severity) > capIndex) {
+                            return { ...v, severity: fileSeverityCap };
+                        }
+                    }
+                    return v;
+                });
+                // Accumulate violations
+                const ar = visitorResults.get(visitor.name);
+                ar.violations.push(...processedViolations);
+                ar.status = {
+                    status: 'ran',
+                    filesProcessed: (ar.status.filesProcessed ?? 0) + 1,
+                };
+                // Accumulate facts
+                if (result.facts && Object.keys(result.facts).length > 0) {
+                    const existing = allFacts.get(visitor.name) ?? {};
+                    allFacts.set(visitor.name, { ...existing, ...result.facts });
+                }
+                // Collect index facts
+                if (result.indexFacts && result.indexFacts.length > 0) {
+                    indexFacts.push(...result.indexFacts);
+                }
+            }
+            catch (err) {
+                // Visitor error on this file — collect but don't abort
+                const errs = errors.get(visitor.name);
+                errs.push({ file: tuple.file, error: err.message });
+            }
+        }
+    }
+    // Finalize results
+    const totalDuration = performance.now() - t0;
+    for (const [name, result] of visitorResults) {
+        const visitorTime = timingMap.get(name) ?? 0;
+        result.executionTime = visitorTime;
+        // Sync filesProcessed from status (which tracks per-file increments)
+        // to the top-level field (which runZeroFilesDiagnostics reads directly)
+        result.filesProcessed = result.status.filesProcessed;
+        const errList = errors.get(name);
+        if (errList && errList.length > 0) {
+            result.errors = errList;
+        }
+    }
+    return {
+        visitorResults,
+        allFacts,
+        indexFacts,
+        visitorDurationMs: timingMap,
+        fileCount: tuples.length,
+    };
+}
+// ── Stage 3: Corpus reducers ───────────────────────────────────────────────
+async function runStage3(allFacts, reducers, config, indexHandle) {
+    const t0 = performance.now();
+    const reducerResults = new Map();
+    const reducerFacts = new Map();
+    const factsObj = Object.fromEntries(allFacts);
+    const factsConsumed = allFacts.size;
+    const reducerContext = {
+        projectRoot: config.projectRoot,
+        config: config.config ?? {},
+        indexHandle,
+        abortSignal: config.abortSignal,
+    };
+    for (const reducer of reducers) {
+        if (config.abortSignal?.aborted) {
+            throw new AuditAbortedError(`Audit aborted during stage 3 (${reducer.name})`);
+        }
+        try {
+            const r0 = performance.now();
+            const result = await reducer.reduce(factsObj, reducerContext);
+            const rMs = performance.now() - r0;
+            reducerResults.set(reducer.name, {
+                violations: result.violations.map((v) => ({
+                    ...v,
+                    analyzer: v.analyzer ?? reducer.name,
+                })),
+                status: { status: 'ran', factsConsumed },
+                filesProcessed: 0,
+                executionTime: rMs,
+                analyzerName: reducer.name,
+            });
+            if (result.facts && Object.keys(result.facts).length > 0) {
+                reducerFacts.set(reducer.name, result.facts);
+            }
+        }
+        catch (err) {
+            reducerResults.set(reducer.name, {
+                violations: [],
+                status: {
+                    status: 'notRun',
+                    reason: `Reducer error: ${err.message}`,
+                },
+                filesProcessed: 0,
+                executionTime: 0,
+                analyzerName: reducer.name,
+                errors: [{ file: '(reducer)', error: err.message }],
+            });
+        }
+    }
+    return {
+        reducerResults,
+        reducerFacts,
+        durationMs: performance.now() - t0,
+    };
+}
+// ── Stage 4: Derived reducers ──────────────────────────────────────────────
+async function runStage4(allFacts, derivedReducers, config, indexHandle) {
+    const t0 = performance.now();
+    const derivedResults = new Map();
+    const factsConsumed = Object.keys(allFacts).length;
+    const reducerContext = {
+        projectRoot: config.projectRoot,
+        config: config.config ?? {},
+        indexHandle,
+        abortSignal: config.abortSignal,
+    };
+    for (const dr of derivedReducers) {
+        if (config.abortSignal?.aborted) {
+            throw new AuditAbortedError(`Audit aborted during stage 4 (${dr.name})`);
+        }
+        try {
+            const r0 = performance.now();
+            const result = await dr.reduce(allFacts, reducerContext);
+            const rMs = performance.now() - r0;
+            derivedResults.set(dr.name, {
+                violations: result.violations.map((v) => ({
+                    ...v,
+                    analyzer: v.analyzer ?? dr.name,
+                })),
+                status: { status: 'ran', factsConsumed },
+                filesProcessed: 0,
+                executionTime: rMs,
+                analyzerName: dr.name,
+            });
+        }
+        catch (err) {
+            derivedResults.set(dr.name, {
+                violations: [],
+                status: {
+                    status: 'notRun',
+                    reason: `Derived reducer error: ${err.message}`,
+                },
+                filesProcessed: 0,
+                executionTime: 0,
+                analyzerName: dr.name,
+                errors: [{ file: '(derived-reducer)', error: err.message }],
+            });
+        }
+    }
+    return {
+        derivedResults,
+        durationMs: performance.now() - t0,
+    };
+}
+// ── Main pipeline entry ────────────────────────────────────────────────────
+/**
+ * Run the full 4-stage pipeline.
+ *
+ * @param config Pipeline configuration with visitors, reducers, and derived reducers.
+ * @param indexHandle Optional DB handle for reducers (in-memory overlay for scoped runs).
+ * @returns PipelineResult with analyzerResults and metadata.
+ */
+export async function runPipeline(config, indexHandle) {
+    const totalT0 = performance.now();
+    const stageTiming = {};
+    const visitors = config.visitors ?? [];
+    const reducers = config.reducers ?? [];
+    const derivedReducers = config.derivedReducers ?? [];
+    // ── Validate facts dependencies ──────────────────────────────────────────
+    const depErrors = validateFactsDependencies(visitors, reducers, derivedReducers);
+    if (depErrors.length > 0) {
+        throw new Error(`Pipeline facts dependency errors:\n${depErrors.map((e) => `  - ${e}`).join('\n')}`);
+    }
+    // ── Stage 1: Traverse + Parse ────────────────────────────────────────────
+    const stage1 = await runStage1(config);
+    stageTiming['stage1-parse'] = stage1.parseDurationMs;
+    if (config.progressCallback) {
+        config.progressCallback({
+            current: stage1.fileCount,
+            total: stage1.fileCount,
+            analyzer: 'pipeline',
+            phase: 'stage1-complete',
+            message: `${stage1.fileCount} files parsed in ${stage1.parseDurationMs.toFixed(0)}ms`,
+        });
+    }
+    // ── Stage 2: Per-file visitors ───────────────────────────────────────────
+    const stage2 = await runStage2(stage1.tuples, visitors, config);
+    stageTiming['stage2-visitors'] = performance.now() - totalT0 - stage1.parseDurationMs;
+    if (config.progressCallback) {
+        config.progressCallback({
+            current: stage2.fileCount,
+            total: stage2.fileCount,
+            analyzer: 'pipeline',
+            phase: 'stage2-complete',
+            message: `${visitors.length} visitors ran on ${stage2.fileCount} files`,
+        });
+    }
+    // ── Stage 3: Corpus reducers ─────────────────────────────────────────────
+    const stage3T0 = performance.now();
+    const stage3 = await runStage3(stage2.allFacts, reducers, config, indexHandle);
+    stageTiming['stage3-reducers'] = performance.now() - stage3T0;
+    // Merge stage 2 + stage 3 facts for stage 4
+    const combinedFacts = {};
+    for (const [name, facts] of stage2.allFacts) {
+        combinedFacts[name] = facts;
+    }
+    for (const [name, facts] of stage3.reducerFacts) {
+        combinedFacts[name] = facts;
+    }
+    // ── Stage 4: Derived reducers ────────────────────────────────────────────
+    const stage4T0 = performance.now();
+    const stage4 = await runStage4(combinedFacts, derivedReducers, config, indexHandle);
+    stageTiming['stage4-derived'] = performance.now() - stage4T0;
+    // ── Build result ─────────────────────────────────────────────────────────
+    const analyzerResults = {};
+    // Stage 2 results
+    for (const [name, result] of stage2.visitorResults) {
+        analyzerResults[name] = result;
+    }
+    // Stage 3 results
+    for (const [name, result] of stage3.reducerResults) {
+        analyzerResults[name] = result;
+    }
+    // Stage 4 results
+    for (const [name, result] of stage4.derivedResults) {
+        analyzerResults[name] = result;
+    }
+    // Collect diagnostics
+    const diagnostics = [];
+    for (const [name, result] of Object.entries(analyzerResults)) {
+        if (result.status && result.status.status === 'notRun') {
+            diagnostics.push({
+                analyzerName: name,
+                kind: 'not-run',
+                message: result.status.reason,
+            });
+        }
+    }
+    const totalDuration = performance.now() - totalT0;
+    return {
+        analyzerResults,
+        metadata: {
+            auditDuration: totalDuration,
+            filesAnalyzed: stage1.fileCount,
+            stageTiming,
+            scoped: config.isScoped,
+            diagnostics,
+        },
+    };
+}
+/**
+ * Run pipeline with index fact handling.
+ *
+ * For scoped runs (changed, path-filtered), index facts are kept in-memory.
+ * For full runs (plain audit), index facts are written to persistent storage
+ * via the provided writeFn.
+ */
+export async function runPipelineWithIndex(config, indexHandle, writeIndexFacts) {
+    const result = await runPipeline(config, indexHandle);
+    // Index facts are accumulated during stage 2 and need to be extracted
+    // Since runStage2 is internal, we expose a separate path that re-runs
+    // or we can modify runPipeline to pass index facts through.
+    //
+    // For now, we use runPipeline and the caller handles index facts
+    // separately through the visitor results.
+    return {
+        result,
+        indexFacts: [],
+    };
+}
+//# sourceMappingURL=pipeline.js.map