@rigour-labs/core 5.0.1 → 5.1.1

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

@@ -0,0 +1,211 @@
+import { classifyCasing } from './types.js';
+class CSharpAdapter {
+    id = 'csharp';
+    name = 'C#';
+    extensions = ['.cs'];
+    extractFunctions(source) {
+        const lines = source.split('\n');
+        const functions = [];
+        // Match: public/private/protected/internal static? async? ReturnType MethodName(
+        const methodRegex = /^\s*(public|private|protected|internal)?\s*(static)?\s*(async)?\s*(\w+)\s+(\w+)\s*\(/;
+        let i = 0;
+        while (i < lines.length) {
+            const match = lines[i].match(methodRegex);
+            if (match) {
+                const isAsync = !!match[3];
+                const returnType = match[4];
+                const methodName = match[5];
+                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');
+        // Match: using Namespace; or using static Namespace;
+        const usingRegex = /^\s*using\s+(static\s+)?([^;]+);/;
+        lines.forEach((line, idx) => {
+            const match = line.match(usingRegex);
+            if (match) {
+                const module = match[2].trim();
+                imports.push({
+                    module,
+                    names: [],
+                    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 (/Console\.(Write|WriteLine)/.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 PascalCase methods
+        const methodRegex = /\b(public|private|protected|internal)?\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 = /\bclass\s+([A-Z]\w+)/g;
+        while ((match = classRegex.exec(source)) !== null) {
+            patterns.push({
+                name: match[1],
+                kind: 'class',
+                convention: classifyCasing(match[1]),
+            });
+        }
+        // Extract _camelCase private fields
+        const fieldRegex = /\b(_[a-z]\w+)\s*[=;]/g;
+        while ((match = fieldRegex.exec(source)) !== null) {
+            patterns.push({
+                name: match[1],
+                kind: 'variable',
+                convention: classifyCasing(match[1]),
+            });
+        }
+        // Extract SCREAMING_SNAKE constants
+        const constRegex = /\b(const\s+)?([A-Z][A-Z0-9_]*)\s*=/g;
+        while ((match = constRegex.exec(source)) !== null) {
+            const name = match[2];
+            if (/^[A-Z][A-Z0-9_]+$/.test(name)) {
+                patterns.push({
+                    name,
+                    kind: 'constant',
+                    convention: classifyCasing(name),
+                });
+            }
+        }
+        return patterns;
+    }
+    stripComments(source) {
+        // Remove // comments
+        let result = source.replace(/\/\/.*$/gm, '');
+        // Remove /* */ comments (handles multiline)
+        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) || [];
+        return (ifMatches.length +
+            elseIfMatches.length +
+            elseMatches.length +
+            switchMatches.length +
+            caseMatches.length);
+    }
+    countReturns(source) {
+        const stripped = this.stripComments(source);
+        const returnMatches = stripped.match(/\breturn\b/g) || [];
+        return returnMatches.length;
+    }
+}
+export const csharpAdapter = new CSharpAdapter();

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

@@ -0,0 +1,26 @@
+/**
+ * Go Language Adapter
+ *
+ * Handles Go-specific code analysis:
+ * - Function extraction (func Name, func (r *Receiver) Name)
+ * - Import parsing (single and multiline blocks)
+ * - Error handling (if err != nil patterns)
+ * - Naming conventions (PascalCase exports, camelCase unexported)
+ */
+import { LanguageAdapter, FunctionFact, ImportFact, ErrorHandlerFact, NamingPattern } from './types.js';
+export declare class GoAdapter implements LanguageAdapter {
+    readonly id = "go";
+    readonly name = "Go";
+    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 classifyGoErrorStrategy;
+}
+export declare const goAdapter: GoAdapter;

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

@@ -0,0 +1,195 @@
+/**
+ * Go Language Adapter
+ *
+ * Handles Go-specific code analysis:
+ * - Function extraction (func Name, func (r *Receiver) Name)
+ * - Import parsing (single and multiline blocks)
+ * - Error handling (if err != nil patterns)
+ * - Naming conventions (PascalCase exports, camelCase unexported)
+ */
+import { classifyCasing } from './types.js';
+export class GoAdapter {
+    id = 'go';
+    name = 'Go';
+    extensions = ['.go'];
+    extractFunctions(source, filePath) {
+        const functions = [];
+        const lines = source.split('\n');
+        // Match: func Name(...) or func (r *Receiver) Name(...)
+        const funcRegex = /^\s*func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/;
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(funcRegex);
+            if (!match)
+                continue;
+            const name = match[1];
+            const startLine = i + 1;
+            const body = this.extractBraceBody(lines, i);
+            const bodyStr = body.join('\n');
+            functions.push({
+                name,
+                startLine,
+                endLine: startLine + body.length,
+                body: bodyStr,
+                isAsync: false,
+                isExported: /^[A-Z]/.test(name),
+            });
+        }
+        return functions;
+    }
+    extractImports(source) {
+        const imports = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // Single import: import "pkg"
+            const singleMatch = line.match(/^\s*import\s+"([^"]+)"/);
+            if (singleMatch) {
+                imports.push({
+                    module: singleMatch[1],
+                    names: [],
+                    line: i + 1,
+                    isDynamic: false,
+                });
+                continue;
+            }
+            // Multiline import block: import ( "pkg1" "pkg2" )
+            if (line.startsWith('import') && line.includes('(')) {
+                let j = i;
+                while (j < lines.length && !lines[j].includes(')')) {
+                    j++;
+                }
+                for (let k = i + 1; k < j; k++) {
+                    const importLine = lines[k].trim();
+                    if (importLine.startsWith('//'))
+                        continue;
+                    const pkgMatch = importLine.match(/"([^"]+)"/);
+                    if (pkgMatch) {
+                        imports.push({
+                            module: pkgMatch[1],
+                            names: [],
+                            line: k + 1,
+                            isDynamic: false,
+                        });
+                    }
+                }
+                i = j;
+            }
+        }
+        return imports;
+    }
+    extractErrorHandlers(source) {
+        const handlers = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Match: if err != nil {
+            if (/if\s+err\s*!=\s*nil\s*\{/.test(line)) {
+                const body = this.extractBraceBody(lines, i).join('\n');
+                const strategy = this.classifyGoErrorStrategy(body);
+                handlers.push({
+                    type: 'if-err',
+                    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
+            const funcMatch = line.match(/^\s*func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/);
+            if (funcMatch) {
+                const name = funcMatch[1];
+                patterns.push({
+                    name,
+                    kind: 'function',
+                    convention: classifyCasing(name),
+                });
+                continue;
+            }
+            // Const/var declarations
+            const varMatch = line.match(/^\s*(?:const|var)\s+(\w+)\s*=/);
+            if (varMatch) {
+                const name = varMatch[1];
+                const kind = line.includes('const') ? 'constant' : 'variable';
+                patterns.push({
+                    name,
+                    kind,
+                    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(/\bswitch\s/g) || []).length;
+        count += (cleaned.match(/\bcase\s+/g) || []).length;
+        count += (cleaned.match(/\bselect\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;
+    }
+    classifyGoErrorStrategy(body) {
+        const trimmed = body.trim();
+        if (!trimmed)
+            return 'swallow';
+        if (/\breturn\b.*\berr\b/.test(trimmed))
+            return 'return-error';
+        if (/\breturn\b.*fmt\.Errorf|errors\.Wrap/.test(trimmed))
+            return 'wrap';
+        if (/\bpanic\b/.test(trimmed))
+            return 'panic';
+        if (/\blog\b/.test(trimmed))
+            return 'log';
+        return 'other';
+    }
+}
+export const goAdapter = new GoAdapter();

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

@@ -0,0 +1,15 @@
+/**
+ * Language Adapters — Barrel Export
+ *
+ * Single entry point for the language adapter layer.
+ * Gates import from here: `import { languageAdapters } from './language-adapters/index.js'`
+ */
+export * from './types.js';
+export * from './registry.js';
+export { jsAdapter } from './js-adapter.js';
+export { pythonAdapter } from './python-adapter.js';
+export { goAdapter } from './go-adapter.js';
+export { rubyAdapter } from './ruby-adapter.js';
+export { rustAdapter } from './rust-adapter.js';
+export { csharpAdapter } from './csharp-adapter.js';
+export { javaAdapter } from './java-adapter.js';

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

@@ -0,0 +1,16 @@
+/**
+ * Language Adapters — Barrel Export
+ *
+ * Single entry point for the language adapter layer.
+ * Gates import from here: `import { languageAdapters } from './language-adapters/index.js'`
+ */
+export * from './types.js';
+export * from './registry.js';
+// Individual adapters (for direct use if needed)
+export { jsAdapter } from './js-adapter.js';
+export { pythonAdapter } from './python-adapter.js';
+export { goAdapter } from './go-adapter.js';
+export { rubyAdapter } from './ruby-adapter.js';
+export { rustAdapter } from './rust-adapter.js';
+export { csharpAdapter } from './csharp-adapter.js';
+export { javaAdapter } from './java-adapter.js';

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

@@ -0,0 +1,16 @@
+import type { LanguageAdapter, FunctionFact, ImportFact, ErrorHandlerFact, NamingPattern } from './types.js';
+declare class JavaAdapter implements LanguageAdapter {
+    readonly id = "java";
+    readonly name = "Java/Kotlin";
+    readonly extensions: string[];
+    extractFunctions(source: 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;
+}
+export declare const javaAdapter: JavaAdapter;
+export {};