@rigour-labs/core 3.0.2 → 3.0.4

package/dist/gates/phantom-apis.test.d.ts

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

package/dist/gates/phantom-apis.test.js

@@ -0,0 +1,320 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockFindFiles = vi.hoisted(() => vi.fn());
+const mockReadFile = vi.hoisted(() => vi.fn());
+const mockPathExists = vi.hoisted(() => vi.fn());
+vi.mock('../utils/scanner.js', () => ({
+    FileScanner: { findFiles: mockFindFiles },
+}));
+vi.mock('fs-extra', () => ({
+    default: {
+        readFile: mockReadFile,
+        pathExists: mockPathExists,
+        pathExistsSync: vi.fn().mockReturnValue(false),
+        readFileSync: vi.fn().mockReturnValue(''),
+        readJson: vi.fn().mockResolvedValue(null),
+        readdirSync: vi.fn().mockReturnValue([]),
+    },
+}));
+import { PhantomApisGate } from './phantom-apis.js';
+describe('PhantomApisGate — Node.js', () => {
+    let gate;
+    beforeEach(() => {
+        gate = new PhantomApisGate();
+        vi.clearAllMocks();
+    });
+    it('should flag non-existent fs methods', async () => {
+        mockFindFiles.mockResolvedValue(['src/utils.ts']);
+        mockReadFile.mockResolvedValue(`
+import fs from 'fs';
+const data = fs.readFileAsync('test.txt');
+const result = fs.writeFilePromise('out.txt', data);
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('readFileAsync');
+        expect(failures[0].details).toContain('writeFilePromise');
+    });
+    it('should NOT flag real fs methods', async () => {
+        mockFindFiles.mockResolvedValue(['src/utils.ts']);
+        mockReadFile.mockResolvedValue(`
+import fs from 'fs';
+const data = fs.readFileSync('test.txt', 'utf-8');
+fs.writeFileSync('out.txt', data);
+fs.existsSync('/tmp');
+const stream = fs.createReadStream('big.txt');
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(0);
+    });
+    it('should flag non-existent path methods', async () => {
+        mockFindFiles.mockResolvedValue(['src/paths.ts']);
+        mockReadFile.mockResolvedValue(`
+import path from 'path';
+const combined = path.combine('a', 'b');
+const exists = path.exists('/tmp');
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('combine');
+        expect(failures[0].details).toContain('exists');
+    });
+    it('should NOT flag real path methods', async () => {
+        mockFindFiles.mockResolvedValue(['src/paths.ts']);
+        mockReadFile.mockResolvedValue(`
+import path from 'path';
+const p = path.join('a', 'b');
+const ext = path.extname('file.txt');
+const abs = path.resolve('.');
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(0);
+    });
+    it('should flag non-existent crypto methods', async () => {
+        mockFindFiles.mockResolvedValue(['src/crypto.ts']);
+        mockReadFile.mockResolvedValue(`
+import crypto from 'crypto';
+const hash = crypto.generateHash('sha256', 'data');
+const key = crypto.createKey('aes-256');
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('generateHash');
+        expect(failures[0].details).toContain('createKey');
+    });
+    it('should NOT flag real crypto methods', async () => {
+        mockFindFiles.mockResolvedValue(['src/crypto.ts']);
+        mockReadFile.mockResolvedValue(`
+import crypto from 'crypto';
+const hash = crypto.createHash('sha256');
+const uuid = crypto.randomUUID();
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(0);
+    });
+    it('should handle require() imports', async () => {
+        mockFindFiles.mockResolvedValue(['src/legacy.js']);
+        mockReadFile.mockResolvedValue(`
+const fs = require('fs');
+fs.readFileAsync('data.txt');
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('readFileAsync');
+    });
+    it('should handle node: protocol imports', async () => {
+        mockFindFiles.mockResolvedValue(['src/modern.ts']);
+        mockReadFile.mockResolvedValue(`
+import os from 'node:os';
+const info = os.cpuInfo();
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('cpuInfo');
+    });
+    it('should suggest closest real method', async () => {
+        mockFindFiles.mockResolvedValue(['src/typo.ts']);
+        mockReadFile.mockResolvedValue(`
+import fs from 'fs';
+fs.readFileSyn('data.txt');
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('readFileSync');
+    });
+    it('should not scan when disabled', async () => {
+        const disabled = new PhantomApisGate({ enabled: false });
+        const failures = await disabled.run({ cwd: '/project' });
+        expect(failures).toHaveLength(0);
+        expect(mockFindFiles).not.toHaveBeenCalled();
+    });
+});
+describe('PhantomApisGate — Python', () => {
+    let gate;
+    beforeEach(() => {
+        gate = new PhantomApisGate();
+        vi.clearAllMocks();
+    });
+    it('should flag non-existent os methods', async () => {
+        mockFindFiles.mockResolvedValue(['utils.py']);
+        mockReadFile.mockResolvedValue(`
+import os
+current = os.getCurrentDirectory()
+files = os.listFiles('.')
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('getCurrentDirectory');
+        expect(failures[0].details).toContain('listFiles');
+    });
+    it('should NOT flag real os methods', async () => {
+        mockFindFiles.mockResolvedValue(['utils.py']);
+        mockReadFile.mockResolvedValue(`
+import os
+current = os.getcwd()
+files = os.listdir('.')
+exists = os.path
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(0);
+    });
+    it('should flag non-existent json methods', async () => {
+        mockFindFiles.mockResolvedValue(['parser.py']);
+        mockReadFile.mockResolvedValue(`
+import json
+data = json.parse('{"key": "value"}')
+result = json.stringify(data)
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('parse');
+        expect(failures[0].details).toContain('stringify');
+    });
+    it('should NOT flag real json methods', async () => {
+        mockFindFiles.mockResolvedValue(['parser.py']);
+        mockReadFile.mockResolvedValue(`
+import json
+data = json.loads('{"key": "value"}')
+output = json.dumps(data)
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(0);
+    });
+    it('should handle aliased imports', async () => {
+        mockFindFiles.mockResolvedValue(['utils.py']);
+        mockReadFile.mockResolvedValue(`
+import os as operating_system
+result = operating_system.getCurrentDirectory()
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('getCurrentDirectory');
+    });
+    it('should flag non-existent subprocess methods', async () => {
+        mockFindFiles.mockResolvedValue(['runner.py']);
+        mockReadFile.mockResolvedValue(`
+import subprocess
+result = subprocess.execute(['ls', '-la'])
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('execute');
+    });
+});
+describe('PhantomApisGate — Go', () => {
+    let gate;
+    beforeEach(() => {
+        gate = new PhantomApisGate();
+        vi.clearAllMocks();
+    });
+    it('should flag Python-style Go method names', async () => {
+        mockFindFiles.mockResolvedValue(['main.go']);
+        mockReadFile.mockResolvedValue(`
+package main
+import "strings"
+func main() {
+    result := strings.includes("hello", "ell")
+}
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('includes');
+        expect(failures[0].details).toContain('strings.Contains');
+    });
+    it('should flag JS-style JSON methods in Go', async () => {
+        mockFindFiles.mockResolvedValue(['parser.go']);
+        mockReadFile.mockResolvedValue(`
+package main
+import "encoding/json"
+func parse() {
+    data := json.parse(raw)
+    out := json.stringify(data)
+}
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('parse');
+    });
+    it('should flag os.Exists in Go', async () => {
+        mockFindFiles.mockResolvedValue(['files.go']);
+        mockReadFile.mockResolvedValue(`
+package main
+import "os"
+func check() {
+    exists := os.Exists("/tmp/file")
+}
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures).toHaveLength(1);
+        expect(failures[0].details).toContain('Exists');
+    });
+});
+describe('PhantomApisGate — C#', () => {
+    let gate;
+    beforeEach(() => {
+        gate = new PhantomApisGate();
+        vi.clearAllMocks();
+    });
+    it('should flag Java-style method casing in C#', async () => {
+        mockFindFiles.mockResolvedValue(['Program.cs']);
+        mockReadFile.mockResolvedValue(`
+using System;
+class Program {
+    void Main() {
+        string s = "hello";
+        int len = s.length;
+        bool eq = s.equals("world");
+        string str = s.toString();
+    }
+}
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures.length).toBeGreaterThanOrEqual(1);
+        expect(failures[0].details).toMatch(/length|equals|toString/);
+    });
+    it('should flag Java collections in C#', async () => {
+        mockFindFiles.mockResolvedValue(['Service.cs']);
+        mockReadFile.mockResolvedValue(`
+using System.Collections.Generic;
+List<string> items = new ArrayList<string>();
+HashMap<string, int> map = new HashMap<string, int>();
+System.out.println("hello");
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures.length).toBeGreaterThanOrEqual(1);
+    });
+});
+describe('PhantomApisGate — Java', () => {
+    let gate;
+    beforeEach(() => {
+        gate = new PhantomApisGate();
+        vi.clearAllMocks();
+    });
+    it('should flag JS/Python-style method names in Java', async () => {
+        mockFindFiles.mockResolvedValue(['Main.java']);
+        mockReadFile.mockResolvedValue(`
+import java.util.List;
+class Main {
+    void test() {
+        List<String> items = new ArrayList<>();
+        items.push("hello");
+        items.includes("test");
+    }
+}
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures.length).toBeGreaterThanOrEqual(1);
+        expect(failures[0].details).toMatch(/push|includes/);
+    });
+    it('should flag new List() in Java', async () => {
+        mockFindFiles.mockResolvedValue(['Service.java']);
+        mockReadFile.mockResolvedValue(`
+import java.util.*;
+class Service {
+    List<String> items = new List<String>();
+    Map<String, Integer> map = new Map<String, Integer>();
+}
+        `);
+        const failures = await gate.run({ cwd: '/project' });
+        expect(failures.length).toBeGreaterThanOrEqual(1);
+    });
+});

package/dist/gates/runner.js

@@ -18,6 +18,9 @@ import { HallucinatedImportsGate } from './hallucinated-imports.js';
 import { InconsistentErrorHandlingGate } from './inconsistent-error-handling.js';
 import { ContextWindowArtifactsGate } from './context-window-artifacts.js';
 import { PromiseSafetyGate } from './promise-safety.js';
+import { PhantomApisGate } from './phantom-apis.js';
+import { DeprecatedApisGate } from './deprecated-apis.js';
+import { TestQualityGate } from './test-quality.js';
 import { execa } from 'execa';
 import { Logger } from '../utils/logger.js';
 export class GateRunner {
@@ -78,6 +81,16 @@ export class GateRunner {
         if (this.config.gates.promise_safety?.enabled !== false) {
             this.gates.push(new PromiseSafetyGate(this.config.gates.promise_safety));
         }
+        // v3.1+ Extended Hallucination Detection
+        if (this.config.gates.phantom_apis?.enabled !== false) {
+            this.gates.push(new PhantomApisGate(this.config.gates.phantom_apis));
+        }
+        if (this.config.gates.deprecated_apis?.enabled !== false) {
+            this.gates.push(new DeprecatedApisGate(this.config.gates.deprecated_apis));
+        }
+        if (this.config.gates.test_quality?.enabled !== false) {
+            this.gates.push(new TestQualityGate(this.config.gates.test_quality));
+        }
         // Environment Alignment Gate (Should be prioritized)
         if (this.config.gates.environment?.enabled) {
             this.gates.unshift(new EnvironmentGate(this.config.gates));
@@ -162,20 +175,34 @@ export class GateRunner {
         }
         const score = Math.max(0, 100 - totalDeduction);
         // Two-score system: separate AI health from structural quality
+        // IMPORTANT: Only ai-drift affects ai_health_score, only traditional affects structural_score.
+        // Security and governance affect the overall score but NOT the sub-scores,
+        // preventing security criticals from incorrectly zeroing structural_score.
         let aiDeduction = 0;
-        let aiCount = 0;
         let structuralDeduction = 0;
-        let structuralCount = 0;
+        const provenanceCounts = {
+            'ai-drift': 0,
+            'traditional': 0,
+            'security': 0,
+            'governance': 0,
+        };
         for (const f of failures) {
             const sev = (f.severity || 'medium');
             const weight = SEVERITY_WEIGHTS[sev] ?? 5;
-            if (f.provenance === 'ai-drift') {
-                aiDeduction += weight;
-                aiCount++;
-            }
-            else {
-                structuralDeduction += weight;
-                structuralCount++;
+            const prov = f.provenance || 'traditional';
+            provenanceCounts[prov] = (provenanceCounts[prov] || 0) + 1;
+            switch (prov) {
+                case 'ai-drift':
+                    aiDeduction += weight;
+                    break;
+                case 'traditional':
+                    structuralDeduction += weight;
+                    break;
+                // security and governance contribute to overall score (totalDeduction)
+                // but do NOT pollute the sub-scores
+                case 'security':
+                case 'governance':
+                    break;
             }
         }
         return {
@@ -188,12 +215,7 @@ export class GateRunner {
                 ai_health_score: Math.max(0, 100 - aiDeduction),
                 structural_score: Math.max(0, 100 - structuralDeduction),
                 severity_breakdown: severityBreakdown,
-                provenance_breakdown: {
-                    'ai-drift': aiCount,
-                    traditional: structuralCount - failures.filter(f => f.provenance === 'security' || f.provenance === 'governance').length,
-                    security: failures.filter(f => f.provenance === 'security').length,
-                    governance: failures.filter(f => f.provenance === 'governance').length,
-                },
+                provenance_breakdown: provenanceCounts,
             },
         };
     }

package/dist/gates/test-quality.d.ts

@@ -0,0 +1,67 @@
+/**
+ * AI Test Quality Gate
+ *
+ * Detects AI-generated test anti-patterns that create false confidence.
+ * AI models generate tests that look comprehensive but actually test
+ * the AI's own assumptions rather than the developer's intent.
+ *
+ * Detected anti-patterns:
+ *   1. Empty test bodies — tests with no assertions
+ *   2. Tautological assertions — expect(true).toBe(true), assert True
+ *   3. Mock-everything — tests that mock every dependency (test nothing real)
+ *   4. Missing error path tests — only happy path tested
+ *   5. Shallow snapshot abuse — snapshot tests with no semantic assertions
+ *   6. Assertion-free async — async tests that never await/assert
+ *
+ * Supported test frameworks:
+ *   JS/TS  — Jest, Vitest, Mocha, Jasmine, Node test runner
+ *   Python — pytest, unittest
+ *   Go     — testing package (t.Run, table-driven tests)
+ *   Java   — JUnit 4/5, TestNG
+ *   Kotlin — JUnit 5, kotlin.test
+ *
+ * @since v3.0.0
+ * @since v3.0.3 — Go, Java, Kotlin support added
+ */
+import { Gate, GateContext } from './base.js';
+import { Failure, Provenance } from '../types/index.js';
+export interface TestQualityIssue {
+    file: string;
+    line: number;
+    pattern: string;
+    reason: string;
+}
+export interface TestQualityConfig {
+    enabled?: boolean;
+    check_empty_tests?: boolean;
+    check_tautological?: boolean;
+    check_mock_heavy?: boolean;
+    check_snapshot_abuse?: boolean;
+    check_assertion_free_async?: boolean;
+    max_mocks_per_test?: number;
+    ignore_patterns?: string[];
+}
+export declare class TestQualityGate extends Gate {
+    private config;
+    constructor(config?: TestQualityConfig);
+    protected get provenance(): Provenance;
+    run(context: GateContext): Promise<Failure[]>;
+    private checkJSTestQuality;
+    private analyzeJSTestBlock;
+    private checkPythonTestQuality;
+    private analyzePythonTestBlock;
+    /**
+     * Go test quality checks.
+     * Go tests use func TestXxx(t *testing.T) pattern.
+     * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
+     * Also checks for t.Run subtests and table-driven patterns.
+     */
+    private checkGoTestQuality;
+    /**
+     * Java/Kotlin test quality checks.
+     * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
+     * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
+     * Kotlin: @Test + kotlin.test assertEquals, etc.
+     */
+    private checkJavaKotlinTestQuality;
+}