@ccpluginizer/ccpluginizer 0.2.2 → 0.4.0

package/README.md

@@ -2,39 +2,46 @@
 
 > CLI for pluginizing non-plugin Claude Code repos.
 
-Generate, validate, and submit [ccpluginizer marketplace](https://github.com/lifebugz/ccpluginizer) entries from any GitHub repo containing Claude Code-compatible content (skills, agents, commands, hooks, MCP servers).
+Generate and validate [ccpluginizer marketplace](https://github.com/lifebugz/ccpluginizer) entries from any GitHub repo with Claude Code-compatible content (skills, agents, commands, hooks, MCP servers).
 
 ## Install
 
+Works with either runtime. Pick whichever you have.
+
+With Bun:
+
 ```bash
 bun add -g @ccpluginizer/ccpluginizer
+# or one-shot:
+bunx @ccpluginizer/ccpluginizer scan <owner/repo>
 ```
 
-Or run one-shot without installing:
+With npm or Node:
 
 ```bash
-bunx @ccpluginizer/ccpluginizer scan <owner/repo>
+npm install -g @ccpluginizer/ccpluginizer
+# or one-shot:
+npx @ccpluginizer/ccpluginizer scan <owner/repo>
 ```
 
+At runtime the CLI prefers Bun when it's around (it starts faster), and falls back to Node otherwise. You don't need to configure anything.
+
 ## Usage
 
 ```bash
 ccpluginizer scan <owner/repo>     # Generate a marketplace entry
-ccpluginizer submit <owner/repo>   # Open a PR to add the repo to the catalog
 ccpluginizer validate <entry.json> # Validate an entry against the schema
 ```
 
+To add a repo to the catalog, run `scan`, commit the JSON to `entries/<name>.json` in the catalog repo, and open a PR. See the catalog's [CONTRIBUTING.md](https://github.com/lifebugz/ccpluginizer/blob/main/CONTRIBUTING.md).
+
 `<owner/repo>` accepts either GitHub shorthand (`elysiajs/skills`) or a full URL (`https://github.com/elysiajs/skills`).
 
 ## How it works
 
-ccpluginizer detects skills, agents, commands, hooks, and MCP servers in the source repo, then synthesizes a marketplace entry that uses Claude Code's `strict: false` mode to point at the source. Source code is never copied or redistributed.
-
-Three detection layers:
+ccpluginizer detects skills, agents, commands, hooks, and MCP servers in the source repo, then synthesizes a marketplace entry that uses Claude Code's `strict: false` mode to point at the source. The catalog never holds a copy of the source itself.
 
-1. **Convention paths** — `.claude/skills/`, `.claude/agents/`, `.claude/commands/`, etc.
-2. **Manifest metadata** — `.claude-plugin/manifest.json` or `.ccpluginizer.json` marker file.
-3. **Heuristic fallback** — looks for `SKILL.md` files with YAML frontmatter, `commands/*.md`, etc.
+Detection runs in three passes. The first looks at convention paths like `.claude/skills/`, `.claude/agents/`, and `.claude/commands/`. The second reads `.claude-plugin/manifest.json` or a `.ccpluginizer.json` marker file if the repo has one. The third is a heuristic fallback for repos that follow neither convention. It scans for `SKILL.md` files with YAML frontmatter, `commands/*.md`, and similar patterns.
 
 ## Repository
 

package/bin/ccpluginizer

@@ -8,4 +8,10 @@ while [ -L "$script" ]; do
     *)  script="$(dirname "$script")/$link" ;;
   esac
 done
-exec bun "$(cd "$(dirname "$script")" && pwd)/../dist/index.js" "$@"
+dist="$(cd "$(dirname "$script")" && pwd)/../dist/index.js"
+# Prefer bun when available (bunx users); fall back to node (npx/npm users).
+# The dist bundle is built with --target node so both runtimes work.
+if command -v bun >/dev/null 2>&1; then
+  exec bun "$dist" "$@"
+fi
+exec node "$dist" "$@"

package/dist/index.js

@@ -589,13 +589,324 @@ class R {
   }
 }
 
+// ../../node_modules/.bun/@crustjs+core@0.0.16+7524df1edfed9f02/node_modules/@crustjs/core/dist/index.js
+init_chunk_vt64gs69();
+function T2(j) {
+  return { meta: { name: j }, localFlags: {}, effectiveFlags: {}, args: undefined, subCommands: {}, plugins: [], preRun: undefined, run: undefined, postRun: undefined };
+}
+function z2(j, q2) {
+  let J = {};
+  for (let [Q, $] of Object.entries(j))
+    if ($.inherit === true)
+      J[Q] = $;
+  for (let [Q, $] of Object.entries(q2))
+    J[Q] = $;
+  return J;
+}
+function D2(j, q2) {
+  let J = [j.meta.name], Q = j, $ = q2;
+  while ($.length > 0) {
+    let K = Q.subCommands;
+    if (!K || Object.keys(K).length === 0)
+      break;
+    let Z = $[0];
+    if (!Z || Z.startsWith("-"))
+      break;
+    if (Z in K && K[Z]) {
+      Q = K[Z], J.push(Z), $ = $.slice(1);
+      continue;
+    }
+    if (Q.run)
+      break;
+    let H = Object.keys(K);
+    throw new W("COMMAND_NOT_FOUND", `Unknown command "${Z}".`, { input: Z, available: H, commandPath: [...J], parentCommand: Q });
+  }
+  return { command: Q, argv: $, commandPath: J };
+}
+function N2(j) {
+  for (let [q2, J] of Object.entries(j)) {
+    if (q2.startsWith("no-")) {
+      let Q = q2.slice(3);
+      throw new W("DEFINITION", `Flag "--${q2}" must not use "no-" prefix; define "${Q}" and negate with "--no-${Q}"`);
+    }
+    if (J.short?.startsWith("no-"))
+      throw new W("DEFINITION", `Short alias "-${J.short}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
+    if (J.aliases) {
+      for (let Q of J.aliases)
+        if (Q.startsWith("no-"))
+          throw new W("DEFINITION", `Alias "--${Q}" on "--${q2}" must not use "no-" prefix (reserved for negation)`);
+    }
+  }
+}
+var w2 = "CRUST_INTERNAL_VALIDATE_ONLY";
+var P3 = 130;
+var v2 = "__CRUST_VALIDATE_RESULT__";
+function x2() {
+  let j = new Map;
+  return { get(q2) {
+    return j.get(q2);
+  }, has(q2) {
+    return j.has(q2);
+  }, set(q2, J) {
+    j.set(q2, J);
+  }, delete(q2) {
+    return j.delete(q2);
+  } };
+}
+function B2(j) {
+  if (!(j instanceof Error))
+    return false;
+  return j.name === "CancelledError";
+}
+function b3(j, q2) {
+  j.effectiveFlags = z2(q2, j.localFlags);
+  for (let J of Object.values(j.subCommands))
+    b3(J, j.effectiveFlags);
+}
+function y2(j) {
+  return { addFlag(q2, J, Q) {
+    if (J in q2.effectiveFlags)
+      j?.push(`Plugin flag "--${J}" on "${q2.meta.name}" overrides existing flag`);
+    q2.effectiveFlags[J] = Q;
+  }, addSubCommand(q2, J, Q) {
+    if (!J.trim())
+      throw new W("DEFINITION", "addSubCommand: name must be a non-empty string");
+    if (q2.subCommands[J]) {
+      j?.push(`Plugin subcommand "${J}" on "${q2.meta.name}" skipped (already exists)`);
+      return;
+    }
+    b3(Q, q2.effectiveFlags), q2.subCommands[J] = Q;
+  } };
+}
+async function A3(j, q2, J) {
+  for (let Q of j) {
+    if (!Q.setup)
+      continue;
+    await Q.setup(q2, J);
+  }
+}
+async function F2(j, q2, J) {
+  let Q = j.map((Z) => Z.middleware).filter((Z) => Boolean(Z)), $ = -1, K = async (Z) => {
+    if (Z <= $)
+      throw new W("DEFINITION", "Plugin middleware called next() multiple times");
+    if ($ = Z, Z === Q.length) {
+      await J();
+      return;
+    }
+    let H = Q[Z];
+    if (!H)
+      throw new W("DEFINITION", "Plugin middleware stack is invalid");
+    await H(q2, () => K(Z + 1));
+  };
+  await K(0);
+}
+function I3(j) {
+  let q2 = [...j.plugins];
+  for (let J of Object.values(j.subCommands))
+    q2.push(...I3(J));
+  return q2;
+}
+function k2(j) {
+  let q2 = {};
+  for (let [J, Q] of Object.entries(j))
+    q2[J] = { ...Q, aliases: Q.aliases ? [...Q.aliases] : undefined };
+  return q2;
+}
+function h3(j) {
+  let q2 = {};
+  for (let [J, Q] of Object.entries(j.subCommands))
+    q2[J] = h3(Q);
+  return { meta: { ...j.meta }, localFlags: k2(j.localFlags), effectiveFlags: k2(j.effectiveFlags), args: j.args ? j.args.map((J) => ({ ...J })) : undefined, subCommands: q2, plugins: [...j.plugins], preRun: j.preRun, run: j.run, postRun: j.postRun };
+}
+function _4(j) {
+  if (Object.freeze(j), Object.freeze(j.localFlags), Object.freeze(j.effectiveFlags), Object.freeze(j.meta), Object.freeze(j.plugins), j.args)
+    Object.freeze(j.args);
+  for (let q2 of Object.values(j.subCommands))
+    _4(q2);
+  Object.freeze(j.subCommands);
+}
+
+class R2 {
+  _node;
+  _inheritedFlags;
+  constructor(j) {
+    if (!j.trim())
+      throw new W("DEFINITION", "meta.name must be a non-empty string");
+    this._node = T2(j), this._inheritedFlags = {};
+  }
+  static _createChild(j, q2) {
+    let J = new R2(j);
+    return J._inheritedFlags = q2, J;
+  }
+  _clone(j) {
+    let q2 = Object.create(Object.getPrototypeOf(this)), J = { ...this._node, localFlags: { ...this._node.localFlags }, effectiveFlags: { ...this._node.effectiveFlags }, subCommands: { ...this._node.subCommands }, plugins: [...this._node.plugins], meta: { ...this._node.meta }, args: this._node.args ? [...this._node.args] : undefined, ...j };
+    return q2._node = J, q2._inheritedFlags = this._inheritedFlags, q2;
+  }
+  meta(j) {
+    return this._clone({ meta: { ...this._node.meta, ...j } });
+  }
+  flags(j) {
+    N2(j);
+    let q2 = {};
+    for (let [J, Q] of Object.entries(j))
+      q2[J] = { ...Q };
+    return this._clone({ localFlags: q2, effectiveFlags: z2(this._inheritedFlags, q2) });
+  }
+  args(j) {
+    let q2 = j.map((J) => ({ ...J }));
+    return this._clone({ args: q2 });
+  }
+  run(j) {
+    return this._clone({ run: j });
+  }
+  preRun(j) {
+    return this._clone({ preRun: j });
+  }
+  postRun(j) {
+    return this._clone({ postRun: j });
+  }
+  use(j) {
+    return this._clone({ plugins: [...this._node.plugins, j] });
+  }
+  sub(j) {
+    if (!j.trim())
+      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+    let q2 = z2(this._inheritedFlags, this._node.localFlags);
+    return R2._createChild(j, q2);
+  }
+  command(j, q2) {
+    if (typeof j === "string") {
+      let K = j;
+      if (!q2)
+        throw new W("DEFINITION", "command(name, cb) requires a callback");
+      if (!K.trim())
+        throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+      if (this._node.subCommands[K])
+        throw new W("DEFINITION", `Subcommand "${K}" is already registered`);
+      let Z = z2(this._inheritedFlags, this._node.localFlags), H = R2._createChild(K, Z), X2 = q2(H), W2 = { ...X2._node, effectiveFlags: z2(X2._inheritedFlags, X2._node.localFlags) };
+      return this._clone({ subCommands: { ...this._node.subCommands, [K]: W2 } });
+    }
+    let J = j, Q = J._node.meta.name;
+    if (!Q.trim())
+      throw new W("DEFINITION", "Subcommand name must be a non-empty string");
+    if (this._node.subCommands[Q])
+      throw new W("DEFINITION", `Subcommand "${Q}" is already registered`);
+    let $ = { ...J._node, effectiveFlags: z2(J._inheritedFlags, J._node.localFlags) };
+    return this._clone({ subCommands: { ...this._node.subCommands, [Q]: $ } });
+  }
+  async prepareCommandTree(j) {
+    let q2 = j?.argv ?? [], J = h3(this._node), Q = I3(J), $ = [], K = x2(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y2($);
+    try {
+      await A3(Q, Z, H);
+    } catch (W2) {
+      if (B2(W2))
+        throw W2;
+      if (W2 instanceof W)
+        throw W2;
+      if (W2 instanceof Error)
+        throw W2;
+      throw new W("DEFINITION", String(W2));
+    }
+    _4(J);
+    let { validateCommandTree: X2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
+    return X2(J), { root: J, warnings: $ };
+  }
+  async execute(j) {
+    let q2 = j?.argv ?? process.argv.slice(2), J = this._node, Q = I3(J), $ = [], K = x2(), Z = { argv: [...q2], rootCommand: J, state: K }, H = y2($);
+    try {
+      await A3(Q, Z, H);
+    } catch (W2) {
+      if (B2(W2)) {
+        process.exitCode = P3;
+        return;
+      }
+      if (W2 instanceof W) {
+        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+        return;
+      }
+      let U2 = W2 instanceof Error ? W2.message : String(W2);
+      console.error(`Error: ${U2}`), process.exitCode = 1;
+      return;
+    }
+    if (_4(J), process.env[w2] === "1") {
+      let W2 = (async () => {
+        try {
+          let { validateCommandTree: U2 } = await Promise.resolve().then(() => (init_chunk_5apf3vnv(), exports_chunk_5apf3vnv));
+          U2(J);
+          for (let Y of $)
+            console.warn(`Warning: ${Y}`);
+          return { ok: true };
+        } catch (U2) {
+          let Y = U2 instanceof Error ? U2.message : String(U2);
+          return console.error(Y), process.exitCode = 1, { ok: false, error: U2 };
+        }
+      })();
+      return globalThis[v2] = W2, await W2, process.exit(process.exitCode ?? 0);
+    }
+    for (let W2 of $)
+      console.warn(`Warning: ${W2}`);
+    let X2 = { argv: [...q2], rootCommand: J, state: K, route: null, input: null };
+    try {
+      let W2, U2;
+      try {
+        let Y = D2(J, [...q2]);
+        X2.route = Y, W2 = Y.command, U2 = b(W2, Y.argv), X2.input = U2;
+      } catch (Y) {
+        await F2(Q, X2, async () => {
+          throw Y;
+        });
+        return;
+      }
+      await F2(Q, X2, async () => {
+        if (E(W2, U2), !W2.run)
+          return;
+        let Y = { args: U2.args, flags: U2.flags, rawArgs: U2.rawArgs, command: W2 }, V;
+        try {
+          if (W2.preRun)
+            await W2.preRun(Y);
+          await W2.run(Y);
+        } catch (M3) {
+          V = M3;
+        }
+        if (W2.postRun)
+          try {
+            await W2.postRun(Y);
+          } catch (M3) {
+            if (!V)
+              V = M3;
+            else
+              console.error(`Error in postRun: ${M3 instanceof Error ? M3.message : String(M3)}`);
+          }
+        if (V)
+          throw V;
+      });
+    } catch (W2) {
+      if (B2(W2)) {
+        process.exitCode = P3;
+        return;
+      }
+      if (W2 instanceof W) {
+        console.error(`Error: ${W2.message}`), process.exitCode = 1;
+        return;
+      }
+      if (W2 instanceof Error) {
+        let U2 = new W("EXECUTION", W2.message).withCause(W2);
+        console.error(`Error: ${U2.message}`), process.exitCode = 1;
+        return;
+      }
+      console.error(`Error: ${String(W2)}`), process.exitCode = 1;
+    }
+  }
+}
+
 // src/commands/scan.ts
-import { writeFileSync } from "fs";
+import { writeFileSync } from "node:fs";
 
 // src/sources/github.ts
-import { mkdtempSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 // src/errors.ts
 class CcpluginizerError extends Error {
@@ -639,19 +950,17 @@ class SourceCloneError extends CcpluginizerError {
 }
 
 // src/sources/github.ts
-async function resolveGithub(repo) {
+function resolveGithub(repo) {
   const dest = mkdtempSync(join(tmpdir(), `ccp-${repo.replace("/", "-")}-`));
   const url = `https://github.com/${repo}.git`;
-  const proc = Bun.spawn(["git", "clone", "--depth=1", url, dest], {
-    stdout: "pipe",
-    stderr: "pipe"
+  const result = spawnSync("git", ["clone", "--depth=1", url, dest], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8"
   });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new SourceCloneError(repo, stderr);
+  if (result.status !== 0) {
+    throw new SourceCloneError(repo, result.stderr);
   }
-  return dest;
+  return Promise.resolve(dest);
 }
 
 // src/sources/index.ts
@@ -690,8 +999,8 @@ async function resolveSource(input) {
 }
 
 // src/detector/marketplaceGuard.ts
-import { existsSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync } from "node:fs";
+import { join as join2 } from "node:path";
 function checkMarketplaceGuard(repoRoot) {
   const marketplaceFile = join2(repoRoot, ".claude-plugin", "marketplace.json");
   if (existsSync(marketplaceFile)) {
@@ -700,8 +1009,8 @@ function checkMarketplaceGuard(repoRoot) {
 }
 
 // src/detector/markerFile.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join as join3 } from "node:path";
 
 // ../../node_modules/.bun/valibot@1.3.1+7524df1edfed9f02/node_modules/valibot/dist/index.mjs
 var store$4;
@@ -1413,8 +1722,8 @@ function detectMarkerFile(repoRoot) {
 }
 
 // src/detector/conventions.ts
-import { existsSync as existsSync3, readdirSync, statSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readdirSync, statSync } from "node:fs";
+import { join as join4 } from "node:path";
 var FOLDER_KINDS = [
   { folder: "skills", kind: "skills" },
   { folder: "agents", kind: "agents" },
@@ -1481,8 +1790,8 @@ function mergeByKind(findings) {
 }
 
 // src/detector/nonStandardManifest.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { join as join5 } from "node:path";
 
 // src/schemas/nonStandardManifest.ts
 var NonStandardManifestSchema = object({
@@ -1535,8 +1844,8 @@ function detectNonStandardManifest(repoRoot) {
 }
 
 // src/detector/contentSniff.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { join as join6, dirname, relative } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import { join as join6, dirname, relative } from "node:path";
 
 // src/schemas/frontmatter.ts
 var SkillFrontmatterSchema = object({
@@ -1654,8 +1963,8 @@ function coerceYamlValue(raw) {
 }
 
 // src/detector/normalize.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join7 } from "node:path";
 function normalizePath(input) {
   if (input.split("/").includes("..")) {
     throw new PathNormalizationError(input, "path traversal (..) not allowed");
@@ -1820,7 +2129,7 @@ function defaultEntryName(sourceRepo) {
 }
 
 // src/commands/scan.ts
-var scanCommand = new R("scan").meta({ description: "Scan a non-plugin repo and emit a marketplace entry" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo, URL, or local path" }]).flags({
+var scanCommand = new R2("scan").meta({ description: "Scan a non-plugin repo and emit a marketplace entry" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo, URL, or local path" }]).flags({
   output: { type: "string", short: "o", description: "Write entry JSON to file" }
 }).run(async ({ args, flags }) => {
   const repoPath = await resolveSource(args.repo);
@@ -1836,7 +2145,7 @@ var scanCommand = new R("scan").meta({ description: "Scan a non-plugin repo and
 });
 
 // src/commands/validate.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 
 // src/schemas/marketplaceEntry.ts
 var PathString = pipe(string(), startsWith("./"));
@@ -1882,7 +2191,7 @@ var MarketplaceEntrySchema = object({
 });
 
 // src/commands/validate.ts
-var validateCommand = new R("validate").meta({ description: "Validate a marketplace entry JSON file against the schema" }).args([{ name: "entryFile", type: "string", required: true, description: "Path to entry JSON file" }]).run(({ args }) => {
+var validateCommand = new R2("validate").meta({ description: "Validate a marketplace entry JSON file against the schema" }).args([{ name: "entryFile", type: "string", required: true, description: "Path to entry JSON file" }]).run(({ args }) => {
   const raw = readFileSync4(args.entryFile, "utf8");
   const parsed = JSON.parse(raw);
   const result = safeParse(MarketplaceEntrySchema, parsed);
@@ -1896,30 +2205,6 @@ var validateCommand = new R("validate").meta({ description: "Validate a marketpl
   console.log("OK");
 });
 
-// src/commands/submit.ts
-import { writeFileSync as writeFileSync2, mkdtempSync as mkdtempSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join8 } from "path";
-var submitCommand = new R("submit").meta({ description: "Generate an entry and open a PR against ccpluginizer/marketplace" }).args([{ name: "repo", type: "string", required: true, description: "owner/repo to pluginize" }]).flags({
-  dryRun: { type: "boolean", short: "n", description: "Print the PR plan without opening it" }
-}).run(async ({ args, flags }) => {
-  const repoPath = await resolveSource(args.repo);
-  const sourceRepo = inferSourceRepo(args.repo);
-  const entry = synthesizeEntry({ repoRoot: repoPath, sourceRepo });
-  const tmpFile = join8(mkdtempSync2(join8(tmpdir2(), "ccp-submit-")), `${entry.name}.json`);
-  writeFileSync2(tmpFile, JSON.stringify(entry, null, 2) + `
-`, "utf8");
-  if (flags.dryRun === true) {
-    console.log(`Would submit:
-  entry: ${tmpFile}
-  to:    ccpluginizer/marketplace`);
-    console.log(JSON.stringify(entry, null, 2));
-    return;
-  }
-  console.log(`Generated entry at ${tmpFile}`);
-  console.log("Run with --dryRun to preview, or follow the manual PR workflow in CONTRIBUTING.md.");
-});
-
 // src/index.ts
-var app = new R("ccpluginizer").meta({ description: "Pluginize non-plugin Claude Code repos" }).command(scanCommand).command(validateCommand).command(submitCommand);
+var app = new R("ccpluginizer").meta({ description: "Pluginize non-plugin Claude Code repos" }).command(scanCommand).command(validateCommand);
 await app.execute();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccpluginizer/ccpluginizer",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "CLI for pluginizing non-plugin Claude Code repos",
   "license": "MIT",
   "type": "module",
@@ -34,11 +34,12 @@
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --max-warnings 0",
     "test": "bun test",
-    "build": "bun build src/index.ts --outdir dist --target bun --format esm",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm",
     "dev": "bun run src/index.ts",
     "prepublishOnly": "bun run build"
   },
   "engines": {
+    "node": ">=20",
     "bun": ">=1.0.0"
   },
   "publishConfig": {