@rigour-labs/core 5.0.1 → 5.1.1

package/dist/gates/language-adapters/rust-adapter.js

@@ -0,0 +1,235 @@
+/**
+ * Rust Language Adapter
+ *
+ * Handles Rust-specific code analysis:
+ * - Function extraction (fn, pub fn, pub async fn)
+ * - Import parsing (use statements)
+ * - Error handling (match, unwrap_or_else)
+ * - Naming conventions (snake_case functions, PascalCase types)
+ */
+import { classifyCasing } from './types.js';
+export class RustAdapter {
+    id = 'rust';
+    name = 'Rust';
+    extensions = ['.rs'];
+    extractFunctions(source, filePath) {
+        const functions = [];
+        const lines = source.split('\n');
+        // Match: fn name(...), pub fn, pub async fn, impl blocks with methods
+        const fnRegex = /^\s*(?:pub\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+(\w+)\s*\(/;
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(fnRegex);
+            if (!match)
+                continue;
+            const name = match[1];
+            const startLine = i + 1;
+            const body = this.extractBraceBody(lines, i);
+            const bodyStr = body.join('\n');
+            const isAsync = /\basync\s+fn\b/.test(lines[i]);
+            functions.push({
+                name,
+                startLine,
+                endLine: startLine + body.length,
+                body: bodyStr,
+                isAsync,
+                isExported: /\bpub\b/.test(lines[i]),
+            });
+        }
+        return functions;
+    }
+    extractImports(source) {
+        const imports = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // use std::foo;
+            // use crate::bar;
+            // extern crate baz;
+            let match = line.match(/^\s*use\s+([\w:]+)(?:\s*::\s*\{([^}]+)\})?;/);
+            if (match) {
+                const module = match[1];
+                const names = match[2] ? match[2].split(',').map(n => n.trim()) : [];
+                imports.push({
+                    module,
+                    names,
+                    line: i + 1,
+                    isDynamic: false,
+                });
+                continue;
+            }
+            match = line.match(/^\s*extern\s+crate\s+(\w+);/);
+            if (match) {
+                imports.push({
+                    module: match[1],
+                    names: [],
+                    line: i + 1,
+                    isDynamic: false,
+                });
+            }
+        }
+        return imports;
+    }
+    extractErrorHandlers(source) {
+        const handlers = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Match: match result { Err(e) =>
+            if (/match\s+/.test(line)) {
+                const body = this.extractBraceBody(lines, i).join('\n');
+                const strategy = this.classifyRustErrorStrategy(body);
+                handlers.push({
+                    type: 'match',
+                    strategy,
+                    startLine: i + 1,
+                    body,
+                });
+                continue;
+            }
+            // Match: .unwrap_or_else(|e| ...)
+            if (/\.unwrap_or_else\s*\(\s*\|/.test(line)) {
+                const body = this.extractCallbackBody(lines, i);
+                const strategy = this.classifyRustErrorStrategy(body);
+                handlers.push({
+                    type: 'unwrap_or_else',
+                    strategy,
+                    startLine: i + 1,
+                    body,
+                });
+            }
+        }
+        return handlers;
+    }
+    extractNamingPatterns(source) {
+        const patterns = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Function definitions
+            let match = line.match(/^\s*(?:pub\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+(\w+)/);
+            if (match) {
+                const name = match[1];
+                patterns.push({
+                    name,
+                    kind: 'function',
+                    convention: classifyCasing(name),
+                });
+                continue;
+            }
+            // Struct definitions
+            match = line.match(/^\s*(?:pub\s+)?struct\s+(\w+)/);
+            if (match) {
+                const name = match[1];
+                patterns.push({
+                    name,
+                    kind: 'class',
+                    convention: classifyCasing(name),
+                });
+                continue;
+            }
+            // Enum definitions
+            match = line.match(/^\s*(?:pub\s+)?enum\s+(\w+)/);
+            if (match) {
+                const name = match[1];
+                patterns.push({
+                    name,
+                    kind: 'class',
+                    convention: classifyCasing(name),
+                });
+                continue;
+            }
+            // Const declarations
+            match = line.match(/^\s*(?:pub\s+)?const\s+(\w+)\s*:/);
+            if (match) {
+                const name = match[1];
+                patterns.push({
+                    name,
+                    kind: 'constant',
+                    convention: classifyCasing(name),
+                });
+            }
+        }
+        return patterns;
+    }
+    stripComments(source) {
+        // Remove line comments: //
+        let result = source.replace(/\/\/.*/g, '');
+        // Remove block comments: /* */
+        result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+        return result;
+    }
+    extractComparisonOps(source) {
+        const ops = [];
+        const cleaned = this.stripComments(source);
+        const matches = cleaned.matchAll(/(==|!=|>=|<=|>(?!=)|<(?!=))/g);
+        for (const m of matches) {
+            ops.push(m[1]);
+        }
+        return ops;
+    }
+    countBranches(source) {
+        let count = 0;
+        const cleaned = this.stripComments(source);
+        count += (cleaned.match(/\bif\s+/g) || []).length;
+        count += (cleaned.match(/\belse\s+if\s+/g) || []).length;
+        count += (cleaned.match(/\belse\s*\{/g) || []).length;
+        count += (cleaned.match(/\bmatch\s+/g) || []).length;
+        count += (cleaned.match(/=>\s*/g) || []).length;
+        return count;
+    }
+    countReturns(source) {
+        // Count explicit return + ? operator (early returns)
+        let count = (source.match(/\breturn\b/g) || []).length;
+        count += (source.match(/\?\s*(?:;|,|\))/g) || []).length;
+        return count;
+    }
+    extractBraceBody(lines, startIndex) {
+        let braceDepth = 0;
+        let started = false;
+        const body = [];
+        for (let i = startIndex; i < lines.length; i++) {
+            const line = lines[i];
+            for (const ch of line) {
+                if (ch === '{') {
+                    braceDepth++;
+                    started = true;
+                }
+                if (ch === '}')
+                    braceDepth--;
+            }
+            if (started)
+                body.push(line);
+            if (started && braceDepth === 0)
+                break;
+        }
+        return body;
+    }
+    extractCallbackBody(lines, startIndex) {
+        // Extract the closure/callback body: |e| ...
+        const line = lines[startIndex];
+        const pipeStart = line.indexOf('|');
+        const pipeEnd = line.indexOf('|', pipeStart + 1);
+        if (pipeEnd === -1) {
+            return line.substring(pipeStart);
+        }
+        // Body is after the second pipe
+        return line.substring(pipeEnd + 1);
+    }
+    classifyRustErrorStrategy(body) {
+        const trimmed = body.trim();
+        if (!trimmed)
+            return 'swallow';
+        if (/\bpanic!\b|\?/.test(trimmed))
+            return 'rethrow';
+        if (/\beprintln!\b|\blog::\w+\b/.test(trimmed))
+            return 'log';
+        if (/\.map_err|map\s*\(/.test(trimmed))
+            return 'wrap';
+        if (/\breturn\s+Err|Err\s*\(/.test(trimmed))
+            return 'return-error';
+        if (/\bunwrap\b|\bexpect\b/.test(trimmed))
+            return 'unwrap';
+        return 'other';
+    }
+}
+export const rustAdapter = new RustAdapter();

package/dist/gates/language-adapters/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Language Adapter Types
+ *
+ * Unified interface for language-specific code analysis.
+ * Gates use these adapters instead of inline `if ext === '.py'` chains.
+ */
+export interface LanguageAdapter {
+    /** Language identifier (e.g., 'js', 'python', 'go') */
+    readonly id: string;
+    /** Human-readable name */
+    readonly name: string;
+    /** File extensions this adapter handles (e.g., ['.py', '.pyw']) */
+    readonly extensions: string[];
+    /** Extract function declarations from source */
+    extractFunctions(source: string, filePath?: string): FunctionFact[];
+    /** Extract import statements */
+    extractImports(source: string): ImportFact[];
+    /** Extract error handling patterns */
+    extractErrorHandlers(source: string): ErrorHandlerFact[];
+    /** Extract naming patterns (variables, functions, classes) */
+    extractNamingPatterns(source: string): NamingPattern[];
+    /** Strip comments from source (for analysis accuracy) */
+    stripComments(source: string): string;
+    /** Detect comparison operators in a code block */
+    extractComparisonOps(source: string): string[];
+    /** Count branch points (if/else/switch/match) */
+    countBranches(source: string): number;
+    /** Count return points */
+    countReturns(source: string): number;
+}
+export interface FunctionFact {
+    name: string;
+    startLine: number;
+    endLine: number;
+    body: string;
+    isAsync: boolean;
+    isExported: boolean;
+}
+export interface ImportFact {
+    module: string;
+    names: string[];
+    line: number;
+    isDynamic: boolean;
+}
+export interface ErrorHandlerFact {
+    type: string;
+    strategy: string;
+    startLine: number;
+    body: string;
+}
+export interface NamingPattern {
+    name: string;
+    kind: 'function' | 'class' | 'variable' | 'constant' | 'method';
+    convention: NamingConvention;
+}
+export type NamingConvention = 'camelCase' | 'PascalCase' | 'snake_case' | 'SCREAMING_SNAKE' | 'kebab-case' | 'other';
+/**
+ * Classify a name into its casing convention.
+ */
+export declare function classifyCasing(name: string): NamingConvention;

package/dist/gates/language-adapters/types.js

@@ -0,0 +1,22 @@
+/**
+ * Language Adapter Types
+ *
+ * Unified interface for language-specific code analysis.
+ * Gates use these adapters instead of inline `if ext === '.py'` chains.
+ */
+/**
+ * Classify a name into its casing convention.
+ */
+export function classifyCasing(name) {
+    if (/^[A-Z][A-Z0-9_]*$/.test(name))
+        return 'SCREAMING_SNAKE';
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(name))
+        return 'PascalCase';
+    if (/^[a-z][a-zA-Z0-9]*$/.test(name))
+        return 'camelCase';
+    if (/^[a-z][a-z0-9_]*$/.test(name))
+        return 'snake_case';
+    if (/^[a-z][a-z0-9-]*$/.test(name))
+        return 'kebab-case';
+    return 'other';
+}

package/dist/gates/logic-drift-extractors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Logic Drift Gate — Drift-Specific Analysis Helpers
+ *
+ * Language-specific extraction (stripComments, countBranches, etc.) now
+ * delegates to the language adapter layer. This module retains only the
+ * drift-detection logic that is specific to the gate.
+ */
+/**
+ * Extract ordered sequence of function calls
+ */
+export declare function extractCallSequence(body: string): string[];
+/**
+ * Classify whether an operator change is "dangerous" (likely unintentional)
+ */
+export declare function isDangerousMutation(from: string, to: string): boolean;

package/dist/gates/logic-drift-extractors.js

@@ -0,0 +1,34 @@
+/**
+ * Logic Drift Gate — Drift-Specific Analysis Helpers
+ *
+ * Language-specific extraction (stripComments, countBranches, etc.) now
+ * delegates to the language adapter layer. This module retains only the
+ * drift-detection logic that is specific to the gate.
+ */
+// ─── Logic Drift-Specific Functions ───────────────────────────────
+/**
+ * Extract ordered sequence of function calls
+ */
+export function extractCallSequence(body) {
+    const calls = [];
+    const matches = body.matchAll(/\b(\w+)\s*\(/g);
+    const keywords = new Set(['if', 'for', 'while', 'switch', 'catch', 'function', 'async', 'await', 'return', 'new', 'typeof', 'instanceof']);
+    for (const m of matches) {
+        if (!keywords.has(m[1])) {
+            calls.push(m[1]);
+        }
+    }
+    return calls;
+}
+/**
+ * Classify whether an operator change is "dangerous" (likely unintentional)
+ */
+export function isDangerousMutation(from, to) {
+    const dangerous = new Set([
+        '>=:>', '>:>=',
+        '<=:<', '<:<=',
+        '===:==', '==:===',
+        '!==:!=', '!=:!==',
+    ]);
+    return dangerous.has(`${from}:${to}`);
+}

package/dist/gates/logic-drift.d.ts

@@ -15,8 +15,6 @@
  * Strategy: Collect baselines for critical functions, then detect
  * mutations between scans. This foundation enables future LLM-powered
  * deeper analysis (feeding baselines into DriftBench training).
- *
- * @since v5.1.0
  */
 import { Gate, GateContext } from './base.js';
 import { Failure, Provenance } from '../types/index.js';
@@ -33,38 +31,10 @@ export declare class LogicDriftGate extends Gate {
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
     private extractFunctionBaselines;
-    private extractBody;
-    /**
-     * Extract all comparison operators from function body in order.
-     * These are the most critical mutations: >= to > causes off-by-one.
-     */
-    private extractComparisonOps;
-    private countBranches;
-    private countReturns;
-    /**
-     * Extract ordered sequence of function calls.
-     * Useful for detecting when AI reorders operations.
-     */
-    private extractCallSequence;
     /**
      * Detect specific operator mutations between two ordered operator lists.
      * Only reports CHANGED operators, not added/removed ones (those are
      * covered by branch count changes).
-     *
-     * Example:
-     * prev: ['>=', '===', '!==']
-     * curr: ['>',  '===', '!==']
-     * → [{from: '>=', to: '>'}]
      */
     private detectOperatorMutations;
-    /**
-     * Classify whether an operator change is "dangerous" (likely unintentional).
-     *
-     * Dangerous mutations:
-     * - >= to > (boundary change, off-by-one)
-     * - <= to < (boundary change)
-     * - === to == (type coercion change)
-     * - !== to != (type coercion change)
-     */
-    private isDangerousMutation;
 }

package/dist/gates/logic-drift.js

@@ -15,12 +15,12 @@
  * Strategy: Collect baselines for critical functions, then detect
  * mutations between scans. This foundation enables future LLM-powered
  * deeper analysis (feeding baselines into DriftBench training).
- *
- * @since v5.1.0
  */
 import { Gate } from './base.js';
 import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
+import { languageAdapters } from './language-adapters/index.js';
+import { extractCallSequence, isDangerousMutation } from './logic-drift-extractors.js';
 import fs from 'fs-extra';
 import path from 'path';
 import crypto from 'crypto';
@@ -42,10 +42,10 @@ export class LogicDriftGate extends Gate {
             return [];
         const failures = [];
         const baselinePath = path.join(context.cwd, this.config.baseline_path);
-        // Find source files
+        // Find source files using adapter-supported patterns
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: context.patterns || ['**/*.{ts,tsx,js,jsx}'],
+            patterns: context.patterns || languageAdapters.getScanPatterns(),
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'],
         });
         if (files.length === 0)
@@ -61,7 +61,14 @@ export class LogicDriftGate extends Gate {
         let previousBaseline = null;
         if (await fs.pathExists(baselinePath)) {
             try {
-                previousBaseline = await fs.readJson(baselinePath);
+                const raw = await fs.readJson(baselinePath);
+                // Validate baseline has required structure
+                if (raw && Array.isArray(raw.functions)) {
+                    previousBaseline = raw;
+                }
+                else {
+                    Logger.debug('Invalid or empty logic baseline format, will recreate');
+                }
             }
             catch {
                 Logger.debug('Failed to load logic baseline');
@@ -133,148 +140,51 @@ export class LogicDriftGate extends Gate {
     // ─── Function Baseline Extraction ────────────────────────────────
     extractFunctionBaselines(content, file) {
         const baselines = [];
-        const lines = content.split('\n');
-        const fnPatterns = [
-            /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
-            /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|(\w+))\s*=>/,
-            /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/,
-        ];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            for (const pattern of fnPatterns) {
-                const match = line.match(pattern);
-                if (match) {
-                    const name = match[1];
-                    if (['if', 'for', 'while', 'switch', 'catch', 'constructor'].includes(name))
-                        continue;
-                    const body = this.extractBody(lines, i);
-                    if (body.length < 3)
-                        continue; // Skip trivial functions
-                    const bodyText = body.join('\n');
-                    const normalized = bodyText
-                        .replace(/\/\/.*/g, '')
-                        .replace(/\/\*[\s\S]*?\*\//g, '')
-                        .replace(/\s+/g, ' ')
-                        .trim();
-                    baselines.push({
-                        name,
-                        file,
-                        line: i + 1,
-                        comparisonOps: this.extractComparisonOps(bodyText),
-                        branchCount: this.countBranches(bodyText),
-                        returnCount: this.countReturns(bodyText),
-                        callSequence: this.extractCallSequence(bodyText),
-                        bodyHash: crypto.createHash('md5').update(normalized).digest('hex'),
-                    });
-                    break;
-                }
-            }
-        }
-        return baselines;
-    }
-    extractBody(lines, startIndex) {
-        let braceDepth = 0;
-        let started = false;
-        const body = [];
-        for (let i = startIndex; i < lines.length; i++) {
-            const line = lines[i];
-            for (const ch of line) {
-                if (ch === '{') {
-                    braceDepth++;
-                    started = true;
-                }
-                if (ch === '}')
-                    braceDepth--;
-            }
-            if (started)
-                body.push(line);
-            if (started && braceDepth === 0)
-                break;
-        }
-        return body;
-    }
-    /**
-     * Extract all comparison operators from function body in order.
-     * These are the most critical mutations: >= to > causes off-by-one.
-     */
-    extractComparisonOps(body) {
-        const ops = [];
-        const matches = body.matchAll(/(===|!==|==|!=|>=|<=|>(?!=)|<(?!=))/g);
-        for (const m of matches) {
-            ops.push(m[1]);
+        const adapter = languageAdapters.getAdapter(file);
+        if (!adapter) {
+            return baselines; // Unsupported language
         }
-        return ops;
-    }
-    countBranches(body) {
-        let count = 0;
-        // Count if, else if, else, switch, case, ternary
-        count += (body.match(/\bif\s*\(/g) || []).length;
-        count += (body.match(/\belse\s+if\s*\(/g) || []).length;
-        count += (body.match(/\belse\s*\{/g) || []).length;
-        count += (body.match(/\bswitch\s*\(/g) || []).length;
-        count += (body.match(/\bcase\s+/g) || []).length;
-        count += (body.match(/\?\s*[^?]/g) || []).length; // ternary (approximate)
-        return count;
-    }
-    countReturns(body) {
-        return (body.match(/\breturn\b/g) || []).length;
-    }
-    /**
-     * Extract ordered sequence of function calls.
-     * Useful for detecting when AI reorders operations.
-     */
-    extractCallSequence(body) {
-        const calls = [];
-        const matches = body.matchAll(/\b(\w+)\s*\(/g);
-        const keywords = new Set(['if', 'for', 'while', 'switch', 'catch', 'function', 'async', 'await', 'return', 'new', 'typeof', 'instanceof']);
-        for (const m of matches) {
-            if (!keywords.has(m[1])) {
-                calls.push(m[1]);
-            }
+        const skipKeywords = new Set(['if', 'for', 'while', 'switch', 'catch', 'constructor', 'else', 'elif', 'elsif', 'rescue']);
+        const functions = adapter.extractFunctions(content, file);
+        for (const fn of functions) {
+            // Skip control flow keywords
+            if (skipKeywords.has(fn.name))
+                continue;
+            // Skip very small functions
+            if (fn.body.length < 3)
+                continue;
+            const normalized = adapter.stripComments(fn.body)
+                .replace(/\s+/g, ' ')
+                .trim();
+            baselines.push({
+                name: fn.name,
+                file,
+                line: fn.startLine,
+                comparisonOps: adapter.extractComparisonOps(fn.body),
+                branchCount: adapter.countBranches(fn.body),
+                returnCount: adapter.countReturns(fn.body),
+                callSequence: extractCallSequence(fn.body),
+                bodyHash: crypto.createHash('md5').update(normalized).digest('hex'),
+            });
         }
-        return calls;
+        return baselines;
     }
     // ─── Mutation Detection ──────────────────────────────────────────
     /**
      * Detect specific operator mutations between two ordered operator lists.
      * Only reports CHANGED operators, not added/removed ones (those are
      * covered by branch count changes).
-     *
-     * Example:
-     * prev: ['>=', '===', '!==']
-     * curr: ['>',  '===', '!==']
-     * → [{from: '>=', to: '>'}]
      */
     detectOperatorMutations(prev, curr) {
         const mutations = [];
-        // Use LCS-like alignment for best matching
         const minLen = Math.min(prev.length, curr.length);
         for (let i = 0; i < minLen; i++) {
             if (prev[i] !== curr[i]) {
-                // Check if this is a "dangerous" mutation (same family, different strictness)
-                if (this.isDangerousMutation(prev[i], curr[i])) {
+                if (isDangerousMutation(prev[i], curr[i])) {
                     mutations.push({ from: prev[i], to: curr[i] });
                 }
             }
         }
         return mutations;
     }
-    /**
-     * Classify whether an operator change is "dangerous" (likely unintentional).
-     *
-     * Dangerous mutations:
-     * - >= to > (boundary change, off-by-one)
-     * - <= to < (boundary change)
-     * - === to == (type coercion change)
-     * - !== to != (type coercion change)
-     */
-    isDangerousMutation(from, to) {
-        const dangerous = new Set([
-            '>=:>', '>:>=', // Boundary mutations
-            '<=:<', '<:<=', // Boundary mutations
-            '===:==', '==:===', // Type coercion mutations
-            '!==:!=', '!=:!==', // Type coercion mutations
-        ]);
-        return dangerous.has(`${from}:${to}`);
-    }
 }

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

@@ -16,8 +16,6 @@
  *   C#     — Common .NET hallucinated APIs (LINQ, File I/O, string methods)
  *   Java   — Common hallucinated JDK APIs (Collections, String, Stream, Files)
  *
- * @since v3.0.0
- * @since v3.0.3 — Go, C#, Java pattern-based detection added
  */
 import { Gate, GateContext } from './base.js';
 import { Failure, Provenance } from '../types/index.js';