@rigour-labs/core 1.7.0 → 2.1.0

package/dist/types/index.js

@@ -1,73 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReportSchema = exports.FailureSchema = exports.StatusSchema = exports.ConfigSchema = exports.CommandsSchema = exports.GatesSchema = void 0;
-const zod_1 = require("zod");
-exports.GatesSchema = zod_1.z.object({
-    max_file_lines: zod_1.z.number().optional().default(500),
-    forbid_todos: zod_1.z.boolean().optional().default(true),
-    forbid_fixme: zod_1.z.boolean().optional().default(true),
-    forbid_paths: zod_1.z.array(zod_1.z.string()).optional().default([]),
-    required_files: zod_1.z.array(zod_1.z.string()).optional().default([
+import { z } from 'zod';
+export const GatesSchema = z.object({
+    max_file_lines: z.number().optional().default(500),
+    forbid_todos: z.boolean().optional().default(true),
+    forbid_fixme: z.boolean().optional().default(true),
+    forbid_paths: z.array(z.string()).optional().default([]),
+    required_files: z.array(z.string()).optional().default([
         'docs/SPEC.md',
         'docs/ARCH.md',
         'docs/DECISIONS.md',
         'docs/TASKS.md',
     ]),
-    ast: zod_1.z.object({
-        complexity: zod_1.z.number().optional().default(10),
-        max_methods: zod_1.z.number().optional().default(10),
-        max_params: zod_1.z.number().optional().default(5),
-        max_nesting: zod_1.z.number().optional().default(4),
-        max_inheritance_depth: zod_1.z.number().optional().default(3),
-        max_class_dependencies: zod_1.z.number().optional().default(5),
-        max_function_lines: zod_1.z.number().optional().default(50),
+    ast: z.object({
+        complexity: z.number().optional().default(10),
+        max_methods: z.number().optional().default(10),
+        max_params: z.number().optional().default(5),
+        max_nesting: z.number().optional().default(4),
+        max_inheritance_depth: z.number().optional().default(3),
+        max_class_dependencies: z.number().optional().default(5),
+        max_function_lines: z.number().optional().default(50),
     }).optional().default({}),
-    dependencies: zod_1.z.object({
-        forbid: zod_1.z.array(zod_1.z.string()).optional().default([]),
-        trusted_registry: zod_1.z.string().optional(),
+    dependencies: z.object({
+        forbid: z.array(z.string()).optional().default([]),
+        trusted_registry: z.string().optional(),
     }).optional().default({}),
-    architecture: zod_1.z.object({
-        boundaries: zod_1.z.array(zod_1.z.object({
-            from: zod_1.z.string(),
-            to: zod_1.z.string(),
-            mode: zod_1.z.enum(['allow', 'deny']).default('deny'),
+    architecture: z.object({
+        boundaries: z.array(z.object({
+            from: z.string(),
+            to: z.string(),
+            mode: z.enum(['allow', 'deny']).default('deny'),
         })).optional().default([]),
     }).optional().default({}),
-    safety: zod_1.z.object({
-        max_files_changed_per_cycle: zod_1.z.number().optional().default(10),
-        protected_paths: zod_1.z.array(zod_1.z.string()).optional().default(['.github/**', 'docs/**', 'rigour.yml']),
+    safety: z.object({
+        max_files_changed_per_cycle: z.number().optional().default(10),
+        protected_paths: z.array(z.string()).optional().default(['.github/**', 'docs/**', 'rigour.yml']),
+    }).optional().default({}),
+    context: z.object({
+        enabled: z.boolean().optional().default(true),
+        sensitivity: z.number().min(0).max(1).optional().default(0.8), // 0.8 correlation threshold
+        mining_depth: z.number().optional().default(100), // Number of files to sample
+        ignored_patterns: z.array(z.string()).optional().default([]),
+    }).optional().default({}),
+    environment: z.object({
+        enabled: z.boolean().optional().default(true),
+        enforce_contracts: z.boolean().optional().default(true), // Auto-discovery of versions from truth sources
+        tools: z.record(z.string()).optional().default({}), // Explicit overrides
+        required_env: z.array(z.string()).optional().default([]),
     }).optional().default({}),
 });
-exports.CommandsSchema = zod_1.z.object({
-    format: zod_1.z.string().optional(),
-    lint: zod_1.z.string().optional(),
-    typecheck: zod_1.z.string().optional(),
-    test: zod_1.z.string().optional(),
+export const CommandsSchema = z.object({
+    format: z.string().optional(),
+    lint: z.string().optional(),
+    typecheck: z.string().optional(),
+    test: z.string().optional(),
 });
-exports.ConfigSchema = zod_1.z.object({
-    version: zod_1.z.number().default(1),
-    preset: zod_1.z.string().optional(),
-    paradigm: zod_1.z.string().optional(),
-    commands: exports.CommandsSchema.optional().default({}),
-    gates: exports.GatesSchema.optional().default({}),
-    output: zod_1.z.object({
-        report_path: zod_1.z.string().default('rigour-report.json'),
+export const ConfigSchema = z.object({
+    version: z.number().default(1),
+    preset: z.string().optional(),
+    paradigm: z.string().optional(),
+    commands: CommandsSchema.optional().default({}),
+    gates: GatesSchema.optional().default({}),
+    output: z.object({
+        report_path: z.string().default('rigour-report.json'),
     }).optional().default({}),
-    planned: zod_1.z.array(zod_1.z.string()).optional().default([]),
+    planned: z.array(z.string()).optional().default([]),
+    ignore: z.array(z.string()).optional().default([]),
 });
-exports.StatusSchema = zod_1.z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
-exports.FailureSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    title: zod_1.z.string(),
-    details: zod_1.z.string(),
-    files: zod_1.z.array(zod_1.z.string()).optional(),
-    hint: zod_1.z.string().optional(),
+export const StatusSchema = z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
+export const FailureSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    details: z.string(),
+    files: z.array(z.string()).optional(),
+    hint: z.string().optional(),
 });
-exports.ReportSchema = zod_1.z.object({
-    status: exports.StatusSchema,
-    summary: zod_1.z.record(exports.StatusSchema),
-    failures: zod_1.z.array(exports.FailureSchema),
-    stats: zod_1.z.object({
-        duration_ms: zod_1.z.number(),
+export const ReportSchema = z.object({
+    status: StatusSchema,
+    summary: z.record(StatusSchema),
+    failures: z.array(FailureSchema),
+    stats: z.object({
+        duration_ms: z.number(),
+        score: z.number().optional(),
     }),
 });

package/dist/utils/logger.js

@@ -1,35 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.LogLevel = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-var LogLevel;
+import chalk from 'chalk';
+export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
     LogLevel[LogLevel["INFO"] = 1] = "INFO";
     LogLevel[LogLevel["WARN"] = 2] = "WARN";
     LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-class Logger {
+})(LogLevel || (LogLevel = {}));
+export class Logger {
     static level = LogLevel.INFO;
     static setLevel(level) {
         this.level = level;
     }
     static info(message) {
         if (this.level <= LogLevel.INFO) {
-            console.log(chalk_1.default.blue('info: ') + message);
+            console.log(chalk.blue('info: ') + message);
         }
     }
     static warn(message) {
         if (this.level <= LogLevel.WARN) {
-            console.log(chalk_1.default.yellow('warn: ') + message);
+            console.log(chalk.yellow('warn: ') + message);
         }
     }
     static error(message, error) {
         if (this.level <= LogLevel.ERROR) {
-            console.error(chalk_1.default.red('error: ') + message);
+            console.error(chalk.red('error: ') + message);
             if (error) {
                 console.error(error);
             }
@@ -37,8 +31,7 @@ class Logger {
     }
     static debug(message) {
         if (this.level <= LogLevel.DEBUG) {
-            console.log(chalk_1.default.dim('debug: ') + message);
+            console.log(chalk.dim('debug: ') + message);
         }
     }
 }
-exports.Logger = Logger;

package/dist/utils/scanner.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileScanner = void 0;
-const globby_1 = require("globby");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-class FileScanner {
+import { globby } from 'globby';
+import fs from 'fs-extra';
+import path from 'path';
+export class FileScanner {
     static DEFAULT_PATTERNS = ['**/*.{ts,js,py,css,html,md}'];
     static DEFAULT_IGNORE = [
         '**/node_modules/**',
@@ -18,18 +12,21 @@ class FileScanner {
         'rigour-report.json'
     ];
     static async findFiles(options) {
-        return (0, globby_1.globby)(options.patterns || this.DEFAULT_PATTERNS, {
-            cwd: options.cwd,
-            ignore: options.ignore || this.DEFAULT_IGNORE,
+        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(p => p.replace(/\\/g, '/'));
+        const ignore = (options.ignore || this.DEFAULT_IGNORE).map(p => p.replace(/\\/g, '/'));
+        const normalizedCwd = options.cwd.replace(/\\/g, '/');
+        return globby(patterns, {
+            cwd: normalizedCwd,
+            ignore: ignore,
         });
     }
     static async readFiles(cwd, files) {
         const contents = new Map();
         for (const file of files) {
-            const filePath = path_1.default.join(cwd, file);
-            contents.set(file, await fs_extra_1.default.readFile(filePath, 'utf-8'));
+            const normalizedFile = file.replace(/\//g, path.sep);
+            const filePath = path.isAbsolute(normalizedFile) ? normalizedFile : path.join(cwd, normalizedFile);
+            contents.set(file, await fs.readFile(filePath, 'utf-8'));
         }
         return contents;
     }
 }
-exports.FileScanner = FileScanner;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@rigour-labs/core",
-  "version": "1.7.0",
+  "version": "2.1.0",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
@@ -17,14 +18,17 @@
     "fs-extra": "^11.3.3",
     "globby": "^14.1.0",
     "micromatch": "^4.0.8",
+    "semver": "^7.7.3",
     "typescript": "^5.9.3",
+    "web-tree-sitter": "^0.26.3",
     "yaml": "^2.3.4",
     "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/micromatch": "^4.0.10",
-    "@types/node": "^25.0.3"
+    "@types/node": "^25.0.3",
+    "@types/semver": "^7.7.1"
   },
   "scripts": {
     "build": "tsc",

package/src/context.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { GateRunner } from '../src/gates/runner.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEST_CWD = path.join(__dirname, '../temp-test-context');
+
+describe('Context Awareness Engine', () => {
+    beforeAll(async () => {
+        await fs.ensureDir(TEST_CWD);
+    });
+
+    afterAll(async () => {
+        await fs.remove(TEST_CWD);
+    });
+
+    it('should detect context drift for redundant env suffixes (Golden Example)', async () => {
+        // Setup: Define standard GCP_PROJECT_ID
+        await fs.writeFile(path.join(TEST_CWD, '.env.example'), 'GCP_PROJECT_ID=my-project\n');
+
+        // Setup: Use drifted GCP_PROJECT_ID_PRODUCTION
+        await fs.writeFile(path.join(TEST_CWD, 'feature.js'), `
+            const id = process.env.GCP_PROJECT_ID_PRODUCTION;
+            console.log(id);
+        `);
+
+        const config = {
+            version: 1,
+            commands: {},
+            gates: {
+                context: {
+                    enabled: true,
+                    sensitivity: 0.8,
+                    mining_depth: 10,
+                },
+            },
+            output: { report_path: 'rigour-report.json' }
+        };
+
+        const runner = new GateRunner(config as any);
+        const report = await runner.run(TEST_CWD);
+
+        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
+        expect(driftFailures.length).toBeGreaterThan(0);
+        expect(driftFailures[0].details).toContain('GCP_PROJECT_ID_PRODUCTION');
+        expect(driftFailures[0].hint).toContain('GCP_PROJECT_ID');
+    });
+
+    it('should not flag valid environment variables', async () => {
+        await fs.writeFile(path.join(TEST_CWD, 'valid.js'), `
+            const id = process.env.GCP_PROJECT_ID;
+        `);
+
+        const config = {
+            version: 1,
+            commands: {},
+            gates: {
+                context: { enabled: true },
+            },
+            output: { report_path: 'rigour-report.json' }
+        };
+
+        const runner = new GateRunner(config as any);
+        const report = await runner.run(TEST_CWD);
+
+        const driftFailures = report.failures.filter(f => f.id === 'context-drift');
+        // Filter out failures from other files if they still exist in TEST_CWD
+        const specificFailures = driftFailures.filter(f => f.files?.includes('valid.js'));
+        expect(specificFailures.length).toBe(0);
+    });
+});

package/src/environment.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { GateRunner } from './gates/runner.js';
+import { Config, RawConfig, ConfigSchema } from './types/index.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+describe('Environment Alignment Gate', () => {
+    const testDir = path.join(process.cwd(), 'temp-test-env');
+
+    beforeEach(async () => {
+        await fs.ensureDir(testDir);
+    });
+
+    afterEach(async () => {
+        await fs.remove(testDir);
+    });
+
+    it('should detect tool version mismatch (Explicit)', async () => {
+        const rawConfig: RawConfig = {
+            version: 1,
+            gates: {
+                environment: {
+                    enabled: true,
+                    enforce_contracts: false,
+                    tools: {
+                        node: ">=99.0.0" // Guaranteed to fail
+                    }
+                }
+            }
+        };
+
+        const config = ConfigSchema.parse(rawConfig);
+        const runner = new GateRunner(config);
+        const report = await runner.run(testDir);
+
+        expect(report.status).toBe('FAIL');
+        const envFailure = report.failures.find(f => f.id === 'environment-alignment');
+        expect(envFailure).toBeDefined();
+        expect(envFailure?.details).toContain('node');
+        expect(envFailure?.details).toContain('version mismatch');
+    });
+
+    it('should detect missing environment variables', async () => {
+        const rawConfig: RawConfig = {
+            version: 1,
+            gates: {
+                environment: {
+                    enabled: true,
+                    required_env: ["RIGOUR_TEST_VAR_MISSING"]
+                }
+            }
+        };
+
+        const config = ConfigSchema.parse(rawConfig);
+        const runner = new GateRunner(config);
+        const report = await runner.run(testDir);
+
+        expect(report.status).toBe('FAIL');
+        expect(report.failures[0].details).toContain('RIGOUR_TEST_VAR_MISSING');
+    });
+
+    it('should discover contracts from pyproject.toml', async () => {
+        // Create mock pyproject.toml with a version that will surely fail
+        await fs.writeFile(path.join(testDir, 'pyproject.toml'), `
+[tool.ruff]
+ruff = ">=99.14.0"
+`);
+
+        const rawConfig: RawConfig = {
+            version: 1,
+            gates: {
+                environment: {
+                    enabled: true,
+                    enforce_contracts: true,
+                    tools: {} // Should discover ruff from file
+                }
+            }
+        };
+
+        const config = ConfigSchema.parse(rawConfig);
+        const runner = new GateRunner(config);
+        const report = await runner.run(testDir);
+
+        // This might pass or fail depending on the local ruff version, 
+        // but we want to check if the gate attempted to check ruff.
+        // If ruff is missing, it will fail with "is missing".
+        const ruffFailure = report.failures.find(f => f.details.includes('ruff'));
+        expect(ruffFailure).toBeDefined();
+    });
+
+    it('should prioritize environment gate and run it first', async () => {
+        const rawConfig: RawConfig = {
+            version: 1,
+            gates: {
+                max_file_lines: 1,
+                environment: {
+                    enabled: true,
+                    required_env: ["MANDATORY_SECRET_MISSING"]
+                }
+            }
+        };
+
+        const config = ConfigSchema.parse(rawConfig);
+
+        // Create a file that would fail max_file_lines
+        await fs.writeFile(path.join(testDir, 'large.js'), 'line1\nline2\nline3');
+
+        const runner = new GateRunner(config);
+        const report = await runner.run(testDir);
+
+        // In a real priority system, we might want to stop after environment failure.
+        // Currently GateRunner runs all, but environment-alignment has been unshifted.
+        expect(Object.keys(report.summary)[0]).toBe('environment-alignment');
+    });
+});

package/src/gates/ast-handlers/base.ts

@@ -0,0 +1,13 @@
+import { Failure, Gates } from '../../types/index.js';
+
+export interface ASTHandlerContext {
+    cwd: string;
+    file: string;
+    content: string;
+}
+
+export abstract class ASTHandler {
+    constructor(protected config: Gates) { }
+    abstract supports(file: string): boolean;
+    abstract run(context: ASTHandlerContext): Promise<Failure[]>;
+}

package/src/gates/ast-handlers/python.ts

@@ -0,0 +1,71 @@
+import { execa } from 'execa';
+import { ASTHandler, ASTHandlerContext } from './base.js';
+import { Failure } from '../../types/index.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export class PythonHandler extends ASTHandler {
+    supports(file: string): boolean {
+        return /\.py$/.test(file);
+    }
+
+    async run(context: ASTHandlerContext): Promise<Failure[]> {
+        const failures: Failure[] = [];
+        const scriptPath = path.join(__dirname, 'python_parser.py');
+
+        try {
+            const { stdout } = await execa('python3', [scriptPath], {
+                input: context.content,
+                cwd: context.cwd
+            });
+
+            const metrics = JSON.parse(stdout);
+            if (metrics.error) return [];
+
+            const astConfig = this.config.ast || {};
+            const maxComplexity = astConfig.complexity || 10;
+            const maxParams = astConfig.max_params || 5;
+            const maxMethods = astConfig.max_methods || 10;
+
+            for (const item of metrics) {
+                if (item.type === 'function') {
+                    if (item.parameters > maxParams) {
+                        failures.push({
+                            id: 'AST_MAX_PARAMS',
+                            title: `Function '${item.name}' has ${item.parameters} parameters (max: ${maxParams})`,
+                            details: `High parameter count detected in ${context.file} at line ${item.lineno}`,
+                            files: [context.file],
+                            hint: `Reduce number of parameters or use an options object.`
+                        });
+                    }
+                    if (item.complexity > maxComplexity) {
+                        failures.push({
+                            id: 'AST_COMPLEXITY',
+                            title: `Function '${item.name}' has complexity of ${item.complexity} (max: ${maxComplexity})`,
+                            details: `High complexity detected in ${context.file} at line ${item.lineno}`,
+                            files: [context.file],
+                            hint: `Refactor '${item.name}' into smaller, more focused functions.`
+                        });
+                    }
+                } else if (item.type === 'class') {
+                    if (item.methods > maxMethods) {
+                        failures.push({
+                            id: 'AST_MAX_METHODS',
+                            title: `Class '${item.name}' has ${item.methods} methods (max: ${maxMethods})`,
+                            details: `God Object pattern detected in ${context.file} at line ${item.lineno}`,
+                            files: [context.file],
+                            hint: `Split class '${item.name}' into smaller services.`
+                        });
+                    }
+                }
+            }
+
+        } catch (e: any) {
+            // If python3 is missing, we skip AST but other gates still run
+        }
+
+        return failures;
+    }
+}

package/src/gates/ast-handlers/python_parser.py

@@ -0,0 +1,60 @@
+import ast
+import sys
+import json
+
+class MetricsVisitor(ast.NodeVisitor):
+    def __init__(self):
+        self.metrics = []
+
+    def visit_FunctionDef(self, node):
+        self.analyze_function(node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self.analyze_function(node)
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node):
+        methods = [n for n in node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+        self.metrics.append({
+            "type": "class",
+            "name": node.name,
+            "methods": len(methods),
+            "lineno": node.lineno
+        })
+        self.generic_visit(node)
+
+    def analyze_function(self, node):
+        complexity = 1
+        for n in ast.walk(node):
+            if isinstance(n, (ast.If, ast.While, ast.For, ast.AsyncFor, ast.Try, ast.ExceptHandler, ast.With, ast.AsyncWith)):
+                complexity += 1
+            elif isinstance(n, ast.BoolOp):
+                complexity += len(n.values) - 1
+            elif isinstance(n, ast.IfExp):
+                complexity += 1
+        
+        params = len(node.args.args) + len(node.args.kwonlyargs)
+        if node.args.vararg: params += 1
+        if node.args.kwarg: params += 1
+
+        self.metrics.append({
+            "type": "function",
+            "name": node.name,
+            "complexity": complexity,
+            "parameters": params,
+            "lineno": node.lineno
+        })
+
+def analyze_code(content):
+    try:
+        tree = ast.parse(content)
+        visitor = MetricsVisitor()
+        visitor.visit(tree)
+        return visitor.metrics
+    except Exception as e:
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    content = sys.stdin.read()
+    print(json.dumps(analyze_code(content)))