importy 0.0.6 → 0.0.7

package/README.md

@@ -1 +1,171 @@
 # Importy
+
+A powerful CLI tool for analyzing JavaScript/TypeScript imports from libraries.
+
+[![npm version](https://img.shields.io/npm/v/importy.svg)](https://www.npmjs.com/package/importy)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](https://github.com/yourusername/importy)
+
+## Overview
+
+Importy scans your codebase to identify and analyze imports from specific libraries. It helps you:
+
+- Identify which components from a library are being used in your codebase
+- Find all occurrences of specific imported components
+- Analyze library usage patterns across your project
+- Generate detailed reports for dependency management
+
+## Installation
+
+```bash
+# Using npm
+npm install -g importy
+
+# Using yarn
+yarn global add importy
+
+# Using pnpm
+pnpm add -g importy
+```
+
+## Usage
+
+```bash
+importy --dir <directory> --lib <library-name> [options]
+```
+
+### Required Options
+
+- `-d, --dir <directory>`: Directory to scan (required)
+- `-l, --lib <library>`: Library name to match (required)
+
+### Additional Options
+
+- `-o, --output <file>`: Output results to a JSON file instead of stdout
+- `-v, --verbose`: Enable verbose logging
+- `-i, --include <pattern>`: Only include files matching pattern (glob)
+- `-e, --exclude <pattern>`: Exclude files matching pattern (glob)
+- `-c, --concurrency <number>`: Number of worker threads (defaults to CPU count - 1)
+- `--version`: Show version number
+- `--help`: Show help
+
+## Examples
+
+### Basic Usage
+
+```bash
+# Find all React imports in src directory
+importy --dir ./src --lib react
+
+# Find all MUI components used in your project
+importy --dir ./src --lib @mui/material
+```
+
+### Advanced Usage
+
+```bash
+# Export results to a JSON file
+importy --dir ./src --lib lodash --output imports.json
+
+# Only scan TypeScript files
+importy --dir ./src --lib axios --include "**/*.ts"
+
+# Exclude test files
+importy --dir ./src --lib react --exclude "**/*.test.{ts,tsx}"
+
+# Limit concurrency
+importy --dir ./src --lib react --concurrency 4
+```
+
+## Output Format
+
+The tool outputs JSON in the following format:
+
+```json
+{
+  "summary": {
+    "library": "react",
+    "componentsFound": 5,
+    "totalImports": 12,
+    "filesScanned": 42
+  },
+  "components": {
+    "useState": [
+      "src/components/Counter.tsx",
+      "src/components/Form.tsx"
+    ],
+    "useEffect": [
+      "src/components/Dashboard.tsx"
+    ],
+    "Component": [
+      "src/components/BaseComponent.tsx"
+    ]
+  }
+}
+```
+
+## Performance
+
+Importy uses parallel processing with promises, making it efficient even for large codebases. You can adjust the concurrency level to match your system's capabilities using the `--concurrency` option.
+
+## Development
+
+### Prerequisites
+
+- Node.js 16+
+- npm, yarn, or pnpm
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/importy.git
+cd importy
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run tests
+npm test
+```
+
+### Testing
+
+Importy uses Vitest for testing. There are two types of tests:
+
+1. **Programmatic tests**: Test the core functionality through the JavaScript API
+2. **CLI tests**: Test the command-line interface
+
+Run tests with:
+
+```bash
+# Run all tests
+npm test
+
+# Run specific tests
+npx vitest run tests/programmatic.test.ts
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Troubleshooting
+
+### Common Issues
+
+- **ES Module Compatibility**: If you encounter issues with ES modules, ensure your Node.js version is compatible (16+) and you're using the correct import syntax.
+- **Parsing Errors**: Complex TypeScript/JSX syntax may occasionally cause parsing errors. These files are skipped with a warning.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

package/dist/index.js

@@ -1,74 +1,292 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import { program } from "commander";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+
+// src/cli.ts
 import fs from "fs";
 import path from "path";
-import { program } from "commander";
 import * as parser from "@babel/parser";
 import _traverse from "@babel/traverse";
-var traverse = _traverse.default ?? _traverse;
-program.requiredOption("-d, --dir <directory>", "Directory to scan").requiredOption("-l, --lib <library>", "Library name to match").parse(process.argv);
-var { dir, lib } = program.opts();
+import os from "os";
+var traverse = _traverse.default;
 function isJavaScriptFile(file) {
   return /\.(js|ts|jsx|tsx)$/.test(file);
 }
-function getAllFiles(dirPath, arrayOfFiles = []) {
-  const files = fs.readdirSync(dirPath);
-  for (const file of files) {
-    const fullPath = path.join(dirPath, file);
-    const stat = fs.statSync(fullPath);
-    if (stat.isDirectory()) {
-      getAllFiles(fullPath, arrayOfFiles);
-    } else if (isJavaScriptFile(fullPath)) {
-      arrayOfFiles.push(fullPath);
+function getAllFiles(dirPath, arrayOfFiles = [], includePattern, excludePattern, verbose = false) {
+  try {
+    const files = fs.readdirSync(dirPath);
+    for (const file of files) {
+      const fullPath = path.join(dirPath, file);
+      try {
+        const stat = fs.statSync(fullPath);
+        if (excludePattern && stat.isDirectory() && minimatch(fullPath, excludePattern)) {
+          if (verbose) console.log(`Skipping excluded directory: ${fullPath}`);
+          continue;
+        }
+        if (stat.isDirectory()) {
+          getAllFiles(fullPath, arrayOfFiles, includePattern, excludePattern, verbose);
+        } else if (isJavaScriptFile(fullPath)) {
+          const shouldInclude = !includePattern || minimatch(fullPath, includePattern);
+          const shouldExclude = excludePattern && minimatch(fullPath, excludePattern);
+          if (shouldInclude && !shouldExclude) {
+            arrayOfFiles.push(fullPath);
+          } else if (verbose) {
+            console.log(`Skipping file due to patterns: ${fullPath}`);
+          }
+        }
+      } catch (error) {
+        if (verbose) console.warn(`Error accessing file ${fullPath}: ${error instanceof Error ? error.message : String(error)}`);
+      }
     }
+  } catch (error) {
+    if (verbose) console.error(`Error reading directory ${dirPath}: ${error instanceof Error ? error.message : String(error)}`);
   }
   return arrayOfFiles;
 }
+function minimatch(filePath, pattern) {
+  try {
+    const regExpPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/{{GLOBSTAR}}/g, ".*");
+    const regex = new RegExp(`^${regExpPattern}$`, "i");
+    const result = regex.test(filePath);
+    return result;
+  } catch (error) {
+    console.warn(`Invalid pattern: ${pattern}`);
+    return false;
+  }
+}
+function chunkArray(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
+async function processFilesInBatches(items, batchSize, processor, onProgress) {
+  const results = [];
+  const batches = chunkArray(items, batchSize);
+  let completed = 0;
+  const total = items.length;
+  for (const batch of batches) {
+    const batchResults = await Promise.all(
+      batch.map(async (item) => {
+        try {
+          const result = await processor(item);
+          completed++;
+          if (onProgress) {
+            onProgress(completed, total);
+          }
+          return result;
+        } catch (error) {
+          console.warn(`Error processing item: ${error instanceof Error ? error.message : String(error)}`);
+          completed++;
+          if (onProgress) {
+            onProgress(completed, total);
+          }
+          return [];
+        }
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
 function extractImportsFromFile(filePath, targetLib) {
-  const code = fs.readFileSync(filePath, "utf-8");
-  let ast;
   try {
-    ast = parser.parse(code, {
-      sourceType: "module",
-      plugins: ["typescript", "jsx"]
+    const code = fs.readFileSync(filePath, "utf-8");
+    let ast;
+    try {
+      ast = parser.parse(code, {
+        sourceType: "module",
+        plugins: ["typescript", "jsx"],
+        errorRecovery: true
+      });
+    } catch (err) {
+      try {
+        ast = parser.parse(code, {
+          sourceType: "module",
+          plugins: ["typescript", "jsx", "decorators-legacy", "classProperties"],
+          errorRecovery: true
+        });
+      } catch (secondErr) {
+        console.warn(`Skipping ${filePath}: Failed to parse: ${secondErr}`);
+        return [];
+      }
+    }
+    const matches = [];
+    const lines = code.split("\n");
+    traverse(ast, {
+      ImportDeclaration(path3) {
+        const node = path3.node;
+        if (node.source.value === targetLib || // Handle subpath imports like 'library/subpath'
+        node.source.value.startsWith(`${targetLib}/`)) {
+          const lineNumber = node.loc?.start.line;
+          for (const specifier of node.specifiers) {
+            let importedName;
+            if (specifier.type === "ImportDefaultSpecifier") {
+              importedName = "default";
+            } else if (specifier.type === "ImportNamespaceSpecifier") {
+              importedName = "*";
+            } else if ("imported" in specifier && specifier.imported) {
+              importedName = specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+            } else {
+              importedName = "unknown";
+            }
+            const localName = specifier.local.name;
+            matches.push({
+              importedName,
+              localName,
+              file: filePath,
+              line: lineNumber
+            });
+          }
+        }
+      }
     });
-  } catch (err) {
-    console.warn(`Skipping ${filePath}: Failed to parse`);
+    return matches;
+  } catch (error) {
+    console.warn(`Error reading file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
     return [];
   }
-  const matches = [];
-  traverse(ast, {
-    ImportDeclaration(path2) {
-      const node = path2.node;
-      if (node.source.value === targetLib) {
-        for (const specifier of node.specifiers) {
-          const importedName = "imported" in specifier && specifier.imported ? specifier.imported.name : "default";
-          const localName = specifier.local.name;
-          matches.push({
-            importedName,
-            localName,
-            file: filePath
-          });
+}
+async function analyzeImports(options2) {
+  const { dir, lib, include, exclude, verbose = false } = options2;
+  const concurrency = options2.concurrency || Math.max(1, Math.min(4, os.cpus().length - 1));
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Directory '${dir}' does not exist`);
+  }
+  if (!fs.statSync(dir).isDirectory()) {
+    throw new Error(`'${dir}' is not a directory`);
+  }
+  const allFiles = getAllFiles(dir, [], include, exclude, verbose);
+  if (verbose) console.log(`Found ${allFiles.length} files to process`);
+  if (allFiles.length === 0) {
+    return {
+      summary: {
+        library: lib,
+        componentsFound: 0,
+        totalImports: 0,
+        filesScanned: 0
+      },
+      components: {}
+    };
+  }
+  const batchSize = Math.max(1, Math.ceil(allFiles.length / concurrency));
+  if (verbose) console.log(`Processing ${allFiles.length} files with ${concurrency} concurrent processes`);
+  let processedCount = 0;
+  const results = await processFilesInBatches(
+    allFiles,
+    batchSize,
+    (file) => extractImportsFromFile(file, lib),
+    (completed, total) => {
+      if (verbose) {
+        const percentComplete = Math.floor(completed / total * 100);
+        if (percentComplete % 10 === 0 && processedCount !== percentComplete) {
+          processedCount = percentComplete;
+          console.log(`Progress: ${percentComplete}% (${completed}/${total} files)`);
         }
       }
     }
-  });
-  return matches;
-}
-var allFiles = getAllFiles(dir);
-var componentMap = {};
-for (const file of allFiles) {
-  const imports = extractImportsFromFile(file, lib);
-  for (const { importedName, file: filePath } of imports) {
-    if (!componentMap[importedName]) {
-      componentMap[importedName] = /* @__PURE__ */ new Set();
+  );
+  const componentMap = {};
+  for (const imports of results) {
+    if (!imports) {
+      continue;
     }
-    componentMap[importedName].add(filePath);
+    for (const { importedName, file: filePath } of imports) {
+      if (!componentMap[importedName]) {
+        componentMap[importedName] = /* @__PURE__ */ new Set();
+      }
+      componentMap[importedName].add(filePath);
+    }
+  }
+  const output = {};
+  for (const [component, files] of Object.entries(componentMap)) {
+    output[component] = [...files];
+  }
+  const totalImports = Object.values(output).reduce((sum, files) => sum + files.length, 0);
+  const totalComponents = Object.keys(output).length;
+  if (verbose) {
+    console.log(`Analysis complete - Found ${totalComponents} components with ${totalImports} total imports across ${allFiles.length} files`);
   }
+  return {
+    summary: {
+      library: lib,
+      componentsFound: totalComponents,
+      totalImports,
+      filesScanned: allFiles.length
+    },
+    components: output
+  };
 }
-var output = {};
-for (const [component, files] of Object.entries(componentMap)) {
-  output[component] = [...files];
+
+// src/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var packageJson;
+try {
+  const packagePath = path2.resolve(__dirname, "../package.json");
+  const packageData = fs2.readFileSync(packagePath, "utf8");
+  packageJson = JSON.parse(packageData);
+} catch (error) {
+  packageJson = { version: "0.0.0", name: "importy" };
+  console.warn("Could not load package.json, using default version");
+}
+program.version(packageJson.version).description("Analyze JavaScript/TypeScript imports from a specific library").requiredOption("-d, --dir <directory>", "Directory to scan").requiredOption("-l, --lib <library>", "Library name to match").option(
+  "-o, --output <file>",
+  "Output results to a JSON file instead of stdout"
+).option("-v, --verbose", "Enable verbose logging").option(
+  "-i, --include <pattern>",
+  "Only include files matching pattern (glob)"
+).option("-e, --exclude <pattern>", "Exclude files matching pattern (glob)").option(
+  "-c, --concurrency <number>",
+  "Number of worker threads (defaults to CPU count - 1)"
+).parse(process.argv);
+var options = program.opts();
+async function main() {
+  try {
+    const result = await analyzeImports({
+      dir: options.dir,
+      lib: options.lib,
+      include: options.include,
+      exclude: options.exclude,
+      verbose: options.verbose || false,
+      concurrency: options.concurrency ? parseInt(options.concurrency, 10) : void 0
+    });
+    if (options.output) {
+      try {
+        fs2.writeFileSync(options.output, JSON.stringify(result, null, 2));
+        console.log(`Results written to ${options.output}`);
+      } catch (error) {
+        console.error(
+          `Error writing to output file: ${error instanceof Error ? error.message : String(error)}`
+        );
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    if (Object.keys(result.components).length === 0) {
+      console.warn(
+        `No imports from '${options.lib}' were found in the specified directory.`
+      );
+      process.exit(0);
+    }
+    return result;
+  } catch (error) {
+    console.error(
+      `Error during processing: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
 }
-console.log(JSON.stringify(output, null, 2));
+main().catch((error) => {
+  console.error(
+    `Unhandled error: ${error instanceof Error ? error.message : String(error)}`
+  );
+  process.exit(1);
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "importy",
-  "version": "0.0.6",
-  "description": "",
+  "version": "0.0.7",
+  "description": "A CLI tool for analyzing JavaScript/TypeScript imports from libraries",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
@@ -13,11 +13,20 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
     "@babel/types": "^7.27.3",
+    "@types/babel__traverse": "^7.20.7",
     "@types/node": "^22.15.29",
+    "@typescript-eslint/eslint-plugin": "^7.4.0",
+    "@typescript-eslint/parser": "^7.4.0",
+    "eslint": "^8.57.0",
+    "ts-node": "^10.9.2",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^1.4.0"
   },
   "dependencies": {
     "@babel/parser": "^7.27.5",
@@ -25,6 +34,11 @@
     "commander": "^14.0.0"
   },
   "scripts": {
-    "build": "tsup"
+    "build": "tsup src/index.ts",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/**/*.ts"
   }
 }

package/.github/workflows/publish.yml

@@ -1,36 +0,0 @@
-name: Publish to npm (pnpm)
-
-on:
-  push:
-    tags:
-      - "v*" # triggers on tags like v1.0.0
-
-jobs:
-  publish:
-    name: Publish package
-    runs-on: ubuntu-latest
-    environment:
-      name: releases
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-          registry-url: "https://registry.npmjs.org/"
-
-      - name: Install pnpm
-        run: npm install -g pnpm
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Build
-        run: pnpm build
-
-      - name: Publish to npm
-        run: pnpm publish --no-git-checks
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/src/index.ts

@@ -1,105 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { program } from 'commander';
-import * as parser from '@babel/parser';
-
-import _traverse from '@babel/traverse';
-const traverse = (_traverse as any).default ?? _traverse;
-import type { ImportDeclaration } from '@babel/types';
-
-// Define CLI options
-program
-  .requiredOption('-d, --dir <directory>', 'Directory to scan')
-  .requiredOption('-l, --lib <library>', 'Library name to match')
-  .parse(process.argv);
-
-const { dir, lib } = program.opts<{
-  dir: string;
-  lib: string;
-}>();
-
-// Helpers
-function isJavaScriptFile(file: string): boolean {
-  return /\.(js|ts|jsx|tsx)$/.test(file);
-}
-
-function getAllFiles(dirPath: string, arrayOfFiles: string[] = []): string[] {
-  const files = fs.readdirSync(dirPath);
-  for (const file of files) {
-    const fullPath = path.join(dirPath, file);
-    const stat = fs.statSync(fullPath);
-    if (stat.isDirectory()) {
-      getAllFiles(fullPath, arrayOfFiles);
-    } else if (isJavaScriptFile(fullPath)) {
-      arrayOfFiles.push(fullPath);
-    }
-  }
-  return arrayOfFiles;
-}
-
-type ImportMatch = {
-  importedName: string;
-  localName: string;
-  file: string;
-};
-
-function extractImportsFromFile(filePath: string, targetLib: string): ImportMatch[] {
-  const code = fs.readFileSync(filePath, 'utf-8');
-  let ast;
-  try {
-    ast = parser.parse(code, {
-      sourceType: 'module',
-      plugins: ['typescript', 'jsx'],
-    });
-  } catch (err) {
-    console.warn(`Skipping ${filePath}: Failed to parse`);
-    return [];
-  }
-
-  const matches: ImportMatch[] = [];
-
-  traverse(ast, {
-    ImportDeclaration(path: any) {
-      const node = path.node as ImportDeclaration;
-      if (node.source.value === targetLib) {
-        for (const specifier of node.specifiers) {
-          const importedName =
-            'imported' in specifier && specifier.imported
-              ? specifier.imported.name as any
-              : 'default';
-          const localName = specifier.local.name;
-
-          matches.push({
-            importedName,
-            localName,
-            file: filePath,
-          });
-        }
-      }
-    },
-  });
-
-  return matches;
-}
-
-// Process all files and build result
-const allFiles = getAllFiles(dir);
-const componentMap: Record<string, Set<string>> = {};
-
-for (const file of allFiles) {
-  const imports = extractImportsFromFile(file, lib);
-  for (const { importedName, file: filePath } of imports) {
-    if (!componentMap[importedName]) {
-      componentMap[importedName] = new Set();
-    }
-    componentMap[importedName].add(filePath);
-  }
-}
-
-// Final output
-const output: Record<string, string[]> = {};
-for (const [component, files] of Object.entries(componentMap)) {
-  output[component] = [...files];
-}
-
-console.log(JSON.stringify(output, null, 2));

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "verbatimModuleSyntax": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "dist"
-  },
-  "include": ["src"]
-}

package/tsup.config.ts

@@ -1,12 +0,0 @@
-// tsup.config.ts
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts"],
-  format: ["esm"],
-  outDir: "dist",
-  banner: {
-    js: "#!/usr/bin/env node",
-  },
-  target: "node18",
-});