@rigour-labs/core 4.0.4 → 4.1.0

package/dist/gates/deprecated-apis.js

@@ -52,12 +52,14 @@ export class DeprecatedApisGate extends Gate {
             cwd: context.cwd,
             patterns: ['**/*.{ts,js,tsx,jsx,py,go,cs,java,kt}'],
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
+                '**/*.test.*', '**/*.spec.*', '**/__tests__/**',
                 '**/.venv/**', '**/venv/**', '**/vendor/**', '**/__pycache__/**',
                 '**/bin/Debug/**', '**/bin/Release/**', '**/obj/**',
                 '**/target/**', '**/.gradle/**', '**/out/**'],
         });
-        Logger.info(`Deprecated APIs: Scanning ${files.length} files`);
-        for (const file of files) {
+        const analyzableFiles = files.filter(file => !this.shouldSkipFile(file));
+        Logger.info(`Deprecated APIs: Scanning ${analyzableFiles.length} files`);
+        for (const file of analyzableFiles) {
             try {
                 const fullPath = path.join(context.cwd, file);
                 const content = await fs.readFile(fullPath, 'utf-8');
@@ -105,6 +107,17 @@ export class DeprecatedApisGate extends Gate {
         }
         return failures;
     }
+    shouldSkipFile(file) {
+        const normalized = file.replace(/\\/g, '/');
+        return (this.config.ignore_patterns.some(pattern => new RegExp(pattern).test(normalized)) ||
+            normalized.includes('/examples/') ||
+            normalized.includes('/__tests__/') ||
+            normalized.endsWith('/deprecated-apis-rules-node.ts') ||
+            normalized.endsWith('/deprecated-apis-rules-lang.ts') ||
+            normalized.endsWith('/deprecated-apis-rules.ts') ||
+            /\.test\.[^.]+$/i.test(normalized) ||
+            /\.spec\.[^.]+$/i.test(normalized));
+    }
     checkNodeDeprecated(content, file, deprecated) {
         const lines = content.split('\n');
         for (let i = 0; i < lines.length; i++) {

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

@@ -40,8 +40,22 @@ export declare class HallucinatedImportsGate extends Gate {
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
     private checkJSImports;
+    private collectJSImportSpecs;
+    private resolveJSDepsForFile;
+    private resolveTsPathAlias;
+    private matchTsPathRule;
+    private resolveTsPathTarget;
+    private resolveTsPathConfigForFile;
+    private loadTsPathConfig;
+    private readLooseJson;
     private checkPyImports;
     private resolveRelativeImport;
     private extractPackageName;
     private shouldIgnore;
+    /**
+     * Build candidate source paths for an import.
+     * Handles ESM-style TS source imports like "./foo.js" that map to "./foo.ts" pre-build.
+     */
+    private buildImportCandidates;
+    private shouldSkipFile;
 }

package/dist/gates/hallucinated-imports.js

@@ -24,6 +24,7 @@ import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
 import fs from 'fs-extra';
 import path from 'path';
+import ts from 'typescript';
 import { isNodeBuiltin, isPythonStdlib } from './hallucinated-imports-stdlib.js';
 import { checkGoImports, checkRubyImports, checkCSharpImports, checkRustImports, checkJavaKotlinImports, loadPackageJson } from './hallucinated-imports-lang.js';
 export class HallucinatedImportsGate extends Gate {
@@ -50,28 +51,35 @@ export class HallucinatedImportsGate extends Gate {
             cwd: context.cwd,
             patterns: ['**/*.{ts,js,tsx,jsx,py,go,rb,cs,rs,java,kt}'],
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
+                '**/examples/**',
+                '**/studio-dist/**', '**/.next/**', '**/coverage/**',
+                '**/*.test.*', '**/*.spec.*', '**/__tests__/**',
                 '**/.venv/**', '**/venv/**', '**/vendor/**', '**/bin/Debug/**', '**/bin/Release/**', '**/obj/**',
                 '**/target/debug/**', '**/target/release/**', // Rust
                 '**/out/**', '**/.gradle/**', '**/gradle/**'], // Java/Kotlin
         });
-        Logger.info(`Hallucinated Imports: Scanning ${files.length} files`);
+        const analyzableFiles = files.filter(file => !this.shouldSkipFile(file));
+        Logger.info(`Hallucinated Imports: Scanning ${analyzableFiles.length} files`);
         // Build lookup sets for fast resolution
-        const projectFiles = new Set(files.map(f => f.replace(/\\/g, '/')));
+        const projectFiles = new Set(analyzableFiles.map(f => f.replace(/\\/g, '/')));
         const packageJson = await loadPackageJson(context.cwd);
-        const allDeps = new Set([
+        const rootDeps = new Set([
             ...Object.keys(packageJson?.dependencies || {}),
             ...Object.keys(packageJson?.devDependencies || {}),
             ...Object.keys(packageJson?.peerDependencies || {}),
+            ...Object.keys(packageJson?.optionalDependencies || {}),
         ]);
+        const depCacheByDir = new Map();
+        const tsPathCacheByDir = new Map();
         // Check if node_modules exists (for package verification)
         const hasNodeModules = await fs.pathExists(path.join(context.cwd, 'node_modules'));
-        for (const file of files) {
+        for (const file of analyzableFiles) {
             try {
                 const fullPath = path.join(context.cwd, file);
                 const content = await fs.readFile(fullPath, 'utf-8');
                 const ext = path.extname(file);
                 if (['.ts', '.js', '.tsx', '.jsx'].includes(ext)) {
-                    await this.checkJSImports(content, file, context.cwd, projectFiles, allDeps, hasNodeModules, hallucinated);
+                    await this.checkJSImports(content, file, context.cwd, projectFiles, rootDeps, depCacheByDir, hasNodeModules, hallucinated, tsPathCacheByDir);
                 }
                 else if (ext === '.py') {
                     await this.checkPyImports(content, file, context.cwd, projectFiles, hallucinated);
@@ -107,62 +115,230 @@ export class HallucinatedImportsGate extends Gate {
         }
         return failures;
     }
-    async checkJSImports(content, file, cwd, projectFiles, allDeps, hasNodeModules, hallucinated) {
-        const lines = content.split('\n');
-        // Match: import ... from '...', require('...'), import('...')
-        const importPatterns = [
-            /import\s+(?:{[^}]*}|\*\s+as\s+\w+|\w+(?:\s*,\s*{[^}]*})?)\s+from\s+['"]([^'"]+)['"]/g,
-            /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-            /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-            /export\s+(?:{[^}]*}|\*)\s+from\s+['"]([^'"]+)['"]/g,
-        ];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            for (const pattern of importPatterns) {
-                pattern.lastIndex = 0;
-                let match;
-                while ((match = pattern.exec(line)) !== null) {
-                    const importPath = match[1];
-                    // Skip ignored patterns (assets, etc.)
-                    if (this.shouldIgnore(importPath))
-                        continue;
-                    if (importPath.startsWith('.')) {
-                        // Relative import — check file exists
-                        if (this.config.check_relative) {
-                            const resolved = this.resolveRelativeImport(file, importPath, projectFiles);
-                            if (!resolved) {
-                                hallucinated.push({
-                                    file, line: i + 1, importPath, type: 'relative',
-                                    reason: `File not found: ${importPath}`,
-                                });
-                            }
-                        }
+    async checkJSImports(content, file, cwd, projectFiles, rootDeps, depCacheByDir, hasNodeModules, hallucinated, tsPathCacheByDir) {
+        const depsForFile = await this.resolveJSDepsForFile(file, cwd, rootDeps, depCacheByDir);
+        for (const spec of this.collectJSImportSpecs(content, file)) {
+            const { importPath, line } = spec;
+            if (!importPath || this.shouldIgnore(importPath))
+                continue;
+            if (importPath.startsWith('.')) {
+                if (this.config.check_relative) {
+                    const resolved = this.resolveRelativeImport(file, importPath, projectFiles);
+                    if (!resolved) {
+                        hallucinated.push({
+                            file, line, importPath, type: 'relative',
+                            reason: `File not found: ${importPath}`,
+                        });
                     }
-                    else {
-                        // Package import — check it exists
-                        if (this.config.check_packages) {
-                            const pkgName = this.extractPackageName(importPath);
-                            // Skip Node.js built-ins
-                            if (isNodeBuiltin(pkgName))
+                }
+            }
+            else {
+                const aliasResolution = await this.resolveTsPathAlias(file, importPath, cwd, projectFiles, tsPathCacheByDir);
+                if (aliasResolution === true)
+                    continue;
+                if (aliasResolution === false) {
+                    hallucinated.push({
+                        file, line, importPath, type: 'package',
+                        reason: `Path alias '${importPath}' does not resolve to a project file`,
+                    });
+                    continue;
+                }
+                if (this.config.check_packages) {
+                    const pkgName = this.extractPackageName(importPath);
+                    if (isNodeBuiltin(pkgName))
+                        continue;
+                    if (!depsForFile.has(pkgName)) {
+                        if (hasNodeModules) {
+                            const pkgPath = path.join(cwd, 'node_modules', pkgName);
+                            if (await fs.pathExists(pkgPath))
                                 continue;
-                            if (!allDeps.has(pkgName)) {
-                                // Double-check node_modules if available
-                                if (hasNodeModules) {
-                                    const pkgPath = path.join(cwd, 'node_modules', pkgName);
-                                    if (await fs.pathExists(pkgPath))
-                                        continue;
-                                }
-                                hallucinated.push({
-                                    file, line: i + 1, importPath, type: 'package',
-                                    reason: `Package '${pkgName}' not in package.json dependencies`,
-                                });
-                            }
                         }
+                        hallucinated.push({
+                            file, line, importPath, type: 'package',
+                            reason: `Package '${pkgName}' not in package.json dependencies`,
+                        });
                     }
                 }
             }
         }
     }
+    collectJSImportSpecs(content, file) {
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+        const specs = [];
+        const add = (node, value) => {
+            if (!value)
+                return;
+            const line = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+            specs.push({ importPath: value, line });
+        };
+        const visit = (node) => {
+            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+                add(node, node.moduleSpecifier.text);
+            }
+            else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                add(node, node.moduleSpecifier.text);
+            }
+            else if (ts.isCallExpression(node)) {
+                // require('x')
+                if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+                    const firstArg = node.arguments[0];
+                    if (firstArg && ts.isStringLiteral(firstArg)) {
+                        add(node, firstArg.text);
+                    }
+                }
+                // import('x')
+                if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+                    const firstArg = node.arguments[0];
+                    if (firstArg && ts.isStringLiteral(firstArg)) {
+                        add(node, firstArg.text);
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(sourceFile, visit);
+        return specs;
+    }
+    async resolveJSDepsForFile(file, cwd, rootDeps, depCacheByDir) {
+        const rootDir = path.resolve(cwd);
+        let currentDir = path.dirname(path.resolve(cwd, file));
+        while (currentDir.startsWith(rootDir)) {
+            const cached = depCacheByDir.get(currentDir);
+            if (cached)
+                return cached;
+            const packageJsonPath = path.join(currentDir, 'package.json');
+            if (await fs.pathExists(packageJsonPath)) {
+                try {
+                    const packageJson = await fs.readJson(packageJsonPath);
+                    const deps = new Set([
+                        ...rootDeps,
+                        ...Object.keys(packageJson?.dependencies || {}),
+                        ...Object.keys(packageJson?.devDependencies || {}),
+                        ...Object.keys(packageJson?.peerDependencies || {}),
+                        ...Object.keys(packageJson?.optionalDependencies || {}),
+                    ]);
+                    depCacheByDir.set(currentDir, deps);
+                    return deps;
+                }
+                catch {
+                    depCacheByDir.set(currentDir, rootDeps);
+                    return rootDeps;
+                }
+            }
+            const parent = path.dirname(currentDir);
+            if (parent === currentDir)
+                break;
+            currentDir = parent;
+        }
+        return rootDeps;
+    }
+    async resolveTsPathAlias(file, importPath, cwd, projectFiles, tsPathCacheByDir) {
+        const config = await this.resolveTsPathConfigForFile(file, cwd, tsPathCacheByDir);
+        if (!config || config.rules.length === 0)
+            return null;
+        for (const rule of config.rules) {
+            const wildcard = this.matchTsPathRule(rule, importPath);
+            if (wildcard === null)
+                continue;
+            for (const target of rule.targets) {
+                const candidatePattern = rule.hasWildcard ? target.replace('*', wildcard) : target;
+                if (this.resolveTsPathTarget(config.baseDir, candidatePattern, cwd, projectFiles)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return null;
+    }
+    matchTsPathRule(rule, importPath) {
+        if (!rule.hasWildcard) {
+            return importPath === rule.key ? '' : null;
+        }
+        if (!importPath.startsWith(rule.prefix) || !importPath.endsWith(rule.suffix)) {
+            return null;
+        }
+        return importPath.slice(rule.prefix.length, importPath.length - rule.suffix.length);
+    }
+    resolveTsPathTarget(baseDir, candidatePattern, cwd, projectFiles) {
+        const absolute = path.resolve(baseDir, candidatePattern);
+        const relative = path.relative(cwd, absolute).replace(/\\/g, '/');
+        const normalized = relative.replace(/\/$/, '');
+        const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.d.ts'];
+        const candidates = [
+            ...extensions.map(ext => normalized + ext),
+            ...extensions.map(ext => `${normalized}/index${ext}`),
+        ];
+        return candidates.some(c => projectFiles.has(c));
+    }
+    async resolveTsPathConfigForFile(file, cwd, tsPathCacheByDir) {
+        const rootDir = path.resolve(cwd);
+        let currentDir = path.dirname(path.resolve(cwd, file));
+        while (currentDir.startsWith(rootDir)) {
+            if (tsPathCacheByDir.has(currentDir)) {
+                const cached = tsPathCacheByDir.get(currentDir) || null;
+                if (cached)
+                    return cached;
+            }
+            else {
+                const config = await this.loadTsPathConfig(currentDir);
+                tsPathCacheByDir.set(currentDir, config);
+                if (config)
+                    return config;
+            }
+            const parent = path.dirname(currentDir);
+            if (parent === currentDir)
+                break;
+            currentDir = parent;
+        }
+        return null;
+    }
+    async loadTsPathConfig(searchDir) {
+        const candidates = ['tsconfig.json', 'jsconfig.json', 'tsconfig.base.json'];
+        for (const configName of candidates) {
+            const configPath = path.join(searchDir, configName);
+            if (!(await fs.pathExists(configPath)))
+                continue;
+            const parsed = await this.readLooseJson(configPath);
+            const compilerOptions = parsed?.compilerOptions || {};
+            const paths = compilerOptions.paths;
+            if (!paths || typeof paths !== 'object')
+                continue;
+            const baseUrl = typeof compilerOptions.baseUrl === 'string' ? compilerOptions.baseUrl : '.';
+            const baseDir = path.resolve(searchDir, baseUrl);
+            const rules = [];
+            for (const [key, value] of Object.entries(paths)) {
+                if (typeof key !== 'string' || !Array.isArray(value) || value.length === 0)
+                    continue;
+                const hasWildcard = key.includes('*');
+                const [prefix, suffix = ''] = key.split('*');
+                const targets = value.filter(v => typeof v === 'string');
+                if (targets.length === 0)
+                    continue;
+                rules.push({ key, hasWildcard, prefix, suffix, targets });
+            }
+            if (rules.length === 0)
+                continue;
+            return { baseDir, rules };
+        }
+        return null;
+    }
+    async readLooseJson(filePath) {
+        try {
+            const text = await fs.readFile(filePath, 'utf-8');
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                const noBlockComments = text.replace(/\/\*[\s\S]*?\*\//g, '');
+                const noLineComments = noBlockComments.replace(/(^|\s)\/\/.*$/gm, '$1');
+                const noTrailingCommas = noLineComments.replace(/,\s*([}\]])/g, '$1');
+                return JSON.parse(noTrailingCommas);
+            }
+        }
+        catch {
+            return null;
+        }
+    }
     async checkPyImports(content, file, cwd, projectFiles, hallucinated) {
         const lines = content.split('\n');
         for (let i = 0; i < lines.length; i++) {
@@ -223,13 +399,7 @@ export class HallucinatedImportsGate extends Gate {
     resolveRelativeImport(fromFile, importPath, projectFiles) {
         const dir = path.dirname(fromFile);
         const resolved = path.join(dir, importPath).replace(/\\/g, '/');
-        // Try exact match, then common extensions
-        const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-        const indexFiles = extensions.map(ext => `${resolved}/index${ext}`);
-        const candidates = [
-            ...extensions.map(ext => resolved + ext),
-            ...indexFiles,
-        ];
+        const candidates = this.buildImportCandidates(resolved);
         return candidates.some(c => projectFiles.has(c));
     }
     extractPackageName(importPath) {
@@ -244,4 +414,41 @@ export class HallucinatedImportsGate extends Gate {
     shouldIgnore(importPath) {
         return this.config.ignore_patterns.some(pattern => new RegExp(pattern).test(importPath));
     }
+    /**
+     * Build candidate source paths for an import.
+     * Handles ESM-style TS source imports like "./foo.js" that map to "./foo.ts" pre-build.
+     */
+    buildImportCandidates(resolvedPath) {
+        const extension = path.extname(resolvedPath).toLowerCase();
+        const sourceExtensions = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.d.ts'];
+        const runtimeExtensions = new Set(['.js', '.jsx', '.mjs', '.cjs']);
+        let candidates = [];
+        if (runtimeExtensions.has(extension)) {
+            const withoutExt = resolvedPath.slice(0, -extension.length);
+            candidates = [
+                ...sourceExtensions.map(ext => withoutExt + ext),
+                ...sourceExtensions.map(ext => `${withoutExt}/index${ext}`),
+                resolvedPath,
+                `${resolvedPath}/index`,
+            ];
+        }
+        else if (extension) {
+            candidates = [resolvedPath, `${resolvedPath}/index`];
+        }
+        else {
+            candidates = [
+                ...sourceExtensions.map(ext => resolvedPath + ext),
+                ...sourceExtensions.map(ext => `${resolvedPath}/index${ext}`),
+            ];
+        }
+        return [...new Set(candidates)];
+    }
+    shouldSkipFile(file) {
+        const normalized = file.replace(/\\/g, '/');
+        return (normalized.includes('/examples/') ||
+            normalized.includes('/studio-dist/') ||
+            normalized.includes('/__tests__/') ||
+            /\.test\.[^.]+$/i.test(normalized) ||
+            /\.spec\.[^.]+$/i.test(normalized));
+    }
 }

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

@@ -10,6 +10,7 @@
  */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { HallucinatedImportsGate } from './hallucinated-imports.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(() => ({
     mockPathExists: vi.fn(),
@@ -40,6 +41,7 @@ vi.mock('../utils/scanner.js', () => ({
     },
 }));
 import { FileScanner } from '../utils/scanner.js';
+const normalizePath = (input) => input.replace(/\\/g, '/');
 // ═══════════════════════════════════════════════════════════════
 // GO
 // ═══════════════════════════════════════════════════════════════
@@ -253,7 +255,8 @@ from urllib.parse import urlparse
 // ═══════════════════════════════════════════════════════════════
 describe('HallucinatedImportsGate — JS/TS Node builtins', () => {
     let gate;
-    const testCwd = '/tmp/test-node-project';
+    const testCwd = path.resolve('/tmp/test-node-project');
+    const testCwdNormalized = normalizePath(testCwd);
     const context = { cwd: testCwd, ignore: [] };
     beforeEach(() => {
         vi.clearAllMocks();
@@ -296,6 +299,166 @@ import { ReadableStream } from 'stream/web';
         const failures = await gate.run(context);
         expect(failures).toHaveLength(0);
     });
+    it('should resolve dependencies from nearest package.json in monorepos', async () => {
+        const jsContent = `
+import { app } from 'electron';
+import React from 'react';
+`;
+        FileScanner.findFiles.mockResolvedValue(['apps/desktop/src/main.ts']);
+        mockReadFile.mockResolvedValue(jsContent);
+        mockPathExists.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            return normalized === `${testCwdNormalized}/apps/desktop/package.json`
+                || normalized === `${testCwdNormalized}/package.json`
+                || normalized.includes('/node_modules/electron')
+                || normalized.includes('/node_modules/react');
+        });
+        mockReadJson.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            if (normalized.endsWith('/apps/desktop/package.json')) {
+                return {
+                    dependencies: { electron: '^31.0.0', react: '^18.0.0' },
+                    devDependencies: {},
+                    peerDependencies: {},
+                    optionalDependencies: {},
+                };
+            }
+            // Root package.json should not incorrectly block desktop deps
+            return {
+                dependencies: {},
+                devDependencies: {},
+                peerDependencies: {},
+                optionalDependencies: {},
+            };
+        });
+        const failures = await gate.run(context);
+        expect(failures).toHaveLength(0);
+    });
+    it('should NOT flag tsconfig path aliases that resolve in monorepos', async () => {
+        const jsContent = `
+import { logger } from '@/utils/logger';
+import { cfg } from '~shared/config';
+`;
+        const tsconfigContent = `{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "~shared/*": ["../shared/src/*"]
+    }
+  }
+}`;
+        FileScanner.findFiles.mockResolvedValue([
+            'apps/desktop/src/main.ts',
+            'apps/desktop/src/utils/logger.ts',
+            'apps/shared/src/config.ts',
+        ]);
+        mockReadFile.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            if (normalized.endsWith('/apps/desktop/tsconfig.json'))
+                return tsconfigContent;
+            if (normalized.endsWith('/apps/desktop/src/main.ts'))
+                return jsContent;
+            return 'export const ok = true;';
+        });
+        mockPathExists.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            return normalized === `${testCwdNormalized}/apps/desktop/tsconfig.json`
+                || normalized === `${testCwdNormalized}/package.json`;
+        });
+        mockReadJson.mockResolvedValue({
+            dependencies: {},
+            devDependencies: {},
+            peerDependencies: {},
+            optionalDependencies: {},
+        });
+        const failures = await gate.run(context);
+        expect(failures).toHaveLength(0);
+    });
+    it('should flag tsconfig path aliases when target does not resolve', async () => {
+        const jsContent = `import { logger } from '@/utils/missing';`;
+        const tsconfigContent = `{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  }
+}`;
+        FileScanner.findFiles.mockResolvedValue(['apps/desktop/src/main.ts']);
+        mockReadFile.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            if (normalized.endsWith('/apps/desktop/tsconfig.json'))
+                return tsconfigContent;
+            return jsContent;
+        });
+        mockPathExists.mockImplementation(async (p) => {
+            const normalized = normalizePath(p);
+            return normalized === `${testCwdNormalized}/apps/desktop/tsconfig.json`
+                || normalized === `${testCwdNormalized}/package.json`;
+        });
+        mockReadJson.mockResolvedValue({
+            dependencies: {},
+            devDependencies: {},
+            peerDependencies: {},
+            optionalDependencies: {},
+        });
+        const failures = await gate.run(context);
+        expect(failures).toHaveLength(1);
+        // Depending on tsconfig resolution context, this may surface as
+        // a direct alias resolution failure OR a missing package fallback.
+        const details = failures[0].details;
+        expect(details.includes("Path alias '@/utils/missing' does not resolve to a project file")
+            || details.includes("Package '@/utils' not in package.json dependencies")).toBe(true);
+    });
+    it('should NOT flag ESM .js specifiers that resolve to .ts source files', async () => {
+        const jsContent = `
+import { helper } from './utils.js';
+`;
+        FileScanner.findFiles.mockResolvedValue(['src/main.ts', 'src/utils.ts']);
+        mockReadFile.mockImplementation(async (p) => {
+            const normalized = p.replace(/\\/g, '/');
+            if (normalized.endsWith('/src/main.ts'))
+                return jsContent;
+            return 'export const helper = () => 42;';
+        });
+        mockPathExists.mockImplementation(async (p) => {
+            const normalized = p.replace(/\\/g, '/');
+            return normalized === '/tmp/test-node-project/package.json';
+        });
+        mockReadJson.mockResolvedValue({
+            dependencies: {},
+            devDependencies: {},
+            peerDependencies: {},
+            optionalDependencies: {},
+        });
+        const failures = await gate.run(context);
+        expect(failures).toHaveLength(0);
+    });
+});
+describe('HallucinatedImportsGate — ignore generated/test artifacts', () => {
+    let gate;
+    const testCwd = '/tmp/test-ignore-project';
+    const context = { cwd: testCwd, ignore: [] };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockReaddirSync.mockReturnValue([]);
+        gate = new HallucinatedImportsGate({ enabled: true });
+    });
+    it('skips studio-dist files by default', async () => {
+        FileScanner.findFiles.mockResolvedValue(['packages/rigour-cli/studio-dist/assets/index.js']);
+        mockReadFile.mockResolvedValue(`import 'definitely-not-a-real-package';`);
+        mockPathExists.mockResolvedValue(false);
+        const failures = await gate.run(context);
+        expect(failures).toHaveLength(0);
+    });
+    it('skips test files by default', async () => {
+        FileScanner.findFiles.mockResolvedValue(['src/example.test.ts']);
+        mockReadFile.mockResolvedValue(`import 'totally-not-installed';`);
+        mockPathExists.mockResolvedValue(false);
+        const failures = await gate.run(context);
+        expect(failures).toHaveLength(0);
+    });
 });
 // ═══════════════════════════════════════════════════════════════
 // RUBY

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

@@ -36,4 +36,5 @@ export declare class InconsistentErrorHandlingGate extends Gate {
     private classifyStrategy;
     private extractCatchBody;
     private extractCatchCallbackBody;
+    private shouldSkipFile;
 }