@rigour-labs/core 5.0.1 → 5.1.0

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

@@ -0,0 +1,183 @@
+/**
+ * Python Language Adapter
+ *
+ * Handles: .py, .pyw
+ *
+ * Regex-based static analysis for Python code patterns.
+ */
+import { classifyCasing } from './types.js';
+class PythonAdapter {
+    id = 'python';
+    name = 'Python';
+    extensions = ['.py', '.pyw'];
+    extractFunctions(source, filePath) {
+        const functions = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // def foo(...): or async def foo(...):
+            const match = line.match(/^\s*(async\s+)?def\s+(\w+)\s*\(/);
+            if (match) {
+                const isAsync = !!match[1];
+                const name = match[2];
+                const body = this.extractIndentBody(lines, i);
+                const endLine = i + body.length;
+                const isExported = false; // Python doesn't have explicit exports in the traditional sense
+                functions.push({
+                    name, startLine: i + 1, endLine: endLine + 1,
+                    body: body.join('\n'), isAsync, isExported,
+                });
+            }
+        }
+        return functions;
+    }
+    extractImports(source) {
+        const imports = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // import x or import x as y
+            let match = line.match(/^\s*import\s+([\w.]+)(?:\s+as\s+(\w+))?/);
+            if (match) {
+                const names = match[2] ? [match[2]] : [match[1]];
+                imports.push({
+                    module: match[1], names, line: i + 1, isDynamic: false,
+                });
+            }
+            // from x import y, z
+            match = line.match(/^\s*from\s+([\w.]+)\s+import\s+(.+)/);
+            if (match) {
+                const names = match[2]
+                    .split(',')
+                    .map(s => s.trim())
+                    .filter(s => s && s !== '*');
+                imports.push({
+                    module: match[1], names: names.length > 0 ? 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];
+            // except ExceptionType as e:  OR  bare except:
+            const match = line.match(/^\s*except\s*(?:(\w[\w.]*)(?:\s+as\s+(\w+))?)?\s*:/);
+            if (match) {
+                const body = this.extractIndentBody(lines, i);
+                const exceptionType = match[1] || null; // null = bare except
+                const strategy = this.classifyPythonErrorStrategy(body.join('\n'), exceptionType);
+                handlers.push({
+                    type: exceptionType ? 'except' : 'bare-except',
+                    strategy,
+                    startLine: i + 1, body: body.join('\n'),
+                });
+            }
+        }
+        return handlers;
+    }
+    extractNamingPatterns(source) {
+        const patterns = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // def foo(...):
+            let match = line.match(/^\s*def\s+(\w+)\s*\(/);
+            if (match) {
+                patterns.push({
+                    name: match[1], kind: 'function',
+                    convention: classifyCasing(match[1]),
+                });
+            }
+            // class Foo:
+            match = line.match(/^\s*class\s+(\w+)/);
+            if (match) {
+                patterns.push({
+                    name: match[1], kind: 'class',
+                    convention: classifyCasing(match[1]),
+                });
+            }
+            // foo = ... (variable assignment at module level)
+            match = line.match(/^(\w+)\s*=/);
+            if (match && !line.includes('def') && !line.includes('class')) {
+                const name = match[1];
+                // Distinguish constants from regular variables
+                const kind = /^[A-Z][A-Z0-9_]*$/.test(name) ? 'constant' : 'variable';
+                patterns.push({
+                    name, kind,
+                    convention: classifyCasing(name),
+                });
+            }
+        }
+        return patterns;
+    }
+    stripComments(source) {
+        // Remove line comments (#)
+        let result = source.replace(/#.*/g, '');
+        // Remove docstrings (""" or ''')
+        result = result.replace(/"""[\s\S]*?"""/g, '');
+        result = result.replace(/'''[\s\S]*?'''/g, '');
+        return result;
+    }
+    extractComparisonOps(source) {
+        const ops = [];
+        const cleaned = this.stripComments(source);
+        const matches = cleaned.matchAll(/(==|!=|>=|<=|>(?!=)|<(?!=)|\bis\s+not\b|\bis\b|\bnot\s+in\b|\bin\b)/g);
+        for (const m of matches) {
+            ops.push(m[1].trim());
+        }
+        return ops;
+    }
+    countBranches(source) {
+        let count = 0;
+        const cleaned = this.stripComments(source);
+        count += (cleaned.match(/\bif\s+/g) || []).length;
+        count += (cleaned.match(/\belif\s+/g) || []).length;
+        count += (cleaned.match(/\belse\s*:/g) || []).length;
+        count += (cleaned.match(/\bmatch\s+/g) || []).length;
+        count += (cleaned.match(/\bcase\s+/g) || []).length;
+        return count;
+    }
+    countReturns(source) {
+        return (source.match(/\breturn\b/g) || []).length;
+    }
+    extractIndentBody(lines, startIndex) {
+        const body = [];
+        const defLine = lines[startIndex];
+        const defIndent = defLine.match(/^(\s*)/)?.[1]?.length || 0;
+        for (let i = startIndex + 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim() === '') {
+                body.push(line);
+                continue;
+            }
+            const currentIndent = line.match(/^(\s*)/)?.[1]?.length || 0;
+            if (currentIndent <= defIndent)
+                break;
+            body.push(line);
+        }
+        return body;
+    }
+    classifyPythonErrorStrategy(body, exceptionType) {
+        const trimmed = body.trim();
+        // Bare except with just pass/... is always a swallow anti-pattern
+        if (!trimmed || trimmed === 'pass' || trimmed === '...')
+            return 'swallow';
+        // `except Exception: pass` is also a swallow (catches everything, does nothing useful)
+        if (exceptionType === 'Exception' && (trimmed === 'pass' || trimmed === '...' || !trimmed))
+            return 'swallow';
+        if (/\braise\b/.test(trimmed)) {
+            if (/\braise\s+\w+Error\b/.test(trimmed))
+                return 'wrap';
+            return 'rethrow';
+        }
+        if (/\breturn\s+None\b|\breturn\s*$/.test(trimmed))
+            return 'return-error';
+        if (/\blogging\.\w+|\blogger\.\w+|\bprint\s*\(/.test(trimmed))
+            return 'log';
+        return 'other';
+    }
+}
+export const pythonAdapter = new PythonAdapter();

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

@@ -0,0 +1,26 @@
+/**
+ * Language Adapter Registry
+ *
+ * Single source of truth for language detection and adapter resolution.
+ * Gates call `registry.getAdapter(filePath)` instead of branching on extensions.
+ */
+import type { LanguageAdapter } from './types.js';
+export declare class LanguageAdapterRegistry {
+    private extensionMap;
+    private adapters;
+    constructor(adapters?: LanguageAdapter[]);
+    /** Auto-detect language from file extension and return the appropriate adapter */
+    getAdapter(filePath: string): LanguageAdapter | null;
+    /** Check if a file extension is supported */
+    isSupported(filePath: string): boolean;
+    /** Get all registered language IDs */
+    getSupportedLanguages(): string[];
+    /** Get all registered adapters */
+    getAllAdapters(): LanguageAdapter[];
+    /** Get scan glob patterns that cover all registered languages */
+    getScanPatterns(): string[];
+    /** Get all supported file extensions */
+    getSupportedExtensions(): string[];
+}
+/** Singleton registry instance — import this in gates */
+export declare const languageAdapters: LanguageAdapterRegistry;

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

@@ -0,0 +1,65 @@
+/**
+ * Language Adapter Registry
+ *
+ * Single source of truth for language detection and adapter resolution.
+ * Gates call `registry.getAdapter(filePath)` instead of branching on extensions.
+ */
+import path from 'path';
+import { jsAdapter } from './js-adapter.js';
+import { pythonAdapter } from './python-adapter.js';
+import { goAdapter } from './go-adapter.js';
+import { rubyAdapter } from './ruby-adapter.js';
+import { rustAdapter } from './rust-adapter.js';
+import { csharpAdapter } from './csharp-adapter.js';
+import { javaAdapter } from './java-adapter.js';
+const ALL_ADAPTERS = [
+    jsAdapter,
+    pythonAdapter,
+    goAdapter,
+    rubyAdapter,
+    rustAdapter,
+    csharpAdapter,
+    javaAdapter,
+];
+export class LanguageAdapterRegistry {
+    extensionMap = new Map();
+    adapters;
+    constructor(adapters = ALL_ADAPTERS) {
+        this.adapters = adapters;
+        for (const adapter of adapters) {
+            for (const ext of adapter.extensions) {
+                this.extensionMap.set(ext.toLowerCase(), adapter);
+            }
+        }
+    }
+    /** Auto-detect language from file extension and return the appropriate adapter */
+    getAdapter(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return this.extensionMap.get(ext) ?? null;
+    }
+    /** Check if a file extension is supported */
+    isSupported(filePath) {
+        return this.getAdapter(filePath) !== null;
+    }
+    /** Get all registered language IDs */
+    getSupportedLanguages() {
+        return this.adapters.map(a => a.id);
+    }
+    /** Get all registered adapters */
+    getAllAdapters() {
+        return [...this.adapters];
+    }
+    /** Get scan glob patterns that cover all registered languages */
+    getScanPatterns() {
+        const allExts = this.adapters
+            .flatMap(a => a.extensions)
+            .map(e => e.replace('.', ''));
+        return [`**/*.{${allExts.join(',')}}`];
+    }
+    /** Get all supported file extensions */
+    getSupportedExtensions() {
+        return [...this.extensionMap.keys()];
+    }
+}
+/** Singleton registry instance — import this in gates */
+export const languageAdapters = new LanguageAdapterRegistry();

package/dist/gates/language-adapters/ruby-adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Ruby Language Adapter
+ *
+ * Handles Ruby-specific code analysis:
+ * - Function extraction (def method_name with indent-based body)
+ * - Import parsing (require, require_relative, gem)
+ * - Error handling (rescue blocks)
+ * - Naming conventions (snake_case methods, PascalCase classes)
+ */
+import { LanguageAdapter, FunctionFact, ImportFact, ErrorHandlerFact, NamingPattern } from './types.js';
+export declare class RubyAdapter implements LanguageAdapter {
+    readonly id = "ruby";
+    readonly name = "Ruby";
+    readonly extensions: string[];
+    extractFunctions(source: string, filePath?: string): FunctionFact[];
+    extractImports(source: string): ImportFact[];
+    extractErrorHandlers(source: string): ErrorHandlerFact[];
+    extractNamingPatterns(source: string): NamingPattern[];
+    stripComments(source: string): string;
+    extractComparisonOps(source: string): string[];
+    countBranches(source: string): number;
+    countReturns(source: string): number;
+    private classifyRubyStrategy;
+}
+export declare const rubyAdapter: RubyAdapter;

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

@@ -0,0 +1,217 @@
+/**
+ * Ruby Language Adapter
+ *
+ * Handles Ruby-specific code analysis:
+ * - Function extraction (def method_name with indent-based body)
+ * - Import parsing (require, require_relative, gem)
+ * - Error handling (rescue blocks)
+ * - Naming conventions (snake_case methods, PascalCase classes)
+ */
+import { classifyCasing } from './types.js';
+export class RubyAdapter {
+    id = 'ruby';
+    name = 'Ruby';
+    extensions = ['.rb', '.rake'];
+    extractFunctions(source, filePath) {
+        const functions = [];
+        const lines = source.split('\n');
+        // Match: def method_name(...) or def self.method_name(...)
+        const defRegex = /^\s*def\s+(?:self\.)?(\w+)\s*(?:\(|$)/;
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(defRegex);
+            if (!match)
+                continue;
+            const name = match[1];
+            const startLine = i + 1;
+            const baseIndent = lines[i].match(/^(\s*)/)?.[1]?.length || 0;
+            const body = [];
+            // Extract indent-based body until 'end' at same indent level
+            for (let j = i + 1; j < lines.length; j++) {
+                const currentLine = lines[j];
+                if (currentLine.trim() === '') {
+                    body.push(currentLine);
+                    continue;
+                }
+                const currentIndent = currentLine.match(/^(\s*)/)?.[1]?.length || 0;
+                if (currentIndent <= baseIndent && currentLine.trim() === 'end') {
+                    break;
+                }
+                if (currentIndent <= baseIndent && currentLine.trim() !== '') {
+                    break;
+                }
+                body.push(currentLine);
+            }
+            functions.push({
+                name,
+                startLine,
+                endLine: startLine + body.length,
+                body: body.join('\n'),
+                isAsync: false,
+                isExported: true, // Ruby doesn't have true exports; all methods accessible
+            });
+        }
+        return functions;
+    }
+    extractImports(source) {
+        const imports = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // require 'foo'
+            let match = line.match(/^\s*require\s+['"]([^'"]+)['"]/);
+            if (match) {
+                imports.push({
+                    module: match[1],
+                    names: [],
+                    line: i + 1,
+                    isDynamic: false,
+                });
+                continue;
+            }
+            // require_relative 'foo'
+            match = line.match(/^\s*require_relative\s+['"]([^'"]+)['"]/);
+            if (match) {
+                imports.push({
+                    module: match[1],
+                    names: [],
+                    line: i + 1,
+                    isDynamic: false,
+                });
+                continue;
+            }
+            // gem 'baz'
+            match = line.match(/^\s*gem\s+['"]([^'"]+)['"]/);
+            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: rescue ExceptionClass => var
+            if (/^\s*rescue\s+/.test(line)) {
+                const baseIndent = line.match(/^(\s*)/)?.[1]?.length || 0;
+                const body = [];
+                // Collect body until next rescue/else/ensure/end at same level
+                for (let j = i + 1; j < lines.length; j++) {
+                    const currentLine = lines[j];
+                    if (currentLine.trim() === '') {
+                        body.push(currentLine);
+                        continue;
+                    }
+                    const currentIndent = currentLine.match(/^(\s*)/)?.[1]?.length || 0;
+                    if (currentIndent <= baseIndent && /^\s*(?:rescue|else|ensure|end)\b/.test(currentLine)) {
+                        break;
+                    }
+                    body.push(currentLine);
+                }
+                const bodyStr = body.join('\n');
+                const strategy = this.classifyRubyStrategy(bodyStr);
+                handlers.push({
+                    type: 'rescue',
+                    strategy,
+                    startLine: i + 1,
+                    body: bodyStr,
+                });
+            }
+        }
+        return handlers;
+    }
+    extractNamingPatterns(source) {
+        const patterns = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Method definitions
+            let match = line.match(/^\s*def\s+(?:self\.)?(\w+)/);
+            if (match) {
+                const name = match[1];
+                patterns.push({
+                    name,
+                    kind: 'method',
+                    convention: classifyCasing(name),
+                });
+                continue;
+            }
+            // Class definitions
+            match = line.match(/^\s*class\s+(\w+)/);
+            if (match) {
+                const name = match[1];
+                patterns.push({
+                    name,
+                    kind: 'class',
+                    convention: classifyCasing(name),
+                });
+                continue;
+            }
+            // Constant assignments
+            match = line.match(/^\s*([A-Z_]\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: =begin...=end
+        result = result.replace(/^\s*=begin\b[\s\S]*?^\s*=end\b/m, '');
+        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(/\belsif\s+/g) || []).length;
+        count += (cleaned.match(/\belse\b/g) || []).length;
+        count += (cleaned.match(/\bunless\s+/g) || []).length;
+        count += (cleaned.match(/\bcase\s+/g) || []).length;
+        count += (cleaned.match(/\bwhen\s+/g) || []).length;
+        return count;
+    }
+    countReturns(source) {
+        // Count explicit return statements
+        return (source.match(/\breturn\b/g) || []).length;
+    }
+    classifyRubyStrategy(body) {
+        const trimmed = body.trim();
+        if (!trimmed)
+            return 'swallow';
+        if (/\braise\b/.test(trimmed))
+            return 'rethrow';
+        if (/\breturn\s+nil\b/.test(trimmed))
+            return 'return-null';
+        if (/\breturn\s+false\b/.test(trimmed))
+            return 'return-false';
+        if (/\breturn\s+/.test(trimmed))
+            return 'return-value';
+        if (/\bputs\b|\blogger\b|\bRails\.logger\b/i.test(trimmed))
+            return 'log';
+        return 'other';
+    }
+}
+export const rubyAdapter = new RubyAdapter();

package/dist/gates/language-adapters/rust-adapter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { LanguageAdapter, FunctionFact, ImportFact, ErrorHandlerFact, NamingPattern } from './types.js';
+export declare class RustAdapter implements LanguageAdapter {
+    readonly id = "rust";
+    readonly name = "Rust";
+    readonly extensions: string[];
+    extractFunctions(source: string, filePath?: string): FunctionFact[];
+    extractImports(source: string): ImportFact[];
+    extractErrorHandlers(source: string): ErrorHandlerFact[];
+    extractNamingPatterns(source: string): NamingPattern[];
+    stripComments(source: string): string;
+    extractComparisonOps(source: string): string[];
+    countBranches(source: string): number;
+    countReturns(source: string): number;
+    private extractBraceBody;
+    private extractCallbackBody;
+    private classifyRustErrorStrategy;
+}
+export declare const rustAdapter: RustAdapter;