@rigour-labs/core 3.0.5 → 4.0.0

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

@@ -0,0 +1,374 @@
+/**
+ * Language-specific import checkers and dependency loaders for hallucinated-imports gate.
+ * Go, Ruby, C#, Rust, Java/Kotlin parsers extracted to keep main gate file under 500 lines.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { isGoStdlib, isRubyStdlib, isDotNetFramework, isRustStdCrate, isJavaStdlib, isKotlinStdlib } from './hallucinated-imports-stdlib.js';
+export function checkGoImports(content, file, cwd, projectFiles, hallucinated) {
+    const lines = content.split('\n');
+    let inImportBlock = false;
+    // Try to read go.mod for the module path
+    const goModPath = path.join(cwd, 'go.mod');
+    let modulePath = null;
+    try {
+        if (fs.pathExistsSync(goModPath)) {
+            const goMod = fs.readFileSync(goModPath, 'utf-8');
+            const moduleMatch = goMod.match(/^module\s+(\S+)/m);
+            if (moduleMatch)
+                modulePath = moduleMatch[1];
+        }
+    }
+    catch { /* no go.mod — skip project-relative checks entirely */ }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Detect import block: import ( ... )
+        if (/^import\s*\(/.test(line)) {
+            inImportBlock = true;
+            continue;
+        }
+        if (inImportBlock && line === ')') {
+            inImportBlock = false;
+            continue;
+        }
+        // Single import: import "path"  or  import alias "path"
+        const singleMatch = line.match(/^import\s+(?:\w+\s+)?"([^"]+)"/);
+        const blockMatch = inImportBlock ? line.match(/^\s*(?:\w+\s+)?"([^"]+)"/) : null;
+        const importPath = singleMatch?.[1] || blockMatch?.[1];
+        if (!importPath)
+            continue;
+        // 1. Skip Go standard library — comprehensive list
+        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));
+            if (!hasMatchingFile) {
+                hallucinated.push({
+                    file, line: i + 1, importPath, type: 'go',
+                    reason: `Go import '${importPath}' — package directory '${relPath}' not found in project`,
+                });
+            }
+            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('.'))
+            continue;
+        // 4. No dots, no go.mod match, not stdlib → likely an internal package
+        //    without go.mod context we can't verify, so skip to avoid false positives
+    }
+}
+export function checkRubyImports(content, file, cwd, projectFiles, hallucinated) {
+    const lines = content.split('\n');
+    // Parse Gemfile for known gem dependencies
+    const gemDeps = loadRubyGems(cwd);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Skip comments
+        if (line.startsWith('#'))
+            continue;
+        // require_relative 'path' — must resolve to a real file
+        const relMatch = line.match(/require_relative\s+['"]([^'"]+)['"]/);
+        if (relMatch) {
+            const reqPath = relMatch[1];
+            const dir = path.dirname(file);
+            const resolved = path.join(dir, reqPath).replace(/\\/g, '/');
+            const candidates = [resolved + '.rb', resolved];
+            if (!candidates.some(c => projectFiles.has(c))) {
+                hallucinated.push({
+                    file, line: i + 1, importPath: reqPath, type: 'ruby',
+                    reason: `require_relative '${reqPath}' — file not found in project`,
+                });
+            }
+            continue;
+        }
+        // require 'something' — check stdlib, gems, then local
+        const reqMatch = line.match(/^require\s+['"]([^'"]+)['"]/);
+        if (reqMatch) {
+            const reqPath = reqMatch[1];
+            // Skip Ruby stdlib
+            if (isRubyStdlib(reqPath))
+                continue;
+            // Skip gems listed in Gemfile
+            const gemName = reqPath.split('/')[0];
+            if (gemDeps.has(gemName))
+                continue;
+            // Check if it resolves to a project file
+            const candidates = [
+                reqPath + '.rb',
+                reqPath,
+                'lib/' + reqPath + '.rb',
+                'lib/' + reqPath,
+            ];
+            const found = candidates.some(c => projectFiles.has(c));
+            if (!found) {
+                // If we have a Gemfile and it's not in it, it might be hallucinated
+                if (gemDeps.size > 0) {
+                    hallucinated.push({
+                        file, line: i + 1, importPath: reqPath, type: 'ruby',
+                        reason: `require '${reqPath}' — not in stdlib, Gemfile, or project files`,
+                    });
+                }
+            }
+        }
+    }
+}
+export function loadRubyGems(cwd) {
+    const gems = new Set();
+    try {
+        const gemfilePath = path.join(cwd, 'Gemfile');
+        if (fs.pathExistsSync(gemfilePath)) {
+            const content = fs.readFileSync(gemfilePath, '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 */ }
+            }
+        }
+    }
+    catch { /* no Gemfile */ }
+    return gems;
+}
+export function checkCSharpImports(content, file, cwd, projectFiles, hallucinated) {
+    const lines = content.split('\n');
+    const nugetPackages = loadNuGetPackages(cwd);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Match: using Namespace; and using static Namespace.Class;
+        // Skip: using alias = Namespace; and using (var x = ...) disposable
+        const usingMatch = line.match(/^using\s+(?:static\s+)?([\w.]+)\s*;/);
+        if (!usingMatch)
+            continue;
+        const namespace = usingMatch[1];
+        // 1. Skip .NET framework and BCL namespaces
+        if (isDotNetFramework(namespace))
+            continue;
+        // 2. Skip NuGet packages from .csproj
+        const topLevel = namespace.split('.')[0];
+        if (nugetPackages.has(topLevel) || nugetPackages.has(namespace.split('.').slice(0, 2).join('.')))
+            continue;
+        // 3. Check if the namespace maps to any .cs file in the project
+        //    C# namespaces often have a root prefix (project name) not in the directory tree
+        //    e.g. MyProject.Services.UserService → check Services/UserService AND MyProject/Services/UserService
+        const nsParts = namespace.split('.');
+        const nsPath = namespace.replace(/\./g, '/');
+        // Also check without root prefix (common convention: namespace root != directory root)
+        const nsPathNoRoot = nsParts.slice(1).join('/');
+        const csFiles = [...projectFiles].filter(f => f.endsWith('.cs'));
+        const hasMatch = csFiles.some(f => f.includes(nsPath) || (nsPathNoRoot && f.includes(nsPathNoRoot)));
+        // Only flag if we have .csproj context (proves this is a real .NET project)
+        if (!hasMatch && namespace.includes('.') && nugetPackages.size >= 0) {
+            // Check if we actually have .csproj context (a real .NET project)
+            const hasCsproj = hasCsprojFile(cwd);
+            if (hasCsproj) {
+                hallucinated.push({
+                    file, line: i + 1, importPath: namespace, type: 'csharp',
+                    reason: `Namespace '${namespace}' — no matching files in project, not in NuGet packages`,
+                });
+            }
+        }
+    }
+}
+export function hasCsprojFile(cwd) {
+    try {
+        const files = fs.readdirSync?.(cwd) || [];
+        return files.some((f) => typeof f === 'string' && f.endsWith('.csproj'));
+    }
+    catch {
+        return false;
+    }
+}
+export function loadNuGetPackages(cwd) {
+    const packages = new Set();
+    try {
+        const files = fs.readdirSync?.(cwd) || [];
+        for (const f of files) {
+            if (typeof f === 'string' && f.endsWith('.csproj')) {
+                try {
+                    const content = fs.readFileSync(path.join(cwd, f), 'utf-8');
+                    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]);
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    catch { /* no .csproj */ }
+    return packages;
+}
+export function checkRustImports(content, file, cwd, projectFiles, hallucinated) {
+    const lines = content.split('\n');
+    const cargoDeps = loadCargoDeps(cwd);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('//') || line.startsWith('/*'))
+            continue;
+        // extern crate foo;
+        const externMatch = line.match(/^extern\s+crate\s+(\w+)/);
+        if (externMatch) {
+            const crateName = externMatch[1];
+            if (isRustStdCrate(crateName))
+                continue;
+            if (cargoDeps.has(crateName))
+                continue;
+            hallucinated.push({
+                file, line: i + 1, importPath: crateName, type: 'rust',
+                reason: `extern crate '${crateName}' — not in Cargo.toml or Rust std`,
+            });
+            continue;
+        }
+        // use foo::bar::baz;  or  use foo::{bar, baz};
+        const useMatch = line.match(/^(?:pub\s+)?use\s+(\w+)::/);
+        if (useMatch) {
+            const crateName = useMatch[1];
+            if (isRustStdCrate(crateName))
+                continue;
+            if (cargoDeps.has(crateName))
+                continue;
+            // 'crate' and 'self' and 'super' are Rust path keywords
+            if (['crate', 'self', 'super'].includes(crateName))
+                continue;
+            hallucinated.push({
+                file, line: i + 1, importPath: crateName, type: 'rust',
+                reason: `use ${crateName}:: — crate not in Cargo.toml or Rust std`,
+            });
+        }
+    }
+}
+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;
+            let inDeps = false;
+            for (const line of content.split('\n')) {
+                if (/^\[(?:.*-)?dependencies/.test(line.trim())) {
+                    inDeps = true;
+                    continue;
+                }
+                if (/^\[/.test(line.trim()) && inDeps) {
+                    inDeps = false;
+                    continue;
+                }
+                if (inDeps) {
+                    const m = line.match(/^\s*([\w][\w-]*)\s*=/);
+                    if (m)
+                        deps.add(m[1].replace(/-/g, '_')); // Rust uses _ in code for - in Cargo
+                }
+            }
+        }
+    }
+    catch { /* no Cargo.toml */ }
+    return deps;
+}
+export function checkJavaKotlinImports(content, file, ext, cwd, projectFiles, hallucinated) {
+    const lines = content.split('\n');
+    const buildDeps = loadJavaDeps(cwd);
+    const isKotlin = ext === '.kt';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // import com.example.package.Class
+        const importMatch = line.match(/^import\s+(?:static\s+)?([\w.]+)/);
+        if (!importMatch)
+            continue;
+        const importPath = importMatch[1];
+        // Skip Java stdlib
+        if (isJavaStdlib(importPath))
+            continue;
+        // Skip Kotlin stdlib
+        if (isKotlin && isKotlinStdlib(importPath))
+            continue;
+        // Skip known build dependencies (by group prefix)
+        const parts = importPath.split('.');
+        const group2 = parts.slice(0, 2).join('.');
+        const group3 = parts.slice(0, 3).join('.');
+        if (buildDeps.has(group2) || buildDeps.has(group3))
+            continue;
+        // Check if it resolves to a project file
+        const javaPath = importPath.replace(/\./g, '/');
+        const candidates = [
+            javaPath + '.java',
+            javaPath + '.kt',
+            'src/main/java/' + javaPath + '.java',
+            'src/main/kotlin/' + javaPath + '.kt',
+        ];
+        const found = candidates.some(c => projectFiles.has(c)) ||
+            [...projectFiles].some(f => f.includes(javaPath));
+        if (!found) {
+            // Only flag if we have build deps context (Gradle/Maven project)
+            if (buildDeps.size > 0) {
+                hallucinated.push({
+                    file, line: i + 1, importPath, type: isKotlin ? 'kotlin' : 'java',
+                    reason: `import '${importPath}' — not in stdlib, build deps, or project files`,
+                });
+            }
+        }
+    }
+}
+export function loadJavaDeps(cwd) {
+    const deps = new Set();
+    try {
+        // Gradle: build.gradle or build.gradle.kts
+        for (const gradleFile of ['build.gradle', 'build.gradle.kts']) {
+            const gradlePath = path.join(cwd, gradleFile);
+            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;
+                let m;
+                while ((m = depPattern.exec(content)) !== null) {
+                    deps.add(m[1]); // group ID like "com.google.guava"
+                }
+            }
+        }
+        // Maven: pom.xml
+        const pomPath = path.join(cwd, 'pom.xml');
+        if (fs.pathExistsSync(pomPath)) {
+            const content = fs.readFileSync(pomPath, 'utf-8');
+            const groupPattern = /<groupId>([^<]+)<\/groupId>/g;
+            let m;
+            while ((m = groupPattern.exec(content)) !== null) {
+                deps.add(m[1]);
+            }
+        }
+    }
+    catch { /* no build files */ }
+    return deps;
+}
+export async function loadPackageJson(cwd) {
+    try {
+        const pkgPath = path.join(cwd, 'package.json');
+        if (await fs.pathExists(pkgPath)) {
+            return await fs.readJson(pkgPath);
+        }
+    }
+    catch (e) { }
+    return null;
+}

package/dist/gates/hallucinated-imports-stdlib.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Standard library detection helpers for hallucinated-imports gate.
+ * Each function returns true if the given import path is part of that language's stdlib.
+ */
+export declare function isNodeBuiltin(name: string): boolean;
+export declare function isPythonStdlib(modulePath: string): boolean;
+export declare function isGoStdlib(importPath: string): boolean;
+export declare function isRubyStdlib(name: string): boolean;
+export declare function isDotNetFramework(namespace: string): boolean;
+export declare function isRustStdCrate(name: string): boolean;
+export declare function isJavaStdlib(importPath: string): boolean;
+export declare function isKotlinStdlib(importPath: string): boolean;

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

@@ -0,0 +1,228 @@
+/**
+ * Standard library detection helpers for hallucinated-imports gate.
+ * Each function returns true if the given import path is part of that language's stdlib.
+ */
+export function isNodeBuiltin(name) {
+    // Fast path: node: protocol prefix
+    if (name.startsWith('node:'))
+        return true;
+    const builtins = new Set([
+        'assert', 'assert/strict', 'async_hooks', 'buffer', 'child_process',
+        'cluster', 'console', 'constants', 'crypto', 'dgram', 'diagnostics_channel',
+        'dns', 'dns/promises', 'domain', 'events', 'fs', 'fs/promises',
+        'http', 'http2', 'https', 'inspector', 'inspector/promises', 'module',
+        'net', 'os', 'path', 'path/posix', 'path/win32', 'perf_hooks',
+        'process', 'punycode', 'querystring', 'readline', 'readline/promises',
+        'repl', 'stream', 'stream/consumers', 'stream/promises', 'stream/web',
+        'string_decoder', 'sys', 'test', 'timers', 'timers/promises',
+        'tls', 'trace_events', 'tty', 'url', 'util', 'util/types',
+        'v8', 'vm', 'wasi', 'worker_threads', 'zlib',
+    ]);
+    return builtins.has(name);
+}
+export function isPythonStdlib(modulePath) {
+    const topLevel = modulePath.split('.')[0];
+    const stdlibs = new Set([
+        'abc', 'aifc', 'argparse', 'array', 'ast', 'asyncio', 'atexit',
+        'base64', 'bdb', 'binascii', 'binhex', 'bisect', 'builtins',
+        'calendar', 'cgi', 'cgitb', 'chunk', 'cmath', 'cmd', 'code',
+        'codecs', 'codeop', 'collections', 'colorsys', 'compileall',
+        'concurrent', 'configparser', 'contextlib', 'contextvars', 'copy',
+        'copyreg', 'cProfile', 'csv', 'ctypes', 'curses', 'dataclasses',
+        'datetime', 'dbm', 'decimal', 'difflib', 'dis', 'distutils',
+        'doctest', 'email', 'encodings', 'enum', 'errno', 'faulthandler',
+        'fcntl', 'filecmp', 'fileinput', 'fnmatch', 'fractions', 'ftplib',
+        'functools', 'gc', 'getopt', 'getpass', 'gettext', 'glob', 'grp',
+        'gzip', 'hashlib', 'heapq', 'hmac', 'html', 'http', 'idlelib',
+        'imaplib', 'imghdr', 'importlib', 'inspect', 'io', 'ipaddress',
+        'itertools', 'json', 'keyword', 'lib2to3', 'linecache', 'locale',
+        'logging', 'lzma', 'mailbox', 'mailcap', 'marshal', 'math',
+        'mimetypes', 'mmap', 'modulefinder', 'multiprocessing', 'netrc',
+        'nis', 'nntplib', 'numbers', 'operator', 'optparse', 'os',
+        'ossaudiodev', 'parser', 'pathlib', 'pdb', 'pickle', 'pickletools',
+        'pipes', 'pkgutil', 'platform', 'plistlib', 'poplib', 'posix',
+        'posixpath', 'pprint', 'profile', 'pstats', 'pty', 'pwd', 'py_compile',
+        'pyclbr', 'pydoc', 'queue', 'quopri', 'random', 're', 'readline',
+        'reprlib', 'resource', 'rlcompleter', 'runpy', 'sched', 'secrets',
+        'select', 'selectors', 'shelve', 'shlex', 'shutil', 'signal',
+        'site', 'smtpd', 'smtplib', 'sndhdr', 'socket', 'socketserver',
+        'spwd', 'sqlite3', 'sre_compile', 'sre_constants', 'sre_parse',
+        'ssl', 'stat', 'statistics', 'string', 'stringprep', 'struct',
+        'subprocess', 'sunau', 'symtable', 'sys', 'sysconfig', 'syslog',
+        'tabnanny', 'tarfile', 'telnetlib', 'tempfile', 'termios', 'test',
+        'textwrap', 'threading', 'time', 'timeit', 'tkinter', 'token',
+        'tokenize', 'tomllib', 'trace', 'traceback', 'tracemalloc', 'tty',
+        'turtle', 'turtledemo', 'types', 'typing', 'unicodedata', 'unittest',
+        'urllib', 'uu', 'uuid', 'venv', 'warnings', 'wave', 'weakref',
+        'webbrowser', 'winreg', 'winsound', 'wsgiref', 'xdrlib', 'xml',
+        'xmlrpc', 'zipapp', 'zipfile', 'zipimport', 'zlib',
+        '_thread', '__future__', '__main__',
+    ]);
+    return stdlibs.has(topLevel);
+}
+export function isGoStdlib(importPath) {
+    // Fast check: single-segment packages are always stdlib if no dots
+    if (!importPath.includes('/') && !importPath.includes('.'))
+        return true;
+    // Check the full path against known stdlib packages with sub-paths
+    const topLevel = importPath.split('/')[0];
+    // All Go stdlib top-level packages (including those with sub-packages)
+    const stdlibTopLevel = new Set([
+        // Single-word packages
+        'archive', 'bufio', 'builtin', 'bytes', 'cmp', 'compress',
+        'container', 'context', 'crypto', 'database', 'debug',
+        'embed', 'encoding', 'errors', 'expvar', 'flag', 'fmt',
+        'go', 'hash', 'html', 'image', 'index', 'io', 'iter',
+        'log', 'maps', 'math', 'mime', 'net', 'os', 'path',
+        'plugin', 'reflect', 'regexp', 'runtime', 'slices', 'sort',
+        'strconv', 'strings', 'structs', 'sync', 'syscall',
+        'testing', 'text', 'time', 'unicode', 'unique', 'unsafe',
+        // Internal packages (used by stdlib, sometimes by tools)
+        'internal', 'vendor',
+    ]);
+    if (stdlibTopLevel.has(topLevel))
+        return true;
+    // Explicit full-path list for maximum safety — covers all Go 1.22 stdlib paths
+    // This catches any edge case the top-level check might miss
+    const knownStdlibPaths = new Set([
+        // archive/*
+        'archive/tar', 'archive/zip',
+        // compress/*
+        'compress/bzip2', 'compress/flate', 'compress/gzip', 'compress/lzw', 'compress/zlib',
+        // container/*
+        'container/heap', 'container/list', 'container/ring',
+        // crypto/*
+        'crypto/aes', 'crypto/cipher', 'crypto/des', 'crypto/dsa',
+        'crypto/ecdh', 'crypto/ecdsa', 'crypto/ed25519', 'crypto/elliptic',
+        'crypto/hmac', 'crypto/md5', 'crypto/rand', 'crypto/rc4',
+        'crypto/rsa', 'crypto/sha1', 'crypto/sha256', 'crypto/sha512',
+        'crypto/subtle', 'crypto/tls', 'crypto/x509', 'crypto/x509/pkix',
+        // database/*
+        'database/sql', 'database/sql/driver',
+        // debug/*
+        'debug/buildinfo', 'debug/dwarf', 'debug/elf', 'debug/gosym',
+        'debug/macho', 'debug/pe', 'debug/plan9obj',
+        // encoding/*
+        'encoding/ascii85', 'encoding/asn1', 'encoding/base32', 'encoding/base64',
+        'encoding/binary', 'encoding/csv', 'encoding/gob', 'encoding/hex',
+        'encoding/json', 'encoding/pem', 'encoding/xml',
+        // go/*
+        'go/ast', 'go/build', 'go/build/constraint', 'go/constant',
+        'go/doc', 'go/doc/comment', 'go/format', 'go/importer',
+        'go/parser', 'go/printer', 'go/scanner', 'go/token', 'go/types', 'go/version',
+        // hash/*
+        'hash/adler32', 'hash/crc32', 'hash/crc64', 'hash/fnv', 'hash/maphash',
+        // html/*
+        'html/template',
+        // image/*
+        'image/color', 'image/color/palette', 'image/draw',
+        'image/gif', 'image/jpeg', 'image/png',
+        // index/*
+        'index/suffixarray',
+        // io/*
+        'io/fs', 'io/ioutil',
+        // log/*
+        'log/slog', 'log/syslog',
+        // math/*
+        'math/big', 'math/bits', 'math/cmplx', 'math/rand', 'math/rand/v2',
+        // mime/*
+        'mime/multipart', 'mime/quotedprintable',
+        // net/*
+        'net/http', 'net/http/cgi', 'net/http/cookiejar', 'net/http/fcgi',
+        'net/http/httptest', 'net/http/httptrace', 'net/http/httputil',
+        'net/http/pprof', 'net/mail', 'net/netip', 'net/rpc',
+        'net/rpc/jsonrpc', 'net/smtp', 'net/textproto', 'net/url',
+        // os/*
+        'os/exec', 'os/signal', 'os/user',
+        // path/*
+        'path/filepath',
+        // regexp/*
+        'regexp/syntax',
+        // runtime/*
+        'runtime/cgo', 'runtime/coverage', 'runtime/debug', 'runtime/metrics',
+        'runtime/pprof', 'runtime/race', 'runtime/trace',
+        // sync/*
+        'sync/atomic',
+        // testing/*
+        'testing/fstest', 'testing/iotest', 'testing/quick', 'testing/slogtest',
+        // text/*
+        'text/scanner', 'text/tabwriter', 'text/template', 'text/template/parse',
+        // unicode/*
+        'unicode/utf16', 'unicode/utf8',
+    ]);
+    return knownStdlibPaths.has(importPath);
+}
+export function isRubyStdlib(name) {
+    const topLevel = name.split('/')[0];
+    const stdlibs = new Set([
+        // Core libs (always available)
+        'abbrev', 'base64', 'benchmark', 'bigdecimal', 'cgi', 'csv',
+        'date', 'delegate', 'did_you_mean', 'digest', 'drb', 'english',
+        'erb', 'error_highlight', 'etc', 'fcntl', 'fiddle', 'fileutils',
+        'find', 'forwardable', 'getoptlong', 'io', 'ipaddr', 'irb',
+        'json', 'logger', 'matrix', 'minitest', 'monitor', 'mutex_m',
+        'net', 'nkf', 'objspace', 'observer', 'open3', 'open-uri',
+        'openssl', 'optparse', 'ostruct', 'pathname', 'pp', 'prettyprint',
+        'prime', 'pstore', 'psych', 'racc', 'rake', 'rdoc', 'readline',
+        'reline', 'resolv', 'resolv-replace', 'rinda', 'ruby2_keywords',
+        'rubygems', 'securerandom', 'set', 'shellwords', 'singleton',
+        'socket', 'stringio', 'strscan', 'syntax_suggest', 'syslog',
+        'tempfile', 'time', 'timeout', 'tmpdir', 'tsort', 'un',
+        'unicode_normalize', 'uri', 'weakref', 'yaml', 'zlib',
+        // Default gems (ship with Ruby, can be overridden)
+        'bundler', 'debug', 'net-ftp', 'net-http', 'net-imap',
+        'net-pop', 'net-protocol', 'net-smtp', 'power_assert',
+        'test-unit', 'rexml', 'rss', 'typeprof',
+        // Common C extensions
+        'stringio', 'io/console', 'io/nonblock', 'io/wait',
+        'rbconfig', 'mkmf', 'thread',
+        // Rails-adjacent but actually stdlib
+        'webrick', 'cmath', 'complex', 'rational',
+        'coverage', 'ripper', 'win32ole', 'win32api',
+    ]);
+    return stdlibs.has(topLevel);
+}
+export function isDotNetFramework(namespace) {
+    const topLevel = namespace.split('.')[0];
+    const frameworkPrefixes = new Set([
+        // BCL / .NET Runtime
+        'System', 'Microsoft', 'Windows',
+        // Common ecosystem (NuGet defaults everyone uses)
+        'Newtonsoft', 'NUnit', 'Xunit', 'Moq', 'AutoMapper',
+        'FluentAssertions', 'FluentValidation', 'Serilog', 'NLog',
+        'Dapper', 'MediatR', 'Polly', 'Swashbuckle', 'Hangfire',
+        'StackExchange', 'Npgsql', 'MongoDB', 'MySql', 'Oracle',
+        'Amazon', 'Google', 'Azure', 'Grpc',
+        'Bogus', 'Humanizer', 'CsvHelper', 'MailKit', 'MimeKit',
+        'RestSharp', 'Refit', 'AutoFixture', 'Shouldly',
+        'IdentityModel', 'IdentityServer4',
+    ]);
+    return frameworkPrefixes.has(topLevel);
+}
+export function isRustStdCrate(name) {
+    const stdCrates = new Set([
+        'std', 'core', 'alloc', 'proc_macro', 'test',
+        // Common proc-macro / compiler crates
+        'proc_macro2', 'syn', 'quote',
+    ]);
+    return stdCrates.has(name);
+}
+export function isJavaStdlib(importPath) {
+    const prefixes = [
+        'java.', 'javax.', 'jakarta.',
+        'sun.', 'com.sun.', 'jdk.',
+        // Android SDK
+        'android.', 'androidx.',
+        // Common ecosystem (so ubiquitous they're basically stdlib)
+        'org.junit.', 'org.slf4j.', 'org.apache.logging.',
+    ];
+    return prefixes.some(p => importPath.startsWith(p));
+}
+export function isKotlinStdlib(importPath) {
+    const prefixes = [
+        'kotlin.', 'kotlinx.',
+        // Java interop (Kotlin can use Java stdlib directly)
+        'java.', 'javax.', 'jakarta.',
+    ];
+    return prefixes.some(p => importPath.startsWith(p));
+}