migrate-barrel-imports 1.5.1 → 1.7.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export declare function main(): Promise<void>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAIA,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAmD1C"}

package/dist/cli.js

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import { migrateBarrelImports } from './migrate-barrel-imports';
+import { defaultOptions } from './options';
+export async function main() {
+    const program = new Command();
+    program
+        .name('migrate-barrel-imports')
+        .description('CLI tool to migrate barrel files imports to direct imports')
+        .argument('<source-path>', 'Glob pattern for source packages containing barrel files (e.g. "libs/*")')
+        .argument('[target-path]', 'Path to the directory where imports should be migrated (default: current directory)')
+        .option('--ignore-source-files <patterns>', 'Comma-separated list of file patterns to ignore in source directory')
+        .option('--ignore-target-files <patterns>', 'Comma-separated list of file patterns to ignore in target directory')
+        .option('--no-extension', 'Exclude js|jsx|ts|tsx|mjs|cjs file extensions from import statements')
+        .allowUnknownOption(false)
+        .parse(process.argv);
+    const args = program.args;
+    if (!args[0]) {
+        console.error('Error: source-path is required');
+        process.exit(1);
+    }
+    const sourcePath = args[0];
+    const targetPath = args[1] || defaultOptions.targetPath;
+    const options = program.opts();
+    await migrateBarrelImports({
+        sourcePath,
+        targetPath,
+        ignoreSourceFiles: options.ignoreSourceFiles
+            ? options.ignoreSourceFiles.split(',')
+            : defaultOptions.ignoreSourceFiles,
+        ignoreTargetFiles: options.ignoreTargetFiles
+            ? options.ignoreTargetFiles.split(',')
+            : defaultOptions.ignoreTargetFiles,
+        includeExtension: options.extension !== false ? true : defaultOptions.includeExtension
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
-import{Command as e}from"commander";import o,{readFileSync as s,writeFileSync as r}from"node:fs";import t from"node:path";import i from"@babel/generator";import{parse as n}from"@babel/parser";import l from"@babel/traverse";import{isVariableDeclaration as a,isIdentifier as c,isFunctionDeclaration as p,isTSEnumDeclaration as g,isTSInterfaceDeclaration as d,isTSTypeAliasDeclaration as u,isClassDeclaration as f,isExportSpecifier as m,isImportSpecifier as h,importDeclaration as $,stringLiteral as x,importSpecifier as S}from"@babel/types";import F from"fast-glob";import k from"micromatch";let w=i.default||i,y=l.default||l,b={sourceType:"module",plugins:["typescript","jsx","decorators-legacy","classProperties","classPrivateProperties","classPrivateMethods","exportDefaultFrom","exportNamespaceFrom","functionBind","functionSent","dynamicImport","nullishCoalescingOperator","optionalChaining","objectRestSpread","asyncGenerators","doExpressions","importMeta","logicalAssignment","moduleBlocks","moduleStringNames","numericSeparator","partialApplication","privateIn","throwExpressions","topLevelAwait"]};async function E(e){return JSON.parse(s(t.join(e,"package.json"),"utf-8"))}async function P({packagePath:e,ignoreSourceFiles:o=[],stats:r}){let i=[];console.log(`Scanning for TypeScript and JavaScript files in: ${e}`);let l=await F("**/*.{ts,tsx,js,jsx}",{cwd:e,ignore:["**/node_modules/**","**/dist/**","**/build/**"]});for(let h of(console.log(`Found ${l.length} files`),l)){let l=o.some(e=>k.isMatch(h,e));l&&(console.log(`File matches ignore pattern but will be preserved: ${h}`),r&&r.sourceFilesSkipped++);let $=t.join(e,h);console.log(`
-Processing file: ${h}`);let x=s($,"utf-8");try{let e=n(x,b);y(e,{ExportNamedDeclaration(e){if(console.log(`Found named export in ${h}`),e.node.source){let o=e.node.source.value;if(o.includes("node_modules")||!o.startsWith(".")){console.log(`Skipping re-export from external package: ${o}`);return}}if(e.node.declaration){var o;let s=(o=e.node.declaration)?a(o)?o.declarations.map(e=>c(e.id)?e.id.name:null).filter(e=>null!==e):p(o)&&o.id||g(o)||d(o)||u(o)||f(o)&&o.id?[o.id.name]:[]:[];s.length>0&&(console.log(`Named exports found: ${s.join(", ")}`),i.push({source:h,exports:s,isIgnored:l}))}let s=e.node.specifiers.map(e=>{if(m(e)){let o=e.exported;return c(o)?o.name:o.value}return null}).filter(e=>null!==e);s.length>0&&(console.log(`Named exports found: ${s.join(", ")}`),i.push({source:h,exports:s,isIgnored:l}))},ExportDefaultDeclaration(e){console.log(`Found default export in ${h}`);let o=e.node.declaration,s=c(o)?o.name:p(o)&&o.id?o.id.name:null;s?(console.log(`Default export name: ${s}`),i.push({source:h,exports:[s],isIgnored:l})):console.log("Default export is not an identifier or named function")}})}catch(e){console.error(`Error parsing ${h}:`,e)}}return console.log(`
-Total exports found: ${i.length}`),i}async function j({packageName:e,monorepoRoot:o}){try{let r=new Set,t=await F(["**/*.{ts,tsx,js,jsx}"],{cwd:o,absolute:!0,ignore:["**/node_modules/**","**/dist/**","**/build/**"],followSymbolicLinks:!1});for(let o of(console.log(`Found ${t.length} files to scan`),t))try{let t=s(o,"utf-8"),i=n(t,b);y(i,{ImportDeclaration(s){let t=s.node.source.value;(t===e||t.startsWith(`${e}/`))&&r.add(o)}})}catch(e){console.error(`Error processing file ${o}:`,e)}let i=Array.from(r);if(i.length>0)for(let o of(console.log(`Found total of ${i.length} files with imports from ${e}`),console.log("Files found:"),i))console.log(`  ${o}`);else console.log(`No files found importing from ${e}`);return i}catch(e){return console.error("Error finding imports:",e),[]}}async function T({filePath:e,packageName:o,exports:t,includeExtension:i=!0,warnings:l,stats:a}){console.log(`
-Processing file: ${e}`);let p=s(e,"utf-8");try{let s=n(p,b),a=!1,g=0,d=new Set;if(y(s,{ImportDeclaration(s){let r=s.node.source.value;if(!d.has(r)&&r===o){g++,console.log(`Found import from ${o}`);let n=s.node.specifiers,p=new Map,u=[],f=!1;for(let s of n)if(h(s)){let r=s.imported,n=c(r)?r.name:r.value,g=t.find(e=>e.exports.includes(n));if(g){if(console.log(`  Found export ${n} in ${g.source}`),g.isIgnored){console.log(`  Keeping original import for ignored file: ${g.source}`),u.push(s);continue}let e=i?`${o}/${g.source}`:`${o}/${g.source.replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/,"")}`;p.has(e)||p.set(e,[]),p.get(e)?.push({local:s.local,imported:s.imported}),a=!0,f=!0}else{if(t.some(e=>e.source.includes("node_modules")||!e.source.startsWith("."))){let o=`Skipping re-export from external package: ${n} in "${e}"`;console.log(`  ${o}`),l&&l.push(o),u.push(s);continue}let o=`Could not find export ${n} in ${e}`;console.log(`  Warning: ${o}`),l&&l.push(o),u.push(s)}}else u.push(s);if(!f){console.log("  Keeping original import due to no direct exports to migrate"),d.add(r);return}let m=[];for(let[e,s]of(u.length>0&&m.push($(u,x(o))),p.entries()))m.push($(s.map(e=>S(e.local,e.imported)),x(e)));s.replaceWithMultiple(m),console.log("  Replaced import with direct imports from source files"),d.add(r)}}}),a){console.log(`Writing changes to ${e}`);let o=w(s,{retainLines:!0,retainFunctionParens:!0},p);r(e,o.code)}else g>0?console.log(`No changes needed for ${g} imports`):console.log("No imports found to update")}catch(o){a&&a.errors++,console.error(`Error processing ${e}:`,o)}}async function N(e){let{sourcePath:r,targetPath:i,ignoreSourceFiles:n,ignoreTargetFiles:l}=e,a={totalFiles:0,filesProcessed:0,filesSkipped:0,importsUpdated:0,filesWithNoUpdates:0,errors:0,totalExports:0,sourceFilesScanned:0,sourceFilesWithExports:0,sourceFilesSkipped:0,targetFilesFound:[],packagesProcessed:0,packagesSkipped:0,warnings:[]},c=await F(r,{cwd:i,absolute:!0,ignore:["**/node_modules/**","**/dist/**","**/build/**","**/target-app/**"],followSymbolicLinks:!1,onlyDirectories:!0}),p=[];for(let e of c){let s=t.join(e,"package.json");try{await o.promises.access(s),p.push(s)}catch{console.log(`No package.json found in ${e}, skipping`)}}for(let o of(console.log(`Found ${p.length} source packages to process`),p))try{let r=t.dirname(o);console.log(`
-Processing package: ${r}`);let c=await E(r),p=await P({packagePath:r,ignoreSourceFiles:n,stats:a});a.totalExports+=p.reduce((e,o)=>e+o.exports.length,0),a.sourceFilesWithExports+=new Set(p.map(e=>e.source)).size,a.sourceFilesScanned+=(await F("**/*.{ts,tsx}",{cwd:r,ignore:["**/node_modules/**","**/dist/**","**/build/**"]})).length;let g=await j({packageName:c.name,monorepoRoot:i});for(let o of(a.totalFiles+=g.length,a.targetFilesFound.push(...g),g)){let r=t.relative(i,o);if(l.some(e=>k.isMatch(r,e))){console.log(`Skipping ignored file: ${o} (matches pattern in ${l.join(", ")})`),a.filesSkipped++;continue}try{let r=s(o,"utf-8");await T({filePath:o,packageName:c.name,exports:p,includeExtension:e.includeExtension,warnings:a.warnings,stats:a});let t=s(o,"utf-8");r!==t?a.importsUpdated++:a.filesWithNoUpdates++,a.filesProcessed++}catch(e){a.errors++,console.error(`Error processing ${o}:`,e)}}a.packagesProcessed++}catch(e){a.packagesSkipped++,console.error(`Error processing package ${o}:`,e)}if(console.log("\nMigration Summary"),console.log(`Source packages found: ${p.length}`),console.log(`Source packages processed: ${a.packagesProcessed}`),console.log(`Source packages skipped: ${a.packagesSkipped}`),console.log(`Source files found: ${a.sourceFilesScanned}`),console.log(`Source files with exports: ${a.sourceFilesWithExports}`),console.log(`Source files skipped: ${a.sourceFilesSkipped}`),console.log(`Exports found: ${a.totalExports}`),console.log(`Target files found: ${a.totalFiles}`),console.log(`Target files processed: ${a.filesProcessed}`),console.log(`Target files with imports updated: ${a.importsUpdated}`),console.log(`Target files with no changes needed: ${a.filesWithNoUpdates}`),console.log(`Target files skipped: ${a.filesSkipped}`),a.warnings.length>0)for(let e of(console.log("\nWarnings:"),a.warnings))console.log(`  - ${e}`);a.errors>0&&console.log(`
-Warning: ${a.errors} errors encountered during processing`)}let v={targetPath:".",ignoreSourceFiles:[],ignoreTargetFiles:[],includeExtension:!1};async function D(){let o=new e;o.name("migrate-barrel-imports").description("CLI tool to migrate barrel files imports to direct imports").argument("<source-path>",'Glob pattern for source packages containing barrel files (e.g. "libs/*")').argument("[target-path]","Path to the directory where imports should be migrated (default: current directory)").option("--ignore-source-files <patterns>","Comma-separated list of file patterns to ignore in source directory").option("--ignore-target-files <patterns>","Comma-separated list of file patterns to ignore in target directory").option("--no-extension","Exclude js|jsx|ts|tsx|mjs|cjs file extensions from import statements").allowUnknownOption(!1).parse(process.argv);let s=o.args;s[0]||(console.error("Error: source-path is required"),process.exit(1));let r=s[0],t=s[1]||v.targetPath,i=o.opts();await N({sourcePath:r,targetPath:t,ignoreSourceFiles:i.ignoreSourceFiles?i.ignoreSourceFiles.split(","):v.ignoreSourceFiles,ignoreTargetFiles:i.ignoreTargetFiles?i.ignoreTargetFiles.split(","):v.ignoreTargetFiles,includeExtension:!1!==i.extension||v.includeExtension})}(async()=>{await D()})();
+import { main } from './cli';
+void (async () => {
+    await main();
+})();

package/dist/migrate-barrel-imports.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Tool for migrating TypeScript projects from barrel file exports to direct file imports
+ *
+ * This tool helps migrate TypeScript projects that use barrel files (index.ts files that re-export)
+ * to use direct imports from source files instead. This improves:
+ * - Tree-shaking efficiency
+ * - Build performance
+ * - Code maintainability
+ * - TypeScript compilation speed
+ *
+ * The migration process:
+ * 1. Scans source package for all exports
+ * 2. Finds all files importing from the package
+ * 3. Updates imports to point directly to source files
+ * 4. Preserves original import names and types
+ */
+import type { Options as MigrationOptions } from './options';
+/**
+ * Main migration function that orchestrates the barrel file migration process
+ *
+ * Process flow:
+ * 1. Finds all source packages matching the glob pattern
+ * 2. For each package:
+ *    - Reads package.json to get package name and configuration
+ *    - Scans source package for all exports (named and default)
+ *    - Finds all files in the monorepo that import from the package
+ *    - Updates each import to point directly to source files
+ *
+ * @param {Options} options - Migration configuration options
+ * @returns {Promise<void>}
+ */
+export declare function migrateBarrelImports(options: MigrationOptions): Promise<void>;
+//# sourceMappingURL=migrate-barrel-imports.d.ts.map

package/dist/migrate-barrel-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-barrel-imports.d.ts","sourceRoot":"","sources":["../src/migrate-barrel-imports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAkCH,OAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,WAAW,CAAA;AA2tB5D;;;;;;;;;;;;;GAaG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,gBAAgB,GACvB,OAAO,CAAC,IAAI,CAAC,CAoFf"}

package/dist/migrate-barrel-imports.js

@@ -0,0 +1,681 @@
+/**
+ * @fileoverview Tool for migrating TypeScript projects from barrel file exports to direct file imports
+ *
+ * This tool helps migrate TypeScript projects that use barrel files (index.ts files that re-export)
+ * to use direct imports from source files instead. This improves:
+ * - Tree-shaking efficiency
+ * - Build performance
+ * - Code maintainability
+ * - TypeScript compilation speed
+ *
+ * The migration process:
+ * 1. Scans source package for all exports
+ * 2. Finds all files importing from the package
+ * 3. Updates imports to point directly to source files
+ * 4. Preserves original import names and types
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import _generate from '@babel/generator';
+import { parse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+import { importDeclaration, importSpecifier, isClassDeclaration, isExportSpecifier, isFunctionDeclaration, isIdentifier, isImportDefaultSpecifier, isImportNamespaceSpecifier, isImportSpecifier, isTSEnumDeclaration, isTSInterfaceDeclaration, isTSTypeAliasDeclaration, isVariableDeclaration, stringLiteral } from '@babel/types';
+import fg from 'fast-glob';
+import micromatch from 'micromatch';
+// @ts-expect-error
+const generate = _generate.default || _generate;
+// @ts-expect-error
+const traverse = _traverse.default || _traverse;
+// Common Babel configuration for parsing TypeScript files
+const BABEL_CONFIG = {
+    sourceType: 'module',
+    plugins: [
+        'typescript',
+        'jsx',
+        'decorators-legacy',
+        'classProperties',
+        'classPrivateProperties',
+        'classPrivateMethods',
+        'exportDefaultFrom',
+        'exportNamespaceFrom',
+        'functionBind',
+        'functionSent',
+        'dynamicImport',
+        'nullishCoalescingOperator',
+        'optionalChaining',
+        'objectRestSpread',
+        'asyncGenerators',
+        'doExpressions',
+        'importMeta',
+        'logicalAssignment',
+        'moduleBlocks',
+        'moduleStringNames',
+        'numericSeparator',
+        'partialApplication',
+        'privateIn',
+        'throwExpressions',
+        'topLevelAwait'
+    ]
+};
+/**
+ * Reads and parses the package.json file for a given package path
+ *
+ * @param {string} packagePath - The path to the package directory
+ * @returns {Promise<PackageJson>} The parsed package.json contents
+ * @throws {Error} If package.json cannot be read or parsed
+ */
+async function _getPackageInfo(packagePath) {
+    const packageJsonPath = path.join(packagePath, 'package.json');
+    const content = readFileSync(packageJsonPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Extracts export names from a declaration node
+ */
+function getExportNames(declaration) {
+    if (!declaration)
+        return [];
+    if (isVariableDeclaration(declaration)) {
+        return declaration.declarations
+            .map((d) => (isIdentifier(d.id) ? d.id.name : null))
+            .filter((name) => name !== null);
+    }
+    if (isFunctionDeclaration(declaration) && declaration.id) {
+        return [declaration.id.name];
+    }
+    if (isTSEnumDeclaration(declaration)) {
+        return [declaration.id.name];
+    }
+    if (isTSInterfaceDeclaration(declaration)) {
+        return [declaration.id.name];
+    }
+    if (isTSTypeAliasDeclaration(declaration)) {
+        return [declaration.id.name];
+    }
+    if (isClassDeclaration(declaration) && declaration.id) {
+        return [declaration.id.name];
+    }
+    return [];
+}
+/**
+ * Checks if a file is a barrel file by analyzing its exports
+ *
+ * @param {string} filePath - Path to the file to check
+ * @returns {Promise<boolean>} Whether the file is a barrel file
+ */
+async function isBarrelFile(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const ast = parse(content, BABEL_CONFIG);
+        let hasReExports = false;
+        let _hasDirectExports = false;
+        traverse(ast, {
+            ExportNamedDeclaration(path) {
+                if (path.node.source) {
+                    hasReExports = true;
+                }
+                else {
+                    _hasDirectExports = true;
+                }
+            },
+            ExportDefaultDeclaration() {
+                _hasDirectExports = true;
+            }
+        });
+        // A barrel file typically has re-exports and may or may not have direct exports
+        return hasReExports;
+    }
+    catch (error) {
+        console.error(`Error checking if ${filePath} is a barrel file:`, error);
+        return false;
+    }
+}
+/**
+ * Recursively finds all exports in a package by scanning all TypeScript files
+ *
+ * This function:
+ * 1. Scans all .ts and .tsx files in the package
+ * 2. Identifies both named exports and default exports
+ * 3. Skips re-exports to avoid circular dependencies
+ * 4. Filters out ignored files based on patterns
+ * 5. Handles barrel files by tracking their re-exports
+ *
+ * @param {FindExportsParams} params - Parameters for finding exports
+ * @returns {Promise<ExportInfo[]>} Array of export information, including source file and exported names
+ */
+async function findExports({ packagePath, ignoreSourceFiles = [], stats }) {
+    const exports = [];
+    const barrelFiles = new Set();
+    const _processedFiles = new Set();
+    const _exportSources = {};
+    const exportFiles = {};
+    console.log(`Scanning for TypeScript and JavaScript files in: ${packagePath}`);
+    const allFiles = await fg('**/*.{ts,tsx,js,jsx}', {
+        cwd: packagePath,
+        ignore: ['**/node_modules/**', '**/dist/**', '**/build/**']
+    });
+    console.log(`Found ${allFiles.length} files`);
+    // First pass: identify barrel files
+    for (const file of allFiles) {
+        const fullPath = path.join(packagePath, file);
+        if (await isBarrelFile(fullPath)) {
+            barrelFiles.add(file);
+            console.log(`Identified barrel file: ${file}`);
+        }
+    }
+    // Second pass: process all files
+    for (const file of allFiles) {
+        // Mark files that match ignore patterns but still process them
+        const isIgnored = ignoreSourceFiles.some((pattern) => micromatch.isMatch(file, pattern));
+        if (isIgnored) {
+            console.log(`File matches ignore pattern but will be preserved: ${file}`);
+            if (stats) {
+                stats.sourceFilesSkipped++;
+            }
+        }
+        const fullPath = path.join(packagePath, file);
+        console.log(`\nProcessing file: ${file}`);
+        const content = readFileSync(fullPath, 'utf-8');
+        try {
+            const ast = parse(content, BABEL_CONFIG);
+            const fileExports = [];
+            const reExports = {};
+            const fileExportSources = {};
+            const defaultExportNames = [];
+            traverse(ast, {
+                ExportNamedDeclaration(nodePath) {
+                    // Handle re-exports from external packages
+                    if (nodePath.node.source) {
+                        const sourceValue = nodePath.node.source.value;
+                        if (sourceValue.includes('node_modules') ||
+                            !sourceValue.startsWith('.')) {
+                            // Extract export names and their original source
+                            nodePath.node.specifiers.forEach((specifier) => {
+                                if (isExportSpecifier(specifier)) {
+                                    const exported = specifier.exported;
+                                    const exportName = isIdentifier(exported)
+                                        ? exported.name
+                                        : exported.value;
+                                    reExports[exportName] = sourceValue;
+                                    fileExports.push(exportName);
+                                    fileExportSources[exportName] = file;
+                                    // Track all files that export this symbol
+                                    if (!exportFiles[exportName]) {
+                                        exportFiles[exportName] = [];
+                                    }
+                                    exportFiles[exportName].push(file);
+                                }
+                            });
+                            return;
+                        }
+                    }
+                    // Handle variable declarations with exports
+                    if (nodePath.node.declaration) {
+                        const exportNames = getExportNames(nodePath.node.declaration);
+                        if (exportNames.length > 0) {
+                            fileExports.push(...exportNames);
+                            exportNames.forEach((name) => {
+                                fileExportSources[name] = file;
+                                // Track all files that export this symbol
+                                if (!exportFiles[name]) {
+                                    exportFiles[name] = [];
+                                }
+                                exportFiles[name].push(file);
+                            });
+                        }
+                    }
+                    // Handle export specifiers
+                    const exportNames = nodePath.node.specifiers
+                        .map((s) => {
+                        if (isExportSpecifier(s)) {
+                            const exported = s.exported;
+                            const exportName = isIdentifier(exported)
+                                ? exported.name
+                                : exported.value;
+                            if (nodePath.node.source) {
+                                // If it's a re-export from another file, track the source
+                                const sourceValue = nodePath.node.source.value;
+                                if (sourceValue.startsWith('.')) {
+                                    const resolvedPath = path.join(path.dirname(file), sourceValue);
+                                    fileExportSources[exportName] = resolvedPath.replace(/\.[^/.]+$/, '');
+                                    // Track all files that export this symbol
+                                    if (!exportFiles[exportName]) {
+                                        exportFiles[exportName] = [];
+                                    }
+                                    exportFiles[exportName].push(file);
+                                }
+                            }
+                            return exportName;
+                        }
+                        return null;
+                    })
+                        .filter((name) => name !== null);
+                    if (exportNames.length > 0) {
+                        fileExports.push(...exportNames);
+                        exportNames.forEach((name) => {
+                            if (!fileExportSources[name]) {
+                                fileExportSources[name] = file;
+                            }
+                        });
+                    }
+                },
+                ExportDefaultDeclaration(path) {
+                    const exported = path.node.declaration;
+                    const exportName = isIdentifier(exported)
+                        ? exported.name
+                        : isFunctionDeclaration(exported) && exported.id
+                            ? exported.id.name
+                            : isClassDeclaration(exported) && exported.id
+                                ? exported.id.name
+                                : 'default';
+                    fileExports.push(exportName);
+                    fileExportSources[exportName] = file;
+                    // If this is a named entity (class, function) being exported as default, track its name
+                    if (exportName !== 'default') {
+                        defaultExportNames.push(exportName);
+                    }
+                }
+            });
+            if (fileExports.length > 0 || Object.keys(reExports).length > 0) {
+                exports.push({
+                    source: file,
+                    exports: fileExports,
+                    isIgnored,
+                    ...(Object.keys(reExports).length > 0 && { reExports }),
+                    ...(Object.keys(fileExportSources).length > 0 && {
+                        exportSources: fileExportSources
+                    }),
+                    ...(defaultExportNames.length > 0 && { defaultExportNames }),
+                    ...((await isBarrelFile(fullPath)) && { isBarrelFile: true }),
+                    ...(Object.keys(exportFiles).length > 0 && { exportFiles })
+                });
+                // Print exports in a single line
+                if (fileExports.length > 0) {
+                    console.log(`Found exports ${fileExports.join(', ')} in ${file}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error parsing ${file}:`, error);
+        }
+    }
+    console.log(`\nTotal exports found: ${exports.length}`);
+    console.log(`Barrel files found: ${barrelFiles.size}`);
+    return exports;
+}
+/**
+ * Finds all files in the monorepo that import from a specific package
+ *
+ * This function:
+ * 1. Uses fast-glob to find all TypeScript files
+ * 2. Parses each file's AST to find imports
+ * 3. Handles both direct package imports and subpath imports
+ * 4. Excludes node_modules, dist, and build directories
+ *
+ * @param {FindImportsParams} params - Parameters for finding imports
+ * @returns {Promise<string[]>} Array of file paths that import from the package
+ */
+async function findImports({ packageName, targetPath, stats: _stats }) {
+    try {
+        const allFiles = new Set();
+        // Find all TypeScript and JavaScript files in the monorepo
+        const files = await fg(['**/*.{ts,tsx,js,jsx}'], {
+            cwd: targetPath,
+            absolute: true,
+            ignore: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+            followSymbolicLinks: false
+        });
+        console.log(`Found ${files.length} files to scan`);
+        // Scan each file for imports
+        for (const file of files) {
+            try {
+                const content = readFileSync(file, 'utf-8');
+                const ast = parse(content, BABEL_CONFIG);
+                traverse(ast, {
+                    ImportDeclaration(path) {
+                        const source = path.node.source.value;
+                        // Check for exact package import or subpath import
+                        if (source === packageName ||
+                            source.startsWith(`${packageName}/`)) {
+                            allFiles.add(file);
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`Error processing file ${file}:`, error);
+            }
+        }
+        const uniqueFiles = Array.from(allFiles);
+        if (uniqueFiles.length > 0) {
+            console.log(`Found total of ${uniqueFiles.length} files with imports from ${packageName}`);
+            console.log('Files found:');
+            for (const file of uniqueFiles) {
+                console.log(`  ${file}`);
+            }
+        }
+        else {
+            console.log(`No files found importing from ${packageName}`);
+        }
+        return uniqueFiles;
+    }
+    catch (error) {
+        console.error('Error finding imports:', error);
+        return [];
+    }
+}
+/**
+ * Updates imports in a file to point directly to source files instead of using barrel files
+ *
+ * This function:
+ * 1. Parses the file's AST to find imports from the package
+ * 2. For each import, finds the source file containing the export
+ * 3. Updates the import to point directly to the source file
+ * 4. Preserves original import names and types
+ * 5. Only modifies the file if changes are needed
+ *
+ * @param {UpdateImportsParams} params - Parameters for updating imports
+ * @returns {Promise<void>}
+ */
+async function updateImports({ filePath, packageName, exports, includeExtension = true, warnings: _warnings, stats: _stats }) {
+    console.log(`\nProcessing file: ${filePath}`);
+    const content = readFileSync(filePath, 'utf-8');
+    let modified = false;
+    try {
+        const ast = parse(content, BABEL_CONFIG);
+        const importDeclarations = [];
+        // First pass: collect all import declarations
+        traverse(ast, {
+            ImportDeclaration(path) {
+                const importSource = path.node.source.value;
+                if (importSource.startsWith(packageName)) {
+                    importDeclarations.push(path.node);
+                }
+            }
+        });
+        const importsBySource = new Map();
+        const remainingSpecifiers = [];
+        for (const declaration of importDeclarations) {
+            const _importSource = declaration.source.value;
+            const specifiers = declaration.specifiers;
+            for (const specifier of specifiers) {
+                if (isImportSpecifier(specifier)) {
+                    const imported = specifier.imported;
+                    const importName = isIdentifier(imported)
+                        ? imported.name
+                        : imported.value;
+                    const exportInfo = exports.find((e) => e.exports.includes(importName));
+                    if (exportInfo) {
+                        if (exportInfo.isIgnored) {
+                            remainingSpecifiers.push(specifier);
+                            continue;
+                        }
+                        // Check if this is a re-export from an external package
+                        if (exportInfo.reExports?.[importName]) {
+                            const reExportSource = exportInfo.reExports[importName];
+                            if (!reExportSource.startsWith('.')) {
+                                // Keep the original import from the external package
+                                const sourcePath = reExportSource;
+                                if (!importsBySource.has(sourcePath)) {
+                                    importsBySource.set(sourcePath, []);
+                                }
+                                importsBySource.get(sourcePath)?.push({
+                                    local: specifier.local,
+                                    imported: specifier.imported
+                                });
+                                modified = true;
+                                continue;
+                            }
+                        }
+                        // Then check if it's a direct export from index.ts
+                        if (exportInfo.source === 'src/index.ts' &&
+                            exportInfo.exports.includes(importName) &&
+                            !exportInfo.reExports?.[importName]) {
+                            // Handle entities that are exported as default
+                            const isDefaultExportedEntity = exportInfo.defaultExportNames?.includes(importName);
+                            if (isDefaultExportedEntity) {
+                                // For entities that are exported as default, import directly from the package
+                                const sourcePath = packageName;
+                                if (!importsBySource.has(sourcePath)) {
+                                    importsBySource.set(sourcePath, []);
+                                }
+                                importsBySource.get(sourcePath)?.push({
+                                    local: specifier.local,
+                                    imported: specifier.imported
+                                });
+                                modified = true;
+                                continue;
+                            }
+                            // Check if this is a named export or default export
+                            if (importName !== 'default') {
+                                // For each named export from index.ts, create a separate import source path
+                                const sourcePath = includeExtension
+                                    ? `${packageName}/${exportInfo.source}`
+                                    : `${packageName}/${exportInfo.source.replace(/\.[^/.]+$/, '')}`;
+                                if (!importsBySource.has(sourcePath)) {
+                                    importsBySource.set(sourcePath, []);
+                                }
+                                importsBySource.get(sourcePath)?.push({
+                                    local: specifier.local,
+                                    imported: specifier.imported
+                                });
+                                modified = true;
+                                continue;
+                            }
+                        }
+                        // Find the best source file for this export
+                        const exportFiles = exportInfo.exportFiles?.[importName] || [];
+                        let bestSourceFile = exportFiles[0]; // Default to first file if no better option
+                        // Prefer main source files over auxiliary files
+                        if (exportFiles.length > 1) {
+                            // Remove story files, test files, and other auxiliary files from consideration
+                            const mainFiles = exportFiles.filter((file) => !file.includes('.stories.') &&
+                                !file.includes('.test.') &&
+                                !file.includes('.spec.') &&
+                                !file.includes('.stories/') &&
+                                !file.includes('.test/') &&
+                                !file.includes('.spec/'));
+                            if (mainFiles.length > 0) {
+                                bestSourceFile = mainFiles[0];
+                            }
+                        }
+                        if (bestSourceFile) {
+                            const sourcePath = includeExtension
+                                ? `${packageName}/${bestSourceFile}`
+                                : `${packageName}/${bestSourceFile.replace(/\.[^/.]+$/, '')}`;
+                            // Check if this import is aliased and if we already have the original import
+                            const isAliased = specifier.local.name !== importName;
+                            const hasOriginalImport = Array.from(importsBySource.values()).some((specs) => specs.some((spec) => spec.imported &&
+                                isIdentifier(spec.imported) &&
+                                spec.imported.name === importName));
+                            // Only add the import if it's not aliased or if we don't have the original import yet
+                            if (!isAliased || !hasOriginalImport) {
+                                if (!importsBySource.has(sourcePath)) {
+                                    importsBySource.set(sourcePath, []);
+                                }
+                                importsBySource.get(sourcePath)?.push({
+                                    local: specifier.local,
+                                    imported: specifier.imported
+                                });
+                                modified = true;
+                            }
+                            continue;
+                        }
+                        remainingSpecifiers.push(specifier);
+                    }
+                    else if (isImportDefaultSpecifier(specifier) ||
+                        isImportNamespaceSpecifier(specifier)) {
+                        remainingSpecifiers.push(specifier);
+                    }
+                }
+            }
+        }
+        // Second pass: update the AST with new imports
+        traverse(ast, {
+            ImportDeclaration(path) {
+                const importSource = path.node.source.value;
+                if (importSource.startsWith(packageName)) {
+                    // Remove the original import declaration
+                    path.remove();
+                }
+            }
+        });
+        // Add new import declarations
+        const newImports = [];
+        for (const [source, specifiers] of importsBySource) {
+            if (specifiers.length > 0) {
+                newImports.push(importDeclaration(specifiers.map(({ local, imported }) => importSpecifier(local, imported)), stringLiteral(source)));
+                if (_stats) {
+                    _stats.importsMigrated += specifiers.length;
+                }
+            }
+        }
+        // Add remaining specifiers if any
+        if (remainingSpecifiers.length > 0) {
+            newImports.push(importDeclaration(remainingSpecifiers, stringLiteral(packageName)));
+        }
+        // Add all new imports at the top of the file
+        if (newImports.length > 0) {
+            ast.program.body.unshift(...newImports);
+            modified = true;
+        }
+        if (modified) {
+            // Write changes back to file
+            const output = generate(ast, {
+                // To avoid removing spaces in code
+                retainLines: true,
+                retainFunctionParens: true
+            }, content).code;
+            writeFileSync(filePath, output);
+            console.log(`Writing changes to ${filePath}`);
+            if (_stats) {
+                _stats.importsUpdated++;
+            }
+        }
+        else if (_stats) {
+            _stats.noChangesNeeded++;
+        }
+    }
+    catch (error) {
+        console.error(`Error updating imports in ${filePath}:`, error);
+    }
+}
+/**
+ * Main migration function that orchestrates the barrel file migration process
+ *
+ * Process flow:
+ * 1. Finds all source packages matching the glob pattern
+ * 2. For each package:
+ *    - Reads package.json to get package name and configuration
+ *    - Scans source package for all exports (named and default)
+ *    - Finds all files in the monorepo that import from the package
+ *    - Updates each import to point directly to source files
+ *
+ * @param {Options} options - Migration configuration options
+ * @returns {Promise<void>}
+ */
+export async function migrateBarrelImports(options) {
+    const { sourcePath, targetPath, includeExtension = true } = options;
+    // Track migration statistics
+    const stats = {
+        sourcePackagesFound: 0,
+        sourcePackagesProcessed: 0,
+        sourcePackagesSkipped: 0,
+        sourceFilesFound: 0,
+        sourceFilesWithExports: 0,
+        sourceFilesSkipped: 0,
+        exportsFound: 0,
+        targetFilesFound: 0,
+        targetFilesProcessed: 0,
+        importsUpdated: 0,
+        noChangesNeeded: 0,
+        targetFilesSkipped: 0,
+        importsMigrated: 0
+    };
+    // Track warnings
+    const warnings = [];
+    try {
+        // Find source packages
+        const sourcePackages = await findSourcePackages(sourcePath);
+        stats.sourcePackagesFound = sourcePackages.length;
+        for (const packagePath of sourcePackages) {
+            console.log(`\nProcessing package: ${packagePath}`);
+            // Find exports in source package
+            const exports = await findExports({ packagePath, stats });
+            stats.exportsFound = exports.reduce((total, info) => total + info.exports.length, 0);
+            stats.sourceFilesWithExports = exports.length;
+            // Find files that import from this package
+            const packageName = await getPackageName(packagePath);
+            const targetFiles = await findImports({ packageName, targetPath, stats });
+            stats.targetFilesFound = targetFiles.length;
+            // Update imports in target files
+            for (const filePath of targetFiles) {
+                stats.targetFilesProcessed++;
+                await updateImports({
+                    filePath,
+                    packageName,
+                    exports,
+                    includeExtension,
+                    warnings,
+                    stats
+                });
+            }
+            stats.sourcePackagesProcessed++;
+        }
+        // Print migration summary
+        console.log('\nMigration Summary');
+        console.log(`Source packages found: ${stats.sourcePackagesFound}`);
+        console.log(`Source packages processed: ${stats.sourcePackagesProcessed}`);
+        console.log(`Source packages skipped: ${stats.sourcePackagesSkipped}`);
+        console.log(`Source files found: ${stats.sourceFilesFound}`);
+        console.log(`Source files with exports: ${stats.sourceFilesWithExports}`);
+        console.log(`Source files skipped: ${stats.sourceFilesSkipped}`);
+        console.log(`Exports found: ${stats.exportsFound}`);
+        console.log(`Target files found: ${stats.targetFilesFound}`);
+        console.log(`Target files processed: ${stats.targetFilesProcessed}`);
+        console.log(`Target files with imports updated: ${stats.importsUpdated}`);
+        console.log(`Target files with no changes needed: ${stats.noChangesNeeded}`);
+        console.log(`Target files skipped: ${stats.targetFilesSkipped}`);
+        console.log(`Total imports migrated: ${stats.importsMigrated}`);
+        if (warnings.length > 0) {
+            console.log('\nWarnings:');
+            warnings.forEach((warning) => console.log(`  - ${warning}`));
+        }
+    }
+    catch (error) {
+        console.error('Error during migration:', error);
+        throw error;
+    }
+}
+/**
+ * Gets the package name from package.json
+ *
+ * @param {string} packagePath - Path to the package directory
+ * @returns {Promise<string>} Package name
+ */
+async function getPackageName(packagePath) {
+    const packageJsonPath = path.join(packagePath, 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    return packageJson.name;
+}
+/**
+ * Finds all source packages in the given path
+ *
+ * @param {string} sourcePath - Path to search for source packages
+ * @returns {Promise<string[]>} Array of package paths
+ */
+async function findSourcePackages(sourcePath) {
+    // Use a local variable instead of reassigning the parameter
+    const resolvedPath = path.isAbsolute(sourcePath)
+        ? path.resolve(sourcePath)
+        : path.join(process.cwd(), sourcePath);
+    console.log(`Looking for source packages in: ${resolvedPath}`);
+    const packageJsonFiles = await fg('{package.json,**/package.json}', {
+        cwd: resolvedPath,
+        ignore: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+        absolute: true
+    });
+    console.log(`Found ${packageJsonFiles.length} package.json files:`);
+    packageJsonFiles.forEach((file) => console.log(`  - ${file}`));
+    return packageJsonFiles.map(path.dirname);
+}

package/dist/options.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Configuration options for the migration process
+ * @property {string} sourcePath - Glob pattern for source packages to migrate
+ * @property {string} targetPath - Path to the monorepo root to search for imports
+ * @property {string[]} ignoreSourceFiles - Patterns to ignore when scanning source files
+ * @property {string[]} ignoreTargetFiles - Patterns to ignore when scanning target files
+ * @property {boolean} [includeExtension] - Whether to include file extensions in imports
+ */
+export type Options = {
+    sourcePath: string;
+    targetPath: string;
+    ignoreSourceFiles: string[];
+    ignoreTargetFiles: string[];
+    includeExtension?: boolean;
+};
+export declare const defaultOptions: Omit<Options, 'sourcePath'>;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,IAAI,CAAC,OAAO,EAAE,YAAY,CAKtD,CAAA"}

package/dist/options.js

@@ -0,0 +1,6 @@
+export const defaultOptions = {
+    targetPath: '.',
+    ignoreSourceFiles: [],
+    ignoreTargetFiles: [],
+    includeExtension: false
+};

package/package.json

@@ -1,88 +1,90 @@
 {
-  "name": "migrate-barrel-imports",
-  "version": "1.5.1",
-  "description": "A CLI tool to migrate barrel imports in JavaScript/TypeScript monorepos",
-  "files": [
-    "dist/"
-  ],
-  "main": "./dist/index.js",
-  "targets": {
-    "main": {
-      "optimize": true
-    }
-  },
-  "keywords": [
-    "typescript",
-    "javascript",
-    "monorepo",
-    "cli",
-    "tool",
-    "migrate",
-    "barrel",
-    "import",
-    "imports"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/brandhaug/migrate-barrel-imports.git"
-  },
-  "bugs": {
-    "url": "https://github.com/brandhaug/migrate-barrel-imports/issues"
-  },
-  "homepage": "https://github.com/brandhaug/migrate-barrel-imports#readme",
-  "type": "module",
-  "bin": {
-    "migrate-barrel-imports": "dist/index.js"
-  },
-  "scripts": {
-    "build": "parcel build src/index.ts --no-source-maps",
-    "start": "node dist/index.js",
-    "lint": "biome lint",
-    "check-write": "biome check --write",
-    "typecheck": "tsc",
-    "prepare": "husky",
-    "test": "vitest",
-    "validate": "npm run lint && npm run typecheck && npm run test"
-  },
-  "dependencies": {
-    "@babel/generator": "7.26.10",
-    "@babel/parser": "7.26.10",
-    "@babel/traverse": "7.26.10",
-    "@babel/types": "7.26.10",
-    "commander": "13.1.0",
-    "fast-glob": "3.3.3",
-    "micromatch": "4.0.8",
-    "ts-morph": "25.0.1"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@commitlint/cli": "19.8.0",
-    "@commitlint/config-conventional": "19.8.0",
-    "@semantic-release/changelog": "6.0.3",
-    "@types/babel__generator": "7.6.8",
-    "@types/babel__traverse": "7.20.6",
-    "@types/micromatch": "4.0.9",
-    "execa": "9.5.2",
-    "husky": "9.1.7",
-    "lint-staged": "15.5.0",
-    "parcel": "2.14.1",
-    "semantic-release": "24.2.3",
-    "tsc-files": "1.1.4",
-    "tsx": "4.19.3",
-    "typescript": "5.8.2",
-    "vitest": "3.0.9"
-  },
-  "author": "Martin Brandhaug",
-  "license": "MIT",
-  "lint-staged": {
-    "*.{ts,json}": [
-      "biome check --write"
-    ],
-    "*.ts": [
-      "tsc-files"
-    ]
-  },
-  "engines": {
-    "node": ">=20"
-  }
+	"name": "migrate-barrel-imports",
+	"version": "1.7.0",
+	"description": "A CLI tool to migrate barrel imports in JavaScript/TypeScript monorepos",
+	"files": [
+		"dist/"
+	],
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"keywords": [
+		"typescript",
+		"javascript",
+		"monorepo",
+		"cli",
+		"tool",
+		"migrate",
+		"barrel",
+		"import",
+		"imports"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/brandhaug/migrate-barrel-imports.git"
+	},
+	"bugs": {
+		"url": "https://github.com/brandhaug/migrate-barrel-imports/issues"
+	},
+	"homepage": "https://github.com/brandhaug/migrate-barrel-imports#readme",
+	"type": "module",
+	"bin": {
+		"migrate-barrel-imports": "dist/index.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"start": "node dist/index.js",
+		"lint": "biome lint",
+		"check-write": "biome check --write",
+		"typecheck": "tsc",
+		"prepare": "husky",
+		"test": "vitest",
+		"validate": "npm run lint && npm run typecheck && npm run test"
+	},
+	"dependencies": {
+		"@babel/generator": "7.28.0",
+		"@babel/parser": "7.28.0",
+		"@babel/traverse": "7.28.0",
+		"@babel/types": "7.28.2",
+		"commander": "14.0.0",
+		"fast-glob": "3.3.3",
+		"micromatch": "4.0.8",
+		"ts-morph": "26.0.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.1.4",
+		"@commitlint/cli": "19.8.1",
+		"@commitlint/config-conventional": "19.8.1",
+		"@semantic-release/changelog": "6.0.3",
+		"@types/babel__generator": "7.27.0",
+		"@types/babel__traverse": "7.28.0",
+		"@types/micromatch": "4.0.9",
+		"execa": "9.6.0",
+		"husky": "9.1.7",
+		"lint-staged": "16.1.5",
+		"semantic-release": "24.2.7",
+		"tsc-files": "1.1.4",
+		"tsx": "4.20.3",
+		"typescript": "5.9.2",
+		"vitest": "3.2.4"
+	},
+	"author": "Martin Brandhaug",
+	"license": "MIT",
+	"lint-staged": {
+		"*.{ts,json}": [
+			"biome check --write"
+		],
+		"*.ts": [
+			"tsc-files"
+		]
+	},
+	"engines": {
+		"node": ">=20"
+	}
 }