@rigour-labs/core 5.0.1 → 5.1.1

package/dist/gates/hallucinated-imports-lang.js

@@ -9,8 +9,8 @@ export function checkGoImports(content, file, cwd, projectFiles, hallucinated) {
     const lines = content.split('\n');
     let inImportBlock = false;
     // Find go.mod by walking up from the Go file's directory (monorepo support).
-    // A monorepo may have go.mod in subdirectories like kubernetes/go.mod, server/go.mod, etc.
     let modulePath = null;
+    const replaceModules = new Set(); // Modules with local replace directives
     const fileAbsDir = path.dirname(path.resolve(cwd, file));
     const rootDir = path.resolve(cwd);
     let searchDir = fileAbsDir;
@@ -22,8 +22,26 @@ export function checkGoImports(content, file, cwd, projectFiles, hallucinated) {
                 const moduleMatch = goMod.match(/^module\s+(\S+)/m);
                 if (moduleMatch) {
                     modulePath = moduleMatch[1];
-                    break;
                 }
+                // Parse replace directives: replace github.com/foo/bar => ../local-bar
+                // These modules are valid even without being in go.sum
+                const replacePattern = /^replace\s+(\S+)\s+=>\s+/gm;
+                let rm;
+                while ((rm = replacePattern.exec(goMod)) !== null) {
+                    replaceModules.add(rm[1]);
+                }
+                // Also handle replace blocks: replace ( ... )
+                const replaceBlockMatch = goMod.match(/^replace\s*\(([\s\S]*?)\)/m);
+                if (replaceBlockMatch) {
+                    const blockLines = replaceBlockMatch[1].split('\n');
+                    for (const bl of blockLines) {
+                        const blMatch = bl.trim().match(/^(\S+)\s+=>/);
+                        if (blMatch)
+                            replaceModules.add(blMatch[1]);
+                    }
+                }
+                if (modulePath)
+                    break;
             }
         }
         catch { /* skip */ }
@@ -32,6 +50,30 @@ export function checkGoImports(content, file, cwd, projectFiles, hallucinated) {
             break;
         searchDir = parent;
     }
+    // Check for go.work file (Go workspace mode)
+    const goWorkModules = new Set();
+    try {
+        const goWorkPath = path.join(rootDir, 'go.work');
+        if (fs.pathExistsSync(goWorkPath)) {
+            const goWork = fs.readFileSync(goWorkPath, 'utf-8');
+            // use directives: use ./service-a or use ( ./service-a ./service-b )
+            const usePattern = /use\s+(\.\S+)/g;
+            let um;
+            while ((um = usePattern.exec(goWork)) !== null) {
+                // Read go.mod from each workspace member
+                const memberModPath = path.join(rootDir, um[1], 'go.mod');
+                if (fs.pathExistsSync(memberModPath)) {
+                    const memberMod = fs.readFileSync(memberModPath, 'utf-8');
+                    const memberModMatch = memberMod.match(/^module\s+(\S+)/m);
+                    if (memberModMatch)
+                        goWorkModules.add(memberModMatch[1]);
+                }
+            }
+        }
+    }
+    catch { /* skip */ }
+    // Check for vendor/ directory — if it exists, all vendored modules are valid
+    const hasVendor = fs.pathExistsSync(path.join(rootDir, 'vendor'));
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i].trim();
         // Detect import block: import ( ... )
@@ -53,7 +95,6 @@ export function checkGoImports(content, file, cwd, projectFiles, hallucinated) {
         if (isGoStdlib(importPath))
             continue;
         // 2. If we have a module path, check project-relative imports FIRST
-        //    (project imports like github.com/myorg/project/pkg also have dots)
         if (modulePath && importPath.startsWith(modulePath + '/')) {
             const relPath = importPath.slice(modulePath.length + 1);
             const hasMatchingFile = [...projectFiles].some(f => f.endsWith('.go') && f.startsWith(relPath));
@@ -65,6 +106,29 @@ export function checkGoImports(content, file, cwd, projectFiles, hallucinated) {
             }
             continue;
         }
+        // 2b. Check if import matches a go.work workspace member module
+        let matchesWorkspace = false;
+        for (const wm of goWorkModules) {
+            if (importPath === wm || importPath.startsWith(wm + '/')) {
+                matchesWorkspace = true;
+                break;
+            }
+        }
+        if (matchesWorkspace)
+            continue;
+        // 2c. Check if import matches a replace directive (local replacement)
+        let matchesReplace = false;
+        for (const rm of replaceModules) {
+            if (importPath === rm || importPath.startsWith(rm + '/')) {
+                matchesReplace = true;
+                break;
+            }
+        }
+        if (matchesReplace)
+            continue;
+        // 2d. If vendor/ exists, all external imports are valid (vendored)
+        if (hasVendor && importPath.includes('.'))
+            continue;
         // 3. Skip external modules — any import containing a dot is a domain
         //    e.g. github.com/*, google.golang.org/*, go.uber.org/*
         if (importPath.includes('.'))
@@ -128,36 +192,60 @@ export function checkRubyImports(content, file, cwd, projectFiles, hallucinated)
         }
     }
 }
-export function loadRubyGems(cwd) {
+export function loadRubyGems(cwd, projectFiles) {
     const gems = new Set();
-    try {
-        const gemfilePath = path.join(cwd, 'Gemfile');
-        if (fs.pathExistsSync(gemfilePath)) {
-            const content = fs.readFileSync(gemfilePath, 'utf-8');
+    const parseGemfile = (filePath) => {
+        try {
+            if (!fs.pathExistsSync(filePath))
+                return;
+            const content = fs.readFileSync(filePath, 'utf-8');
             const gemPattern = /gem\s+['"]([^'"]+)['"]/g;
             let m;
             while ((m = gemPattern.exec(content)) !== null) {
                 gems.add(m[1]);
             }
         }
-        // Also check .gemspec
-        const gemspecs = [...new Set()]; // placeholder
-        const files = fs.readdirSync?.(cwd) || [];
-        for (const f of files) {
-            if (typeof f === 'string' && f.endsWith('.gemspec')) {
-                try {
-                    const spec = fs.readFileSync(path.join(cwd, f), 'utf-8');
-                    const depPattern = /add_(?:runtime_)?dependency\s+['"]([^'"]+)['"]/g;
-                    let dm;
-                    while ((dm = depPattern.exec(spec)) !== null) {
-                        gems.add(dm[1]);
-                    }
+        catch { /* skip */ }
+    };
+    const parseGemspec = (filePath) => {
+        try {
+            if (!fs.pathExistsSync(filePath))
+                return;
+            const spec = fs.readFileSync(filePath, 'utf-8');
+            // add_runtime_dependency, add_dependency, add_development_dependency
+            const depPattern = /add_(?:runtime_|development_)?dependency\s+['"]([^'"]+)['"]/g;
+            let dm;
+            while ((dm = depPattern.exec(spec)) !== null) {
+                gems.add(dm[1]);
+            }
+        }
+        catch { /* skip */ }
+    };
+    // Parse root Gemfile
+    parseGemfile(path.join(cwd, 'Gemfile'));
+    // Discover ALL Gemfiles and .gemspec files in the project (monorepo support)
+    if (projectFiles) {
+        for (const f of projectFiles) {
+            if (f.endsWith('Gemfile') || f.endsWith('/Gemfile')) {
+                parseGemfile(path.join(cwd, f));
+            }
+            if (f.endsWith('.gemspec')) {
+                parseGemspec(path.join(cwd, f));
+            }
+        }
+    }
+    else {
+        // Fallback: check root directory only
+        try {
+            const files = fs.readdirSync?.(cwd) || [];
+            for (const f of files) {
+                if (typeof f === 'string' && f.endsWith('.gemspec')) {
+                    parseGemspec(path.join(cwd, f));
                 }
-                catch { /* skip */ }
             }
         }
+        catch { /* skip */ }
     }
-    catch { /* no Gemfile */ }
     return gems;
 }
 export function checkCSharpImports(content, file, cwd, projectFiles, hallucinated) {
@@ -218,16 +306,57 @@ export function loadNuGetPackages(cwd) {
             if (typeof f === 'string' && f.endsWith('.csproj')) {
                 try {
                     const content = fs.readFileSync(path.join(cwd, f), 'utf-8');
+                    // PackageReference — NuGet packages
                     const pkgPattern = /PackageReference\s+Include="([^"]+)"/g;
                     let m;
                     while ((m = pkgPattern.exec(content)) !== null) {
                         packages.add(m[1]);
-                        // Also add top-level namespace (e.g. Newtonsoft.Json → Newtonsoft)
                         packages.add(m[1].split('.')[0]);
                     }
+                    // ProjectReference — sibling projects (their namespaces become valid)
+                    const projRefPattern = /ProjectReference\s+Include="([^"]+)"/g;
+                    let pr;
+                    while ((pr = projRefPattern.exec(content)) !== null) {
+                        // Extract project name from path: "../MyLib/MyLib.csproj" → "MyLib"
+                        const projName = path.basename(pr[1], '.csproj');
+                        packages.add(projName);
+                    }
+                    // RootNamespace — project's own root namespace
+                    const nsMatch = content.match(/<RootNamespace>([^<]+)<\/RootNamespace>/);
+                    if (nsMatch) {
+                        packages.add(nsMatch[1]);
+                        packages.add(nsMatch[1].split('.')[0]);
+                    }
                 }
                 catch { /* skip */ }
             }
+            // Legacy packages.config format
+            if (typeof f === 'string' && f === 'packages.config') {
+                try {
+                    const content = fs.readFileSync(path.join(cwd, f), 'utf-8');
+                    const pkgPattern = /id="([^"]+)"/g;
+                    let m;
+                    while ((m = pkgPattern.exec(content)) !== null) {
+                        packages.add(m[1]);
+                        packages.add(m[1].split('.')[0]);
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+        // Check Directory.Build.props for shared package references
+        const buildPropsPath = path.join(cwd, 'Directory.Build.props');
+        if (fs.pathExistsSync(buildPropsPath)) {
+            try {
+                const content = fs.readFileSync(buildPropsPath, 'utf-8');
+                const pkgPattern = /PackageReference\s+Include="([^"]+)"/g;
+                let m;
+                while ((m = pkgPattern.exec(content)) !== null) {
+                    packages.add(m[1]);
+                    packages.add(m[1].split('.')[0]);
+                }
+            }
+            catch { /* skip */ }
         }
     }
     catch { /* no .csproj */ }
@@ -294,31 +423,85 @@ export function checkRustImports(content, file, cwd, projectFiles, hallucinated)
 }
 export function loadCargoDeps(cwd) {
     const deps = new Set();
-    try {
-        const cargoPath = path.join(cwd, 'Cargo.toml');
-        if (fs.pathExistsSync(cargoPath)) {
-            const content = fs.readFileSync(cargoPath, 'utf-8');
-            // Match [dependencies] section entries: name = "version" or name = { ... }
-            const depPattern = /^\s*(\w[\w-]*)\s*=/gm;
+    const parseCargoToml = (filePath) => {
+        try {
+            if (!fs.pathExistsSync(filePath))
+                return;
+            const content = fs.readFileSync(filePath, 'utf-8');
+            // Parse ALL dependency sections: [dependencies], [dev-dependencies], [build-dependencies]
+            // Also handle [target.'cfg(...)'.dependencies]
             let inDeps = false;
             for (const line of content.split('\n')) {
-                if (/^\[(?:.*-)?dependencies/.test(line.trim())) {
+                const trimmed = line.trim();
+                // Match any dependencies section header
+                if (/^\[(?:(?:dev|build)-)?dependencies(?:\.]|\])/.test(trimmed) ||
+                    /^\[target\.[^\]]*\.(?:(?:dev|build)-)?dependencies\]/.test(trimmed) ||
+                    /^\[workspace\.dependencies\]/.test(trimmed)) {
                     inDeps = true;
                     continue;
                 }
-                if (/^\[/.test(line.trim()) && inDeps) {
+                if (/^\[/.test(trimmed) && inDeps) {
                     inDeps = false;
                     continue;
                 }
                 if (inDeps) {
-                    const m = line.match(/^\s*([\w][\w-]*)\s*=/);
+                    const m = trimmed.match(/^([\w][\w-]*)\s*=/);
                     if (m)
                         deps.add(m[1].replace(/-/g, '_')); // Rust uses _ in code for - in Cargo
                 }
             }
+            // Handle [dependencies.foo] format (inline table)
+            const inlineDepPattern = /^\[(?:(?:dev|build)-)?dependencies\.([\w][\w-]*)\]/gm;
+            let dm;
+            while ((dm = inlineDepPattern.exec(content)) !== null) {
+                deps.add(dm[1].replace(/-/g, '_'));
+            }
+            // Handle [features] section — optional deps are valid when feature is enabled
+            let inFeatures = false;
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed === '[features]') {
+                    inFeatures = true;
+                    continue;
+                }
+                if (/^\[/.test(trimmed) && inFeatures) {
+                    inFeatures = false;
+                    continue;
+                }
+                if (inFeatures) {
+                    // Features reference dep names: feature = ["dep:foo", "bar/feature"]
+                    const depRefs = trimmed.match(/"dep:(\w[\w-]*)"/g);
+                    if (depRefs) {
+                        for (const ref of depRefs) {
+                            const name = ref.match(/"dep:(\w[\w-]*)"/)?.[1];
+                            if (name)
+                                deps.add(name.replace(/-/g, '_'));
+                        }
+                    }
+                }
+            }
         }
+        catch { /* skip */ }
+    };
+    // Parse the Cargo.toml in the working directory
+    parseCargoToml(path.join(cwd, 'Cargo.toml'));
+    // Walk up to find workspace Cargo.toml
+    let searchDir = cwd;
+    const rootDir = path.parse(cwd).root;
+    while (searchDir !== rootDir) {
+        const parentCargoPath = path.join(searchDir, 'Cargo.toml');
+        if (fs.pathExistsSync(parentCargoPath)) {
+            const content = fs.readFileSync(parentCargoPath, 'utf-8');
+            if (content.includes('[workspace]')) {
+                parseCargoToml(parentCargoPath);
+                break;
+            }
+        }
+        const parent = path.dirname(searchDir);
+        if (parent === searchDir)
+            break;
+        searchDir = parent;
     }
-    catch { /* no Cargo.toml */ }
     return deps;
 }
 export function checkJavaKotlinImports(content, file, ext, cwd, projectFiles, hallucinated) {
@@ -375,11 +558,45 @@ export function loadJavaDeps(cwd) {
             if (fs.pathExistsSync(gradlePath)) {
                 const content = fs.readFileSync(gradlePath, 'utf-8');
                 // Match: implementation 'group:artifact:version' or "group:artifact:version"
-                const depPattern = /(?:implementation|api|compile|testImplementation|runtimeOnly)\s*[('"]([^:'"]+)/g;
+                const depPattern = /(?:implementation|api|compile|testImplementation|testCompile|runtimeOnly|compileOnly|annotationProcessor)\s*[('"]([^:'"]+)/g;
                 let m;
                 while ((m = depPattern.exec(content)) !== null) {
                     deps.add(m[1]); // group ID like "com.google.guava"
                 }
+                // Also match Kotlin DSL format: implementation("group:artifact:version")
+                const kotlinDslPattern = /(?:implementation|api|testImplementation|runtimeOnly|compileOnly)\s*\(\s*"([^:"]+)/g;
+                while ((m = kotlinDslPattern.exec(content)) !== null) {
+                    deps.add(m[1]);
+                }
+            }
+        }
+        // Gradle settings.gradle(.kts) — find included modules
+        for (const settingsFile of ['settings.gradle', 'settings.gradle.kts']) {
+            const settingsPath = path.join(cwd, settingsFile);
+            if (fs.pathExistsSync(settingsPath)) {
+                try {
+                    const content = fs.readFileSync(settingsPath, 'utf-8');
+                    // include ':module-a', ':module-b'
+                    const includePattern = /include\s*[('"]([^'"]+)/g;
+                    let im;
+                    while ((im = includePattern.exec(content)) !== null) {
+                        const moduleName = im[1].replace(/^:/, '');
+                        deps.add(moduleName);
+                    }
+                    // includeBuild('../composite-project')
+                    const compositePat = /includeBuild\s*\(\s*['"]([^'"]+)/g;
+                    while ((im = compositePat.exec(content)) !== null) {
+                        // Read the included build's group
+                        const compositePath = path.resolve(cwd, im[1], 'build.gradle');
+                        if (fs.pathExistsSync(compositePath)) {
+                            const compositeContent = fs.readFileSync(compositePath, 'utf-8');
+                            const groupMatch = compositeContent.match(/group\s*=\s*['"]([^'"]+)/);
+                            if (groupMatch)
+                                deps.add(groupMatch[1]);
+                        }
+                    }
+                }
+                catch { /* skip */ }
             }
         }
         // Maven: pom.xml
@@ -391,6 +608,24 @@ export function loadJavaDeps(cwd) {
             while ((m = groupPattern.exec(content)) !== null) {
                 deps.add(m[1]);
             }
+            // Maven <modules> — multi-module projects
+            const modulePattern = /<module>([^<]+)<\/module>/g;
+            while ((m = modulePattern.exec(content)) !== null) {
+                deps.add(m[1]);
+                // Also load deps from submodule pom.xml
+                const subPomPath = path.join(cwd, m[1], 'pom.xml');
+                if (fs.pathExistsSync(subPomPath)) {
+                    try {
+                        const subContent = fs.readFileSync(subPomPath, 'utf-8');
+                        const subGroupPattern = /<groupId>([^<]+)<\/groupId>/g;
+                        let sm;
+                        while ((sm = subGroupPattern.exec(subContent)) !== null) {
+                            deps.add(sm[1]);
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
         }
     }
     catch { /* no build files */ }

package/dist/gates/hallucinated-imports.test.js

@@ -6,10 +6,9 @@
  * Tests the fix for Go stdlib false positives (PicoClaw regression)
  * and validates all 8 language checkers for false positive/negative accuracy.
  *
- * @since v3.0.1
  */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HallucinatedImportsGate } from './hallucinated-imports.js';
+import { HallucinatedImportsGate } from './hallucinated-imports/index.js';
 import path from 'path';
 // Mock fs-extra — vi.hoisted ensures these are available when vi.mock runs (hoisted)
 const { mockPathExists, mockPathExistsSync, mockReadFile, mockReadFileSync, mockReadJson, mockReaddirSync } = vi.hoisted(() => ({

package/dist/gates/inconsistent-error-handling.d.ts

@@ -17,7 +17,6 @@
  * - File C: catch(e) { return null }
  * - File D: catch(e) { [empty] }
  *
- * @since v2.16.0
  */
 import { Gate, GateContext } from './base.js';
 import { Failure, Provenance } from '../types/index.js';
@@ -32,9 +31,5 @@ export declare class InconsistentErrorHandlingGate extends Gate {
     constructor(config?: InconsistentErrorHandlingConfig);
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
-    private extractErrorHandlers;
-    private classifyStrategy;
-    private extractCatchBody;
-    private extractCatchCallbackBody;
     private shouldSkipFile;
 }

package/dist/gates/inconsistent-error-handling.js

@@ -17,11 +17,11 @@
  * - File C: catch(e) { return null }
  * - File D: catch(e) { [empty] }
  *
- * @since v2.16.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 fs from 'fs-extra';
 import path from 'path';
 export class InconsistentErrorHandlingGate extends Gate {
@@ -41,7 +41,7 @@ export class InconsistentErrorHandlingGate extends Gate {
             return [];
         const failures = [];
         const handlers = [];
-        const scanPatterns = context.patterns || ['**/*.{ts,js,tsx,jsx}'];
+        const scanPatterns = context.patterns || languageAdapters.getScanPatterns();
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
             patterns: scanPatterns,
@@ -53,7 +53,19 @@ export class InconsistentErrorHandlingGate extends Gate {
                 continue;
             try {
                 const content = await fs.readFile(path.join(context.cwd, file), 'utf-8');
-                this.extractErrorHandlers(content, file, handlers);
+                const adapter = languageAdapters.getAdapter(file);
+                if (!adapter)
+                    continue;
+                const errorHandlerFacts = adapter.extractErrorHandlers(content);
+                for (const fact of errorHandlerFacts) {
+                    handlers.push({
+                        file,
+                        line: fact.startLine,
+                        errorType: fact.type,
+                        strategy: fact.strategy,
+                        rawPattern: fact.body.split('\n')[0]?.trim() || '',
+                    });
+                }
             }
             catch (e) { }
         }
@@ -96,147 +108,6 @@ export class InconsistentErrorHandlingGate extends Gate {
         }
         return failures;
     }
-    extractErrorHandlers(content, file, handlers) {
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            // Match catch clauses: catch (e), catch (error: Error), catch (e: TypeError)
-            const catchMatch = lines[i].match(/\bcatch\s*\(\s*(\w+)(?:\s*:\s*(\w+))?\s*\)/);
-            if (!catchMatch)
-                continue;
-            const varName = catchMatch[1];
-            const explicitType = catchMatch[2] || 'any';
-            // Extract catch body (up to next closing brace at same level)
-            const body = this.extractCatchBody(lines, i);
-            if (!body)
-                continue;
-            const strategy = this.classifyStrategy(body, varName);
-            const rawPattern = body.split('\n')[0]?.trim() || '';
-            handlers.push({
-                file,
-                line: i + 1,
-                errorType: explicitType,
-                strategy,
-                rawPattern,
-            });
-        }
-        // Also detect .catch() promise patterns
-        for (let i = 0; i < lines.length; i++) {
-            const catchMatch = lines[i].match(/\.catch\s*\(\s*(?:async\s+)?(?:\(\s*)?(\w+)/);
-            if (!catchMatch)
-                continue;
-            const varName = catchMatch[1];
-            // Extract the callback body
-            const body = this.extractCatchCallbackBody(lines, i);
-            if (!body)
-                continue;
-            const strategy = this.classifyStrategy(body, varName);
-            handlers.push({
-                file,
-                line: i + 1,
-                errorType: 'Promise',
-                strategy,
-                rawPattern: body.split('\n')[0]?.trim() || '',
-            });
-        }
-    }
-    classifyStrategy(body, varName) {
-        const trimmed = body.trim();
-        // Empty catch (swallow)
-        if (!trimmed || trimmed === '{}' || trimmed === '') {
-            return 'swallow';
-        }
-        // Re-throw
-        if (/\bthrow\b/.test(trimmed)) {
-            if (/\bthrow\s+new\b/.test(trimmed))
-                return 'wrap-and-throw';
-            if (new RegExp(`\\bthrow\\s+${varName}\\b`).test(trimmed))
-                return 'rethrow';
-            return 'throw-new';
-        }
-        // Return patterns
-        if (/\breturn\s+null\b/.test(trimmed))
-            return 'return-null';
-        if (/\breturn\s+undefined\b/.test(trimmed) || /\breturn\s*;/.test(trimmed))
-            return 'return-undefined';
-        if (/\breturn\s+\[\s*\]/.test(trimmed))
-            return 'return-empty-array';
-        if (/\breturn\s+\{\s*\}/.test(trimmed))
-            return 'return-empty-object';
-        if (/\breturn\s+false\b/.test(trimmed))
-            return 'return-false';
-        if (/\breturn\s+/.test(trimmed))
-            return 'return-value';
-        // Logging patterns
-        if (/console\.(error|warn)\b/.test(trimmed))
-            return 'log-error';
-        if (/console\.log\b/.test(trimmed))
-            return 'log-info';
-        if (/\blogger\b/i.test(trimmed) || /\blog\b/i.test(trimmed))
-            return 'log-custom';
-        // Process.exit
-        if (/process\.exit\b/.test(trimmed))
-            return 'exit';
-        // Response patterns (Express/HTTP)
-        if (/\bres\s*\.\s*status\b/.test(trimmed) || /\bres\s*\.\s*json\b/.test(trimmed))
-            return 'http-response';
-        // Notification patterns
-        if (/\bnotif|toast|alert|modal\b/i.test(trimmed))
-            return 'user-notification';
-        return 'other';
-    }
-    extractCatchBody(lines, catchLine) {
-        let braceDepth = 0;
-        let started = false;
-        const body = [];
-        for (let i = catchLine; i < lines.length; i++) {
-            for (const ch of lines[i]) {
-                if (ch === '{') {
-                    braceDepth++;
-                    started = true;
-                }
-                if (ch === '}')
-                    braceDepth--;
-            }
-            if (started && i > catchLine)
-                body.push(lines[i]);
-            if (started && braceDepth === 0)
-                break;
-        }
-        return body.length > 0 ? body.join('\n') : null;
-    }
-    extractCatchCallbackBody(lines, startLine) {
-        // Detect if this is an arrow function (.catch(e => { ... }))
-        const hasArrow = lines[startLine]?.includes('=>');
-        let braceDepth = 0;
-        let started = false;
-        const body = [];
-        for (let i = startLine; i < Math.min(startLine + 20, lines.length); i++) {
-            for (const ch of lines[i]) {
-                // For arrow functions, only track braces (not parens) for body extraction
-                if (hasArrow) {
-                    if (ch === '{') {
-                        braceDepth++;
-                        started = true;
-                    }
-                    if (ch === '}')
-                        braceDepth--;
-                }
-                else {
-                    if (ch === '{' || ch === '(') {
-                        braceDepth++;
-                        started = true;
-                    }
-                    if (ch === '}' || ch === ')')
-                        braceDepth--;
-                }
-            }
-            if (started && i > startLine)
-                body.push(lines[i]);
-            if (started && braceDepth <= 0)
-                break;
-        }
-        return body.length > 0 ? body.join('\n') : null;
-    }
     shouldSkipFile(file) {
         const normalized = file.replace(/\\/g, '/');
         return (normalized.includes('/examples/') ||

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

@@ -0,0 +1,16 @@
+import type { LanguageAdapter, FunctionFact, ImportFact, ErrorHandlerFact, NamingPattern } from './types.js';
+declare class CSharpAdapter implements LanguageAdapter {
+    readonly id = "csharp";
+    readonly name = "C#";
+    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 csharpAdapter: CSharpAdapter;
+export {};