devkit-quality 0.1.0

package/dist/cliLogic.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterFindings = filterFindings;
+exports.isKnownSeverity = isKnownSeverity;
+exports.determineExitFailure = determineExitFailure;
+const SEVERITY_RANK = {
+    INFO: 0,
+    LOW: 1,
+    MEDIUM: 2,
+    HIGH: 3,
+    CRITICAL: 4
+};
+function filterFindings(findings, filters) {
+    return findings.filter((finding) => {
+        if (filters.category && finding.category.toLowerCase() !== filters.category.toLowerCase())
+            return false;
+        if (filters.severity && finding.severity.toLowerCase() !== filters.severity.toLowerCase())
+            return false;
+        return true;
+    });
+}
+function isKnownSeverity(value) {
+    return Object.prototype.hasOwnProperty.call(SEVERITY_RANK, value.toUpperCase());
+}
+function determineExitFailure(summary, gates) {
+    if (gates.minScore !== undefined && summary.score < Number(gates.minScore))
+        return true;
+    if (gates.failOn !== undefined) {
+        const threshold = gates.failOn.toUpperCase();
+        if (!isKnownSeverity(gates.failOn))
+            return true;
+        if (summary.findings.some((finding) => SEVERITY_RANK[finding.severity] >= SEVERITY_RANK[threshold]))
+            return true;
+    }
+    return false;
+}

package/dist/config.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = void 0;
+exports.loadConfig = loadConfig;
+exports.writeConfig = writeConfig;
+exports.isRuleEnabled = isRuleEnabled;
+exports.getRuleThreshold = getRuleThreshold;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.defaultConfig = {
+    project: {
+        name: 'my-project'
+    },
+    scan: {
+        include: ['**/*'],
+        exclude: ['node_modules/**', 'dist/**', 'coverage/**', '.git/**', '.devkit/**']
+    },
+    rules: {}
+};
+function loadConfig(projectRoot) {
+    const configPath = node_path_1.default.join(projectRoot, '.devkitrc.json');
+    if (!node_fs_1.default.existsSync(configPath)) {
+        return exports.defaultConfig;
+    }
+    const raw = node_fs_1.default.readFileSync(configPath, 'utf8');
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            ...exports.defaultConfig,
+            ...parsed,
+            project: { ...exports.defaultConfig.project, ...(parsed.project ?? {}) },
+            scan: { ...exports.defaultConfig.scan, ...(parsed.scan ?? {}) },
+            architecture: parsed.architecture
+                ? { ...parsed.architecture, layers: { ...(exports.defaultConfig.architecture?.layers ?? {}), ...(parsed.architecture.layers ?? {}) } }
+                : exports.defaultConfig.architecture,
+            rules: { ...exports.defaultConfig.rules, ...(parsed.rules ?? {}) }
+        };
+    }
+    catch {
+        return exports.defaultConfig;
+    }
+}
+function writeConfig(projectRoot) {
+    const configPath = node_path_1.default.join(projectRoot, '.devkitrc.json');
+    node_fs_1.default.writeFileSync(configPath, `${JSON.stringify(exports.defaultConfig, null, 2)}\n`);
+    return configPath;
+}
+function isRuleEnabled(config, ruleId) {
+    return config.rules[ruleId]?.enabled !== false;
+}
+function getRuleThreshold(config, ruleId, fallback) {
+    const override = config.rules[ruleId]?.max;
+    return typeof override === 'number' ? override : fallback;
+}

package/dist/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/discovery.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATED_HINTS = exports.IGNORE_DIRS = exports.SOURCE_EXTENSIONS = void 0;
+exports.isRelevantFile = isRelevantFile;
+exports.isTestFile = isTestFile;
+exports.isGeneratedFile = isGeneratedFile;
+exports.isGeneratedByContent = isGeneratedByContent;
+exports.filterScannedFiles = filterScannedFiles;
+exports.walkDirectory = walkDirectory;
+exports.readFileSafe = readFileSafe;
+exports.countLines = countLines;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const glob_1 = require("./glob");
+exports.SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+exports.IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.devkit', 'generated', 'vendor', '.next', '.nuxt', '.svelte-kit', '.angular', 'out']);
+exports.GENERATED_HINTS = ['generated', 'dist', 'build', '.d.ts', '.min.', 'coverage', '.next', '.nuxt', '.svelte-kit', '.angular', 'out'];
+function isRelevantFile(filePath) {
+    const ext = node_path_1.default.extname(filePath).toLowerCase();
+    return exports.SOURCE_EXTENSIONS.has(ext);
+}
+function isTestFile(filePath) {
+    const lower = filePath.toLowerCase();
+    return lower.includes('.test.') || lower.includes('.spec.') || lower.includes('__tests__');
+}
+function isGeneratedFile(filePath) {
+    const lower = filePath.replace(/\\/g, '/').toLowerCase();
+    const segments = lower.split('/');
+    const generatedDirectories = new Set(['generated', 'dist', 'build', 'coverage', '.next', '.nuxt', '.svelte-kit', '.angular', 'out']);
+    const basename = segments[segments.length - 1] ?? '';
+    return segments.some((segment) => generatedDirectories.has(segment)) || basename.endsWith('.d.ts') || basename.includes('.min.');
+}
+function isGeneratedByContent(text) {
+    return /(?:@generated|\bDO NOT EDIT\b|\bGENERATED FILE\b)/i.test(text) || /^\/\/[#@]\s*sourceMappingURL=/m.test(text);
+}
+function filterScannedFiles(allFiles, projectRoot, config, ignorePatterns) {
+    const files = [];
+    const generatedFiles = [];
+    for (const file of allFiles) {
+        if (!isRelevantFile(file))
+            continue;
+        const relative = node_path_1.default.relative(projectRoot, file).replace(/\\/g, '/');
+        if (!(0, glob_1.matchesAnyGlob)(relative, config.scan.include))
+            continue;
+        if ((0, glob_1.matchesAnyGlob)(relative, config.scan.exclude) || (0, glob_1.matchesAnyGlob)(relative, ignorePatterns))
+            continue;
+        const text = readFileSafe(file);
+        if (isGeneratedFile(relative) || isGeneratedByContent(text)) {
+            generatedFiles.push(relative);
+            continue;
+        }
+        files.push(file);
+    }
+    return { files, generatedFiles };
+}
+function walkDirectory(rootDir) {
+    const allFiles = [];
+    const visit = (currentDir) => {
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const absolutePath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                if (exports.IGNORE_DIRS.has(entry.name)) {
+                    continue;
+                }
+                visit(absolutePath);
+                continue;
+            }
+            if (entry.isFile()) {
+                allFiles.push(absolutePath);
+            }
+        }
+    };
+    visit(rootDir);
+    return allFiles;
+}
+function readFileSafe(filePath) {
+    try {
+        return node_fs_1.default.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function countLines(content) {
+    if (!content.trim()) {
+        return 0;
+    }
+    return content.split(/\r\n|\r|\n/).length;
+}

package/dist/finding.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFinding = buildFinding;
+function buildFinding(params) {
+    return {
+        id: `${params.ruleId}-${params.file}-${params.line}-${params.column}`,
+        ruleId: params.ruleId,
+        category: params.category,
+        severity: params.severity,
+        confidence: params.confidence,
+        file: params.file,
+        line: params.line,
+        column: params.column,
+        message: params.message,
+        description: params.description,
+        evidence: params.evidence,
+        suggestion: params.suggestion,
+        fixAvailable: params.fixAvailable ?? false
+    };
+}

package/dist/glob.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globToRegExp = globToRegExp;
+exports.matchesAnyGlob = matchesAnyGlob;
+function globToRegExp(pattern) {
+    let regex = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const char = pattern[i];
+        if (char === '*' && pattern[i + 1] === '*') {
+            regex += '.*';
+            i += 1;
+            if (pattern[i + 1] === '/') {
+                i += 1;
+            }
+            continue;
+        }
+        if (char === '*') {
+            regex += '[^/]*';
+            continue;
+        }
+        if (char === '?') {
+            regex += '[^/]';
+            continue;
+        }
+        if ('.+^${}()|[]\\'.includes(char)) {
+            regex += `\\${char}`;
+            continue;
+        }
+        regex += char;
+    }
+    return new RegExp(`^${regex}$`);
+}
+function matchesAnyGlob(value, patterns) {
+    return patterns.some((pattern) => globToRegExp(pattern).test(value));
+}

package/dist/ignore.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIgnorePatterns = loadIgnorePatterns;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function loadIgnorePatterns(projectRoot) {
+    const patterns = new Set();
+    for (const name of ['.gitignore', '.devkitignore']) {
+        const file = node_path_1.default.join(projectRoot, name);
+        if (!node_fs_1.default.existsSync(file))
+            continue;
+        for (const rawLine of node_fs_1.default.readFileSync(file, 'utf8').split(/\r\n|\r|\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#') || line.startsWith('!'))
+                continue;
+            const normalized = line.replace(/^\//, '').replace(/\/$/, '');
+            if (!normalized)
+                continue;
+            patterns.add(normalized);
+            patterns.add(`**/${normalized}`);
+            patterns.add(`**/${normalized}/**`);
+        }
+    }
+    return [...patterns];
+}

package/dist/moduleGraph.js

@@ -0,0 +1,311 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModuleGraph = buildModuleGraph;
+exports.findImportCycles = findImportCycles;
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const discovery_1 = require("./discovery");
+const parse_1 = require("./ast/parse");
+const walk_1 = require("./ast/walk");
+const glob_1 = require("./glob");
+const moduleResolution_1 = require("./moduleResolution");
+function extractImportsAndExports(file, projectRoot, sourceFile, fileSet, resolutionContext) {
+    const imports = [];
+    const exports = [];
+    const reExportAllTargets = [];
+    const dynamicRequireHints = [];
+    const addImport = (specifier, kind, line, details = {}) => {
+        const info = {
+            specifier,
+            resolved: (0, moduleResolution_1.resolveSpecifier)(file, specifier, kind, fileSet, resolutionContext),
+            isRelative: specifier.startsWith('.'),
+            namedImports: details.namedImports ?? [],
+            hasDefaultImport: details.hasDefaultImport ?? false,
+            hasNamespaceImport: details.hasNamespaceImport ?? false,
+            isSideEffectOnly: details.isSideEffectOnly ?? false,
+            line,
+            kind
+        };
+        imports.push(info);
+        return info;
+    };
+    for (const statement of sourceFile.statements) {
+        if (typescript_1.default.isImportDeclaration(statement) && typescript_1.default.isStringLiteral(statement.moduleSpecifier)) {
+            const clause = statement.importClause;
+            const namedImports = [];
+            let hasDefaultImport = false;
+            let hasNamespaceImport = false;
+            if (clause) {
+                hasDefaultImport = !!clause.name;
+                if (clause.namedBindings && typescript_1.default.isNamespaceImport(clause.namedBindings))
+                    hasNamespaceImport = true;
+                else if (clause?.namedBindings && typescript_1.default.isNamedImports(clause.namedBindings)) {
+                    for (const element of clause.namedBindings.elements)
+                        namedImports.push((element.propertyName ?? element.name).text);
+                }
+            }
+            addImport(statement.moduleSpecifier.text, 'import', (0, walk_1.lineAndColumn)(sourceFile, statement.getStart()).line, {
+                namedImports, hasDefaultImport, hasNamespaceImport, isSideEffectOnly: !clause
+            });
+            continue;
+        }
+        if (typescript_1.default.isImportEqualsDeclaration(statement) && typescript_1.default.isExternalModuleReference(statement.moduleReference)) {
+            const expr = statement.moduleReference.expression;
+            if (typescript_1.default.isStringLiteral(expr))
+                addImport(expr.text, 'importEquals', (0, walk_1.lineAndColumn)(sourceFile, statement.getStart()).line, { hasNamespaceImport: true });
+            continue;
+        }
+        if (typescript_1.default.isExportDeclaration(statement)) {
+            const line = (0, walk_1.lineAndColumn)(sourceFile, statement.getStart()).line;
+            if (statement.moduleSpecifier && typescript_1.default.isStringLiteral(statement.moduleSpecifier)) {
+                const specifier = statement.moduleSpecifier.text;
+                if (!statement.exportClause) {
+                    const info = addImport(specifier, 'exportFrom', line, { hasNamespaceImport: true });
+                    if (info.resolved)
+                        reExportAllTargets.push(info.resolved);
+                    continue;
+                }
+                if (typescript_1.default.isNamedExports(statement.exportClause)) {
+                    for (const element of statement.exportClause.elements)
+                        exports.push({ name: element.name.text, kind: 'named', line });
+                    addImport(specifier, 'exportFrom', line, {
+                        namedImports: statement.exportClause.elements.map((element) => (element.propertyName ?? element.name).text)
+                    });
+                }
+                continue;
+            }
+            if (statement.exportClause && typescript_1.default.isNamedExports(statement.exportClause)) {
+                for (const element of statement.exportClause.elements)
+                    exports.push({ name: element.name.text, kind: 'named', line });
+            }
+            continue;
+        }
+        if (typescript_1.default.isExportAssignment(statement)) {
+            exports.push({ name: 'default', kind: 'default', line: (0, walk_1.lineAndColumn)(sourceFile, statement.getStart()).line });
+            continue;
+        }
+        const modifiers = typescript_1.default.canHaveModifiers(statement) ? typescript_1.default.getModifiers(statement) : undefined;
+        const isExported = modifiers?.some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.ExportKeyword) ?? false;
+        if (!isExported)
+            continue;
+        const isDefault = modifiers?.some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.DefaultKeyword) ?? false;
+        const line = (0, walk_1.lineAndColumn)(sourceFile, statement.getStart()).line;
+        if (isDefault)
+            exports.push({ name: 'default', kind: 'default', line });
+        else if (typescript_1.default.isFunctionDeclaration(statement) && statement.name)
+            exports.push({ name: statement.name.text, kind: 'function', line });
+        else if (typescript_1.default.isClassDeclaration(statement) && statement.name)
+            exports.push({ name: statement.name.text, kind: 'class', line });
+        else if (typescript_1.default.isInterfaceDeclaration(statement))
+            exports.push({ name: statement.name.text, kind: 'interface', line });
+        else if (typescript_1.default.isTypeAliasDeclaration(statement))
+            exports.push({ name: statement.name.text, kind: 'typeAlias', line });
+        else if (typescript_1.default.isEnumDeclaration(statement))
+            exports.push({ name: statement.name.text, kind: 'enum', line });
+        else if (typescript_1.default.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (typescript_1.default.isIdentifier(declaration.name))
+                    exports.push({ name: declaration.name.text, kind: 'variable', line });
+            }
+        }
+    }
+    const dynamicDir = node_path_1.default.relative(projectRoot, node_path_1.default.dirname(file)).replace(/\\/g, '/') || '.';
+    (0, walk_1.forEachNode)(sourceFile, (node) => {
+        if (!typescript_1.default.isCallExpression(node))
+            return;
+        const isRequire = typescript_1.default.isIdentifier(node.expression) && node.expression.text === 'require';
+        const isDynamicImport = node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword;
+        if (!isRequire && !isDynamicImport)
+            return;
+        const kind = isRequire ? 'require' : 'dynamicImport';
+        const argument = node.arguments[0];
+        if (!argument || !(typescript_1.default.isStringLiteral(argument) || typescript_1.default.isNoSubstitutionTemplateLiteral(argument))) {
+            dynamicRequireHints.push(dynamicDir);
+            return;
+        }
+        let namedImports = [];
+        let hasNamespaceImport = true;
+        let isSideEffectOnly = false;
+        let parent = node.parent;
+        if (typescript_1.default.isAwaitExpression(parent))
+            parent = parent.parent;
+        if (typescript_1.default.isVariableDeclaration(parent) && parent.initializer && (parent.initializer === node || (typescript_1.default.isAwaitExpression(parent.initializer) && parent.initializer.expression === node))) {
+            if (typescript_1.default.isObjectBindingPattern(parent.name)) {
+                const hasStaticProperties = parent.name.elements.every((element) => {
+                    if (element.dotDotDotToken)
+                        return false;
+                    const property = element.propertyName ?? element.name;
+                    return typescript_1.default.isIdentifier(property) || typescript_1.default.isStringLiteral(property) || typescript_1.default.isNumericLiteral(property);
+                });
+                if (hasStaticProperties) {
+                    namedImports = parent.name.elements.map((element) => (element.propertyName ?? element.name).getText(sourceFile).replace(/^['"]|['"]$/g, ''));
+                    hasNamespaceImport = false;
+                }
+            }
+        }
+        else if (isRequire && typescript_1.default.isExpressionStatement(node.parent)) {
+            isSideEffectOnly = true;
+        }
+        addImport(argument.text, kind, (0, walk_1.lineAndColumn)(sourceFile, node.getStart()).line, { namedImports, hasNamespaceImport, isSideEffectOnly });
+    });
+    return { imports, exports, reExportAllTargets, dynamicRequireHints };
+}
+function resolveEntryPoints(projectRoot, files, packageJson, config) {
+    const entryPoints = new Set();
+    const fileSet = new Set(files);
+    const addFromRelativePath = (relativePath) => {
+        const resolved = node_path_1.default.resolve(projectRoot, relativePath);
+        if (fileSet.has(resolved)) {
+            entryPoints.add(resolved);
+            return;
+        }
+        for (const ext of discovery_1.SOURCE_EXTENSIONS) {
+            if (fileSet.has(resolved + ext)) {
+                entryPoints.add(resolved + ext);
+            }
+        }
+    };
+    const scanStringForPaths = (value) => {
+        const tokens = value.split(/\s+/);
+        for (const token of tokens) {
+            const cleaned = token.replace(/^["']|["']$/g, '');
+            if ([...discovery_1.SOURCE_EXTENSIONS].some((ext) => cleaned.endsWith(ext))) {
+                addFromRelativePath(cleaned);
+            }
+        }
+    };
+    if (packageJson) {
+        if (typeof packageJson.main === 'string') {
+            addFromRelativePath(packageJson.main);
+        }
+        if (typeof packageJson.bin === 'string') {
+            addFromRelativePath(packageJson.bin);
+        }
+        else if (packageJson.bin && typeof packageJson.bin === 'object') {
+            for (const value of Object.values(packageJson.bin)) {
+                addFromRelativePath(value);
+            }
+        }
+        const scripts = packageJson.scripts;
+        if (scripts) {
+            for (const command of Object.values(scripts)) {
+                scanStringForPaths(command);
+            }
+        }
+        const addExportTargets = (value) => {
+            if (typeof value === 'string') {
+                if (value.startsWith('./'))
+                    addFromRelativePath(value.slice(2));
+            }
+            else if (value && typeof value === 'object') {
+                for (const nested of Object.values(value))
+                    addExportTargets(nested);
+            }
+        };
+        addExportTargets(packageJson.exports);
+        const dependencies = {
+            ...(packageJson.dependencies ?? {}),
+            ...(packageJson.devDependencies ?? {})
+        };
+        if (Object.prototype.hasOwnProperty.call(dependencies, 'next')) {
+            const patterns = [
+                'pages/**/*.js', 'pages/**/*.jsx', 'pages/**/*.ts', 'pages/**/*.tsx',
+                'app/**/page.js', 'app/**/page.jsx', 'app/**/page.ts', 'app/**/page.tsx',
+                'app/**/layout.js', 'app/**/layout.jsx', 'app/**/layout.ts', 'app/**/layout.tsx',
+                'app/**/route.js', 'app/**/route.jsx', 'app/**/route.ts', 'app/**/route.tsx',
+                'app/**/loading.js', 'app/**/loading.jsx', 'app/**/loading.ts', 'app/**/loading.tsx',
+                'app/**/error.js', 'app/**/error.jsx', 'app/**/error.ts', 'app/**/error.tsx',
+                'app/**/not-found.js', 'app/**/not-found.jsx', 'app/**/not-found.ts', 'app/**/not-found.tsx',
+                'app/**/middleware.js', 'app/**/middleware.jsx', 'app/**/middleware.ts', 'app/**/middleware.tsx'
+            ];
+            for (const file of files) {
+                const relative = node_path_1.default.relative(projectRoot, file).replace(/\\/g, '/');
+                if ((0, glob_1.matchesAnyGlob)(relative, patterns))
+                    entryPoints.add(file);
+            }
+        }
+    }
+    // Keep the parameter explicit: framework and custom entry conventions are config-dependent.
+    void config;
+    for (const file of files) {
+        if ((0, discovery_1.isTestFile)(file)) {
+            entryPoints.add(file);
+        }
+    }
+    return entryPoints;
+}
+function buildModuleGraph(projectRoot, files, packageJson, config) {
+    const fileSet = new Set(files);
+    const importsByFile = new Map();
+    const exportsByFile = new Map();
+    const edges = new Map();
+    const reverseEdges = new Map();
+    const reExportAllTargets = new Map();
+    const dynamicRequireHints = new Set();
+    const resolutionContext = (0, moduleResolution_1.createResolutionContext)(projectRoot);
+    for (const file of files) {
+        const text = (0, discovery_1.readFileSafe)(file);
+        const sourceFile = (0, parse_1.parseSourceFile)(file, text);
+        const { imports, exports, reExportAllTargets: reExportTargets, dynamicRequireHints: hints } = extractImportsAndExports(file, projectRoot, sourceFile, fileSet, resolutionContext);
+        hints.forEach((hint) => dynamicRequireHints.add(hint));
+        importsByFile.set(file, imports);
+        exportsByFile.set(file, exports);
+        reExportAllTargets.set(file, new Set(reExportTargets));
+        const edgeSet = new Set();
+        for (const importInfo of imports) {
+            if (importInfo.resolved) {
+                edgeSet.add(importInfo.resolved);
+                if (!reverseEdges.has(importInfo.resolved)) {
+                    reverseEdges.set(importInfo.resolved, new Set());
+                }
+                reverseEdges.get(importInfo.resolved).add(file);
+            }
+        }
+        for (const target of reExportTargets) {
+            edgeSet.add(target);
+            if (!reverseEdges.has(target)) {
+                reverseEdges.set(target, new Set());
+            }
+            reverseEdges.get(target).add(file);
+        }
+        edges.set(file, edgeSet);
+    }
+    const entryPoints = resolveEntryPoints(projectRoot, files, packageJson, config);
+    return { importsByFile, exportsByFile, edges, reverseEdges, reExportAllTargets, entryPoints, fileSet, dynamicRequireHints };
+}
+function findImportCycles(graph) {
+    const cycles = [];
+    const visitedGlobal = new Set();
+    for (const start of graph.edges.keys()) {
+        if (visitedGlobal.has(start)) {
+            continue;
+        }
+        const stack = [];
+        const onStack = new Set();
+        const visit = (node) => {
+            if (onStack.has(node)) {
+                const cycleStart = stack.indexOf(node);
+                if (cycleStart !== -1) {
+                    cycles.push([...stack.slice(cycleStart), node]);
+                }
+                return;
+            }
+            if (visitedGlobal.has(node)) {
+                return;
+            }
+            visitedGlobal.add(node);
+            stack.push(node);
+            onStack.add(node);
+            for (const next of graph.edges.get(node) ?? []) {
+                visit(next);
+            }
+            stack.pop();
+            onStack.delete(node);
+        };
+        visit(start);
+    }
+    return cycles;
+}

package/dist/moduleResolution.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadScannedTsConfig = loadScannedTsConfig;
+exports.createResolutionContext = createResolutionContext;
+exports.resolveSpecifier = resolveSpecifier;
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const discovery_1 = require("./discovery");
+const FALLBACK_RESOLUTION_OPTIONS = {
+    moduleResolution: typescript_1.default.ModuleResolutionKind.NodeNext,
+    module: typescript_1.default.ModuleKind.NodeNext,
+    target: typescript_1.default.ScriptTarget.ES2022,
+    allowJs: true,
+    resolveJsonModule: true,
+    esModuleInterop: true
+};
+function loadScannedTsConfig(projectRoot) {
+    const configPath = typescript_1.default.findConfigFile(projectRoot, typescript_1.default.sys.fileExists, 'tsconfig.json');
+    if (!configPath)
+        return { ...FALLBACK_RESOLUTION_OPTIONS };
+    const configFile = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+    if (configFile.error)
+        return { ...FALLBACK_RESOLUTION_OPTIONS };
+    const parsed = typescript_1.default.parseJsonConfigFileContent(configFile.config, typescript_1.default.sys, node_path_1.default.dirname(configPath), FALLBACK_RESOLUTION_OPTIONS, configPath);
+    return { ...FALLBACK_RESOLUTION_OPTIONS, ...parsed.options };
+}
+function createResolutionContext(projectRoot) {
+    const compilerOptions = loadScannedTsConfig(projectRoot);
+    const cache = typescript_1.default.createModuleResolutionCache(projectRoot, typescript_1.default.sys.useCaseSensitiveFileNames ? (fileName) => fileName : (fileName) => fileName.toLowerCase(), compilerOptions);
+    return { compilerOptions, cache, host: typescript_1.default.sys };
+}
+function resolveRelativeCheap(fromFile, specifier, fileSet) {
+    const base = node_path_1.default.resolve(node_path_1.default.dirname(fromFile), specifier);
+    const direct = [base, ...[...discovery_1.SOURCE_EXTENSIONS].map((extension) => base + extension)];
+    for (const candidate of direct)
+        if (fileSet.has(candidate))
+            return candidate;
+    for (const extension of discovery_1.SOURCE_EXTENSIONS) {
+        const candidate = node_path_1.default.join(base, `index${extension}`);
+        if (fileSet.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+function resolveSpecifier(fromFile, specifier, kind, fileSet, context) {
+    const normalizedFiles = fileSet;
+    if (specifier.startsWith('.')) {
+        const cheap = resolveRelativeCheap(fromFile, specifier, normalizedFiles);
+        if (cheap)
+            return cheap;
+    }
+    // TypeScript treats ESNext as an explicit package-condition mode and can skip `paths`
+    // mappings under NodeNext. The default is correct for ESM imports and path aliases;
+    // only CommonJS specifiers need an explicit condition mode.
+    const mode = kind === 'require' || kind === 'importEquals' ? typescript_1.default.ModuleKind.CommonJS : undefined;
+    const result = typescript_1.default.resolveModuleName(specifier, fromFile, context.compilerOptions, context.host, context.cache, undefined, mode).resolvedModule;
+    if (!result)
+        return null;
+    const resolved = node_path_1.default.resolve(result.resolvedFileName);
+    return normalizedFiles.has(resolved) ? resolved : null;
+}