esupgrade 2025.21.0 → 2025.22.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,32 @@
+{
+  "name": "esupgrade",
+  "description": "Auto-upgrade JavaScript and TypeScript syntax to new ECMAScript features based on browser support.",
+  "owner": {
+    "name": "codingjoe",
+    "email": "security@codingjoe.dev"
+  },
+  "plugins": [
+    {
+      "name": "esupgrade",
+      "source": "./",
+      "description": "Auto-upgrade JavaScript and TypeScript syntax to new ECMAScript features based on browser support.",
+      "displayName": "esupgrade",
+      "author": {
+        "name": "Johannes Maron",
+        "email": "security@codingjoe.dev"
+      },
+      "homepage": "https://github.com/codingjoe/esupgrade",
+      "repository": "https://github.com/codingjoe/esupgrade",
+      "license": "BSD-2-Clause",
+      "keywords": [
+        "javascript",
+        "ecmascript",
+        "modernize",
+        "upgrade",
+        "codemod",
+        "ast",
+        "transform"
+      ]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "esupgrade",
+  "displayName": "ESUpgrade",
+  "description": "Auto-upgrade JavaScript and TypeScript syntax to new ECMAScript features based on browser support.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Johannes Maron",
+    "email": "security@codingjoe.dev"
+  },
+  "homepage": "https://github.com/codingjoe/esupgrade",
+  "repository": "https://github.com/codingjoe/esupgrade",
+  "license": "BSD-2-Clause",
+  "keywords": [
+    "javascript",
+    "ecmascript",
+    "modernize",
+    "upgrade",
+    "codemod",
+    "ast",
+    "transform"
+  ]
+}

package/README.md

@@ -17,12 +17,26 @@ Keeping your JavaScript and TypeScript code up to date with full browser compati
 ## Usage
 
 esupgrade is safe and meant to be used automatically on your codebase.
-We recommend integrating it into your development workflow using [pre-commit] or [husky].
+We recommend integrating it into your development workflow using [pre-commit], [husky], or as an agent skill.
+
+### CLI
 
 To try it out on a repository without writing changes, run:
 
 ```bash
-npx esupgrade $(git ls-files | grep -E -i -w '.*\.(t|j)sx?')
+npx -y esupgrade $(git ls-files | grep -E -i -w '.*\.(t|j)sx?')
+```
+
+To transform code from standard input, pass `-` as the input path:
+
+```bash
+echo 'var x = 1;' | npx esupgrade -
+```
+
+For help with available options:
+
+```bash
+npx esupgrade --help
 ```
 
 ### pre-commit
@@ -49,15 +63,18 @@ pre-commit run esupgrade --all-files
 Assuming Husky is already initialized and `.husky/pre-commit` already contains `set -e`, append:
 
 ```bash
-echo "git diff --cached --name-only --diff-filter=ACMR -z -- '*.js' '*.jsx' '*.ts' '*.tsx' '*.mjs' '*.cjs' | xargs -0 sh -c 'test \"\$#\" -eq 0 && exit 0; npx esupgrade -- \"\$@\"' sh" >> .husky/pre-commit
+echo "git diff --cached --name-only --diff-filter=ACMR -z -- '*.js' '*.jsx' '*.ts' '*.tsx' '*.mjs' '*.cjs' | xargs -0 sh -c 'test \"\$#\" -eq 0 && exit 0; npx -y esupgrade -- \"\$@\"' sh" >> .husky/pre-commit
 echo "git diff --cached --name-only --diff-filter=ACMR -z -- '*.js' '*.jsx' '*.ts' '*.tsx' '*.mjs' '*.cjs' | xargs -0 sh -c 'test \"\$#\" -eq 0 && exit 0; git add -- \"\$@\"' sh" >> .husky/pre-commit
 ```
 
-### CLI
+### Agent Skill
 
-```bash
-npx esupgrade --help
-```
+esupgrade is available as a skill in [Claude Code]. To use it:
+
+1. Run `/plugin marketplace add codingjoe/esupgrade`
+1. Run `/plugin install esupgrade@esupgrade`
+
+The skill will analyze your selected code and suggest transformations based on the Baseline browser support policy.
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/assets/img/baseline-wordmark-dark.svg">
@@ -402,7 +419,7 @@ Transforms constructor functions (both function declarations and variable declar
 
 - Function name starts with an uppercase letter
 - At least one prototype method is defined
-- Prototype methods are matched only to constructors declared in the current or an ancestor lexical scope (never sibling or child scopes)
+- Prototype methods are matched to constructors declared in the current or an ancestor lexical scope (never sibling or child scopes)
 - Prototype methods using `this` in arrow functions are skipped
 - Prototype object literals with getters, setters, or computed properties are skipped
 
@@ -756,6 +773,7 @@ Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is
 
 [baseline]: https://web.dev/baseline/
 [calver]: https://calver.org/
+[claude code]: https://code.claude.com
 [django-upgrade]: https://github.com/adamchainz/django-upgrade
 [husky]: https://typicode.github.io/husky/
 [mdn-arrow-functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions

package/SKILL.md

@@ -1,14 +1,20 @@
 ---
 name: esupgrade
 description: Auto-update JavaScript and TypeScript syntax to new ECMAScript features based on browser support.
+license: BSD-2-Clause
+metadata:
+  author: codingjoe <security@codingjoe.dev>
+allowed-tools: Bash(npx -y esupgrade *) READ
+compatibility: Requires Node.js 24 or later and npx.
 ---
 
-Use the CLI with `npx` on files or directories:
+Use the CLI with `npx` on files, directories, or standard input:
 
 ```console
-npx esupgrade [--baseline <newly-available|widely-available>] [--check] [--write] <files-or-directories>
+npx -y esupgrade [--baseline <newly-available|widely-available>] [--check] [--write] <files-or-directories|->
 ```
 
 - Use `--check` to preview changes and fail when updates are needed.
-- Use `--write` to apply updates in place.
+- Use `-` to read from standard input and write the transformed code to standard output.
+- Use `--write` to apply updates in place for file inputs.
 - Use `--baseline` to choose `newly-available` or `widely-available` (default).

package/bin/esupgrade.js

@@ -10,6 +10,7 @@ import path from "path"
 import { fileURLToPath } from "url"
 import { Worker } from "worker_threads"
 import pkg from "../package.json" with { type: "json" }
+import { transform } from "../src/index.js"
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -179,6 +180,62 @@ class WorkerPool {
   }
 }
 
+/**
+ * Processes stdin and handles output.
+ */
+class StdinProcessor {
+  /**
+   * Process stdin using the configured transformation options.
+   * @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.
+   * @param {boolean} options.verbose - The verbosity level for logging.
+   * @returns {Promise<void>} Complete when stdin processing finishes.
+   */
+  async processStdin(options) {
+    if (options.write) {
+      console.error("Error: '--write' cannot be used with stdin")
+      process.exit(1)
+    }
+
+    try {
+      const code = await this.#readStdin()
+      const result = transform(code, options.baseline)
+
+      if (options.check) {
+        if (result.modified) {
+          process.exit(1)
+        }
+        return
+      }
+
+      process.stdout.write(result.code)
+    } catch (error) {
+      if (options.verbose) console.error(error)
+      console.error(`\x1b[31m✗\x1b[0m Error: stdin: ${error.message}`)
+      process.exit(128)
+    }
+  }
+
+  /**
+   * Read source code from stdin.
+   * @returns {Promise<string>} Source code from stdin.
+   */
+  async #readStdin() {
+    process.stdin.setEncoding("utf8")
+    let code = ""
+
+    function handleChunk(chunk) {
+      code += chunk
+    }
+
+    process.stdin.on("data", handleChunk)
+    await once(process.stdin, "end")
+    return code
+  }
+}
+
 /**
  * Orchestrates the CLI application.
  */
@@ -187,6 +244,7 @@ class CLIRunner {
     const workerRunner = new WorkerRunner(workerPath)
     const fileProcessor = new FileProcessor(workerRunner)
     this.workerPool = new WorkerPool(fileProcessor)
+    this.stdinProcessor = new StdinProcessor()
   }
 
   /**
@@ -195,6 +253,17 @@ class CLIRunner {
    * @param {Object} options - Processing options.
    */
   async run(patterns, options) {
+    switch (this.#getInputMode(patterns)) {
+      case "stdin":
+        await this.stdinProcessor.processStdin(options)
+        return
+      case "mixed":
+        console.error("Error: '-' cannot be combined with file paths")
+        return process.exit(1)
+      default:
+        break
+    }
+
     console.time("Processing")
     // Hand CLI-provided names directly to the worker pool; file validation occurs in processFile.
     const results = await this.workerPool.processFiles(patterns, options)
@@ -203,6 +272,24 @@ class CLIRunner {
     this.#reportSummary(results, options)
   }
 
+  /**
+   * Classify the input mode selected by CLI arguments.
+   * @param {string[]} patterns - File paths to process.
+   * @returns {"files" | "stdin" | "mixed"} Selected input mode.
+   */
+  #getInputMode(patterns) {
+    const stdinCount = patterns.filter((pattern) => pattern === "-").length
+
+    switch (stdinCount) {
+      case 0:
+        return "files"
+      case 1:
+        return patterns.length === 1 ? "stdin" : "mixed"
+      default:
+        return "mixed"
+    }
+  }
+
   #reportSummary(results, options) {
     let modifiedCount = 0
     const errorCount = results.filter((result) => {
@@ -257,7 +344,7 @@ program
   .name("esupgrade")
   .description("Auto-upgrade your JavaScript syntax")
   .version(pkg.version)
-  .argument("<files...>", "Files or directories to process")
+  .argument("<files...>", "Files or directories to process, or '-' to read from stdin")
   .addOption(
     new Option("--baseline <level>", "Set baseline level for transformations")
       .choices(["widely-available", "newly-available"])

package/package.json

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

package/tests/cli.test.js

@@ -106,6 +106,118 @@ describe("CLI", () => {
     assert.equal(result.status, 0, "exits successfully")
   })
 
+  test("transform stdin and write code to stdout", () => {
+    fs.writeFileSync(path.join(tempDir, "-"), "const fromFile = true;")
+
+    const result = spawnSync(process.execPath, [CLI_PATH, "-"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+      cwd: tempDir,
+    })
+
+    assert.match(result.stdout, /const x = 1;/, "writes transformed code to stdout")
+    assert.doesNotMatch(
+      result.stdout,
+      /would be upgraded|All files are up to date|Processing:/,
+      "omits file-processing summary output",
+    )
+    assert.equal(result.status, 0, "exits successfully")
+  })
+
+  test("transform stdin with newly-available baseline", () => {
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, "-", "--baseline", "newly-available"],
+      {
+        encoding: "utf8",
+        input: "const p = new Promise((resolve) => resolve(getData()));",
+      },
+    )
+
+    assert.match(
+      result.stdout,
+      /Promise\.try/,
+      "writes transformations from the selected baseline",
+    )
+    assert.equal(result.status, 0, "exits successfully")
+  })
+
+  test("exit with 1 when --check finds stdin changes", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--check"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+    })
+
+    assert.equal(result.stdout, "", "omits transformed output in check mode")
+    assert.equal(result.status, 1, "exits with 1 when stdin needs upgrading")
+  })
+
+  test("exit with 0 when --check finds no stdin changes", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--check"], {
+      encoding: "utf8",
+      input: "const x = 1;",
+    })
+
+    assert.equal(result.stdout, "", "omits transformed output in check mode")
+    assert.equal(result.status, 0, "exits with 0 when stdin is up to date")
+  })
+
+  test("error when combining stdin with --write", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--write"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+    })
+
+    assert.match(
+      result.stderr,
+      /cannot be used with stdin/,
+      "displays stdin write error",
+    )
+    assert.equal(result.status, 1, "exits with 1")
+  })
+
+  test("error when stdin marker appears multiple times", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "-"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+    })
+
+    assert.match(
+      result.stderr,
+      /cannot be combined with file paths/,
+      "displays input error",
+    )
+    assert.equal(result.status, 1, "exits with 1")
+  })
+
+  test("error when combining stdin with file arguments", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, "var x = 1;")
+
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", testFile], {
+      encoding: "utf8",
+      input: "var y = 2;",
+    })
+
+    assert.match(
+      result.stderr,
+      /cannot be combined with file paths/,
+      "displays input error",
+    )
+    assert.equal(result.status, 1, "exits with 1")
+  })
+
+  test("show stdin parse error with --verbose", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--verbose"], {
+      encoding: "utf8",
+      input: "var x = {{{;",
+    })
+
+    assert.match(result.stderr, /Error:/, "displays error message")
+    assert.match(result.stderr, /\n\s*at /, "includes stack trace at verbosity level 1")
+    assert.equal(result.status, 128, "exits with 128 on stdin errors")
+  })
+
   test("check files without writing with --check", () => {
     const testFile = path.join(tempDir, "test.js")
     const originalCode = `var x = 1;`