@rigour-labs/core 5.2.1 → 5.2.3

package/dist/gates/coverage.d.ts

@@ -4,5 +4,8 @@ export declare class CoverageGate extends Gate {
     private config;
     constructor(config: Gates);
     run(context: GateContext): Promise<Failure[]>;
+    private findCoverageReport;
+    private parseCoverage;
     private parseLcov;
+    private parseCoverageFinalJson;
 }

package/dist/gates/coverage.js

@@ -1,5 +1,6 @@
 import fs from 'fs-extra';
 import path from 'path';
+import readline from 'node:readline';
 import { Gate } from './base.js';
 import { globby } from 'globby';
 export class CoverageGate extends Gate {
@@ -11,22 +12,21 @@ export class CoverageGate extends Gate {
     async run(context) {
         const failures = [];
         // 1. Locate coverage report (lcov.info is standard)
-        const reports = await globby(['**/lcov.info', '**/coverage-final.json'], {
-            cwd: context.cwd,
-            ignore: ['node_modules/**']
-        });
-        if (reports.length === 0) {
+        const report = await this.findCoverageReport(context);
+        if (!report) {
             // If no reports found, and coverage is required, we could flag it.
             // But for now, we'll just skip silently if not configured.
             return [];
         }
-        // 2. Parse coverage (Simplified LCOV parser for demonstration)
-        const coverageData = await this.parseLcov(path.join(context.cwd, reports[0]));
+        // 2. Parse coverage (LCOV or Istanbul JSON)
+        const coverageData = await this.parseCoverage(path.join(context.cwd, report));
         // 3. Quality Handshake: SME SME LOGIC
         // We look for files that have high complexity but low coverage.
         // In a real implementation, we would share data between ASTGate and CoverageGate.
         // For this demo, we'll implement a standalone check.
         for (const [file, stats] of Object.entries(coverageData)) {
+            if (!stats.found)
+                continue;
             const coverage = (stats.hit / stats.found) * 100;
             const threshold = stats.isComplex ? 80 : 50; // SME logic: Complex files need higher coverage
             if (coverage < threshold) {
@@ -43,16 +43,66 @@ export class CoverageGate extends Gate {
         }
         return failures;
     }
+    async findCoverageReport(context) {
+        const candidates = [
+            'lcov.info',
+            'coverage/lcov.info',
+            'coverage/coverage-final.json',
+            'coverage-final.json',
+            '.nyc_output/coverage-final.json',
+        ];
+        for (const candidate of candidates) {
+            if (await fs.pathExists(path.join(context.cwd, candidate))) {
+                return candidate;
+            }
+        }
+        const reports = await globby(['**/lcov.info', '**/coverage-final.json'], {
+            cwd: context.cwd,
+            gitignore: true,
+            followSymbolicLinks: false,
+            onlyFiles: true,
+            deep: 8,
+            ignore: [...new Set([
+                    ...(context.ignore || []),
+                    '**/node_modules/**',
+                    '**/.git/**',
+                    '**/dist/**',
+                    '**/build/**',
+                    '**/coverage/**',
+                    '**/.next/**',
+                    '**/out/**',
+                    '**/target/**',
+                    '**/vendor/**',
+                    '**/.venv/**',
+                    '**/venv/**',
+                ])],
+        });
+        if (reports.length === 0)
+            return null;
+        reports.sort();
+        return reports[0];
+    }
+    async parseCoverage(reportPath) {
+        if (reportPath.endsWith('.json')) {
+            return this.parseCoverageFinalJson(reportPath);
+        }
+        return this.parseLcov(reportPath);
+    }
     async parseLcov(reportPath) {
-        const content = await fs.readFile(reportPath, 'utf-8');
         const results = {};
         let currentFile = '';
-        for (const line of content.split('\n')) {
+        const rl = readline.createInterface({
+            input: fs.createReadStream(reportPath, { encoding: 'utf-8' }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
             if (line.startsWith('SF:')) {
                 currentFile = line.substring(3);
                 results[currentFile] = { found: 0, hit: 0, isComplex: false };
             }
             else if (line.startsWith('LF:')) {
+                if (!currentFile)
+                    continue;
                 const found = parseInt(line.substring(3));
                 results[currentFile].found = found;
                 // SME Logic: If a file has > 100 logical lines, it's considered "Complex"
@@ -61,9 +111,23 @@ export class CoverageGate extends Gate {
                     results[currentFile].isComplex = true;
             }
             else if (line.startsWith('LH:')) {
+                if (!currentFile)
+                    continue;
                 results[currentFile].hit = parseInt(line.substring(3));
             }
         }
         return results;
     }
+    async parseCoverageFinalJson(reportPath) {
+        const raw = await fs.readJson(reportPath);
+        const results = {};
+        for (const [file, data] of Object.entries(raw || {})) {
+            const statements = data?.s || {};
+            const statementHits = Object.values(statements).map((count) => Number(count) || 0);
+            const found = statementHits.length;
+            const hit = statementHits.filter((count) => count > 0).length;
+            results[file] = { found, hit, isComplex: found > 100 };
+        }
+        return results;
+    }
 }

package/dist/gates/coverage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gates/coverage.test.js

@@ -0,0 +1,53 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { CoverageGate } from './coverage.js';
+describe('CoverageGate', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'coverage-gate-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it('flags low coverage from lcov report', async () => {
+        fs.mkdirSync(path.join(testDir, 'coverage'), { recursive: true });
+        fs.writeFileSync(path.join(testDir, 'coverage', 'lcov.info'), [
+            'TN:',
+            'SF:src/alpha.ts',
+            'LF:10',
+            'LH:3',
+            'end_of_record',
+        ].join('\n'), 'utf-8');
+        const gate = new CoverageGate({});
+        const failures = await gate.run({ cwd: testDir });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].id).toBe('DYNAMIC_COVERAGE_LOW');
+        expect(failures[0].files).toEqual(['src/alpha.ts']);
+    });
+    it('parses coverage-final.json reports', async () => {
+        fs.writeFileSync(path.join(testDir, 'coverage-final.json'), JSON.stringify({
+            'src/beta.ts': {
+                s: { '1': 1, '2': 0, '3': 0, '4': 1 },
+            },
+        }), 'utf-8');
+        const gate = new CoverageGate({});
+        const failures = await gate.run({ cwd: testDir });
+        expect(failures).toHaveLength(0);
+    });
+    it('ignores coverage reports under node_modules', async () => {
+        fs.mkdirSync(path.join(testDir, 'node_modules', 'pkg', 'coverage'), { recursive: true });
+        fs.writeFileSync(path.join(testDir, 'node_modules', 'pkg', 'coverage', 'lcov.info'), ['TN:', 'SF:src/dep.ts', 'LF:10', 'LH:0', 'end_of_record'].join('\n'), 'utf-8');
+        const gate = new CoverageGate({});
+        const failures = await gate.run({ cwd: testDir });
+        expect(failures).toHaveLength(0);
+    });
+    it('respects context.ignore for coverage report discovery', async () => {
+        fs.mkdirSync(path.join(testDir, 'generated', 'reports'), { recursive: true });
+        fs.writeFileSync(path.join(testDir, 'generated', 'reports', 'lcov.info'), ['TN:', 'SF:src/generated.ts', 'LF:10', 'LH:0', 'end_of_record'].join('\n'), 'utf-8');
+        const gate = new CoverageGate({});
+        const failures = await gate.run({ cwd: testDir, ignore: ['generated/**'] });
+        expect(failures).toHaveLength(0);
+    });
+});

package/dist/gates/runner.js

@@ -340,13 +340,17 @@ export class GateRunner {
                 ...(deepStats ? { deep: deepStats } : {}),
             },
         };
-        // Store findings + reinforce patterns in local SQLite (non-blocking)
-        persistAndReinforce(cwd, report, deepStats ? {
-            deepTier: deepStats.tier,
-            deepModel: deepStats.model,
-        } : undefined).catch(() => {
+        // Store findings + reinforce patterns in local SQLite before returning.
+        // CLI commands call process.exit(), so fire-and-forget writes can be dropped.
+        try {
+            await persistAndReinforce(cwd, report, deepStats ? {
+                deepTier: deepStats.tier,
+                deepModel: deepStats.model,
+            } : undefined);
+        }
+        catch {
             // Silent — local memory is advisory, never blocks scans
-        });
+        }
         // v5: Record per-provenance data for adaptive thresholds + temporal drift
         try {
             const passedCount = Object.values(summary).filter(s => s === 'PASS').length;
@@ -355,6 +359,8 @@ export class GateRunner {
                 aiDriftFailures: provenanceCounts['ai-drift'],
                 structuralFailures: provenanceCounts['traditional'],
                 securityFailures: provenanceCounts['security'],
+                governanceFailures: provenanceCounts['governance'],
+                deepAnalysisFailures: provenanceCounts['deep-analysis'],
             };
             recordGateRun(cwd, passedCount, failedCount, failures.length, provenanceData);
         }

package/dist/services/adaptive-thresholds.d.ts

@@ -44,6 +44,8 @@ export interface ProvenanceRunData {
     aiDriftFailures: number;
     structuralFailures: number;
     securityFailures: number;
+    governanceFailures?: number;
+    deepAnalysisFailures?: number;
 }
 export interface ProvenanceTrends {
     aiDrift: QualityTrend;

package/dist/services/adaptive-thresholds.js

@@ -164,9 +164,9 @@ export function getProvenanceTrends(cwd) {
     const recent = withProvenance.slice(-RECENT_WINDOW);
     const baseline = withProvenance.slice(0, -RECENT_WINDOW);
     const computeForField = (field) => {
-        const baselineValues = baseline.map(r => r.provenance[field]);
+        const baselineValues = baseline.map(r => r.provenance[field] ?? 0);
         const { mean, std } = meanAndStd(baselineValues);
-        const recentAvg = recent.reduce((sum, r) => sum + r.provenance[field], 0) / recent.length;
+        const recentAvg = recent.reduce((sum, r) => sum + (r.provenance[field] ?? 0), 0) / recent.length;
         const z = zScore(recentAvg, mean, std);
         return { trend: trendFromZScore(z), z: Math.round(z * 100) / 100 };
     };

package/dist/storage/local-memory.js

@@ -97,18 +97,16 @@ export async function persistAndReinforce(cwd, report, meta) {
         return;
     const repoName = path.basename(cwd);
     try {
-        await db.transaction(async (tx) => {
-            const scanId = await insertScan(tx, repoName, report, meta);
-            if (report.failures.length > 0) {
-                await insertFindings(tx, scanId, report.failures);
-            }
-            for (const f of report.failures) {
-                const category = f.category || f.id;
-                const source = f.source === 'llm' ? 'llm' : 'ast';
-                await reinforcePattern(tx, repoName, category, `${f.title}: ${f.details?.substring(0, 120)}`, source);
-            }
-            await decayPatterns(tx, 30);
-        });
+        const scanId = await insertScan(db, repoName, report, meta);
+        if (report.failures.length > 0) {
+            await insertFindings(db, scanId, report.failures);
+        }
+        for (const f of report.failures) {
+            const category = f.category || f.id;
+            const source = f.source === 'llm' ? 'llm' : 'ast';
+            await reinforcePattern(db, repoName, category, `${f.title}: ${f.details?.substring(0, 120)}`, source);
+        }
+        await decayPatterns(db, 30);
         Logger.info(`Local memory: stored ${report.failures.length} findings, ` +
             `reinforced ${report.failures.length} patterns for ${repoName}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "5.2.1",
+  "version": "5.2.3",
   "description": "Deterministic quality gate engine for AI-generated code. AST analysis, drift detection, and Fix Packet generation across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -59,11 +59,11 @@
     "@xenova/transformers": "^2.17.2",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "5.2.1",
-    "@rigour-labs/brain-darwin-x64": "5.2.1",
-    "@rigour-labs/brain-linux-arm64": "5.2.1",
-    "@rigour-labs/brain-linux-x64": "5.2.1",
-    "@rigour-labs/brain-win-x64": "5.2.1"
+    "@rigour-labs/brain-darwin-arm64": "5.2.3",
+    "@rigour-labs/brain-darwin-x64": "5.2.3",
+    "@rigour-labs/brain-linux-arm64": "5.2.3",
+    "@rigour-labs/brain-win-x64": "5.2.3",
+    "@rigour-labs/brain-linux-x64": "5.2.3"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",