@rigour-labs/core 1.7.0 → 2.1.0

package/dist/gates/ast.js

@@ -1,124 +1,48 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASTGate = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const globby_1 = require("globby");
-const base_js_1 = require("./base.js");
-const micromatch_1 = __importDefault(require("micromatch"));
-class ASTGate extends base_js_1.Gate {
+import fs from 'fs-extra';
+import path from 'path';
+import { globby } from 'globby';
+import { Gate } from './base.js';
+import { TypeScriptHandler } from './ast-handlers/typescript.js';
+import { PythonHandler } from './ast-handlers/python.js';
+import { UniversalASTHandler } from './ast-handlers/universal.js';
+export class ASTGate extends Gate {
     config;
+    handlers = [];
     constructor(config) {
         super('ast-analysis', 'AST Structural Analysis');
         this.config = config;
+        this.handlers.push(new TypeScriptHandler(config));
+        this.handlers.push(new PythonHandler(config));
+        this.handlers.push(new UniversalASTHandler(config));
     }
     async run(context) {
         const failures = [];
-        const files = await (0, globby_1.globby)(['**/*.{ts,js,tsx,jsx}'], {
-            cwd: context.cwd,
-            ignore: ['node_modules/**', 'dist/**', 'build/**', '**/*.test.*', '**/*.spec.*'],
+        const patterns = (context.patterns || ['**/*.{ts,js,tsx,jsx,py,go,rs,cs,java,rb,c,cpp,php,swift,kt}']).map(p => p.replace(/\\/g, '/'));
+        const ignore = (context.ignore || ['node_modules/**', 'dist/**', 'build/**', '**/*.test.*', '**/*.spec.*', '**/__pycache__/**']).map(p => p.replace(/\\/g, '/'));
+        const normalizedCwd = context.cwd.replace(/\\/g, '/');
+        // Find all supported files
+        const files = await globby(patterns, {
+            cwd: normalizedCwd,
+            ignore: ignore,
         });
         for (const file of files) {
-            const fullPath = path_1.default.join(context.cwd, file);
-            const content = await fs_extra_1.default.readFile(fullPath, 'utf-8');
-            const sourceFile = typescript_1.default.createSourceFile(file, content, typescript_1.default.ScriptTarget.Latest, true);
-            this.analyzeSourceFile(sourceFile, file, failures);
-        }
-        return failures;
-    }
-    analyzeSourceFile(sourceFile, relativePath, failures) {
-        const astConfig = this.config.ast || {};
-        const maxComplexity = astConfig.complexity || 10;
-        const maxMethods = astConfig.max_methods || 10;
-        const maxParams = astConfig.max_params || 5;
-        const visit = (node) => {
-            // 1. Complexity & Params for functions
-            if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isArrowFunction(node)) {
-                const name = this.getNodeName(node);
-                // Parameter count
-                if (node.parameters.length > maxParams) {
-                    failures.push(this.createFailure(`Function '${name}' has ${node.parameters.length} parameters (max: ${maxParams})`, [relativePath], `Reduce number of parameters or use an options object.`));
-                    // Update: Failures in Runner will be mapped to FixPacket
-                    failures[failures.length - 1].metrics = { count: node.parameters.length, max: maxParams };
-                }
-                // Cyclomatic Complexity (Simplified: nodes that cause branching)
-                let complexity = 1;
-                const countComplexity = (n) => {
-                    if (typescript_1.default.isIfStatement(n) || typescript_1.default.isCaseClause(n) || typescript_1.default.isDefaultClause(n) ||
-                        typescript_1.default.isForStatement(n) || typescript_1.default.isForInStatement(n) || typescript_1.default.isForOfStatement(n) ||
-                        typescript_1.default.isWhileStatement(n) || typescript_1.default.isDoStatement(n) || typescript_1.default.isConditionalExpression(n)) {
-                        complexity++;
-                    }
-                    if (typescript_1.default.isBinaryExpression(n)) {
-                        if (n.operatorToken.kind === typescript_1.default.SyntaxKind.AmpersandAmpersandToken ||
-                            n.operatorToken.kind === typescript_1.default.SyntaxKind.BarBarToken) {
-                            complexity++;
-                        }
-                    }
-                    typescript_1.default.forEachChild(n, countComplexity);
-                };
-                typescript_1.default.forEachChild(node, countComplexity);
-                if (complexity > maxComplexity) {
-                    failures.push(this.createFailure(`Function '${name}' has cyclomatic complexity of ${complexity} (max: ${maxComplexity})`, [relativePath], `Refactor '${name}' into smaller, more focused functions.`));
-                    failures[failures.length - 1].metrics = { complexity, max: maxComplexity };
-                }
+            const handler = this.handlers.find(h => h.supports(file));
+            if (!handler)
+                continue;
+            const fullPath = path.join(context.cwd, file);
+            try {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                const gateFailures = await handler.run({
+                    cwd: context.cwd,
+                    file: file,
+                    content
+                });
+                failures.push(...gateFailures);
             }
-            // 2. Class metrics
-            if (typescript_1.default.isClassDeclaration(node)) {
-                const name = node.name?.text || 'Anonymous Class';
-                const methods = node.members.filter(typescript_1.default.isMethodDeclaration);
-                if (methods.length > maxMethods) {
-                    failures.push(this.createFailure(`Class '${name}' has ${methods.length} methods (max: ${maxMethods})`, [relativePath], `Class '${name}' is becoming a 'God Object'. Split it into smaller services.`));
-                    failures[failures.length - 1].metrics = { methodCount: methods.length, max: maxMethods };
-                }
-            }
-            // 3. Import check for Layer Boundaries
-            if (typescript_1.default.isImportDeclaration(node)) {
-                const importPath = node.moduleSpecifier.text;
-                this.checkBoundary(importPath, relativePath, failures);
-            }
-            typescript_1.default.forEachChild(node, visit);
-        };
-        typescript_1.default.forEachChild(sourceFile, visit);
-    }
-    checkBoundary(importPath, relativePath, failures) {
-        const boundaries = this.config.architecture?.boundaries || [];
-        if (boundaries.length === 0)
-            return;
-        for (const rule of boundaries) {
-            const isFromMatch = micromatch_1.default.isMatch(relativePath, rule.from);
-            if (isFromMatch) {
-                // Approximate resolution (simplified for now)
-                // Real implementation would need to handle alias and absolute path resolution
-                const resolved = importPath.startsWith('.')
-                    ? path_1.default.join(path_1.default.dirname(relativePath), importPath)
-                    : importPath;
-                const isToMatch = micromatch_1.default.isMatch(resolved, rule.to);
-                if (rule.mode === 'deny' && isToMatch) {
-                    failures.push(this.createFailure(`Architectural Violation: '${relativePath}' is forbidden from importing '${importPath}' (denied by boundary rule).`, [relativePath], `Remove this import to maintain architectural layering.`));
-                }
-                else if (rule.mode === 'allow' && !isToMatch && importPath.startsWith('.')) {
-                    // Complexity: Allow rules are trickier to implement strictly without full resolution
-                }
+            catch (error) {
+                // Individual file read failures shouldn't crash the whole run
             }
         }
-    }
-    getNodeName(node) {
-        if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isMethodDeclaration(node)) {
-            return node.name?.getText() || 'anonymous';
-        }
-        if (typescript_1.default.isArrowFunction(node)) {
-            const parent = node.parent;
-            if (typescript_1.default.isVariableDeclaration(parent)) {
-                return parent.name.getText();
-            }
-            return 'anonymous arrow';
-        }
-        return 'unknown';
+        return failures;
     }
 }
-exports.ASTGate = ASTGate;

package/dist/gates/base.d.ts

@@ -1,6 +1,10 @@
+import { GoldenRecord } from '../services/context-engine.js';
 import { Failure } from '../types/index.js';
 export interface GateContext {
     cwd: string;
+    record?: GoldenRecord;
+    ignore?: string[];
+    patterns?: string[];
 }
 export declare abstract class Gate {
     readonly id: string;

package/dist/gates/base.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Gate = void 0;
-class Gate {
+export class Gate {
     id;
     title;
     constructor(id, title) {
@@ -18,4 +15,3 @@ class Gate {
         };
     }
 }
-exports.Gate = Gate;

package/dist/gates/content.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContentGate = void 0;
-const base_js_1 = require("./base.js");
-const scanner_js_1 = require("../utils/scanner.js");
-class ContentGate extends base_js_1.Gate {
+import { Gate } from './base.js';
+import { FileScanner } from '../utils/scanner.js';
+export class ContentGate extends Gate {
     config;
     constructor(config) {
         super('content-check', 'Forbidden Content');
@@ -17,8 +14,12 @@ class ContentGate extends base_js_1.Gate {
             patterns.push(/FIXME/i);
         if (patterns.length === 0)
             return [];
-        const files = await scanner_js_1.FileScanner.findFiles({ cwd: context.cwd });
-        const contents = await scanner_js_1.FileScanner.readFiles(context.cwd, files);
+        const files = await FileScanner.findFiles({
+            cwd: context.cwd,
+            ignore: context.ignore,
+            patterns: context.patterns
+        });
+        const contents = await FileScanner.readFiles(context.cwd, files);
         const violations = [];
         for (const [file, content] of contents) {
             for (const pattern of patterns) {
@@ -36,4 +37,3 @@ class ContentGate extends base_js_1.Gate {
         return [];
     }
 }
-exports.ContentGate = ContentGate;

package/dist/gates/context.d.ts

@@ -0,0 +1,8 @@
+import { Gate, GateContext } from './base.js';
+import { Failure, Gates } from '../types/index.js';
+export declare class ContextGate extends Gate {
+    private config;
+    constructor(config: Gates);
+    run(context: GateContext): Promise<Failure[]>;
+    private checkEnvDrift;
+}

package/dist/gates/context.js

@@ -0,0 +1,43 @@
+import { Gate } from './base.js';
+import { FileScanner } from '../utils/scanner.js';
+import fs from 'fs-extra';
+import path from 'path';
+export class ContextGate extends Gate {
+    config;
+    constructor(config) {
+        super('context-drift', 'Context Awareness & Drift Detection');
+        this.config = config;
+    }
+    async run(context) {
+        const failures = [];
+        const record = context.record;
+        if (!record || !this.config.context?.enabled)
+            return [];
+        const files = await FileScanner.findFiles({ cwd: context.cwd });
+        const envAnchors = record.anchors.filter(a => a.type === 'env' && a.confidence >= 1);
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(path.join(context.cwd, file), 'utf-8');
+                // 1. Detect Redundant Suffixes (The Golden Example)
+                this.checkEnvDrift(content, file, envAnchors, failures);
+            }
+            catch (e) { }
+        }
+        return failures;
+    }
+    checkEnvDrift(content, file, anchors, failures) {
+        // Find all environment variable accesses in the content
+        const matches = content.matchAll(/process\.env(?:\.([A-Z0-9_]+)|\[['"]([A-Z0-9_]+)['"]\])/g);
+        for (const match of matches) {
+            const accessedVar = match[1] || match[2];
+            for (const anchor of anchors) {
+                // If the accessed variable contains the anchor but is not equal to it, 
+                // it's a potential "invented" redundancy (e.g. CORE_URL vs CORE_URL_PROD)
+                if (accessedVar !== anchor.id && accessedVar.includes(anchor.id)) {
+                    const deviation = accessedVar.replace(anchor.id, '').replace(/^_|_$/, '');
+                    failures.push(this.createFailure(`Context Drift: Redundant variation '${accessedVar}' detected in ${file}.`, [file], `The project already uses '${anchor.id}' as a standard anchor. Avoid inventing variations like '${deviation}'. Reuse the existing anchor or align with established project patterns.`));
+                }
+            }
+        }
+    }
+}

package/dist/gates/coverage.d.ts

@@ -0,0 +1,8 @@
+import { Gate, GateContext } from './base.js';
+import { Failure, Gates } from '../types/index.js';
+export declare class CoverageGate extends Gate {
+    private config;
+    constructor(config: Gates);
+    run(context: GateContext): Promise<Failure[]>;
+    private parseLcov;
+}

package/dist/gates/coverage.js

@@ -0,0 +1,62 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { Gate } from './base.js';
+import { globby } from 'globby';
+export class CoverageGate extends Gate {
+    config;
+    constructor(config) {
+        super('coverage-guard', 'Dynamic Coverage Guard');
+        this.config = config;
+    }
+    async run(context) {
+        const failures = [];
+        // 1. Locate coverage report (lcov.info is standard)
+        const reports = await globby(['**/lcov.info', '**/coverage-final.json'], {
+            cwd: context.cwd,
+            ignore: ['node_modules/**']
+        });
+        if (reports.length === 0) {
+            // If no reports found, and coverage is required, we could flag it.
+            // But for now, we'll just skip silently if not configured.
+            return [];
+        }
+        // 2. Parse coverage (Simplified LCOV parser for demonstration)
+        const coverageData = await this.parseLcov(path.join(context.cwd, reports[0]));
+        // 3. Quality Handshake: SME SME LOGIC
+        // We look for files that have high complexity but low coverage.
+        // In a real implementation, we would share data between ASTGate and CoverageGate.
+        // For this demo, we'll implement a standalone check.
+        for (const [file, stats] of Object.entries(coverageData)) {
+            const coverage = (stats.hit / stats.found) * 100;
+            const threshold = stats.isComplex ? 80 : 50; // SME logic: Complex files need higher coverage
+            if (coverage < threshold) {
+                failures.push({
+                    id: 'DYNAMIC_COVERAGE_LOW',
+                    title: `Low coverage for high-risk file: ${file}`,
+                    details: `Current coverage: ${coverage.toFixed(2)}%. Required: ${threshold}% due to structural risk.`,
+                    files: [file],
+                    hint: `Add dynamic tests to cover complex logical branches in this file.`
+                });
+            }
+        }
+        return failures;
+    }
+    async parseLcov(reportPath) {
+        const content = await fs.readFile(reportPath, 'utf-8');
+        const results = {};
+        let currentFile = '';
+        for (const line of content.split('\n')) {
+            if (line.startsWith('SF:')) {
+                currentFile = line.substring(3);
+                results[currentFile] = { found: 0, hit: 0, isComplex: false };
+            }
+            else if (line.startsWith('LF:')) {
+                results[currentFile].found = parseInt(line.substring(3));
+            }
+            else if (line.startsWith('LH:')) {
+                results[currentFile].hit = parseInt(line.substring(3));
+            }
+        }
+        return results;
+    }
+}

package/dist/gates/dependency.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.DependencyGate = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const base_js_1 = require("./base.js");
-class DependencyGate extends base_js_1.Gate {
+import fs from 'fs-extra';
+import path from 'path';
+import { Gate } from './base.js';
+export class DependencyGate extends Gate {
     config;
     constructor(config) {
         super('dependency-guardian', 'Dependency Guardian');
@@ -20,10 +14,10 @@ class DependencyGate extends base_js_1.Gate {
             return [];
         const { cwd } = context;
         // 1. Scan Node.js (package.json)
-        const pkgPath = path_1.default.join(cwd, 'package.json');
-        if (await fs_extra_1.default.pathExists(pkgPath)) {
+        const pkgPath = path.join(cwd, 'package.json');
+        if (await fs.pathExists(pkgPath)) {
             try {
-                const pkg = await fs_extra_1.default.readJson(pkgPath);
+                const pkg = await fs.readJson(pkgPath);
                 const allDeps = {
                     ...(pkg.dependencies || {}),
                     ...(pkg.devDependencies || {}),
@@ -40,4 +34,3 @@ class DependencyGate extends base_js_1.Gate {
         return failures;
     }
 }
-exports.DependencyGate = DependencyGate;

package/dist/gates/environment.d.ts

@@ -0,0 +1,8 @@
+import { Gate, GateContext } from './base.js';
+import { Failure, Gates } from '../types/index.js';
+export declare class EnvironmentGate extends Gate {
+    private config;
+    constructor(config: Gates);
+    run(context: GateContext): Promise<Failure[]>;
+    private discoverContracts;
+}

package/dist/gates/environment.js

@@ -0,0 +1,73 @@
+import { Gate } from './base.js';
+import { execa } from 'execa';
+import semver from 'semver';
+import fs from 'fs-extra';
+import path from 'path';
+export class EnvironmentGate extends Gate {
+    config;
+    constructor(config) {
+        super('environment-alignment', 'Environment & Tooling Alignment');
+        this.config = config;
+    }
+    async run(context) {
+        const failures = [];
+        const envConfig = this.config.environment;
+        if (!envConfig || !envConfig.enabled)
+            return [];
+        const contracts = envConfig.enforce_contracts ? await this.discoverContracts(context.cwd) : {};
+        const toolsToCheck = { ...contracts, ...(envConfig.tools || {}) };
+        // 1. Verify Tool Versions
+        for (const [tool, range] of Object.entries(toolsToCheck)) {
+            // Ensure range is a string
+            const semverRange = String(range);
+            try {
+                const { stdout } = await execa(tool, ['--version'], { shell: true });
+                const versionMatch = stdout.match(/(\d+\.\d+\.\d+)/);
+                if (versionMatch) {
+                    const version = versionMatch[1];
+                    if (!semver.satisfies(version, semverRange)) {
+                        failures.push(this.createFailure(`Environment Alignment: Tool '${tool}' version mismatch.`, [], `Project requires '${tool} ${semverRange}' (discovered from contract), but found version '${version}'. Please align your local environment to prevent drift.`));
+                    }
+                }
+                else {
+                    failures.push(this.createFailure(`Environment Alignment: Could not determine version for '${tool}'.`, [], `Ensure '${tool} --version' returns a standard SemVer string.`));
+                }
+            }
+            catch (e) {
+                failures.push(this.createFailure(`Environment Alignment: Required tool '${tool}' is missing.`, [], `Install '${tool}' and ensure it is in your $PATH.`));
+            }
+        }
+        // 2. Verify Required Env Vars
+        const requiredEnv = envConfig.required_env || [];
+        for (const envVar of requiredEnv) {
+            if (!process.env[envVar]) {
+                failures.push(this.createFailure(`Environment Alignment: Missing required environment variable '${envVar}'.`, [], `Ensure '${envVar}' is defined in your environment or .env file.`));
+            }
+        }
+        return failures;
+    }
+    async discoverContracts(cwd) {
+        const contracts = {};
+        // 1. Scan pyproject.toml (for ruff, mypy)
+        const pyprojectPath = path.join(cwd, 'pyproject.toml');
+        if (await fs.pathExists(pyprojectPath)) {
+            const content = await fs.readFile(pyprojectPath, 'utf-8');
+            // SME Logic: Look for ruff and mypy version constraints
+            // Handle both ruff = "^0.14.0" and ruff = { version = "^0.14.0" }
+            const ruffMatch = content.match(/ruff\s*=\s*(?:['"]([^'"]+)['"]|\{\s*version\s*=\s*['"]([^'"]+)['"]\s*\})/);
+            if (ruffMatch)
+                contracts['ruff'] = ruffMatch[1] || ruffMatch[2];
+            const mypyMatch = content.match(/mypy\s*=\s*(?:['"]([^'"]+)['"]|\{\s*version\s*=\s*['"]([^'"]+)['"]\s*\})/);
+            if (mypyMatch)
+                contracts['mypy'] = mypyMatch[1] || mypyMatch[2];
+        }
+        // 2. Scan package.json (for node/npm/pnpm)
+        const pkgPath = path.join(cwd, 'package.json');
+        if (await fs.pathExists(pkgPath)) {
+            const pkg = await fs.readJson(pkgPath);
+            if (pkg.engines?.node)
+                contracts['node'] = pkg.engines.node;
+        }
+        return contracts;
+    }
+}

package/dist/gates/file.js

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileGate = void 0;
-const base_js_1 = require("./base.js");
-const scanner_js_1 = require("../utils/scanner.js");
-class FileGate extends base_js_1.Gate {
+import { Gate } from './base.js';
+import { FileScanner } from '../utils/scanner.js';
+export class FileGate extends Gate {
     config;
     constructor(config) {
         super('file-size', 'File Size Limit');
         this.config = config;
     }
     async run(context) {
-        const files = await scanner_js_1.FileScanner.findFiles({ cwd: context.cwd });
-        const contents = await scanner_js_1.FileScanner.readFiles(context.cwd, files);
+        const files = await FileScanner.findFiles({
+            cwd: context.cwd,
+            ignore: context.ignore,
+            patterns: context.patterns
+        });
+        const contents = await FileScanner.readFiles(context.cwd, files);
         const violations = [];
         for (const [file, content] of contents) {
             const lines = content.split('\n').length;
@@ -27,4 +28,3 @@ class FileGate extends base_js_1.Gate {
         return [];
     }
 }
-exports.FileGate = FileGate;

package/dist/gates/runner.d.ts

@@ -9,5 +9,5 @@ export declare class GateRunner {
      * Allows adding custom gates dynamically (SOLID - Open/Closed Principle)
      */
     addGate(gate: Gate): void;
-    run(cwd: string): Promise<Report>;
+    run(cwd: string, patterns?: string[]): Promise<Report>;
 }

package/dist/gates/runner.js

@@ -1,15 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GateRunner = void 0;
-const file_js_1 = require("./file.js");
-const content_js_1 = require("./content.js");
-const structure_js_1 = require("./structure.js");
-const ast_js_1 = require("./ast.js");
-const safety_js_1 = require("./safety.js");
-const dependency_js_1 = require("./dependency.js");
-const execa_1 = require("execa");
-const logger_js_1 = require("../utils/logger.js");
-class GateRunner {
+import { FileGate } from './file.js';
+import { ContentGate } from './content.js';
+import { StructureGate } from './structure.js';
+import { ASTGate } from './ast.js';
+import { SafetyGate } from './safety.js';
+import { DependencyGate } from './dependency.js';
+import { CoverageGate } from './coverage.js';
+import { ContextGate } from './context.js';
+import { ContextEngine } from '../services/context-engine.js';
+import { EnvironmentGate } from './environment.js'; // [NEW]
+import { execa } from 'execa';
+import { Logger } from '../utils/logger.js';
+export class GateRunner {
     config;
     gates = [];
     constructor(config) {
@@ -18,18 +19,26 @@ class GateRunner {
     }
     initializeGates() {
         if (this.config.gates.max_file_lines) {
-            this.gates.push(new file_js_1.FileGate({ maxLines: this.config.gates.max_file_lines }));
+            this.gates.push(new FileGate({ maxLines: this.config.gates.max_file_lines }));
         }
-        this.gates.push(new content_js_1.ContentGate({
+        this.gates.push(new ContentGate({
             forbidTodos: !!this.config.gates.forbid_todos,
             forbidFixme: !!this.config.gates.forbid_fixme,
         }));
         if (this.config.gates.required_files) {
-            this.gates.push(new structure_js_1.StructureGate({ requiredFiles: this.config.gates.required_files }));
+            this.gates.push(new StructureGate({ requiredFiles: this.config.gates.required_files }));
+        }
+        this.gates.push(new ASTGate(this.config.gates));
+        this.gates.push(new DependencyGate(this.config));
+        this.gates.push(new SafetyGate(this.config.gates));
+        this.gates.push(new CoverageGate(this.config.gates));
+        if (this.config.gates.context?.enabled) {
+            this.gates.push(new ContextGate(this.config.gates));
+        }
+        // Environment Alignment Gate (Should be prioritized)
+        if (this.config.gates.environment?.enabled) {
+            this.gates.unshift(new EnvironmentGate(this.config.gates));
         }
-        this.gates.push(new ast_js_1.ASTGate(this.config.gates));
-        this.gates.push(new dependency_js_1.DependencyGate(this.config));
-        this.gates.push(new safety_js_1.SafetyGate(this.config.gates));
     }
     /**
      * Allows adding custom gates dynamically (SOLID - Open/Closed Principle)
@@ -37,14 +46,21 @@ class GateRunner {
     addGate(gate) {
         this.gates.push(gate);
     }
-    async run(cwd) {
+    async run(cwd, patterns) {
         const start = Date.now();
         const failures = [];
         const summary = {};
+        const ignore = this.config.ignore;
+        // 0. Run Context Discovery
+        let record;
+        if (this.config.gates.context?.enabled) {
+            const engine = new ContextEngine(this.config);
+            record = await engine.discover(cwd);
+        }
         // 1. Run internal gates
         for (const gate of this.gates) {
             try {
-                const gateFailures = await gate.run({ cwd });
+                const gateFailures = await gate.run({ cwd, record, ignore, patterns });
                 if (gateFailures.length > 0) {
                     failures.push(...gateFailures);
                     summary[gate.id] = 'FAIL';
@@ -54,7 +70,7 @@ class GateRunner {
                 }
             }
             catch (error) {
-                logger_js_1.Logger.error(`Gate ${gate.id} failed with error: ${error.message}`);
+                Logger.error(`Gate ${gate.id} failed with error: ${error.message}`);
                 summary[gate.id] = 'ERROR';
                 failures.push({
                     id: gate.id,
@@ -73,8 +89,8 @@ class GateRunner {
                     continue;
                 }
                 try {
-                    logger_js_1.Logger.info(`Running command gate: ${key} (${cmd})`);
-                    await (0, execa_1.execa)(cmd, { shell: true, cwd });
+                    Logger.info(`Running command gate: ${key} (${cmd})`);
+                    await execa(cmd, { shell: true, cwd });
                     summary[key] = 'PASS';
                 }
                 catch (error) {
@@ -89,14 +105,15 @@ class GateRunner {
             }
         }
         const status = failures.length > 0 ? 'FAIL' : 'PASS';
+        const score = Math.max(0, 100 - (failures.length * 5)); // Basic SME scoring logic
         return {
             status,
             summary,
             failures,
             stats: {
                 duration_ms: Date.now() - start,
+                score,
             },
         };
     }
 }
-exports.GateRunner = GateRunner;