spec-gen-cli 1.0.0

package/dist/core/analyzer/import-parser.js

@@ -0,0 +1,720 @@
+/**
+ * Import/Export Parser
+ *
+ * Parses source files to extract imports and exports.
+ * Uses regex-based parsing for speed and simplicity.
+ * Supports JavaScript/TypeScript and Python.
+ */
+import { readFile } from 'node:fs/promises';
+import { dirname, join, resolve, extname } from 'node:path';
+// ============================================================================
+// NODE.JS BUILTINS
+// ============================================================================
+const NODE_BUILTINS = new Set([
+    'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console',
+    'constants', 'crypto', 'dgram', 'diagnostics_channel', 'dns', 'domain',
+    'events', 'fs', 'http', 'http2', 'https', 'inspector', 'module', 'net',
+    'os', 'path', 'perf_hooks', 'process', 'punycode', 'querystring', 'readline',
+    'repl', 'stream', 'string_decoder', 'timers', 'tls', 'trace_events', 'tty',
+    'url', 'util', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib',
+    // Node.js prefixed versions
+    'node:assert', 'node:async_hooks', 'node:buffer', 'node:child_process',
+    'node:cluster', 'node:console', 'node:constants', 'node:crypto', 'node:dgram',
+    'node:diagnostics_channel', 'node:dns', 'node:domain', 'node:events',
+    'node:fs', 'node:http', 'node:http2', 'node:https', 'node:inspector',
+    'node:module', 'node:net', 'node:os', 'node:path', 'node:perf_hooks',
+    'node:process', 'node:punycode', 'node:querystring', 'node:readline',
+    'node:repl', 'node:stream', 'node:string_decoder', 'node:timers', 'node:tls',
+    'node:trace_events', 'node:tty', 'node:url', 'node:util', 'node:v8',
+    'node:vm', 'node:wasi', 'node:worker_threads', 'node:zlib',
+    // fs/promises and other submodules
+    'fs/promises', 'node:fs/promises', 'stream/promises', 'node:stream/promises',
+    'timers/promises', 'node:timers/promises', 'util/types', 'node:util/types',
+]);
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if a module path is a relative import
+ */
+function isRelativeImport(source) {
+    return source.startsWith('.') || source.startsWith('/');
+}
+/**
+ * Check if a module is a Node.js builtin
+ */
+function isBuiltinModule(source) {
+    return NODE_BUILTINS.has(source) || NODE_BUILTINS.has(source.split('/')[0]);
+}
+/**
+ * Get line number for a match position in content
+ */
+function getLineNumber(content, position) {
+    return content.substring(0, position).split('\n').length;
+}
+/**
+ * Parse named imports from a string like "X, Y as Z, W"
+ */
+function parseNamedImports(namesStr) {
+    return namesStr
+        .split(',')
+        .map(name => {
+        const trimmed = name.trim();
+        // Handle "X as Y" - we want the local name Y
+        const asMatch = trimmed.match(/(\w+)\s+as\s+(\w+)/);
+        if (asMatch) {
+            return asMatch[2];
+        }
+        // Handle type imports like "type X"
+        if (trimmed.startsWith('type ')) {
+            return trimmed.slice(5).trim();
+        }
+        return trimmed;
+    })
+        .filter(name => name && !name.includes(' '));
+}
+// ============================================================================
+// JAVASCRIPT/TYPESCRIPT PARSER
+// ============================================================================
+/**
+ * Parse imports from JavaScript/TypeScript content
+ */
+function parseJSImports(content) {
+    const imports = [];
+    // Remove comments to avoid false matches
+    const cleanContent = content
+        .replace(/\/\*[\s\S]*?\*\//g, '') // Block comments
+        .replace(/\/\/.*$/gm, ''); // Line comments
+    // ES Module: import X from 'module'
+    let match;
+    const defaultImportRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+    while ((match = defaultImportRegex.exec(cleanContent)) !== null) {
+        const source = match[2];
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: [match[1]],
+            hasDefault: true,
+            hasNamespace: false,
+            isTypeOnly: false,
+            isDynamic: false,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // ES Module: import X, { Y, Z } from 'module' (mixed import - default + named)
+    const mixedImportRegex = /import\s+(\w+)\s*,\s*\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+    while ((match = mixedImportRegex.exec(cleanContent)) !== null) {
+        const source = match[3];
+        const names = [match[1], ...parseNamedImports(match[2])];
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: names,
+            hasDefault: true,
+            hasNamespace: false,
+            isTypeOnly: false,
+            isDynamic: false,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // ES Module: import { X, Y } from 'module'
+    const namedImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+    while ((match = namedImportRegex.exec(cleanContent)) !== null) {
+        const source = match[2];
+        const names = parseNamedImports(match[1]);
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: names,
+            hasDefault: false,
+            hasNamespace: false,
+            isTypeOnly: false,
+            isDynamic: false,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // ES Module: import * as X from 'module'
+    const namespaceImportRegex = /import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+    while ((match = namespaceImportRegex.exec(cleanContent)) !== null) {
+        const source = match[2];
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: [match[1]],
+            hasDefault: false,
+            hasNamespace: true,
+            isTypeOnly: false,
+            isDynamic: false,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // ES Module: import 'module' (side effect)
+    const sideEffectRegex = /import\s+['"]([^'"]+)['"](?!\s*from)/g;
+    while ((match = sideEffectRegex.exec(cleanContent)) !== null) {
+        const source = match[1];
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: [],
+            hasDefault: false,
+            hasNamespace: false,
+            isTypeOnly: false,
+            isDynamic: false,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // Type-only imports: import type { X } from 'module'
+    const typeImportRegex = /import\s+type\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+    while ((match = typeImportRegex.exec(cleanContent)) !== null) {
+        const source = match[3];
+        const names = match[1] ? parseNamedImports(match[1]) : [match[2]];
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: names,
+            hasDefault: !!match[2],
+            hasNamespace: false,
+            isTypeOnly: true,
+            isDynamic: false,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // CommonJS: require('module')
+    const requireRegex = /(?:const|let|var)\s+(?:(\w+)|\{([^}]+)\})\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while ((match = requireRegex.exec(cleanContent)) !== null) {
+        const source = match[3];
+        const names = match[1] ? [match[1]] : parseNamedImports(match[2]);
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: names,
+            hasDefault: !!match[1],
+            hasNamespace: false,
+            isTypeOnly: false,
+            isDynamic: false,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // Dynamic import: import('module')
+    const dynamicImportRegex = /(?:await\s+)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while ((match = dynamicImportRegex.exec(cleanContent)) !== null) {
+        const source = match[1];
+        imports.push({
+            source,
+            isRelative: isRelativeImport(source),
+            isPackage: !isRelativeImport(source) && !isBuiltinModule(source),
+            isBuiltin: isBuiltinModule(source),
+            importedNames: [],
+            hasDefault: false,
+            hasNamespace: false,
+            isTypeOnly: false,
+            isDynamic: true,
+            line: getLineNumber(content, match.index),
+        });
+    }
+    return imports;
+}
+/**
+ * Parse exports from JavaScript/TypeScript content
+ */
+function parseJSExports(content) {
+    const exports = [];
+    // Remove comments
+    const cleanContent = content
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/.*$/gm, '');
+    let match;
+    // export default
+    const defaultExportRegex = /export\s+default\s+(?:(class|function)\s+(\w+)|(\w+))/g;
+    while ((match = defaultExportRegex.exec(cleanContent)) !== null) {
+        const kind = match[1];
+        const name = match[2] || match[3] || 'default';
+        exports.push({
+            name,
+            isDefault: true,
+            isType: false,
+            isReExport: false,
+            kind: kind || 'unknown',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // export { X, Y } or export { X } from 'module'
+    const namedExportRegex = /export\s+\{([^}]+)\}(?:\s+from\s+['"]([^'"]+)['"])?/g;
+    while ((match = namedExportRegex.exec(cleanContent)) !== null) {
+        const names = parseNamedImports(match[1]);
+        const reExportSource = match[2];
+        for (const name of names) {
+            exports.push({
+                name,
+                isDefault: false,
+                isType: false,
+                isReExport: !!reExportSource,
+                reExportSource,
+                kind: 'unknown',
+                line: getLineNumber(content, match.index),
+            });
+        }
+    }
+    // export const/let/var
+    const varExportRegex = /export\s+(?:const|let|var)\s+(\w+)/g;
+    while ((match = varExportRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: false,
+            isReExport: false,
+            kind: 'variable',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // export function
+    const funcExportRegex = /export\s+function\s+(\w+)/g;
+    while ((match = funcExportRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: false,
+            isReExport: false,
+            kind: 'function',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // export class
+    const classExportRegex = /export\s+class\s+(\w+)/g;
+    while ((match = classExportRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: false,
+            isReExport: false,
+            kind: 'class',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // export type
+    const typeExportRegex = /export\s+type\s+(\w+)/g;
+    while ((match = typeExportRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: true,
+            isReExport: false,
+            kind: 'type',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // export interface
+    const interfaceExportRegex = /export\s+interface\s+(\w+)/g;
+    while ((match = interfaceExportRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: true,
+            isReExport: false,
+            kind: 'interface',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // export enum
+    const enumExportRegex = /export\s+enum\s+(\w+)/g;
+    while ((match = enumExportRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: false,
+            isReExport: false,
+            kind: 'enum',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // export * from 'module'
+    const reExportAllRegex = /export\s+\*\s+(?:as\s+(\w+)\s+)?from\s+['"]([^'"]+)['"]/g;
+    while ((match = reExportAllRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1] || '*',
+            isDefault: false,
+            isType: false,
+            isReExport: true,
+            reExportSource: match[2],
+            kind: 'unknown',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // module.exports
+    const moduleExportsRegex = /module\.exports\s*=\s*(\w+)/g;
+    while ((match = moduleExportsRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: true,
+            isType: false,
+            isReExport: false,
+            kind: 'unknown',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // exports.X
+    const exportsRegex = /exports\.(\w+)\s*=/g;
+    while ((match = exportsRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: false,
+            isReExport: false,
+            kind: 'unknown',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    return exports;
+}
+// ============================================================================
+// PYTHON PARSER
+// ============================================================================
+const PYTHON_BUILTINS = new Set([
+    // stdlib modules (Python 3)
+    'abc', 'argparse', 'ast', 'asyncio', 'base64', 'builtins', 'cgi', 'cmath',
+    'cmd', 'code', 'codecs', 'collections', 'concurrent', 'configparser',
+    'contextlib', 'copy', 'csv', 'dataclasses', 'datetime', 'decimal',
+    'difflib', 'dis', 'email', 'enum', 'errno', 'fileinput', 'fnmatch',
+    'fractions', 'ftplib', 'functools', 'gc', 'getpass', 'gettext', 'glob',
+    'gzip', 'hashlib', 'heapq', 'hmac', 'html', 'http', 'imaplib', 'importlib',
+    'inspect', 'io', 'ipaddress', 'itertools', 'json', 'keyword', 'linecache',
+    'locale', 'logging', 'lzma', 'math', 'mimetypes', 'multiprocessing',
+    'numbers', 'operator', 'os', 'pathlib', 'pickle', 'platform', 'pprint',
+    'queue', 'random', 're', 'shlex', 'shutil', 'signal', 'smtplib', 'socket',
+    'socketserver', 'sqlite3', 'ssl', 'stat', 'statistics', 'string',
+    'struct', 'subprocess', 'sys', 'tarfile', 'tempfile', 'textwrap',
+    'threading', 'time', 'timeit', 'tkinter', 'token', 'tokenize', 'traceback',
+    'types', 'typing', 'unicodedata', 'unittest', 'urllib', 'uuid', 'warnings',
+    'weakref', 'xml', 'xmlrpc', 'zipfile', 'zipimport', 'zlib',
+    '__future__',
+]);
+/**
+ * Parse imports from Python content
+ */
+function parsePythonImports(content) {
+    const imports = [];
+    // Remove comments and collapse multi-line parenthesized imports onto one line
+    // e.g. "from x import (\n  A,\n  B\n)" → "from x import A, B"
+    const cleanContent = content
+        .replace(/#.*$/gm, '')
+        .replace(/\(\s*([\s\S]*?)\s*\)/g, (_, inner) => inner.replace(/\s*\n\s*/g, ', '));
+    let match;
+    // import X or import X, Y or import X.Y.Z
+    const importRegex = /^import[ \t]+([^\n\r]+)$/gm;
+    while ((match = importRegex.exec(cleanContent)) !== null) {
+        const modules = match[1].split(',').map(m => m.trim()).filter(Boolean);
+        for (const mod of modules) {
+            const source = mod.split(/\s+as\s+/)[0].trim();
+            imports.push({
+                source,
+                isRelative: source.startsWith('.'),
+                isPackage: !source.startsWith('.'),
+                isBuiltin: PYTHON_BUILTINS.has(source.split('.')[0]),
+                importedNames: [mod.includes(' as ') ? mod.split(/\s+as\s+/)[1].trim() : source.split('.').pop()],
+                hasDefault: false,
+                hasNamespace: true,
+                isTypeOnly: false,
+                isDynamic: false,
+                line: getLineNumber(content, match.index),
+            });
+        }
+    }
+    // from X import Y or from X import Y, Z (including multi-line after collapsing)
+    const fromImportRegex = /^from\s+([\w.]+)\s+import\s+(.+)$/gm;
+    while ((match = fromImportRegex.exec(cleanContent)) !== null) {
+        const source = match[1];
+        const importsPart = match[2].trim().replace(/[()]/g, '');
+        if (importsPart === '*') {
+            imports.push({
+                source,
+                isRelative: source.startsWith('.'),
+                isPackage: !source.startsWith('.'),
+                isBuiltin: PYTHON_BUILTINS.has(source.split('.')[0]),
+                importedNames: ['*'],
+                hasDefault: false,
+                hasNamespace: true,
+                isTypeOnly: false,
+                isDynamic: false,
+                line: getLineNumber(content, match.index),
+            });
+        }
+        else {
+            const names = importsPart.split(',').map(n => {
+                const trimmed = n.trim();
+                return trimmed.includes(' as ') ? trimmed.split(/\s+as\s+/)[1].trim() : trimmed;
+            }).filter(Boolean);
+            imports.push({
+                source,
+                isRelative: source.startsWith('.'),
+                isPackage: !source.startsWith('.'),
+                isBuiltin: PYTHON_BUILTINS.has(source.split('.')[0]),
+                importedNames: names,
+                hasDefault: false,
+                hasNamespace: false,
+                isTypeOnly: false,
+                isDynamic: false,
+                line: getLineNumber(content, match.index),
+            });
+        }
+    }
+    return imports;
+}
+/**
+ * Parse exports from Python content (module-level definitions)
+ */
+function parsePythonExports(content) {
+    const exports = [];
+    // Remove comments
+    const cleanContent = content.replace(/#.*$/gm, '');
+    let match;
+    // Check for __all__ definition
+    const allMatch = cleanContent.match(/__all__\s*=\s*\[([^\]]+)\]/);
+    if (allMatch) {
+        const names = allMatch[1].match(/['"](\w+)['"]/g);
+        if (names) {
+            for (const name of names) {
+                const cleanName = name.replace(/['"]/g, '');
+                exports.push({
+                    name: cleanName,
+                    isDefault: false,
+                    isType: false,
+                    isReExport: false,
+                    kind: 'unknown',
+                    line: getLineNumber(content, allMatch.index ?? 0),
+                });
+            }
+        }
+    }
+    // Class definitions at module level (no indentation)
+    const classRegex = /^class\s+(\w+)/gm;
+    while ((match = classRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: false,
+            isReExport: false,
+            kind: 'class',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    // Function definitions at module level (no indentation)
+    const funcRegex = /^def\s+(\w+)/gm;
+    while ((match = funcRegex.exec(cleanContent)) !== null) {
+        // Skip private functions
+        if (!match[1].startsWith('_')) {
+            exports.push({
+                name: match[1],
+                isDefault: false,
+                isType: false,
+                isReExport: false,
+                kind: 'function',
+                line: getLineNumber(content, match.index),
+            });
+        }
+    }
+    // Module-level variables (UPPER_CASE constants)
+    const constRegex = /^([A-Z][A-Z0-9_]*)\s*=/gm;
+    while ((match = constRegex.exec(cleanContent)) !== null) {
+        exports.push({
+            name: match[1],
+            isDefault: false,
+            isType: false,
+            isReExport: false,
+            kind: 'variable',
+            line: getLineNumber(content, match.index),
+        });
+    }
+    return exports;
+}
+// ============================================================================
+// IMPORT RESOLUTION
+// ============================================================================
+/**
+ * Resolve a relative import to an absolute file path
+ */
+export async function resolveImport(importSource, fromFile, options) {
+    // External package - return null
+    if (!isRelativeImport(importSource)) {
+        return null;
+    }
+    const fromDir = dirname(fromFile);
+    const fromExt = extname(fromFile).toLowerCase();
+    const isPython = fromExt === '.py' || fromExt === '.pyw';
+    // Default extensions depend on the source file type
+    const extensions = options.extensions ?? (isPython
+        ? ['.py', '.pyw']
+        : ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+    // Python relative imports use dot-prefix notation:
+    //   from .utils import foo   → source = ".utils"   → resolve as "./utils"
+    //   from ..models import X   → source = "..models"  → resolve as "../models"
+    //   from ...pkg import Y     → source = "...pkg"    → resolve as "../../pkg"
+    // N dots = (N-1) levels up from fromDir. Also handles dotted paths: .db.models → ./db/models
+    let normalizedSource = importSource;
+    if (isPython && importSource.startsWith('.')) {
+        let dots = 0;
+        while (dots < importSource.length && importSource[dots] === '.')
+            dots++;
+        const rest = importSource.slice(dots).replace(/\./g, '/');
+        // dots=1 → './', dots=2 → '../', dots=3 → '../../', etc.
+        const prefix = dots === 1 ? './' : '../'.repeat(dots - 1);
+        normalizedSource = rest ? prefix + rest : prefix.replace(/\/$/, '') || '.';
+    }
+    const basePath = resolve(fromDir, normalizedSource);
+    // Strip any existing extension from the import source.
+    // This handles the TypeScript NodeNext convention where imports are written
+    // as `./foo.js` but the actual file on disk is `./foo.ts`.
+    // Without this, we'd try `foo.js.ts`, `foo.js.tsx`, etc. and find nothing.
+    const existingExt = extname(basePath); // e.g. ".js", ".ts", ""
+    const baseWithoutExt = existingExt
+        ? basePath.slice(0, -existingExt.length)
+        : basePath;
+    // Build candidate list (order matters: most specific first):
+    // 1. Exact path as-is (the import may already point to the real file)
+    // 2. Strip the extension, try every known extension (handles .js -> .ts)
+    // 3. Directory index files (handles `./components` -> `./components/index.ts`)
+    // 4. Python packages: module/__init__.py
+    const candidates = [
+        basePath,
+        ...extensions.map(ext => baseWithoutExt + ext),
+        ...extensions.map(ext => join(basePath, `index${ext}`)),
+        ...extensions.map(ext => join(baseWithoutExt, `index${ext}`)),
+        ...(isPython ? extensions.map(ext => join(basePath, `__init__${ext}`)) : []),
+    ];
+    // Deduplicate while preserving order
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        try {
+            await readFile(candidate);
+            return candidate;
+        }
+        catch {
+            // Not found, try next
+        }
+    }
+    return null;
+}
+// ============================================================================
+// MAIN PARSER CLASS
+// ============================================================================
+/**
+ * Import/Export Parser
+ */
+export class ImportExportParser {
+    cache = new Map();
+    /**
+     * Clear the parse cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get file extension type
+     */
+    getFileType(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        if (['.ts', '.tsx', '.mts', '.cts'].includes(ext))
+            return 'ts';
+        if (['.js', '.jsx', '.mjs', '.cjs'].includes(ext))
+            return 'js';
+        if (['.py', '.pyw'].includes(ext))
+            return 'python';
+        return 'unknown';
+    }
+    /**
+     * Parse a file and extract imports/exports
+     */
+    async parseFile(filePath) {
+        // Check cache
+        const cached = this.cache.get(filePath);
+        if (cached) {
+            return cached;
+        }
+        const analysis = {
+            filePath,
+            imports: [],
+            exports: [],
+            localImports: [],
+            externalImports: [],
+            parseErrors: [],
+        };
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            const fileType = this.getFileType(filePath);
+            if (fileType === 'js' || fileType === 'ts') {
+                analysis.imports = parseJSImports(content);
+                analysis.exports = parseJSExports(content);
+            }
+            else if (fileType === 'python') {
+                analysis.imports = parsePythonImports(content);
+                analysis.exports = parsePythonExports(content);
+            }
+            else {
+                analysis.parseErrors.push(`Unsupported file type: ${extname(filePath)}`);
+            }
+            // Categorize imports
+            for (const imp of analysis.imports) {
+                if (imp.isRelative) {
+                    analysis.localImports.push(imp.source);
+                }
+                else if (imp.isPackage) {
+                    // Extract package name (first part of path)
+                    const pkgName = imp.source.startsWith('@')
+                        ? imp.source.split('/').slice(0, 2).join('/')
+                        : imp.source.split('/')[0];
+                    if (!analysis.externalImports.includes(pkgName)) {
+                        analysis.externalImports.push(pkgName);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            analysis.parseErrors.push(`Failed to read file: ${error.message}`);
+        }
+        // Cache the result
+        this.cache.set(filePath, analysis);
+        return analysis;
+    }
+    /**
+     * Parse multiple files
+     */
+    async parseFiles(filePaths) {
+        const results = new Map();
+        for (const filePath of filePaths) {
+            const analysis = await this.parseFile(filePath);
+            results.set(filePath, analysis);
+        }
+        return results;
+    }
+}
+/**
+ * Convenience function to parse a single file
+ */
+export async function parseFile(filePath) {
+    const parser = new ImportExportParser();
+    return parser.parseFile(filePath);
+}
+/**
+ * Convenience function to parse multiple files
+ */
+export async function parseFiles(filePaths) {
+    const parser = new ImportExportParser();
+    return parser.parseFiles(filePaths);
+}
+//# sourceMappingURL=import-parser.js.map