esupgrade 2025.3.2 → 2025.3.3

package/bin/esupgrade.js

@@ -2,201 +2,317 @@
 
 import fs from "fs"
 import path from "path"
+import os from "os"
+import { Worker } from "worker_threads"
+import { once } from "events"
 import { Command, Option } from "commander"
-import { transform } from "../src/index.js"
+import { fileURLToPath } from "url"
+import process from "node:process"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
 /**
  * CLI tool for esupgrade
  */
 
-const program = new Command()
-
-program
-  .name("esupgrade")
-  .description("Auto-upgrade your JavaScript syntax")
-  .argument("[files...]", "Files or directories to process")
-  .addOption(
-    new Option("--baseline <level>", "Set baseline level for transformations")
-      .choices(["widely-available", "newly-available"])
-      .default("widely-available"),
-  )
-  .option("--check", "Report which files need upgrading and exit with code 1 if any do")
-  .option(
-    "--write",
-    "Write changes to files (default: true unless only --check is specified)",
-  )
-  .action((files, options) => {
-    if (files.length === 0) {
-      console.error("Error: No files specified")
-      program.help()
-    }
+/**
+ * Handles worker thread execution for file processing
+ */
+class WorkerRunner {
+  constructor(workerPath) {
+    this.workerPath = workerPath
+  }
 
-    // Handle check/write options - they are not mutually exclusive
-    // Default: write is true unless ONLY --check is specified (no --write)
-    const shouldWrite = options.write !== undefined ? options.write : !options.check
-    const shouldCheck = options.check || false
+  /**
+   * Run a worker thread to process a file
+   */
+  async run(filePath, baseline) {
+    const worker = new Worker(this.workerPath, {
+      workerData: { filePath, baseline },
+    })
 
-    const processingOptions = {
-      baseline: options.baseline,
-      write: shouldWrite,
-      check: shouldCheck,
-    }
+    const [message] = await once(worker, "message")
+    return message
+  }
+}
 
-    processFiles(files, processingOptions)
-  })
+/**
+ * Processes individual files and handles output
+ */
+class FileProcessor {
+  constructor(workerRunner) {
+    this.workerRunner = workerRunner
+  }
 
-function findFiles(patterns) {
-  const files = []
+  /**
+   * @typedef {Object} ProcessResult
+   * @property {boolean} modified - Whether the file was modified
+   * @property {Array} changes - List of changes made
+   * @property {boolean} error - Whether an error occurred during processing
+   */
 
-  for (const pattern of patterns) {
+  /**
+   * Process a file using a worker thread
+   *
+   * @param {string} filePath - Path to the file to process
+   * @param {Object} options - Processing options
+   * @param {string} options.baseline - Baseline level for transformations
+   * @param {boolean} options.check - Whether to only check for changes
+   * @param {boolean} options.write - Whether to write changes to file
+   * @returns {Promise<ProcessResult>} Result of processing
+   */
+  async processFile(filePath, options) {
     try {
-      const stats = fs.statSync(pattern)
-
-      if (stats.isFile()) {
-        files.push(pattern)
-      } else if (stats.isDirectory()) {
-        // Recursively find .js, .jsx, .ts, .tsx files
-        const dirFiles = walkDirectory(pattern)
-        files.push(...dirFiles)
+      const workerResult = await this.workerRunner.run(filePath, options.baseline)
+
+      if (!workerResult.success) {
+        console.error(`✗ Error: ${filePath}: ${workerResult.error}`)
+        return { modified: false, changes: [], error: true }
+      }
+
+      const result = workerResult.result
+
+      if (result.modified) {
+        if (options.check) {
+          this.#reportChanges(filePath, result.changes)
+        }
+
+        if (options.write) {
+          fs.writeFileSync(filePath, result.code, "utf8")
+          if (!options.check) {
+            console.log(`✓ ${filePath}`)
+          } else {
+            console.log(`  ✓ written`)
+          }
+        }
+
+        return { modified: true, changes: result.changes, error: false }
+      } else {
+        if (!options.check) {
+          console.log(`  ${filePath}`)
+        }
+        return { modified: false, changes: [], error: false }
       }
     } catch (error) {
-      console.error(`Error: Cannot access '${pattern}': ${error.message}`)
-      process.exit(1)
+      console.error(`✗ Error: ${filePath}: ${error.message}`)
+      return { modified: false, changes: [], error: true }
     }
   }
 
-  return files
+  #reportChanges(filePath, changes) {
+    const changesByType = {}
+    if (changes && changes.length > 0) {
+      for (const change of changes) {
+        if (!changesByType[change.type]) {
+          changesByType[change.type] = 0
+        }
+        changesByType[change.type]++
+      }
+    }
+
+    const transformations = Object.keys(changesByType)
+      .map((type) =>
+        type
+          .replace(/([A-Z])/g, " $1")
+          .trim()
+          .toLowerCase(),
+      )
+      .join(", ")
+
+    console.log(`✗ ${filePath}`)
+    if (transformations) {
+      console.log(`  ${transformations}`)
+    }
+  }
 }
 
-function walkDirectory(dir) {
-  const files = []
-  const entries = fs.readdirSync(dir, { withFileTypes: true })
+/**
+ * Manages a pool of workers for parallel file processing
+ */
+class WorkerPool {
+  constructor(fileProcessor, maxWorkers = os.cpus().length) {
+    this.fileProcessor = fileProcessor
+    this.maxWorkers = maxWorkers
+  }
 
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name)
+  /**
+   * Process files with a worker pool for better CPU utilization
+   */
+  async processFiles(files, options) {
+    const results = new Array(files.length)
+    let fileIndex = 0
 
-    if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === ".git") {
-        continue
-      }
-      files.push(...walkDirectory(fullPath))
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name)
-      if ([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"].includes(ext)) {
-        files.push(fullPath)
+    // Worker pool pattern - each worker processes files until queue is empty
+    const processNext = async () => {
+      while (fileIndex < files.length) {
+        const currentIndex = fileIndex++
+        const file = files[currentIndex]
+        results[currentIndex] = await this.fileProcessor.processFile(file, options)
       }
     }
-  }
 
-  return files
+    // Start worker pool and wait for all to complete
+    const workerCount = Math.min(this.maxWorkers, files.length)
+    const workers = Array.from({ length: workerCount }, () => processNext())
+    await Promise.all(workers)
+
+    return results
+  }
 }
 
-function processFile(filePath, options) {
-  try {
-    const code = fs.readFileSync(filePath, "utf8")
-    const result = transform(code, options.baseline)
-
-    if (result.modified) {
-      if (options.check) {
-        // Group changes by type for summary
-        const changesByType = {}
-        if (result.changes && result.changes.length > 0) {
-          for (const change of result.changes) {
-            if (!changesByType[change.type]) {
-              changesByType[change.type] = 0
-            }
-            changesByType[change.type]++
-          }
-        }
+/**
+ * Finds JavaScript files from patterns
+ */
+class FileFinder {
+  static IGNORED_DIRS = ["node_modules", ".git"]
+  static JS_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]
 
-        const transformations = Object.keys(changesByType)
-          .map((type) => {
-            const displayName = type
-              .replace(/([A-Z])/g, " $1")
-              .trim()
-              .toLowerCase()
-            return displayName
-          })
-          .join(", ")
-
-        console.log(`✗ ${filePath}`)
-        if (transformations) {
-          console.log(`  ${transformations}`)
-        }
-      }
+  constructor() {}
 
-      if (options.write) {
-        fs.writeFileSync(filePath, result.code, "utf8")
-        if (!options.check) {
-          console.log(`✓ ${filePath}`)
-        } else {
-          console.log(`  ✓ written`)
+  /**
+   * Find files matching patterns
+   */
+  *find(patterns) {
+    for (const pattern of patterns) {
+      try {
+        const stats = fs.statSync(pattern)
+
+        if (stats.isFile()) {
+          yield pattern
+        } else if (stats.isDirectory()) {
+          yield* this._walkDirectory(pattern)
         }
+      } catch (error) {
+        console.error(`Error: Cannot access '${pattern}': ${error.message}`)
+        process.exit(1)
       }
+    }
+  }
 
-      return { modified: true, changes: result.changes }
-    } else {
-      if (!options.check) {
-        console.log(`  ${filePath}`)
+  *_walkDirectory(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+
+      if (entry.isDirectory()) {
+        if (FileFinder.IGNORED_DIRS.includes(entry.name)) {
+          continue
+        }
+        yield* this._walkDirectory(fullPath)
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name)
+        if (FileFinder.JS_EXTENSIONS.includes(ext)) {
+          yield fullPath
+        }
       }
-      return { modified: false, changes: [] }
     }
-  } catch (error) {
-    console.error(`✗ Error: ${filePath}: ${error.message}`)
-    return { modified: false, changes: [] }
   }
 }
 
-function processFiles(patterns, options) {
-  const files = findFiles(patterns)
-
-  if (files.length === 0) {
-    console.log("No JavaScript files found")
-    process.exit(0)
+/**
+ * Orchestrates the CLI application
+ */
+class CLIRunner {
+  constructor(workerPath) {
+    const workerRunner = new WorkerRunner(workerPath)
+    const fileProcessor = new FileProcessor(workerRunner)
+    this.workerPool = new WorkerPool(fileProcessor)
+    this.fileFinder = new FileFinder()
   }
 
-  let modifiedCount = 0
-  const allChanges = []
+  /**
+   * Process files and report results
+   */
+  async run(patterns, options) {
+    const files = [...this.fileFinder.find(patterns)]
 
-  for (const file of files) {
-    const result = processFile(file, options)
-    if (result.modified) {
-      modifiedCount++
-      allChanges.push(...result.changes)
+    if (files.length === 0) {
+      console.log("No JavaScript files found")
+      process.exit(0)
     }
+
+    const results = await this.workerPool.processFiles(files, options)
+    this.#reportSummary(results, options)
   }
 
-  // Summary
-  if (options.check) {
+  #reportSummary(results, options) {
+    let modifiedCount = 0
+    const allChanges = results.flatMap((result) =>
+      result.modified ? (modifiedCount++, result.changes) : [],
+    )
+
+    const errorCount = results.filter((result) => result.error).length
+
     console.log("")
-    if (modifiedCount > 0) {
-      // Count unique transformation types
-      const transformTypes = new Set(allChanges.map((c) => c.type))
-      const typeCount = transformTypes.size
-      const totalChanges = allChanges.length
-
-      console.log(
-        `${modifiedCount} file${modifiedCount !== 1 ? "s" : ""} need${modifiedCount === 1 ? "s" : ""} upgrading (${totalChanges} change${totalChanges !== 1 ? "s" : ""}, ${typeCount} type${typeCount !== 1 ? "s" : ""})`,
-      )
-      if (options.write) {
-        console.log("Changes have been written")
+
+    if (options.check) {
+      if (modifiedCount > 0) {
+        const transformTypes = new Set(allChanges.map((c) => c.type))
+        const typeCount = transformTypes.size
+        const totalChanges = allChanges.length
+
+        console.log(
+          `${modifiedCount} file${modifiedCount !== 1 ? "s" : ""} need${modifiedCount === 1 ? "s" : ""} upgrading (${totalChanges} change${totalChanges !== 1 ? "s" : ""}, ${typeCount} type${typeCount !== 1 ? "s" : ""})`,
+        )
+        if (options.write) {
+          console.log("Changes have been written")
+        }
+      } else {
+        console.log("All files are up to date")
       }
     } else {
-      console.log("All files are up to date")
+      if (modifiedCount > 0) {
+        console.log(`✓ ${modifiedCount} file${modifiedCount !== 1 ? "s" : ""} upgraded`)
+      } else {
+        console.log("All files are up to date")
+      }
     }
-  } else {
-    console.log("")
-    if (modifiedCount > 0) {
-      console.log(`✓ ${modifiedCount} file${modifiedCount !== 1 ? "s" : ""} upgraded`)
-    } else {
-      console.log("All files are up to date")
+
+    // Errors take precedence over --check flag.
+    // Exit with error code if any file processing errors occurred.
+    if (errorCount > 0) {
+      process.exit(1)
     }
-  }
 
-  // Exit with code 1 if --check specified and there were changes
-  if (options.check && modifiedCount > 0) {
-    process.exit(1)
+    if (options.check && modifiedCount > 0) {
+      process.exit(1)
+    }
   }
 }
 
+// Initialize CLI
+const program = new Command()
+const cliRunner = new CLIRunner(path.join(__dirname, "../src/worker.js"))
+
+program
+  .name("esupgrade")
+  .description("Auto-upgrade your JavaScript syntax")
+  .argument("<files...>", "Files or directories to process")
+  .addOption(
+    new Option("--baseline <level>", "Set baseline level for transformations")
+      .choices(["widely-available", "newly-available"])
+      .default("widely-available"),
+  )
+  .option("--check", "Report which files need upgrading and exit with code 1 if any do")
+  .option(
+    "--write",
+    "Write changes to files (default: true unless only --check is specified)",
+  )
+  .action(async (files, options) => {
+    // Handle check/write options - they are not mutually exclusive
+    // Default: write is true unless ONLY --check is specified (no --write)
+    const shouldWrite = options.write !== undefined ? options.write : !options.check
+    const shouldCheck = options.check || false
+
+    const processingOptions = {
+      baseline: options.baseline,
+      write: shouldWrite,
+      check: shouldCheck,
+    }
+
+    await cliRunner.run(files, processingOptions)
+  })
+
 program.parse()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esupgrade",
-  "version": "2025.3.2",
+  "version": "2025.3.3",
   "description": "Auto-upgrade your JavaScript syntax",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -11,10 +11,10 @@ import * as newlyAvailable from "./newlyAvailable.js"
  */
 
 /**
- * Transform JavaScript code using the specified transformers
- * @param {string} code - The source code to transform
- * @param {string} baseline - Baseline level ('widely-available' or 'newly-available')
- * @returns {TransformResult} - Object with { code, modified, changes }
+ * Transform JavaScript code using the specified transformers.
+ * @param {string} code - The source code to transform.
+ * @param {string} baseline - Baseline level ('widely-available' or 'newly-available').
+ * @returns {TransformResult} Object with transformed code, modification status, and changes.
  */
 export function transform(code, baseline = "widely-available") {
   const j = jscodeshift.withParser("tsx")
@@ -22,11 +22,14 @@ export function transform(code, baseline = "widely-available") {
 
   let modified = false
   const allChanges = []
-  let transformers = widelyAvailable
-  if (baseline === "newly-available")
-    transformers = { ...widelyAvailable, ...newlyAvailable }
-  for (const name in transformers) {
-    const result = transformers[name](j, root)
+
+  const transformers =
+    baseline === "newly-available"
+      ? { ...widelyAvailable, ...newlyAvailable }
+      : widelyAvailable
+
+  for (const transformer of Object.values(transformers)) {
+    const result = transformer(j, root)
     if (result.modified) {
       modified = true
       allChanges.push(...result.changes)

package/src/worker.js

@@ -0,0 +1,26 @@
+import { parentPort, workerData } from "worker_threads"
+import fs from "fs"
+import { transform } from "./index.js"
+
+/**
+ * Worker thread for processing files in parallel.
+ */
+
+const { filePath, baseline } = workerData
+
+try {
+  const code = fs.readFileSync(filePath, "utf8")
+  const result = transform(code, baseline)
+
+  parentPort.postMessage({
+    success: true,
+    filePath,
+    result,
+  })
+} catch (error) {
+  parentPort.postMessage({
+    success: false,
+    filePath,
+    error: error.message,
+  })
+}

package/tests/cli.test.js

@@ -27,10 +27,10 @@ describe("CLI", () => {
 
     assert.match(
       result.stderr,
-      /Error: No files specified/,
+      /error: missing required argument 'files'/,
       "displays error for no files",
     )
-    assert.equal(result.status, 0, "exits with 0 when showing help")
+    assert.equal(result.status, 1, "exits with 1 when showing help")
   })
 
   test("transform a single file with --write", () => {
@@ -361,7 +361,7 @@ describe("CLI", () => {
     assert.equal(result.status, 1, "exits with 1")
   })
 
-  test("handle syntax errors gracefully", () => {
+  test("exit with 1 on syntax errors", () => {
     const testFile = path.join(tempDir, "test.js")
     fs.writeFileSync(testFile, `var x = {{{;`)
 
@@ -370,7 +370,50 @@ describe("CLI", () => {
     })
 
     assert.match(result.stderr, /✗ Error:/, "displays error for syntax issues")
-    assert.equal(result.status, 0, "continues despite errors")
+    assert.equal(result.status, 1, "exits with 1 on errors")
+  })
+
+  test("exit with 1 on parsing errors with --check", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, `const a;\na = 'asdf'`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for parsing issues")
+    assert.equal(result.status, 1, "exits with 1 on errors with --check")
+  })
+
+  test("exit with 1 on parsing errors without --check", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, `const a;\na = 'asdf'`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for parsing issues")
+    assert.equal(result.status, 1, "exits with 1 on errors without --check")
+  })
+
+  test("exit with 1 on errors even with valid files", () => {
+    const validFile = path.join(tempDir, "valid.js")
+    const invalidFile = path.join(tempDir, "invalid.js")
+    fs.writeFileSync(validFile, `var x = 1;`)
+    fs.writeFileSync(invalidFile, `const a;\na = 'asdf'`)
+
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, validFile, invalidFile, "--check"],
+      {
+        encoding: "utf8",
+      },
+    )
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for invalid file")
+    assert.match(result.stdout, /valid\.js/, "processes valid file")
+    assert.equal(result.status, 1, "exits with 1 when any file has errors")
   })
 
   test("handle mixed directory and file arguments", () => {
@@ -391,4 +434,33 @@ describe("CLI", () => {
     assert.match(result.stdout, /2 files upgraded/, "reports 2 files upgraded")
     assert.equal(result.status, 0, "exits successfully")
   })
+
+  test("show individual file markers for mixed results", () => {
+    const file1 = path.join(tempDir, "test1.js")
+    const file2 = path.join(tempDir, "test2.js")
+    fs.writeFileSync(file1, `var x = 1;`)
+    fs.writeFileSync(file2, `const y = 2;`) // Already upgraded
+
+    const result = spawnSync(process.execPath, [CLI_PATH, file1, file2, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /✓/, "shows check mark for modified file")
+    assert.match(result.stdout, /test2\.js/, "shows unmodified file path")
+    assert.equal(result.status, 0, "exits successfully")
+  })
+
+  test("exit with 1 on file write errors", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, `var x = 1;`)
+    // Make file read-only to trigger write error
+    fs.chmodSync(testFile, 0o444)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /✗ Error:/, "displays error for write issues")
+    assert.equal(result.status, 1, "exits with 1 on write errors")
+  })
 })