@rigour-labs/core 4.0.0 → 4.0.1

package/dist/deep/fact-extractor.test.d.ts

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

package/dist/deep/fact-extractor.test.js

@@ -0,0 +1,547 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// We test the internal extractFileFacts by importing extractFacts and factsToPromptString
+// But we need to test extraction logic directly, so we also test via the public API
+const mockGlobby = vi.hoisted(() => vi.fn());
+const mockReadFile = vi.hoisted(() => vi.fn());
+vi.mock('globby', () => ({
+    globby: mockGlobby,
+}));
+vi.mock('fs-extra', () => ({
+    default: {
+        readFile: mockReadFile,
+    },
+}));
+import { extractFacts, factsToPromptString } from './fact-extractor.js';
+describe('Fact Extractor', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    // ── TypeScript extraction ──
+    describe('TypeScript/JavaScript extraction', () => {
+        it('should extract classes with methods and dependencies', async () => {
+            mockGlobby.mockResolvedValue(['src/service.ts']);
+            mockReadFile.mockResolvedValue(`
+import { Logger } from './logger';
+
+export class UserService {
+    constructor(
+        private db: Database,
+        private logger: Logger
+    ) {}
+
+    async findById(id: string): Promise<User> {
+        return this.db.find(id);
+    }
+
+    async create(data: CreateUserDto): Promise<User> {
+        this.logger.info('Creating user');
+        return this.db.create(data);
+    }
+
+    async update(id: string, data: UpdateUserDto): Promise<User> {
+        return this.db.update(id, data);
+    }
+
+    async delete(id: string): Promise<void> {
+        return this.db.delete(id);
+    }
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts).toHaveLength(1);
+            expect(facts[0].language).toBe('typescript');
+            expect(facts[0].classes).toHaveLength(1);
+            expect(facts[0].classes[0].name).toBe('UserService');
+            expect(facts[0].classes[0].methodCount).toBeGreaterThanOrEqual(4);
+            expect(facts[0].classes[0].dependencies).toContain('Database');
+            expect(facts[0].classes[0].dependencies).toContain('Logger');
+        });
+        it('should extract functions with params and async detection', async () => {
+            mockGlobby.mockResolvedValue(['src/utils.ts']);
+            mockReadFile.mockResolvedValue(`
+export async function processData(input: string, config: Config, options: Options): Promise<Result> {
+    if (input.length > 0) {
+        if (config.validate) {
+            if (options.strict) {
+                return validate(input);
+            }
+        }
+    }
+    return { data: input };
+}
+
+export function simpleHelper(x: number): number {
+    return x * 2;
+}
+`);
+            const facts = await extractFacts('/project');
+            const funcs = facts[0].functions;
+            expect(funcs.length).toBeGreaterThanOrEqual(1);
+            const processData = funcs.find(f => f.name === 'processData');
+            expect(processData).toBeDefined();
+            expect(processData.isAsync).toBe(true);
+            expect(processData.isExported).toBe(true);
+            expect(processData.paramCount).toBe(3);
+            expect(processData.maxNesting).toBeGreaterThanOrEqual(3);
+        });
+        it('should extract imports from ES modules and require', async () => {
+            mockGlobby.mockResolvedValue(['src/index.ts']);
+            mockReadFile.mockResolvedValue(`
+import { Router } from 'express';
+import path from 'path';
+const fs = require('fs-extra');
+import type { Config } from './types';
+
+export function init() {
+    const router = Router();
+    return router;
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].imports).toContain('express');
+            expect(facts[0].imports).toContain('path');
+            expect(facts[0].imports).toContain('fs-extra');
+            expect(facts[0].imports).toContain('./types');
+        });
+        it('should extract error handling patterns', async () => {
+            mockGlobby.mockResolvedValue(['src/api.ts']);
+            mockReadFile.mockResolvedValue(`
+async function fetchData() {
+    try {
+        const res = await fetch('/api');
+        return res.json();
+    } catch (err) {
+        console.error(err);
+        throw err;
+    }
+}
+
+async function riskyOp() {
+    try {
+        await doSomething();
+    } catch (err) {
+    }
+}
+
+fetchData().then(data => {
+    process(data);
+}).catch(() => {});
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].errorHandling.length).toBeGreaterThanOrEqual(2);
+            const tryCatches = facts[0].errorHandling.filter(e => e.type === 'try-catch');
+            expect(tryCatches.length).toBeGreaterThanOrEqual(2);
+            // Strategy detection finds console.error first → 'log'
+            const strategies = tryCatches.map(e => e.strategy);
+            expect(strategies.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should detect test files and count assertions', async () => {
+            mockGlobby.mockResolvedValue(['src/utils.test.ts']);
+            mockReadFile.mockResolvedValue(`
+import { describe, it, expect } from 'vitest';
+
+describe('Utils', () => {
+    it('should add numbers', () => {
+        expect(add(1, 2)).toBe(3);
+        expect(add(0, 0)).toBe(0);
+    });
+
+    it('should handle negatives', () => {
+        expect(add(-1, 1)).toBe(0);
+    });
+});
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].hasTests).toBe(true);
+            expect(facts[0].testAssertions).toBeGreaterThanOrEqual(3);
+        });
+        it('should extract exports', async () => {
+            mockGlobby.mockResolvedValue(['src/types.ts']);
+            mockReadFile.mockResolvedValue(`
+export interface User {
+    id: string;
+    name: string;
+}
+
+export const DEFAULT_CONFIG = {};
+
+export function createUser(): User {
+    return { id: '1', name: 'test' };
+}
+
+export type Severity = 'high' | 'low';
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].exports).toContain('User');
+            expect(facts[0].exports).toContain('DEFAULT_CONFIG');
+            expect(facts[0].exports).toContain('createUser');
+            expect(facts[0].exports).toContain('Severity');
+        });
+    });
+    // ── Python extraction ──
+    describe('Python extraction', () => {
+        it('should extract Python classes', async () => {
+            mockGlobby.mockResolvedValue(['app/service.py']);
+            mockReadFile.mockResolvedValue(`
+class UserService:
+    def __init__(self, db):
+        self.db = db
+
+    def find_by_id(self, user_id):
+        return self.db.find(user_id)
+
+    def create(self, data):
+        return self.db.create(data)
+
+    def _validate(self, data):
+        pass
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].language).toBe('python');
+            expect(facts[0].classes).toHaveLength(1);
+            expect(facts[0].classes[0].name).toBe('UserService');
+            expect(facts[0].classes[0].methodCount).toBeGreaterThanOrEqual(3);
+        });
+        it('should extract Python imports', async () => {
+            mockGlobby.mockResolvedValue(['app/main.py']);
+            mockReadFile.mockResolvedValue(`
+import os
+from pathlib import Path
+import json
+from typing import Optional
+from app.service import UserService
+
+def main():
+    svc = UserService()
+    return svc
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].imports).toContain('os');
+            expect(facts[0].imports).toContain('pathlib');
+            expect(facts[0].imports).toContain('app.service');
+        });
+    });
+    // ── Go extraction ──
+    describe('Go extraction', () => {
+        it('should extract Go structs with fields and methods', async () => {
+            mockGlobby.mockResolvedValue(['pkg/server.go']);
+            mockReadFile.mockResolvedValue(`package server
+
+import (
+    "net/http"
+    "sync"
+)
+
+type Server struct {
+    addr    string
+    port    int
+    handler http.Handler
+    mu      sync.Mutex
+    *Base
+}
+
+func NewServer(addr string, port int) *Server {
+    return &Server{addr: addr, port: port}
+}
+
+func (s *Server) Start() error {
+    s.mu.Lock()
+    defer s.mu.Unlock()
+    return http.ListenAndServe(s.addr, s.handler)
+}
+
+func (s *Server) Stop() error {
+    return nil
+}
+
+func (s *Server) Handler() http.Handler {
+    return s.handler
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].language).toBe('go');
+            expect(facts[0].structs).toBeDefined();
+            expect(facts[0].structs.length).toBeGreaterThanOrEqual(1);
+            const server = facts[0].structs[0];
+            expect(server.name).toBe('Server');
+            expect(server.fieldCount).toBeGreaterThanOrEqual(4); // addr, port, handler, mu, Base
+            expect(server.methodCount).toBeGreaterThanOrEqual(3); // Start, Stop, Handler
+            expect(server.methods).toContain('Start');
+            expect(server.methods).toContain('Stop');
+            expect(server.embeds).toContain('Base');
+        });
+        it('should extract Go interfaces', async () => {
+            mockGlobby.mockResolvedValue(['pkg/store.go']);
+            mockReadFile.mockResolvedValue(`package store
+
+type Store interface {
+    Get(key string) (string, error)
+    Set(key string, value string) error
+    Delete(key string) error
+    List(prefix string) ([]string, error)
+    Close() error
+    Watch(key string) <-chan Event
+}
+
+type SimpleStore struct {
+    data map[string]string
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].interfaces).toBeDefined();
+            expect(facts[0].interfaces.length).toBeGreaterThanOrEqual(1);
+            const store = facts[0].interfaces[0];
+            expect(store.name).toBe('Store');
+            expect(store.methodCount).toBe(6);
+            expect(store.methods).toContain('Get');
+            expect(store.methods).toContain('Close');
+        });
+        it('should extract Go functions with receiver methods', async () => {
+            mockGlobby.mockResolvedValue(['pkg/handler.go']);
+            mockReadFile.mockResolvedValue(`package handler
+
+type Handler struct {
+    service Service
+}
+
+func NewHandler(svc Service) *Handler {
+    return &Handler{service: svc}
+}
+
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+    if r.Method == "GET" {
+        h.handleGet(w, r)
+    } else {
+        h.handlePost(w, r)
+    }
+}
+
+func (h *Handler) handleGet(w http.ResponseWriter, r *http.Request) {
+    data, err := h.service.Find(r.URL.Query().Get("id"))
+    if err != nil {
+        http.Error(w, err.Error(), 500)
+        return
+    }
+    json.NewEncoder(w).Encode(data)
+}
+`);
+            const facts = await extractFacts('/project');
+            const funcs = facts[0].functions;
+            // Should have receiver methods named as Receiver.Method
+            const serveHTTP = funcs.find(f => f.name === 'Handler.ServeHTTP');
+            expect(serveHTTP).toBeDefined();
+            const handleGet = funcs.find(f => f.name === 'Handler.handleGet');
+            expect(handleGet).toBeDefined();
+            // NewHandler should be a standalone func (no receiver)
+            const newHandler = funcs.find(f => f.name === 'NewHandler');
+            expect(newHandler).toBeDefined();
+            expect(newHandler.isExported).toBe(true);
+        });
+        it('should count concurrency metrics', async () => {
+            mockGlobby.mockResolvedValue(['pkg/worker.go']);
+            mockReadFile.mockResolvedValue(`package worker
+
+import "sync"
+
+func StartWorkers(n int) {
+    var mu sync.Mutex
+    var wg sync.WaitGroup
+    ch := make(chan int, 10)
+
+    for i := 0; i < n; i++ {
+        wg.Add(1)
+        go processItem(ch, &mu, &wg)
+    }
+
+    go monitorWorkers(ch)
+
+    defer close(ch)
+}
+
+func processItem(ch chan int, mu *sync.Mutex, wg *sync.WaitGroup) {
+    defer wg.Done()
+    for item := range ch {
+        mu.Lock()
+        process(item)
+        mu.Unlock()
+    }
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].goroutines).toBeGreaterThanOrEqual(2);
+            expect(facts[0].channels).toBeGreaterThanOrEqual(1);
+            expect(facts[0].defers).toBeGreaterThanOrEqual(2);
+            expect(facts[0].mutexes).toBeGreaterThanOrEqual(2);
+        });
+    });
+    // ── Quality metrics ──
+    describe('Quality metrics', () => {
+        it('should detect magic numbers', async () => {
+            mockGlobby.mockResolvedValue(['src/calc.ts']);
+            mockReadFile.mockResolvedValue(`
+export function calculate(input: number): number {
+    const base = input * 42;
+    const tax = base * 17;
+    const fee = 325 + 1250;
+    const limit = 9999;
+    return base + tax + fee + limit;
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].magicNumbers).toBeGreaterThanOrEqual(3);
+        });
+        it('should count TODOs', async () => {
+            mockGlobby.mockResolvedValue(['src/app.ts']);
+            mockReadFile.mockResolvedValue(`
+// TODO: implement caching
+export function getData() {
+    // FIXME: this is slow
+    const data = fetch('/api');
+    // HACK: workaround for bug
+    return data;
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].todoCount).toBe(4); // TODO, FIXME, HACK, WORKAROUND
+        });
+        it('should calculate comment ratio', async () => {
+            mockGlobby.mockResolvedValue(['src/app.ts']);
+            mockReadFile.mockResolvedValue(`
+// This is a comment
+// Another comment
+export function foo() {
+    return 1;
+}
+
+function bar() {
+    return 2;
+}
+`);
+            const facts = await extractFacts('/project');
+            expect(facts[0].commentRatio).toBeGreaterThan(0);
+        });
+        it('should skip trivial files (< 3 lines)', async () => {
+            mockGlobby.mockResolvedValue(['src/empty.ts']);
+            mockReadFile.mockResolvedValue(`// empty\n`);
+            const facts = await extractFacts('/project');
+            expect(facts).toHaveLength(0);
+        });
+    });
+    // ── factsToPromptString ──
+    describe('factsToPromptString', () => {
+        it('should serialize file facts to a prompt string', () => {
+            const facts = [
+                {
+                    path: 'src/service.ts',
+                    language: 'typescript',
+                    lineCount: 150,
+                    classes: [{
+                            name: 'UserService',
+                            lineStart: 5,
+                            lineEnd: 140,
+                            methodCount: 8,
+                            methods: ['find', 'create', 'update', 'delete', 'validate', 'transform', 'cache', 'notify'],
+                            publicMethods: ['find', 'create', 'update', 'delete'],
+                            lineCount: 135,
+                            dependencies: ['Database', 'Logger'],
+                        }],
+                    functions: [],
+                    imports: ['express', './types', 'lodash'],
+                    exports: ['UserService'],
+                    errorHandling: [
+                        { type: 'try-catch', lineStart: 10, isEmpty: false, strategy: 'throw' },
+                        { type: 'try-catch', lineStart: 30, isEmpty: true, strategy: 'ignore' },
+                    ],
+                    testAssertions: 0,
+                    hasTests: false,
+                },
+            ];
+            const result = factsToPromptString(facts);
+            expect(result).toContain('FILE: src/service.ts');
+            expect(result).toContain('CLASS UserService');
+            expect(result).toContain('135 lines');
+            expect(result).toContain('8 methods');
+            expect(result).toContain('deps: Database, Logger');
+            expect(result).toContain('ERROR_HANDLING');
+            expect(result).toContain('1 empty catches');
+            expect(result).toContain('IMPORTS: 3');
+        });
+        it('should include Go structs and concurrency info', () => {
+            const facts = [
+                {
+                    path: 'pkg/worker.go',
+                    language: 'go',
+                    lineCount: 200,
+                    classes: [],
+                    functions: [{
+                            name: 'StartWorkers',
+                            lineStart: 10,
+                            lineEnd: 60,
+                            lineCount: 50,
+                            paramCount: 2,
+                            params: ['n int', 'config Config'],
+                            maxNesting: 3,
+                            hasReturn: true,
+                            isAsync: true,
+                            isExported: true,
+                        }],
+                    imports: ['sync', 'context'],
+                    exports: [],
+                    errorHandling: [],
+                    testAssertions: 0,
+                    hasTests: false,
+                    structs: [{
+                            name: 'Worker',
+                            lineStart: 5,
+                            lineEnd: 15,
+                            fieldCount: 4,
+                            methodCount: 3,
+                            methods: ['Start', 'Stop', 'Process'],
+                            lineCount: 10,
+                            embeds: [],
+                        }],
+                    goroutines: 5,
+                    channels: 2,
+                    defers: 3,
+                    mutexes: 1,
+                },
+            ];
+            const result = factsToPromptString(facts);
+            expect(result).toContain('STRUCT Worker');
+            expect(result).toContain('4 fields');
+            expect(result).toContain('3 methods');
+            expect(result).toContain('CONCURRENCY');
+            expect(result).toContain('goroutines:5');
+            expect(result).toContain('channels:2');
+            expect(result).toContain('defers:3');
+            expect(result).toContain('mutexes:1');
+        });
+        it('should respect maxChars budget', () => {
+            const manyFacts = Array.from({ length: 100 }, (_, i) => ({
+                path: `src/file${i}.ts`,
+                language: 'typescript',
+                lineCount: 100,
+                classes: [],
+                functions: [{
+                        name: `func${i}`,
+                        lineStart: 1,
+                        lineEnd: 50,
+                        lineCount: 50,
+                        paramCount: 2,
+                        params: ['a', 'b'],
+                        maxNesting: 2,
+                        hasReturn: true,
+                        isAsync: false,
+                        isExported: true,
+                    }],
+                imports: ['express', 'lodash', 'react'],
+                exports: [`func${i}`],
+                errorHandling: [],
+                testAssertions: 0,
+                hasTests: false,
+            }));
+            const result = factsToPromptString(manyFacts, 500);
+            expect(result.length).toBeLessThanOrEqual(600); // Allow some slack
+        });
+    });
+});

package/dist/deep/prompts.test.d.ts

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

package/dist/deep/prompts.test.js

@@ -0,0 +1,220 @@
+import { describe, it, expect } from 'vitest';
+import { buildAnalysisPrompt, buildCrossFilePrompt, chunkFacts, DEEP_SYSTEM_PROMPT } from './prompts.js';
+// ── Test helpers ──
+function makeGoFacts(overrides = {}) {
+    return {
+        path: 'pkg/server.go',
+        language: 'go',
+        lineCount: 200,
+        classes: [],
+        functions: [{
+                name: 'Server.Start',
+                lineStart: 10,
+                lineEnd: 50,
+                lineCount: 40,
+                paramCount: 1,
+                params: ['ctx context.Context'],
+                maxNesting: 3,
+                hasReturn: true,
+                isAsync: false,
+                isExported: true,
+            }],
+        imports: ['net/http', 'context', 'sync'],
+        exports: [],
+        errorHandling: [],
+        testAssertions: 0,
+        hasTests: false,
+        structs: [{
+                name: 'Server',
+                lineStart: 5,
+                lineEnd: 15,
+                fieldCount: 5,
+                methodCount: 4,
+                methods: ['Start', 'Stop', 'Handle', 'Route'],
+                lineCount: 10,
+                embeds: ['BaseServer'],
+            }],
+        interfaces: [{
+                name: 'Handler',
+                lineStart: 20,
+                methodCount: 2,
+                methods: ['ServeHTTP', 'Health'],
+            }],
+        goroutines: 3,
+        channels: 1,
+        mutexes: 1,
+        defers: 2,
+        ...overrides,
+    };
+}
+function makeTsFacts(overrides = {}) {
+    return {
+        path: 'src/service.ts',
+        language: 'typescript',
+        lineCount: 150,
+        classes: [{
+                name: 'UserService',
+                lineStart: 5,
+                lineEnd: 140,
+                methodCount: 6,
+                methods: ['find', 'create', 'update', 'delete', 'validate', 'notify'],
+                publicMethods: ['find', 'create', 'update', 'delete'],
+                lineCount: 135,
+                dependencies: ['Database', 'Logger'],
+            }],
+        functions: [],
+        imports: ['express', 'lodash', './types'],
+        exports: ['UserService'],
+        errorHandling: [
+            { type: 'try-catch', lineStart: 10, isEmpty: false, strategy: 'throw' },
+        ],
+        testAssertions: 0,
+        hasTests: false,
+        ...overrides,
+    };
+}
+describe('Deep Analysis Prompts', () => {
+    // ── DEEP_SYSTEM_PROMPT ──
+    describe('DEEP_SYSTEM_PROMPT', () => {
+        it('should contain all category groups', () => {
+            expect(DEEP_SYSTEM_PROMPT).toContain('SOLID Principles');
+            expect(DEEP_SYSTEM_PROMPT).toContain('Design Patterns');
+            expect(DEEP_SYSTEM_PROMPT).toContain('DRY');
+            expect(DEEP_SYSTEM_PROMPT).toContain('Error Handling');
+            expect(DEEP_SYSTEM_PROMPT).toContain('Concurrency');
+            expect(DEEP_SYSTEM_PROMPT).toContain('Testing');
+        });
+        it('should contain key category IDs', () => {
+            expect(DEEP_SYSTEM_PROMPT).toContain('god_class');
+            expect(DEEP_SYSTEM_PROMPT).toContain('god_function');
+            expect(DEEP_SYSTEM_PROMPT).toContain('srp_violation');
+            expect(DEEP_SYSTEM_PROMPT).toContain('race_condition');
+            expect(DEEP_SYSTEM_PROMPT).toContain('empty_catch');
+            expect(DEEP_SYSTEM_PROMPT).toContain('missing_test');
+        });
+        it('should include output schema', () => {
+            expect(DEEP_SYSTEM_PROMPT).toContain('"findings"');
+            expect(DEEP_SYSTEM_PROMPT).toContain('"category"');
+            expect(DEEP_SYSTEM_PROMPT).toContain('"severity"');
+            expect(DEEP_SYSTEM_PROMPT).toContain('"confidence"');
+        });
+        it('should contain Go-specific guidance', () => {
+            expect(DEEP_SYSTEM_PROMPT).toContain('Go code');
+            expect(DEEP_SYSTEM_PROMPT).toContain('struct');
+            expect(DEEP_SYSTEM_PROMPT).toContain('receiver method');
+        });
+    });
+    // ── buildAnalysisPrompt ──
+    describe('buildAnalysisPrompt', () => {
+        it('should build prompt with default checks', () => {
+            const factsStr = 'FILE: src/service.ts (typescript, 150 lines)';
+            const prompt = buildAnalysisPrompt(factsStr);
+            // Default checks include descriptions for SOLID, DRY, design patterns
+            expect(prompt).toContain('SOLID');
+            expect(prompt).toContain('DRY');
+            expect(prompt).toContain('god class');
+            expect(prompt).toContain(factsStr);
+        });
+        it('should include language-specific guidance for Go', () => {
+            const factsStr = 'FILE: pkg/server.go (go, 200 lines)\n  STRUCT Server (10 lines, 5 fields)';
+            const prompt = buildAnalysisPrompt(factsStr);
+            // Should detect Go as dominant language and add Go guidance
+            expect(prompt.toLowerCase()).toContain('go');
+        });
+        it('should include language-specific guidance for TypeScript', () => {
+            const factsStr = 'FILE: src/service.ts (typescript, 150 lines)\n  CLASS UserService';
+            const prompt = buildAnalysisPrompt(factsStr);
+            expect(prompt.toLowerCase()).toContain('typescript');
+        });
+        it('should respect custom check selection', () => {
+            const factsStr = 'FILE: src/service.ts (typescript, 150 lines)';
+            const checks = {
+                solid: true,
+                dry: false,
+                design_patterns: false,
+                concurrency: true,
+            };
+            const prompt = buildAnalysisPrompt(factsStr, checks);
+            expect(prompt).toContain('SOLID');
+            expect(prompt).toContain('Concurrency');
+        });
+    });
+    // ── buildCrossFilePrompt ──
+    describe('buildCrossFilePrompt', () => {
+        it('should analyze patterns across multiple files', () => {
+            const allFacts = [
+                makeTsFacts({ path: 'src/user.service.ts' }),
+                makeTsFacts({
+                    path: 'src/order.service.ts',
+                    classes: [{
+                            name: 'OrderService',
+                            lineStart: 1,
+                            lineEnd: 100,
+                            methodCount: 5,
+                            methods: ['find', 'create', 'update', 'delete', 'process'],
+                            publicMethods: ['find', 'create'],
+                            lineCount: 100,
+                            dependencies: ['Database', 'Logger'],
+                        }],
+                }),
+                makeTsFacts({
+                    path: 'src/product.service.ts',
+                    errorHandling: [
+                        { type: 'try-catch', lineStart: 5, isEmpty: false, strategy: 'log' },
+                        { type: 'try-catch', lineStart: 15, isEmpty: false, strategy: 'throw' },
+                    ],
+                }),
+            ];
+            const prompt = buildCrossFilePrompt(allFacts);
+            expect(prompt).toBeDefined();
+            expect(prompt.length).toBeGreaterThan(0);
+            // Should reference file count
+            expect(prompt).toContain('3');
+        });
+        it('should include Go-specific cross-file info', () => {
+            const allFacts = [
+                makeGoFacts({ path: 'pkg/server.go' }),
+                makeGoFacts({
+                    path: 'pkg/handler.go',
+                    structs: [{
+                            name: 'Handler',
+                            lineStart: 1,
+                            lineEnd: 50,
+                            fieldCount: 3,
+                            methodCount: 5,
+                            methods: ['Get', 'Post', 'Put', 'Delete', 'Options'],
+                            lineCount: 50,
+                            embeds: [],
+                        }],
+                }),
+            ];
+            const prompt = buildCrossFilePrompt(allFacts);
+            expect(prompt).toBeDefined();
+            expect(prompt.length).toBeGreaterThan(0);
+        });
+    });
+    // ── chunkFacts ──
+    describe('chunkFacts', () => {
+        it('should split facts into token-limited chunks', () => {
+            const manyFacts = Array.from({ length: 50 }, (_, i) => makeTsFacts({
+                path: `src/file${i}.ts`,
+                lineCount: 200,
+            }));
+            const chunks = chunkFacts(manyFacts, 4000);
+            expect(chunks.length).toBeGreaterThan(1);
+            // All facts should be distributed across chunks
+            const totalFiles = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+            expect(totalFiles).toBe(50);
+        });
+        it('should handle single file within budget', () => {
+            const facts = [makeTsFacts()];
+            const chunks = chunkFacts(facts, 10000);
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0]).toHaveLength(1);
+        });
+        it('should handle empty input', () => {
+            const chunks = chunkFacts([], 4000);
+            expect(chunks).toHaveLength(0);
+        });
+    });
+});

package/dist/deep/verifier.test.d.ts

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

package/dist/deep/verifier.test.js

@@ -0,0 +1,514 @@
+import { describe, it, expect } from 'vitest';
+import { verifyFindings } from './verifier.js';
+// ── Test helpers ──
+function makeFinding(overrides = {}) {
+    return {
+        category: 'god_class',
+        severity: 'high',
+        file: 'src/service.ts',
+        line: 10,
+        description: 'The UserService class has too many responsibilities',
+        suggestion: 'Split into smaller services',
+        confidence: 0.8,
+        ...overrides,
+    };
+}
+function makeFileFacts(overrides = {}) {
+    return {
+        path: 'src/service.ts',
+        language: 'typescript',
+        lineCount: 300,
+        classes: [{
+                name: 'UserService',
+                lineStart: 5,
+                lineEnd: 290,
+                methodCount: 12,
+                methods: ['find', 'create', 'update', 'delete', 'validate', 'transform', 'cache', 'notify', 'log', 'serialize', 'auth', 'batch'],
+                publicMethods: ['find', 'create', 'update', 'delete'],
+                lineCount: 285,
+                dependencies: ['Database', 'Logger'],
+            }],
+        functions: [{
+                name: 'processData',
+                lineStart: 10,
+                lineEnd: 80,
+                lineCount: 70,
+                paramCount: 5,
+                params: ['a', 'b', 'c', 'd', 'e'],
+                maxNesting: 4,
+                hasReturn: true,
+                isAsync: true,
+                isExported: true,
+            }],
+        imports: ['express', './types'],
+        exports: ['UserService'],
+        errorHandling: [
+            { type: 'try-catch', lineStart: 20, isEmpty: false, strategy: 'throw' },
+            { type: 'try-catch', lineStart: 50, isEmpty: true, strategy: 'ignore' },
+        ],
+        testAssertions: 0,
+        hasTests: false,
+        ...overrides,
+    };
+}
+describe('Verifier', () => {
+    // ── File existence ──
+    describe('file existence check', () => {
+        it('should drop findings for files not in facts', () => {
+            const findings = [makeFinding({ file: 'src/nonexistent.ts' })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+        it('should accept findings for files that exist', () => {
+            const findings = [makeFinding()];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should handle path normalization (leading ./)', () => {
+            const findings = [makeFinding({ file: './src/service.ts' })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+        });
+    });
+    // ── Class/Struct findings (SOLID) ──
+    describe('class/struct-based verification', () => {
+        it('should verify god_class when class has many methods', () => {
+            const findings = [makeFinding({ category: 'god_class' })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+            expect(result[0].verificationNotes).toContain('12 methods');
+        });
+        it('should reject god_class when class is small', () => {
+            const findings = [makeFinding({ category: 'god_class' })];
+            const facts = [makeFileFacts({
+                    classes: [{
+                            name: 'UserService',
+                            lineStart: 5,
+                            lineEnd: 30,
+                            methodCount: 3,
+                            methods: ['find', 'create', 'update'],
+                            publicMethods: ['find', 'create'],
+                            lineCount: 25,
+                            dependencies: [],
+                        }],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+        it('should accept god_class for Go structs', () => {
+            const findings = [makeFinding({
+                    category: 'god_class',
+                    file: 'pkg/server.go',
+                    description: 'The Server struct has too many responsibilities',
+                })];
+            const facts = [makeFileFacts({
+                    path: 'pkg/server.go',
+                    language: 'go',
+                    classes: [],
+                    structs: [{
+                            name: 'Server',
+                            lineStart: 5,
+                            lineEnd: 250,
+                            fieldCount: 8,
+                            methodCount: 10,
+                            methods: ['Start', 'Stop', 'Handle', 'Route', 'Auth', 'Log', 'Cache', 'Validate', 'Transform', 'Serialize'],
+                            lineCount: 245,
+                            embeds: [],
+                        }],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should accept Go module-level god_class when file has many functions', () => {
+            const findings = [makeFinding({
+                    category: 'god_class',
+                    file: 'pkg/utils.go',
+                    description: 'This module has too many responsibilities',
+                })];
+            const facts = [makeFileFacts({
+                    path: 'pkg/utils.go',
+                    language: 'go',
+                    classes: [],
+                    structs: [],
+                    functions: Array.from({ length: 15 }, (_, i) => ({
+                        name: `func${i}`,
+                        lineStart: i * 20,
+                        lineEnd: i * 20 + 15,
+                        lineCount: 15,
+                        paramCount: 2,
+                        params: ['a', 'b'],
+                        maxNesting: 2,
+                        hasReturn: true,
+                        isAsync: false,
+                        isExported: true,
+                    })),
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+            expect(result[0].verificationNotes).toContain('15 functions');
+        });
+        it('should reject when entity name not found in file', () => {
+            const findings = [makeFinding({
+                    category: 'srp_violation',
+                    description: 'The NonExistentClass has too many responsibilities',
+                })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            // Should still verify since file has classes with confidence >= 0.4
+            expect(result).toHaveLength(1);
+        });
+    });
+    // ── Function findings ──
+    describe('function-based verification', () => {
+        it('should verify god_function when function is long', () => {
+            const findings = [makeFinding({
+                    category: 'god_function',
+                    description: 'processData is too long and complex',
+                })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject god_function when function is short', () => {
+            const findings = [makeFinding({
+                    category: 'god_function',
+                    description: 'processData is too complex',
+                })];
+            const facts = [makeFileFacts({
+                    functions: [{
+                            name: 'processData',
+                            lineStart: 10,
+                            lineEnd: 25,
+                            lineCount: 15,
+                            paramCount: 2,
+                            params: ['a', 'b'],
+                            maxNesting: 1,
+                            hasReturn: true,
+                            isAsync: false,
+                            isExported: true,
+                        }],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+        it('should verify long_params when function has many params', () => {
+            const findings = [makeFinding({
+                    category: 'long_params',
+                    description: 'processData has too many parameters',
+                })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject long_params when function has few params', () => {
+            const findings = [makeFinding({
+                    category: 'long_params',
+                    description: 'processData has too many parameters',
+                })];
+            const facts = [makeFileFacts({
+                    functions: [{
+                            name: 'processData',
+                            lineStart: 10,
+                            lineEnd: 50,
+                            lineCount: 40,
+                            paramCount: 2,
+                            params: ['a', 'b'],
+                            maxNesting: 2,
+                            hasReturn: true,
+                            isAsync: false,
+                            isExported: true,
+                        }],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+        it('should verify complex_conditional when nesting is deep', () => {
+            const findings = [makeFinding({
+                    category: 'complex_conditional',
+                    description: 'processData has deeply nested conditionals',
+                })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+    });
+    // ── Error handling findings ──
+    describe('error handling verification', () => {
+        it('should verify empty_catch when empty catches exist', () => {
+            const findings = [makeFinding({
+                    category: 'empty_catch',
+                    description: 'Empty catch block silently swallows errors',
+                })];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject empty_catch when no empty catches exist', () => {
+            const findings = [makeFinding({
+                    category: 'empty_catch',
+                    description: 'Empty catch block',
+                })];
+            const facts = [makeFileFacts({
+                    errorHandling: [
+                        { type: 'try-catch', lineStart: 10, isEmpty: false, strategy: 'throw' },
+                    ],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+        it('should verify error_inconsistency when multiple strategies exist', () => {
+            const findings = [makeFinding({
+                    category: 'error_inconsistency',
+                    description: 'Mixed error handling strategies',
+                })];
+            const facts = [makeFileFacts()]; // Has 'throw' and 'ignore' strategies
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+    });
+    // ── Concurrency findings ──
+    describe('concurrency verification', () => {
+        const goFacts = () => makeFileFacts({
+            path: 'pkg/worker.go',
+            language: 'go',
+            goroutines: 3,
+            channels: 2,
+            mutexes: 1,
+            defers: 2,
+        });
+        it('should verify race_condition when concurrency constructs exist', () => {
+            const findings = [makeFinding({
+                    category: 'race_condition',
+                    file: 'pkg/worker.go',
+                    description: 'Potential race condition',
+                    confidence: 0.6,
+                })];
+            const result = verifyFindings(findings, [goFacts()]);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject goroutine_leak when no goroutines exist', () => {
+            const findings = [makeFinding({
+                    category: 'goroutine_leak',
+                    file: 'pkg/worker.go',
+                    description: 'Goroutine leak detected',
+                    confidence: 0.7,
+                })];
+            const facts = goFacts();
+            facts.goroutines = 0;
+            const result = verifyFindings(findings, [facts]);
+            expect(result).toHaveLength(0);
+        });
+        it('should reject channel_misuse when no channels exist', () => {
+            const findings = [makeFinding({
+                    category: 'channel_misuse',
+                    file: 'pkg/worker.go',
+                    description: 'Channel misuse detected',
+                    confidence: 0.7,
+                })];
+            const facts = goFacts();
+            facts.channels = 0;
+            const result = verifyFindings(findings, [facts]);
+            expect(result).toHaveLength(0);
+        });
+        it('should reject concurrency finding when no concurrency exists', () => {
+            const findings = [makeFinding({
+                    category: 'race_condition',
+                    file: 'pkg/worker.go',
+                    description: 'Race condition',
+                    confidence: 0.8,
+                })];
+            const facts = goFacts();
+            facts.goroutines = 0;
+            facts.channels = 0;
+            facts.mutexes = 0;
+            facts.functions = facts.functions.map(f => ({ ...f, isAsync: false }));
+            const result = verifyFindings(findings, [facts]);
+            expect(result).toHaveLength(0);
+        });
+    });
+    // ── Interface findings ──
+    describe('interface verification', () => {
+        it('should verify ISP violation on large interface', () => {
+            const findings = [makeFinding({
+                    category: 'isp_violation_interface',
+                    file: 'pkg/store.go',
+                    description: 'Store interface has too many methods',
+                    confidence: 0.8,
+                })];
+            const facts = [makeFileFacts({
+                    path: 'pkg/store.go',
+                    language: 'go',
+                    interfaces: [{
+                            name: 'Store',
+                            lineStart: 5,
+                            methodCount: 8,
+                            methods: ['Get', 'Set', 'Delete', 'List', 'Close', 'Watch', 'Backup', 'Restore'],
+                        }],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject ISP violation when no interfaces exist', () => {
+            const findings = [makeFinding({
+                    category: 'isp_violation_interface',
+                    file: 'pkg/store.go',
+                    description: 'Interface has too many methods',
+                })];
+            const facts = [makeFileFacts({
+                    path: 'pkg/store.go',
+                    interfaces: [],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+    });
+    // ── Test findings ──
+    describe('test verification', () => {
+        it('should verify missing_test for substantial code files', () => {
+            const findings = [makeFinding({
+                    category: 'missing_test',
+                    description: 'No tests for this module',
+                })];
+            const facts = [makeFileFacts({
+                    functions: [
+                        { name: 'processData', lineStart: 10, lineEnd: 80, lineCount: 70, paramCount: 5, params: ['a', 'b', 'c', 'd', 'e'], maxNesting: 4, hasReturn: true, isAsync: true, isExported: true },
+                        { name: 'helperFn', lineStart: 85, lineEnd: 100, lineCount: 15, paramCount: 1, params: ['x'], maxNesting: 1, hasReturn: true, isAsync: false, isExported: false },
+                    ],
+                })]; // hasTests: false, 300 lines, 2 functions
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject missing_test when file already has tests', () => {
+            const findings = [makeFinding({
+                    category: 'missing_test',
+                    description: 'No tests',
+                })];
+            const facts = [makeFileFacts({ hasTests: true })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+        it('should reject missing_test for trivial files', () => {
+            const findings = [makeFinding({
+                    category: 'missing_test',
+                    description: 'No tests',
+                })];
+            const facts = [makeFileFacts({ lineCount: 20, functions: [] })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+    });
+    // ── File-level categories ──
+    describe('file-level verification', () => {
+        it('should verify long_file when file exceeds 300 lines', () => {
+            const findings = [makeFinding({ category: 'long_file' })];
+            const facts = [makeFileFacts({ lineCount: 500 })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject long_file when file is short', () => {
+            const findings = [makeFinding({ category: 'long_file' })];
+            const facts = [makeFileFacts({ lineCount: 100 })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+        it('should verify magic_number when many magic numbers detected', () => {
+            const findings = [makeFinding({ category: 'magic_number' })];
+            const facts = [makeFileFacts({ magicNumbers: 10 })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+        });
+        it('should reject magic_number when few magic numbers detected', () => {
+            const findings = [makeFinding({ category: 'magic_number' })];
+            const facts = [makeFileFacts({ magicNumbers: 1 })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+    });
+    // ── Confidence-based categories ──
+    describe('confidence-based verification', () => {
+        const confidenceCategories = [
+            'dry_violation', 'feature_envy', 'architecture',
+            'naming_convention', 'dead_code', 'performance',
+        ];
+        for (const category of confidenceCategories) {
+            it(`should accept ${category} with confidence >= 0.3`, () => {
+                const findings = [makeFinding({ category, confidence: 0.5 })];
+                const facts = [makeFileFacts()];
+                const result = verifyFindings(findings, facts);
+                expect(result).toHaveLength(1);
+            });
+            it(`should reject ${category} with low confidence`, () => {
+                const findings = [makeFinding({ category, confidence: 0.1 })];
+                const facts = [makeFileFacts()];
+                const result = verifyFindings(findings, facts);
+                expect(result).toHaveLength(0);
+            });
+        }
+    });
+    // ── Resource leak (Go-specific) ──
+    describe('resource leak verification', () => {
+        it('should verify Go resource leak when resource imports present', () => {
+            const findings = [makeFinding({
+                    category: 'resource_leak',
+                    file: 'pkg/db.go',
+                    confidence: 0.6,
+                })];
+            const facts = [makeFileFacts({
+                    path: 'pkg/db.go',
+                    language: 'go',
+                    imports: ['database/sql', 'net/http'],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(1);
+            expect(result[0].verified).toBe(true);
+        });
+        it('should reject Go resource leak when no resource imports', () => {
+            const findings = [makeFinding({
+                    category: 'resource_leak',
+                    file: 'pkg/util.go',
+                    confidence: 0.6,
+                })];
+            const facts = [makeFileFacts({
+                    path: 'pkg/util.go',
+                    language: 'go',
+                    imports: ['fmt', 'strings'],
+                })];
+            const result = verifyFindings(findings, facts);
+            expect(result).toHaveLength(0);
+        });
+    });
+    // ── Multiple findings batch ──
+    describe('batch verification', () => {
+        it('should process multiple findings and filter correctly', () => {
+            const findings = [
+                makeFinding({ category: 'god_class' }), // Should pass (12 methods)
+                makeFinding({ category: 'god_function', file: 'nonexistent.ts' }), // Should fail (no file)
+                makeFinding({ category: 'long_file' }), // Should fail (300 lines, need >300)
+                makeFinding({ category: 'magic_number' }), // Should fail (no magicNumbers set)
+                makeFinding({ category: 'dry_violation', confidence: 0.1 }), // Should fail (low confidence)
+                makeFinding({ category: 'dry_violation', confidence: 0.5 }), // Should pass
+            ];
+            const facts = [makeFileFacts()];
+            const result = verifyFindings(findings, facts);
+            const verified = result.filter(r => r.verified);
+            expect(verified.length).toBeGreaterThanOrEqual(2); // god_class, dry_violation(0.5)
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "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",