@nu-art/build-and-install 0.401.0 → 0.401.1

package/exports/ExportIndexCache.js

@@ -0,0 +1,115 @@
+import { resolve as pathResolve } from 'path';
+import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { FilesCache } from '../core/FilesCache.js';
+import { promises as fs } from 'fs';
+import { glob } from 'node:fs/promises';
+const cache = new Map();
+export const ExportIndexCache = {
+    getIndexPath(projectRoot, packageName) {
+        return pathResolve(projectRoot, '.trash', 'indices', packageName);
+    },
+    async load(projectRoot, packageRoot, packageName) {
+        const cacheKey = packageRoot;
+        const cached = cache.get(cacheKey);
+        // Check if we need to reload based on index file mtime
+        const indexPath = ExportIndexCache.getIndexPath(projectRoot, packageName);
+        const indexFilePath = pathResolve(indexPath, '_export-for-import.json');
+        if (!await FileSystemUtils.file.exists(indexFilePath)) {
+            throw new Error(`Index file not found: ${indexFilePath}. Run 'bai --map-exports' to generate indices.`);
+        }
+        const indexStat = await fs.stat(indexFilePath);
+        const currentIndexMtime = indexStat.mtimeMs;
+        // If cached and mtime matches, return cached
+        if (cached && cached.indexMtime === currentIndexMtime) {
+            return cached;
+        }
+        // Load index files
+        const exports = await FilesCache.load.json(indexFilePath);
+        const byNameData = await FilesCache.load.json(pathResolve(indexPath, '_export-index-by-name.json'));
+        const byFileData = await FilesCache.load.json(pathResolve(indexPath, '_export-index-by-file.json'));
+        const byTypeData = await FilesCache.load.json(pathResolve(indexPath, '_export-index-by-type.json'));
+        // Convert to Maps for faster lookups
+        const byName = new Map();
+        for (const [name, symbol] of Object.entries(byNameData)) {
+            byName.set(name, symbol);
+        }
+        const byFile = new Map();
+        for (const [filePath, symbols] of Object.entries(byFileData)) {
+            byFile.set(filePath, symbols);
+        }
+        const byType = new Map();
+        for (const [type, symbols] of Object.entries(byTypeData)) {
+            byType.set(type, symbols);
+        }
+        // Calculate max source file mtime
+        const sourceMtime = await ExportIndexCache.calculateSourceMtime(packageRoot);
+        const cachedIndex = {
+            exports,
+            byName,
+            byFile,
+            byType,
+            indexMtime: currentIndexMtime,
+            sourceMtime,
+            packageRoot,
+            packageName,
+            projectRoot
+        };
+        cache.set(cacheKey, cachedIndex);
+        return cachedIndex;
+    },
+    async calculateSourceMtime(packageRoot) {
+        const srcMainTs = `${packageRoot}/src/main/**/*.ts`;
+        const srcMainTsx = `${packageRoot}/src/main/**/*.tsx`;
+        let maxMtime = 0;
+        try {
+            for await (const file of glob(srcMainTs, {})) {
+                const stat = await fs.stat(file);
+                maxMtime = Math.max(maxMtime, stat.mtimeMs);
+            }
+            for await (const file of glob(srcMainTsx, {})) {
+                const stat = await fs.stat(file);
+                maxMtime = Math.max(maxMtime, stat.mtimeMs);
+            }
+        }
+        catch (error) {
+            // If source files don't exist, return 0
+            return 0;
+        }
+        return maxMtime;
+    },
+    async isStale(projectRoot, packageRoot, packageName) {
+        const indexPath = ExportIndexCache.getIndexPath(projectRoot, packageName);
+        const indexFilePath = pathResolve(indexPath, '_export-for-import.json');
+        if (!await FileSystemUtils.file.exists(indexFilePath)) {
+            return true; // No index file means it's stale
+        }
+        const indexStat = await fs.stat(indexFilePath);
+        const indexMtime = indexStat.mtimeMs;
+        const sourceMtime = await ExportIndexCache.calculateSourceMtime(packageRoot);
+        // Stale if any source file is newer than index file
+        return sourceMtime > indexMtime;
+    },
+    async getByName(projectRoot, packageRoot, packageName, symbolName) {
+        const cached = await ExportIndexCache.load(projectRoot, packageRoot, packageName);
+        return cached.byName.get(symbolName) || null;
+    },
+    async getByFile(projectRoot, packageRoot, packageName, filePath) {
+        const cached = await ExportIndexCache.load(projectRoot, packageRoot, packageName);
+        return cached.byFile.get(filePath) || [];
+    },
+    async getByType(projectRoot, packageRoot, packageName, symbolType) {
+        const cached = await ExportIndexCache.load(projectRoot, packageRoot, packageName);
+        return cached.byType.get(symbolType) || [];
+    },
+    async getAll(projectRoot, packageRoot, packageName) {
+        const cached = await ExportIndexCache.load(projectRoot, packageRoot, packageName);
+        return cached.exports;
+    },
+    invalidate(projectRoot, packageRoot, packageName) {
+        const cacheKey = packageRoot;
+        cache.delete(cacheKey);
+    },
+    clear() {
+        cache.clear();
+    }
+};

package/exports/ExportMapper.d.ts

@@ -0,0 +1,43 @@
+import * as ts from 'typescript';
+export type ExportSymbol = {
+    name: string;
+    filePath: string;
+    line: number;
+    symbolType: 'function' | 'class' | 'interface' | 'type' | 'enum' | 'variable' | 'constant' | 'default' | 're-export';
+    signature: string | null;
+    typeInfo: string | null;
+    genericSignature: string | null;
+    parentClass: string | null;
+    interfaces: string[];
+};
+export type ExportError = {
+    level: 'package' | 'folder' | 'file' | 'symbol';
+    path: string;
+    error: string;
+    stack?: string;
+    timestamp: string;
+    retryable: boolean;
+    context?: Record<string, any>;
+};
+export declare class ExportMapper {
+    static getIndexPath(projectRoot: string, packageName: string): string;
+    static generateIndexFiles(projectRoot: string, packageName: string, exports: ExportSymbol[]): Promise<void>;
+    static mapExports(projectRoot: string, packageRoot: string, packageName: string, sourceFiles: string[], retryErrors?: ExportError[]): Promise<{
+        exports: ExportSymbol[];
+        errors: ExportError[];
+    }>;
+    static createProgram(sourceFiles: string[], packageRoot: string): ts.Program;
+    static extractExportsFromFile(sourceFile: ts.SourceFile, checker: ts.TypeChecker, packageRoot: string, errors: ExportError[], errorMap?: Map<string, ExportError>): ExportSymbol[];
+    static extractSymbolMetadata(node: ts.Node, sourceFile: ts.SourceFile, checker: ts.TypeChecker, packageRoot: string, errors: ExportError[], name: string, symbolType: ExportSymbol['symbolType'], errorMap?: Map<string, ExportError>): ExportSymbol | null;
+    static extractGenericSignatures(node: ts.Node, checker: ts.TypeChecker): string | null;
+    static extractClassInheritance(node: ts.ClassDeclaration, checker: ts.TypeChecker): {
+        parentClass: string | null;
+        interfaces: string[];
+    };
+    static hasExportModifier(node: ts.Node): boolean;
+    static getLineNumber(sourceFile: ts.SourceFile, node: ts.Node): number;
+    static getRelativePath(absolutePath: string, packageRoot: string): string;
+    static loadPreviousErrors(projectRoot: string, packageName: string): Promise<ExportError[] | null>;
+    static writeErrors(projectRoot: string, packageName: string, errors: ExportError[]): Promise<void>;
+    static shouldRetryError(error: ExportError, retryErrors?: ExportError[]): boolean;
+}

package/exports/ExportMapper.js

@@ -0,0 +1,519 @@
+import * as ts from 'typescript';
+import { resolve as pathResolve } from 'path';
+import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { __stringify } from '@nu-art/ts-common';
+import { CONST_TS_CONFIG } from '../config/consts.js';
+import { existsSync, readFileSync } from 'fs';
+export class ExportMapper {
+    static getIndexPath(projectRoot, packageName) {
+        return pathResolve(projectRoot, '.trash', 'indices', packageName);
+    }
+    static async generateIndexFiles(projectRoot, packageName, exports) {
+        const indexPath = ExportMapper.getIndexPath(projectRoot, packageName);
+        // Ensure directory exists
+        await FileSystemUtils.folder.create(indexPath);
+        // Generate by-name index
+        const byName = {};
+        for (const exp of exports) {
+            byName[exp.name] = exp;
+        }
+        const byNamePath = pathResolve(indexPath, '_export-index-by-name.json');
+        await FileSystemUtils.file.write(byNamePath, __stringify(byName, true));
+        // Generate by-file index
+        const byFile = {};
+        for (const exp of exports) {
+            if (!byFile[exp.filePath]) {
+                byFile[exp.filePath] = [];
+            }
+            byFile[exp.filePath].push(exp);
+        }
+        const byFilePath = pathResolve(indexPath, '_export-index-by-file.json');
+        await FileSystemUtils.file.write(byFilePath, __stringify(byFile, true));
+        // Generate by-type index
+        const byType = {};
+        for (const exp of exports) {
+            if (!byType[exp.symbolType]) {
+                byType[exp.symbolType] = [];
+            }
+            byType[exp.symbolType].push(exp);
+        }
+        const byTypePath = pathResolve(indexPath, '_export-index-by-type.json');
+        await FileSystemUtils.file.write(byTypePath, __stringify(byType, true));
+    }
+    static async mapExports(projectRoot, packageRoot, packageName, sourceFiles, retryErrors) {
+        const errors = [];
+        const exports = [];
+        // Create error map for quick lookup
+        const errorMap = new Map();
+        if (retryErrors) {
+            for (const error of retryErrors) {
+                errorMap.set(error.path, error);
+            }
+        }
+        // Package level: Create TypeScript program
+        let program;
+        try {
+            program = ExportMapper.createProgram(sourceFiles, packageRoot);
+        }
+        catch (error) {
+            errors.push({
+                level: 'package',
+                path: packageRoot,
+                error: error.message || String(error),
+                stack: error.stack,
+                timestamp: new Date().toISOString(),
+                retryable: true,
+                context: { operation: 'createProgram' }
+            });
+            return { exports, errors };
+        }
+        const checker = program.getTypeChecker();
+        // File level: Process each source file
+        for (const sourceFile of program.getSourceFiles()) {
+            // Skip node_modules and declaration files
+            if (sourceFile.fileName.includes('node_modules') || sourceFile.fileName.endsWith('.d.ts')) {
+                continue;
+            }
+            // Only process files in src/main
+            if (!sourceFile.fileName.includes('/src/main/')) {
+                continue;
+            }
+            const filePath = ExportMapper.getRelativePath(sourceFile.fileName, packageRoot);
+            const fileErrorKey = filePath;
+            // Check if this file had a previous non-retryable error - skip those
+            // If retryable error exists, we'll process it (retry)
+            // If no previous error, process normally
+            if (errorMap.has(fileErrorKey)) {
+                const prevError = errorMap.get(fileErrorKey);
+                if (!prevError.retryable) {
+                    // Skip non-retryable errors
+                    continue;
+                }
+                // If retryable, continue to process (retry it)
+            }
+            try {
+                const fileExports = ExportMapper.extractExportsFromFile(sourceFile, checker, packageRoot, errors, errorMap);
+                exports.push(...fileExports);
+                // Remove from error map if successfully processed
+                if (errorMap.has(fileErrorKey)) {
+                    errorMap.delete(fileErrorKey);
+                }
+            }
+            catch (error) {
+                errors.push({
+                    level: 'file',
+                    path: filePath,
+                    error: error.message || String(error),
+                    stack: error.stack,
+                    timestamp: new Date().toISOString(),
+                    retryable: true,
+                    context: { fileName: sourceFile.fileName }
+                });
+            }
+        }
+        // Add any remaining errors from retry that weren't resolved
+        for (const error of errorMap.values()) {
+            errors.push(error);
+        }
+        return { exports, errors };
+    }
+    static createProgram(sourceFiles, packageRoot) {
+        const tsConfigPath = pathResolve(packageRoot, 'src/main', CONST_TS_CONFIG);
+        let compilerOptions = {};
+        // Try to load tsconfig.json synchronously
+        if (existsSync(tsConfigPath)) {
+            try {
+                const configFileText = readFileSync(tsConfigPath, 'utf8');
+                const configFile = ts.parseConfigFileTextToJson(tsConfigPath, configFileText);
+                if (configFile.config) {
+                    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, pathResolve(packageRoot, 'src/main'));
+                    compilerOptions = parsedConfig.options;
+                }
+            }
+            catch (error) {
+                // Use default options if config loading fails
+            }
+        }
+        // Default compiler options
+        compilerOptions = {
+            ...compilerOptions,
+            allowJs: true,
+            skipLibCheck: true,
+            noEmit: true,
+        };
+        return ts.createProgram(sourceFiles, compilerOptions);
+    }
+    static extractExportsFromFile(sourceFile, checker, packageRoot, errors, errorMap) {
+        const exports = [];
+        const filePath = ExportMapper.getRelativePath(sourceFile.fileName, packageRoot);
+        const visit = (node) => {
+            // Check for export declarations
+            if (ts.isVariableStatement(node) && ExportMapper.hasExportModifier(node)) {
+                // Export variable statements
+                for (const declaration of node.declarationList.declarations) {
+                    if (ts.isIdentifier(declaration.name)) {
+                        const symbol = ExportMapper.extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, declaration.name.text, 'variable', errorMap);
+                        if (symbol)
+                            exports.push(symbol);
+                    }
+                }
+            }
+            else if (ts.isFunctionDeclaration(node) && ExportMapper.hasExportModifier(node) && node.name) {
+                // Export function
+                const symbol = ExportMapper.extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, node.name.text, 'function', errorMap);
+                if (symbol)
+                    exports.push(symbol);
+            }
+            else if (ts.isClassDeclaration(node) && ExportMapper.hasExportModifier(node) && node.name) {
+                // Export class
+                const symbol = ExportMapper.extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, node.name.text, 'class', errorMap);
+                if (symbol)
+                    exports.push(symbol);
+            }
+            else if (ts.isInterfaceDeclaration(node) && ExportMapper.hasExportModifier(node)) {
+                // Export interface
+                const symbol = ExportMapper.extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, node.name.text, 'interface', errorMap);
+                if (symbol)
+                    exports.push(symbol);
+            }
+            else if (ts.isTypeAliasDeclaration(node) && ExportMapper.hasExportModifier(node)) {
+                // Export type
+                const symbol = ExportMapper.extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, node.name.text, 'type', errorMap);
+                if (symbol)
+                    exports.push(symbol);
+            }
+            else if (ts.isEnumDeclaration(node) && ExportMapper.hasExportModifier(node)) {
+                // Export enum
+                const symbol = ExportMapper.extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, node.name.text, 'enum', errorMap);
+                if (symbol)
+                    exports.push(symbol);
+            }
+            else if (ts.isExportAssignment(node)) {
+                // Default export
+                const symbol = ExportMapper.extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, 'default', 'default', errorMap);
+                if (symbol)
+                    exports.push(symbol);
+            }
+            else if (ts.isExportDeclaration(node)) {
+                // Re-export
+                if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                    const symbol = {
+                        name: node.moduleSpecifier.text,
+                        filePath,
+                        line: ExportMapper.getLineNumber(sourceFile, node),
+                        symbolType: 're-export',
+                        signature: null,
+                        typeInfo: node.moduleSpecifier.text,
+                        genericSignature: null,
+                        parentClass: null,
+                        interfaces: []
+                    };
+                    exports.push(symbol);
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return exports;
+    }
+    static extractSymbolMetadata(node, sourceFile, checker, packageRoot, errors, name, symbolType, errorMap) {
+        const filePath = ExportMapper.getRelativePath(sourceFile.fileName, packageRoot);
+        const symbolErrorKey = `${filePath}::${name}`;
+        // Check if this symbol had a previous non-retryable error
+        if (errorMap?.has(symbolErrorKey)) {
+            const prevError = errorMap.get(symbolErrorKey);
+            if (!prevError.retryable) {
+                // Skip non-retryable symbol errors
+                return null;
+            }
+        }
+        try {
+            const line = ExportMapper.getLineNumber(sourceFile, node);
+            let signature = null;
+            let typeInfo = null;
+            let genericSignature = null;
+            let parentClass = null;
+            let interfaces = [];
+            // Extract generic signature
+            try {
+                genericSignature = ExportMapper.extractGenericSignatures(node, checker);
+            }
+            catch (error) {
+                errors.push({
+                    level: 'symbol',
+                    path: symbolErrorKey,
+                    error: `Failed to extract generic signature: ${error.message || String(error)}`,
+                    stack: error.stack,
+                    timestamp: new Date().toISOString(),
+                    retryable: true,
+                    context: { symbolName: name, symbolType, operation: 'extractGenericSignatures' }
+                });
+            }
+            // Extract signature and type info based on symbol type
+            if (symbolType === 'function' && ts.isFunctionDeclaration(node)) {
+                try {
+                    const symbol = checker.getSymbolAtLocation(node);
+                    if (symbol) {
+                        const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+                        const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Call);
+                        if (signatures.length > 0) {
+                            signature = checker.signatureToString(signatures[0], node);
+                        }
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        level: 'symbol',
+                        path: symbolErrorKey,
+                        error: `Failed to extract function signature: ${error.message || String(error)}`,
+                        stack: error.stack,
+                        timestamp: new Date().toISOString(),
+                        retryable: true,
+                        context: { symbolName: name, symbolType, operation: 'extractFunctionSignature' }
+                    });
+                }
+            }
+            else if (symbolType === 'class' && ts.isClassDeclaration(node)) {
+                try {
+                    // Extract class inheritance
+                    const inheritance = ExportMapper.extractClassInheritance(node, checker);
+                    parentClass = inheritance.parentClass;
+                    interfaces = inheritance.interfaces;
+                    // Build class signature
+                    const parts = [];
+                    parts.push('class', name);
+                    if (genericSignature) {
+                        parts[1] = `${name}${genericSignature}`;
+                    }
+                    if (parentClass) {
+                        parts.push('extends', parentClass);
+                    }
+                    if (interfaces.length > 0) {
+                        parts.push('implements', interfaces.join(', '));
+                    }
+                    signature = parts.join(' ');
+                }
+                catch (error) {
+                    errors.push({
+                        level: 'symbol',
+                        path: symbolErrorKey,
+                        error: `Failed to extract class metadata: ${error.message || String(error)}`,
+                        stack: error.stack,
+                        timestamp: new Date().toISOString(),
+                        retryable: true,
+                        context: { symbolName: name, symbolType, operation: 'extractClassMetadata' }
+                    });
+                }
+            }
+            else if (symbolType === 'interface' && ts.isInterfaceDeclaration(node)) {
+                try {
+                    const symbol = checker.getSymbolAtLocation(node);
+                    if (symbol) {
+                        const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+                        typeInfo = checker.typeToString(type, node);
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        level: 'symbol',
+                        path: symbolErrorKey,
+                        error: `Failed to extract interface type info: ${error.message || String(error)}`,
+                        stack: error.stack,
+                        timestamp: new Date().toISOString(),
+                        retryable: true,
+                        context: { symbolName: name, symbolType, operation: 'extractInterfaceTypeInfo' }
+                    });
+                }
+            }
+            else if (symbolType === 'type' && ts.isTypeAliasDeclaration(node)) {
+                try {
+                    const symbol = checker.getSymbolAtLocation(node);
+                    if (symbol) {
+                        const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+                        typeInfo = checker.typeToString(type, node);
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        level: 'symbol',
+                        path: symbolErrorKey,
+                        error: `Failed to extract type info: ${error.message || String(error)}`,
+                        stack: error.stack,
+                        timestamp: new Date().toISOString(),
+                        retryable: true,
+                        context: { symbolName: name, symbolType, operation: 'extractTypeInfo' }
+                    });
+                }
+            }
+            else if (symbolType === 'variable' || symbolType === 'constant') {
+                try {
+                    const symbol = checker.getSymbolAtLocation(node);
+                    if (symbol) {
+                        const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+                        typeInfo = checker.typeToString(type, node);
+                    }
+                }
+                catch (error) {
+                    errors.push({
+                        level: 'symbol',
+                        path: symbolErrorKey,
+                        error: `Failed to extract variable type info: ${error.message || String(error)}`,
+                        stack: error.stack,
+                        timestamp: new Date().toISOString(),
+                        retryable: true,
+                        context: { symbolName: name, symbolType, operation: 'extractVariableTypeInfo' }
+                    });
+                }
+            }
+            const symbol = {
+                name,
+                filePath,
+                line,
+                symbolType,
+                signature,
+                typeInfo,
+                genericSignature,
+                parentClass,
+                interfaces
+            };
+            // Remove from error map if successfully processed (retry succeeded)
+            if (errorMap?.has(symbolErrorKey)) {
+                errorMap.delete(symbolErrorKey);
+            }
+            return symbol;
+        }
+        catch (error) {
+            errors.push({
+                level: 'symbol',
+                path: symbolErrorKey,
+                error: error.message || String(error),
+                stack: error.stack,
+                timestamp: new Date().toISOString(),
+                retryable: true,
+                context: { symbolName: name, symbolType }
+            });
+            return null;
+        }
+    }
+    static extractGenericSignatures(node, checker) {
+        let typeParameters;
+        if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) {
+            typeParameters = node.typeParameters;
+        }
+        else if (ts.isClassDeclaration(node)) {
+            typeParameters = node.typeParameters;
+        }
+        else if (ts.isInterfaceDeclaration(node)) {
+            typeParameters = node.typeParameters;
+        }
+        else if (ts.isTypeAliasDeclaration(node)) {
+            typeParameters = node.typeParameters;
+        }
+        if (!typeParameters || typeParameters.length === 0) {
+            return null;
+        }
+        const params = [];
+        for (const param of typeParameters) {
+            let paramStr = param.name.text;
+            if (param.constraint) {
+                paramStr += ` extends ${param.constraint.getText()}`;
+            }
+            if (param.default) {
+                paramStr += ` = ${param.default.getText()}`;
+            }
+            params.push(paramStr);
+        }
+        return `<${params.join(', ')}>`;
+    }
+    static extractClassInheritance(node, checker) {
+        let parentClass = null;
+        const interfaces = [];
+        if (!node.heritageClauses) {
+            return { parentClass, interfaces };
+        }
+        for (const clause of node.heritageClauses) {
+            if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+                // Extends clause
+                for (const type of clause.types) {
+                    try {
+                        const typeNode = checker.getTypeAtLocation(type);
+                        parentClass = checker.typeToString(typeNode, type);
+                    }
+                    catch (error) {
+                        // If type checking fails, use the text
+                        parentClass = type.getText();
+                    }
+                }
+            }
+            else if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                // Implements clause
+                for (const type of clause.types) {
+                    try {
+                        const typeNode = checker.getTypeAtLocation(type);
+                        interfaces.push(checker.typeToString(typeNode, type));
+                    }
+                    catch (error) {
+                        // If type checking fails, use the text
+                        interfaces.push(type.getText());
+                    }
+                }
+            }
+        }
+        return { parentClass, interfaces };
+    }
+    static hasExportModifier(node) {
+        return (ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword) ?? false));
+    }
+    static getLineNumber(sourceFile, node) {
+        const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        return line + 1; // Convert to 1-based line number
+    }
+    static getRelativePath(absolutePath, packageRoot) {
+        const relative = absolutePath.replace(packageRoot, '').replace(/^\//, '');
+        return relative || absolutePath;
+    }
+    static async loadPreviousErrors(projectRoot, packageName) {
+        const indexPath = ExportMapper.getIndexPath(projectRoot, packageName);
+        const errorFilePath = pathResolve(indexPath, '_export-errors.json');
+        if (!await FileSystemUtils.file.exists(errorFilePath)) {
+            return null;
+        }
+        try {
+            const errorFile = await FileSystemUtils.file.read.json(errorFilePath);
+            return errorFile.errors || [];
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    static async writeErrors(projectRoot, packageName, errors) {
+        const indexPath = ExportMapper.getIndexPath(projectRoot, packageName);
+        await FileSystemUtils.folder.create(indexPath);
+        if (errors.length === 0) {
+            // Remove error file if no errors
+            const errorFilePath = pathResolve(indexPath, '_export-errors.json');
+            if (await FileSystemUtils.file.exists(errorFilePath)) {
+                await FileSystemUtils.file.delete(errorFilePath);
+            }
+            return;
+        }
+        const errorFile = {
+            package: packageName,
+            timestamp: new Date().toISOString(),
+            errors
+        };
+        const errorFilePath = pathResolve(indexPath, '_export-errors.json');
+        await FileSystemUtils.file.write(errorFilePath, __stringify(errorFile, true));
+    }
+    static shouldRetryError(error, retryErrors) {
+        if (!error.retryable) {
+            return false;
+        }
+        if (!retryErrors || retryErrors.length === 0) {
+            // If no retryErrors provided, don't retry (means we're not in retry mode)
+            return false;
+        }
+        // Check if this error exists in retryErrors (meaning it should be retried)
+        return retryErrors.some(e => e.path === error.path && e.level === error.level);
+    }
+}