@rigour-labs/core 5.0.1 → 5.1.0

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

@@ -0,0 +1,237 @@
+import { classifyCasing } from './types.js';
+class JavaAdapter {
+    id = 'java';
+    name = 'Java/Kotlin';
+    extensions = ['.java', '.kt'];
+    extractFunctions(source) {
+        const lines = source.split('\n');
+        const functions = [];
+        // Java: public/private/protected static? ReturnType methodName(
+        const javaMethodRegex = /^\s*(public|private|protected)?\s*(static)?\s*(\w+)\s+(\w+)\s*\(/;
+        // Kotlin: fun methodName( or suspend fun methodName(
+        const kotlinFunRegex = /^\s*(suspend\s+)?fun\s+(\w+)\s*\(/;
+        let i = 0;
+        while (i < lines.length) {
+            let match = lines[i].match(javaMethodRegex);
+            let isKotlin = false;
+            let isAsync = false;
+            let methodName = '';
+            if (!match) {
+                match = lines[i].match(kotlinFunRegex);
+                if (match) {
+                    isKotlin = true;
+                    isAsync = !!match[1];
+                    methodName = match[2];
+                }
+            }
+            else {
+                isAsync = false;
+                methodName = match[4];
+            }
+            if (match && methodName) {
+                const startLine = i + 1;
+                // Find closing brace
+                let braceCount = 0;
+                let foundOpening = false;
+                let j = i;
+                let body = '';
+                while (j < lines.length) {
+                    const line = lines[j];
+                    for (let k = 0; k < line.length; k++) {
+                        if (line[k] === '{') {
+                            braceCount++;
+                            foundOpening = true;
+                        }
+                        else if (line[k] === '}') {
+                            braceCount--;
+                        }
+                    }
+                    body += line + '\n';
+                    if (foundOpening && braceCount === 0)
+                        break;
+                    j++;
+                }
+                functions.push({
+                    name: methodName,
+                    startLine,
+                    endLine: j + 1,
+                    body: body.trim(),
+                    isAsync,
+                    isExported: lines[i].includes('public'),
+                });
+                i = j + 1;
+            }
+            else {
+                i++;
+            }
+        }
+        return functions;
+    }
+    extractImports(source) {
+        const imports = [];
+        const lines = source.split('\n');
+        // Java/Kotlin: import package.Class; or import package.*
+        const importRegex = /^\s*import\s+([^;]+);/;
+        lines.forEach((line, idx) => {
+            const match = line.match(importRegex);
+            if (match) {
+                const fullModule = match[1].trim();
+                // Check if wildcard import
+                const isWildcard = fullModule.endsWith('.*');
+                const module = isWildcard
+                    ? fullModule.slice(0, -2)
+                    : fullModule.split('.').slice(0, -1).join('.');
+                const className = isWildcard
+                    ? '*'
+                    : fullModule.split('.').pop() || '';
+                imports.push({
+                    module,
+                    names: className ? [className] : [],
+                    line: idx + 1,
+                    isDynamic: false,
+                });
+            }
+        });
+        return imports;
+    }
+    extractErrorHandlers(source) {
+        const handlers = [];
+        const lines = source.split('\n');
+        // Match: catch (ExceptionType e) {
+        const catchRegex = /catch\s*\(\s*(\w+)\s+\w+\s*\)\s*{/;
+        let i = 0;
+        while (i < lines.length) {
+            const match = lines[i].match(catchRegex);
+            if (match) {
+                const exceptionType = match[1];
+                const startLine = i + 1;
+                // Extract catch block
+                let braceCount = 0;
+                let foundOpening = false;
+                let j = i;
+                let body = '';
+                while (j < lines.length) {
+                    const line = lines[j];
+                    for (let k = 0; k < line.length; k++) {
+                        if (line[k] === '{') {
+                            braceCount++;
+                            foundOpening = true;
+                        }
+                        else if (line[k] === '}') {
+                            braceCount--;
+                        }
+                    }
+                    body += line + '\n';
+                    if (foundOpening && braceCount === 0)
+                        break;
+                    j++;
+                }
+                // Classify strategy
+                let strategy = 'swallow';
+                if (/\bthrow\s*;/.test(body)) {
+                    strategy = 'rethrow';
+                }
+                else if (/\bthrow\s+new\s+/.test(body)) {
+                    strategy = 'wrap';
+                }
+                else if (/System\.out\.(print|println)|Log\.(d|e|i|w)/.test(body)) {
+                    strategy = 'log';
+                }
+                handlers.push({
+                    type: 'try-catch',
+                    strategy,
+                    startLine,
+                    body: body.trim(),
+                });
+                i = j + 1;
+            }
+            else {
+                i++;
+            }
+        }
+        return handlers;
+    }
+    extractNamingPatterns(source) {
+        const patterns = [];
+        // Extract camelCase methods
+        const methodRegex = /\b(public|private|protected)?\s*(static)?\s*\w+\s+([a-z]\w*)\s*\(/g;
+        let match;
+        while ((match = methodRegex.exec(source)) !== null) {
+            patterns.push({
+                name: match[3],
+                kind: 'method',
+                convention: classifyCasing(match[3]),
+            });
+        }
+        // Extract PascalCase class declarations
+        const classRegex = /\b(class|interface)\s+([A-Z]\w+)/g;
+        while ((match = classRegex.exec(source)) !== null) {
+            patterns.push({
+                name: match[2],
+                kind: 'class',
+                convention: classifyCasing(match[2]),
+            });
+        }
+        // Extract camelCase variables
+        const varRegex = /\b(private|protected)?\s*\w+\s+([a-z]\w+)\s*[=;]/g;
+        while ((match = varRegex.exec(source)) !== null) {
+            patterns.push({
+                name: match[2],
+                kind: 'variable',
+                convention: classifyCasing(match[2]),
+            });
+        }
+        // Extract SCREAMING_SNAKE constants
+        const constRegex = /\bfinal\s+\w+\s+([A-Z][A-Z0-9_]*)\s*=/g;
+        while ((match = constRegex.exec(source)) !== null) {
+            patterns.push({
+                name: match[1],
+                kind: 'constant',
+                convention: classifyCasing(match[1]),
+            });
+        }
+        return patterns;
+    }
+    stripComments(source) {
+        // Remove // comments
+        let result = source.replace(/\/\/.*$/gm, '');
+        // Remove /* */ comments (handles multiline)
+        result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+        // Kotlin: remove /** */ doc comments
+        result = result.replace(/\/\*\*[\s\S]*?\*\//g, '');
+        return result;
+    }
+    extractComparisonOps(source) {
+        const ops = new Set();
+        const opsRegex = /(>=|<=|==|!=|>|<)/g;
+        let match;
+        while ((match = opsRegex.exec(source)) !== null) {
+            ops.add(match[1]);
+        }
+        return Array.from(ops);
+    }
+    countBranches(source) {
+        const stripped = this.stripComments(source);
+        const ifMatches = stripped.match(/\bif\s*\(/g) || [];
+        const elseIfMatches = stripped.match(/\belse\s+if\s*\(/g) || [];
+        const elseMatches = stripped.match(/\belse\s*{/g) || [];
+        const switchMatches = stripped.match(/\bswitch\s*\(/g) || [];
+        const caseMatches = stripped.match(/\bcase\s+/g) || [];
+        // Kotlin-specific
+        const whenMatches = stripped.match(/\bwhen\s*\(/g) || [];
+        const isMatches = stripped.match(/\bis\s+/g) || [];
+        return (ifMatches.length +
+            elseIfMatches.length +
+            elseMatches.length +
+            switchMatches.length +
+            caseMatches.length +
+            whenMatches.length +
+            isMatches.length);
+    }
+    countReturns(source) {
+        const stripped = this.stripComments(source);
+        const returnMatches = stripped.match(/\breturn\b/g) || [];
+        return returnMatches.length;
+    }
+}
+export const javaAdapter = new JavaAdapter();

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

@@ -0,0 +1,26 @@
+/**
+ * JavaScript/TypeScript Language Adapter
+ *
+ * Handles: .ts, .tsx, .js, .jsx, .mjs, .cjs
+ *
+ * Regex-based static analysis for JS/TS code patterns.
+ */
+import type { LanguageAdapter, FunctionFact, ImportFact, ErrorHandlerFact, NamingPattern } from './types.js';
+declare class JsAdapter implements LanguageAdapter {
+    readonly id = "js";
+    readonly name = "JavaScript/TypeScript";
+    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 extractCatchCallbackBody;
+    private classifyJsErrorStrategy;
+}
+export declare const jsAdapter: JsAdapter;
+export {};

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

@@ -0,0 +1,279 @@
+/**
+ * JavaScript/TypeScript Language Adapter
+ *
+ * Handles: .ts, .tsx, .js, .jsx, .mjs, .cjs
+ *
+ * Regex-based static analysis for JS/TS code patterns.
+ */
+import { classifyCasing } from './types.js';
+class JsAdapter {
+    id = 'js';
+    name = 'JavaScript/TypeScript';
+    extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+    extractFunctions(source, filePath) {
+        const functions = [];
+        const lines = source.split('\n');
+        // Match: function foo() { ... }, async function foo() { ... }
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Traditional function declaration
+            let match = line.match(/(?:^|\s)(async\s+)?function\s+(\w+)\s*\(/);
+            if (match) {
+                const isAsync = !!match[1];
+                const name = match[2];
+                const body = this.extractBraceBody(lines, i);
+                const endLine = i + body.length;
+                const isExported = /\bexport\b/.test(lines.slice(Math.max(0, i - 2), i + 1).join(' '));
+                functions.push({
+                    name, startLine: i + 1, endLine: endLine + 1,
+                    body: body.join('\n'), isAsync, isExported,
+                });
+            }
+            // Arrow function: const foo = () => { ... }
+            match = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?\([^)]*\)\s*=>\s*\{/);
+            if (match) {
+                const name = match[1];
+                const isAsync = !!match[2];
+                const body = this.extractBraceBody(lines, i);
+                const endLine = i + body.length;
+                const isExported = /\bexport\b/.test(lines.slice(Math.max(0, i - 2), i + 1).join(' '));
+                functions.push({
+                    name, startLine: i + 1, endLine: endLine + 1,
+                    body: body.join('\n'), isAsync, isExported,
+                });
+            }
+            // Export function: export function foo() { ... }
+            match = line.match(/\bexport\s+(?:async\s+)?function\s+(\w+)\s*\(/);
+            if (match) {
+                const name = match[1];
+                const isAsync = /\basync\b/.test(line);
+                const body = this.extractBraceBody(lines, i);
+                const endLine = i + body.length;
+                functions.push({
+                    name, startLine: i + 1, endLine: endLine + 1,
+                    body: body.join('\n'), isAsync, isExported: true,
+                });
+            }
+            // Class method: methodName() { ... }
+            match = line.match(/^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/);
+            if (match && i > 0) {
+                const prevLine = lines[i - 1];
+                if (/\bclass\s+\w+/.test(prevLine) || /^\s+constructor\s*\(/.test(line) || !prevLine.includes('function')) {
+                    const name = match[1];
+                    const isAsync = /\basync\b/.test(line);
+                    const body = this.extractBraceBody(lines, i);
+                    const endLine = i + body.length;
+                    functions.push({
+                        name, startLine: i + 1, endLine: endLine + 1,
+                        body: body.join('\n'), isAsync, isExported: false,
+                    });
+                }
+            }
+        }
+        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 from 'module'
+            let match = line.match(/^\s*import\s+(?:\{([^}]+)\}|(\w+)|(\*\s+as\s+(\w+)))\s+from\s+['"]([^'"]+)['"]/);
+            if (match) {
+                const names = match[1] ? match[1].split(',').map(s => s.trim()) : (match[4] ? [match[4]] : (match[2] ? [match[2]] : []));
+                imports.push({
+                    module: match[5], names, line: i + 1, isDynamic: false,
+                });
+            }
+            // require('module')
+            match = line.match(/(?:const|let|var)\s+(?:\{([^}]+)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (match) {
+                const names = match[1] ? match[1].split(',').map(s => s.trim()) : [match[2]];
+                imports.push({
+                    module: match[3], names, line: i + 1, isDynamic: false,
+                });
+            }
+            // import('module') - dynamic
+            match = line.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (match) {
+                imports.push({
+                    module: match[1], names: [], line: i + 1, isDynamic: true,
+                });
+            }
+        }
+        return imports;
+    }
+    extractErrorHandlers(source) {
+        const handlers = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // try { ... } catch (e) { ... }
+            if (/\btry\s*\{/.test(line)) {
+                for (let j = i + 1; j < lines.length; j++) {
+                    if (/\bcatch\s*\(/.test(lines[j])) {
+                        const body = this.extractBraceBody(lines, j);
+                        const strategy = this.classifyJsErrorStrategy(body.join('\n'));
+                        handlers.push({
+                            type: 'try-catch', strategy,
+                            startLine: j + 1, body: body.join('\n'),
+                        });
+                        break;
+                    }
+                }
+            }
+            // .catch(e => { ... })
+            if (/\.catch\s*\(/.test(line)) {
+                const body = this.extractCatchCallbackBody(lines, i);
+                if (body) {
+                    const strategy = this.classifyJsErrorStrategy(body);
+                    handlers.push({
+                        type: 'try-catch', 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 foo() { ... }
+            let match = line.match(/\bfunction\s+(\w+)\s*\(/);
+            if (match) {
+                patterns.push({
+                    name: match[1], kind: 'function',
+                    convention: classifyCasing(match[1]),
+                });
+            }
+            // class Foo { ... }
+            match = line.match(/\bclass\s+(\w+)/);
+            if (match) {
+                patterns.push({
+                    name: match[1], kind: 'class',
+                    convention: classifyCasing(match[1]),
+                });
+            }
+            // const foo = ..., let foo = ..., var foo = ...
+            match = line.match(/(?:const|let|var)\s+(\w+)\s*=/);
+            if (match && !line.includes('function')) {
+                const isFunctionExpr = /=\s*(?:async\s+)?\(/.test(line) || /=>\s*/.test(line);
+                const kind = isFunctionExpr ? 'function' : 'variable';
+                patterns.push({
+                    name: match[1], kind,
+                    convention: classifyCasing(match[1]),
+                });
+            }
+            // Method names in classes
+            match = line.match(/^\s+(\w+)\s*\([^)]*\)\s*\{/);
+            if (match && /\bclass\b/.test(lines.slice(Math.max(0, i - 10), i).join(' '))) {
+                patterns.push({
+                    name: match[1], kind: 'method',
+                    convention: classifyCasing(match[1]),
+                });
+            }
+        }
+        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(/\bswitch\s*\(/g) || []).length;
+        count += (cleaned.match(/\bcase\s+/g) || []).length;
+        count += (cleaned.match(/\?\s*[^?]/g) || []).length;
+        return count;
+    }
+    countReturns(source) {
+        return (source.match(/\breturn\b/g) || []).length;
+    }
+    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;
+    }
+    extractCatchCallbackBody(lines, startLine) {
+        const hasArrow = lines[startLine]?.includes('=>');
+        let depth = 0;
+        let started = false;
+        const body = [];
+        for (let i = startLine; i < Math.min(startLine + 20, lines.length); i++) {
+            for (const ch of lines[i]) {
+                if (hasArrow) {
+                    if (ch === '{') {
+                        depth++;
+                        started = true;
+                    }
+                    if (ch === '}')
+                        depth--;
+                }
+                else {
+                    if (ch === '{' || ch === '(') {
+                        depth++;
+                        started = true;
+                    }
+                    if (ch === '}' || ch === ')')
+                        depth--;
+                }
+            }
+            if (started && i > startLine)
+                body.push(lines[i]);
+            if (started && depth <= 0)
+                break;
+        }
+        return body.length > 0 ? body.join('\n') : null;
+    }
+    classifyJsErrorStrategy(body) {
+        const trimmed = body.trim();
+        if (!trimmed || trimmed === '{}')
+            return 'swallow';
+        if (/\bthrow\b/.test(trimmed)) {
+            if (/\bthrow\s+new\b/.test(trimmed))
+                return 'wrap';
+            return 'rethrow';
+        }
+        if (/\breturn\s+null\b|\breturn\s+undefined\b|\breturn\s*;/.test(trimmed))
+            return 'return-error';
+        if (/console\.(error|warn|log)\b/.test(trimmed))
+            return 'log';
+        return 'other';
+    }
+}
+export const jsAdapter = new JsAdapter();

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

@@ -0,0 +1,25 @@
+/**
+ * Python Language Adapter
+ *
+ * Handles: .py, .pyw
+ *
+ * Regex-based static analysis for Python code patterns.
+ */
+import type { LanguageAdapter, FunctionFact, ImportFact, ErrorHandlerFact, NamingPattern } from './types.js';
+declare class PythonAdapter implements LanguageAdapter {
+    readonly id = "python";
+    readonly name = "Python";
+    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 extractIndentBody;
+    private classifyPythonErrorStrategy;
+}
+export declare const pythonAdapter: PythonAdapter;
+export {};