napi-zig 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,7 +1,544 @@
-// packages/cli/src/index.ts
-function greet(name) {
-  return `Hello, ${name}! Welcome to the cli package.`;
+#!/usr/bin/env node
+
+// src/index.ts
+import cac from "cac";
+// package.json
+var version = "0.1.1";
+
+// src/build.ts
+import { exec } from "node:child_process";
+import { copyFile as copyFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { promisify } from "node:util";
+import { Listr, PRESET_TIMER } from "listr2";
+
+// src/constants.ts
+var NAPI_OUT_DIR = "zig-out/napi";
+
+// src/npm.ts
+import { copyFile, mkdir, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+async function generatePackages(opts) {
+  await Promise.all([
+    ...opts.targets.map((t) => writePlatformPackage(opts, t)),
+    writeRootPackage(opts)
+  ]);
 }
-export {
-  greet
+function bindingName(opts, suffix) {
+  if (opts.scoped)
+    return `@${opts.packageName}/${suffix}`;
+  return `${opts.packageName}${opts.delimiter}${suffix}`;
+}
+function bindingDirName(opts, suffix) {
+  return `${opts.packageName}${opts.delimiter}${suffix}`;
+}
+async function writePlatformPackage(opts, target) {
+  const dir = join(opts.outputDir, bindingDirName(opts, target.npmSuffix));
+  const nodeFile = `${opts.addonName}.node`;
+  await mkdir(dir, { recursive: true });
+  const pkg = {
+    name: bindingName(opts, target.npmSuffix),
+    version: opts.version,
+    os: [target.platform],
+    cpu: [target.arch],
+    main: nodeFile,
+    files: [nodeFile]
+  };
+  if (target.libc) {
+    pkg.libc = [target.libc];
+  }
+  await Promise.all([
+    writeFile(join(dir, "package.json"), JSON.stringify(pkg, null, 2) + `
+`),
+    copyFile(`${NAPI_OUT_DIR}/${target.zigTarget}/${nodeFile}`, join(dir, nodeFile))
+  ]);
+}
+async function writeRootPackage(opts) {
+  const dir = join(opts.outputDir, opts.packageName);
+  await mkdir(dir, { recursive: true });
+  const optDeps = {};
+  for (const t of opts.targets) {
+    optDeps[bindingName(opts, t.npmSuffix)] = opts.version;
+  }
+  const pkg = {
+    name: opts.packageName,
+    version: opts.version,
+    main: "index.js",
+    types: "index.d.ts",
+    files: ["index.js", "index.d.ts"],
+    optionalDependencies: optDeps
+  };
+  const firstTarget = opts.targets[0];
+  if (!firstTarget)
+    throw new Error("No targets defined");
+  await Promise.all([
+    writeFile(join(dir, "package.json"), JSON.stringify(pkg, null, 2) + `
+`),
+    writeFile(join(dir, "index.js"), generateIndexJs(opts)),
+    copyFile(`${NAPI_OUT_DIR}/${firstTarget.zigTarget}/${opts.addonName}.d.ts`, join(dir, "index.d.ts"))
+  ]);
+}
+function generateIndexJs(opts) {
+  const platformMap = new Map;
+  for (const t of opts.targets) {
+    const key = `${t.platform}-${t.arch}`;
+    const arr = platformMap.get(key) ?? [];
+    arr.push(bindingName(opts, t.npmSuffix));
+    platformMap.set(key, arr);
+  }
+  const entries = Array.from(platformMap.entries()).map(([key, pkgs]) => `  "${key}": ${JSON.stringify(pkgs)}`).join(`,
+`);
+  return `/* Auto-generated by napi-zig */
+const { createRequire } = require("node:module");
+const localRequire = createRequire(__filename);
+
+const platforms = {
+${entries},
 };
+
+const key = \`\${process.platform}-\${process.arch}\`;
+const candidates = platforms[key];
+
+if (!candidates) {
+  throw new Error(\`Unsupported platform: \${key}\`);
+}
+
+let binding;
+for (const name of candidates) {
+  try {
+    binding = localRequire(name);
+    break;
+  } catch {}
+}
+
+if (!binding) {
+  throw new Error(
+    \`No native binding found for \${key}. Ensure the correct platform package is installed.\`,
+  );
+}
+
+module.exports = binding;
+`;
+}
+async function discoverAddons(zigTarget) {
+  const dir = `${NAPI_OUT_DIR}/${zigTarget}`;
+  const files = await readdir(dir);
+  const addons = files.filter((f) => f.endsWith(".node")).map((f) => f.replace(/\.node$/, ""));
+  if (addons.length === 0) {
+    throw new Error(`No .node artifacts found in ${dir}`);
+  }
+  return addons;
+}
+
+// src/target.ts
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+var TARGETS = [
+  { zigTarget: "x86_64-macos", platform: "darwin", arch: "x64", npmSuffix: "darwin-x64" },
+  { zigTarget: "aarch64-macos", platform: "darwin", arch: "arm64", npmSuffix: "darwin-arm64" },
+  {
+    zigTarget: "x86_64-linux-gnu",
+    platform: "linux",
+    arch: "x64",
+    abi: "gnu",
+    libc: "glibc",
+    npmSuffix: "linux-x64-gnu"
+  },
+  {
+    zigTarget: "x86_64-linux-musl",
+    platform: "linux",
+    arch: "x64",
+    abi: "musl",
+    libc: "musl",
+    npmSuffix: "linux-x64-musl"
+  },
+  {
+    zigTarget: "aarch64-linux-gnu",
+    platform: "linux",
+    arch: "arm64",
+    abi: "gnu",
+    libc: "glibc",
+    npmSuffix: "linux-arm64-gnu"
+  },
+  {
+    zigTarget: "aarch64-linux-musl",
+    platform: "linux",
+    arch: "arm64",
+    abi: "musl",
+    libc: "musl",
+    npmSuffix: "linux-arm64-musl"
+  },
+  { zigTarget: "x86_64-windows-gnu", platform: "win32", arch: "x64", npmSuffix: "win32-x64" },
+  { zigTarget: "aarch64-windows-gnu", platform: "win32", arch: "arm64", npmSuffix: "win32-arm64" }
+];
+function getHostTarget() {
+  const { platform, arch } = process;
+  const candidates = TARGETS.filter((t) => t.platform === platform && t.arch === arch);
+  if (candidates.length === 0) {
+    throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  const match = isMusl() ? candidates.find((t) => t.libc === "musl") : candidates.find((t) => t.libc === "glibc");
+  if (!match) {
+    throw new Error(`No matching target for ${platform}-${arch}`);
+  }
+  return match;
+}
+function isMusl() {
+  try {
+    return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+  } catch {}
+  try {
+    const report = process.report?.getReport();
+    if (report) {
+      const header = report.header;
+      if (header?.glibcVersionRuntime)
+        return false;
+      const sharedObjects = report.sharedObjects;
+      if (sharedObjects?.some((s) => s.includes("libc.musl-") || s.includes("ld-musl-"))) {
+        return true;
+      }
+    }
+  } catch {}
+  try {
+    return execSync("ldd --version 2>&1", { encoding: "utf-8" }).includes("musl");
+  } catch {}
+  return false;
+}
+
+// src/build.ts
+var execAsync = promisify(exec);
+var TIMER = { timer: PRESET_TIMER };
+async function build(options) {
+  await rm(NAPI_OUT_DIR, { recursive: true, force: true });
+  if (options.release) {
+    await releaseBuild(options);
+  } else {
+    await devBuild();
+  }
+}
+async function devBuild() {
+  const target = getHostTarget();
+  let addons = [];
+  const tasks = new Listr([
+    {
+      title: `Compiling for ${target.zigTarget}`,
+      task: async () => {
+        await execAsync(zigBuildCmd(target.zigTarget));
+      }
+    },
+    {
+      title: "Writing entry files",
+      task: async (_, task) => {
+        addons = await discoverAddons(target.zigTarget);
+        const targetDir = `${NAPI_OUT_DIR}/${target.zigTarget}`;
+        for (const addon of addons) {
+          const suffix = addons.length > 1 ? `.${addon}` : "";
+          await Promise.all([
+            writeFile2(`index${suffix}.js`, `module.exports = require("./${targetDir}/${addon}.node");
+`),
+            copyFile2(`${targetDir}/${addon}.d.ts`, `index${suffix}.d.ts`)
+          ]);
+        }
+        task.title = `Wrote ${addons.map((a) => `${a}.js`).join(", ")}`;
+      }
+    }
+  ], { rendererOptions: TIMER });
+  await tasks.run();
+}
+async function releaseBuild(options) {
+  let addons = [];
+  const tasks = new Listr([
+    {
+      title: `Cross-compiling ${TARGETS.length} targets (ReleaseFast)`,
+      task: (_, parent) => parent.newListr(TARGETS.map((t) => ({
+        title: t.zigTarget,
+        task: async () => {
+          await execAsync(zigBuildCmd(t.zigTarget, "ReleaseFast"));
+        }
+      })), { concurrent: true, rendererOptions: TIMER })
+    },
+    {
+      title: "Generating npm packages",
+      task: async (_, task) => {
+        const firstTarget = TARGETS[0];
+        if (!firstTarget)
+          throw new Error("No targets defined");
+        addons = await discoverAddons(firstTarget.zigTarget);
+        await rm(options.outputDir, { recursive: true, force: true });
+        for (const addon of addons) {
+          const opts = {
+            outputDir: options.outputDir,
+            packageName: addon,
+            addonName: addon,
+            version: "0.0.0",
+            scoped: options.scoped,
+            delimiter: options.delimiter,
+            targets: TARGETS
+          };
+          await generatePackages(opts);
+        }
+        const names = addons.join(", ");
+        task.title = `Generated ${names} in ${options.outputDir}/`;
+      }
+    }
+  ], { rendererOptions: TIMER });
+  await tasks.run();
+}
+function zigBuildCmd(zigTarget, optimize) {
+  const args = [`zig build -Dtarget=${zigTarget}`];
+  if (optimize)
+    args.push(`-Doptimize=${optimize}`);
+  return args.join(" ");
+}
+
+// src/version.ts
+import { exec as exec2 } from "node:child_process";
+import { readFile, readdir as readdir2, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { promisify as promisify2, styleText } from "node:util";
+import prompts from "prompts";
+var execAsync2 = promisify2(exec2);
+function parse(version2) {
+  const [main, ...preParts] = version2.split("-");
+  const prerelease = preParts.length > 0 ? preParts.join("-") : undefined;
+  const parts = main.split(".").map(Number);
+  return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+}
+function format(v) {
+  const base = `${v.major}.${v.minor}.${v.patch}`;
+  return v.prerelease ? `${base}-${v.prerelease}` : base;
+}
+function incMajor(v) {
+  return format({ major: v.major + 1, minor: 0, patch: 0 });
+}
+function incMinor(v) {
+  return format({ major: v.major, minor: v.minor + 1, patch: 0 });
+}
+function incPatch(v) {
+  if (v.prerelease) {
+    return format({ major: v.major, minor: v.minor, patch: v.patch });
+  }
+  return format({ major: v.major, minor: v.minor, patch: v.patch + 1 });
+}
+function incNext(v) {
+  if (v.prerelease) {
+    const match = v.prerelease.match(/^(.+?)\.(\d+)$/);
+    if (match) {
+      return format({ ...v, prerelease: `${match[1]}.${Number(match[2]) + 1}` });
+    }
+    return format({ major: v.major, minor: v.minor, patch: v.patch });
+  }
+  return incPatch(v);
+}
+function incPrePatch(v, preid) {
+  const patch = v.prerelease ? v.patch : v.patch + 1;
+  return format({ major: v.major, minor: v.minor, patch, prerelease: `${preid}.1` });
+}
+function incPreMinor(v, preid) {
+  const minor = v.prerelease ? v.minor : v.minor + 1;
+  return format({ major: v.major, minor, patch: 0, prerelease: `${preid}.1` });
+}
+function incPreMajor(v, preid) {
+  const major = v.prerelease ? v.major : v.major + 1;
+  return format({ major, minor: 0, patch: 0, prerelease: `${preid}.1` });
+}
+async function getConventionalBump(v) {
+  try {
+    const { stdout } = await execAsync2("git log --format=%s --no-merges -20");
+    const commits = stdout.trim().split(`
+`);
+    let bump = "patch";
+    for (const msg of commits) {
+      if (msg.includes("BREAKING CHANGE") || /^[a-z]+(\(.+\))?!:/.test(msg)) {
+        bump = "major";
+        break;
+      }
+      if (/^feat(\(.+\))?:/.test(msg)) {
+        bump = "minor";
+      }
+    }
+    switch (bump) {
+      case "major":
+        return incMajor(v);
+      case "minor":
+        return incMinor(v);
+      case "patch":
+        return incPatch(v);
+    }
+  } catch {
+    return incPatch(v);
+  }
+}
+async function discoverPackages(outputDir) {
+  const packages = [];
+  let dirNames;
+  try {
+    dirNames = await readdir2(outputDir);
+  } catch {
+    return packages;
+  }
+  for (const name of dirNames) {
+    const pkgPath = join2(outputDir, name, "package.json");
+    try {
+      const raw = await readFile(pkgPath, "utf-8");
+      packages.push({ path: pkgPath, data: JSON.parse(raw) });
+    } catch {
+      let subNames;
+      try {
+        subNames = await readdir2(join2(outputDir, name));
+      } catch {
+        continue;
+      }
+      for (const sub of subNames) {
+        const subPkgPath = join2(outputDir, name, sub, "package.json");
+        try {
+          const raw = await readFile(subPkgPath, "utf-8");
+          packages.push({ path: subPkgPath, data: JSON.parse(raw) });
+        } catch {}
+      }
+    }
+  }
+  return packages;
+}
+function isRootPackage(pkg) {
+  return pkg.data.optionalDependencies != null;
+}
+function getPackageGroup(root, allPackages) {
+  const deps = root.data.optionalDependencies;
+  if (!deps)
+    return [root];
+  const depNames = new Set(Object.keys(deps));
+  return allPackages.filter((pkg) => pkg === root || depNames.has(pkg.data.name));
+}
+async function version2(options) {
+  const allPackages = await discoverPackages(options.outputDir);
+  if (allPackages.length === 0) {
+    console.error(`No packages found in ${options.outputDir}/. Run "napi build --release" first.`);
+    process.exit(1);
+  }
+  let roots = allPackages.filter(isRootPackage);
+  if (options.name) {
+    roots = roots.filter((pkg) => pkg.data.name === options.name);
+    if (roots.length === 0) {
+      console.error(`No package named "${options.name}" found.`);
+      process.exit(1);
+    }
+  }
+  if (roots.length === 0) {
+    console.error("No root package found.");
+    process.exit(1);
+  }
+  const packagesToUpdate = [];
+  const seen = new Set;
+  for (const root of roots) {
+    for (const pkg of getPackageGroup(root, allPackages)) {
+      if (!seen.has(pkg.path)) {
+        seen.add(pkg.path);
+        packagesToUpdate.push(pkg);
+      }
+    }
+  }
+  const currentVersion = roots[0].data.version || "0.0.0";
+  const v = parse(currentVersion);
+  const preid = v.prerelease?.match(/^([a-zA-Z]+)/)?.[1] ?? "beta";
+  const conventionalVersion = await getConventionalBump(v);
+  const next = {
+    major: incMajor(v),
+    minor: incMinor(v),
+    patch: incPatch(v),
+    next: incNext(v),
+    conventional: conventionalVersion,
+    prepatch: incPrePatch(v, preid),
+    preminor: incPreMinor(v, preid),
+    premajor: incPreMajor(v, preid)
+  };
+  const PADDING = 13;
+  const answers = await prompts([
+    {
+      type: "autocomplete",
+      name: "release",
+      message: `Current version ${styleText("green", currentVersion)}`,
+      initial: "next",
+      choices: [
+        {
+          value: "major",
+          title: `${"major".padStart(PADDING, " ")} ${styleText("bold", next.major)}`
+        },
+        {
+          value: "minor",
+          title: `${"minor".padStart(PADDING, " ")} ${styleText("bold", next.minor)}`
+        },
+        {
+          value: "patch",
+          title: `${"patch".padStart(PADDING, " ")} ${styleText("bold", next.patch)}`
+        },
+        {
+          value: "next",
+          title: `${"next".padStart(PADDING, " ")} ${styleText("bold", next.next)}`
+        },
+        {
+          value: "conventional",
+          title: `${"conventional".padStart(PADDING, " ")} ${styleText("bold", next.conventional)}`
+        },
+        {
+          value: "prepatch",
+          title: `${"pre-patch".padStart(PADDING, " ")} ${styleText("bold", next.prepatch)}`
+        },
+        {
+          value: "preminor",
+          title: `${"pre-minor".padStart(PADDING, " ")} ${styleText("bold", next.preminor)}`
+        },
+        {
+          value: "premajor",
+          title: `${"pre-major".padStart(PADDING, " ")} ${styleText("bold", next.premajor)}`
+        },
+        {
+          value: "none",
+          title: `${"as-is".padStart(PADDING, " ")} ${styleText("bold", currentVersion)}`
+        },
+        { value: "custom", title: "custom ...".padStart(PADDING + 4, " ") }
+      ]
+    },
+    {
+      type: (prev) => prev === "custom" ? "text" : null,
+      name: "custom",
+      message: "Enter the new version number:",
+      initial: currentVersion,
+      validate: (value) => /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/.test(value) || "Invalid semver version"
+    }
+  ]);
+  if (!answers.release)
+    process.exit(1);
+  const newVersion = answers.release === "none" ? currentVersion : answers.release === "custom" ? answers.custom : next[answers.release];
+  if (!newVersion)
+    process.exit(1);
+  for (const pkg of packagesToUpdate) {
+    pkg.data.version = newVersion;
+    if (pkg.data.optionalDependencies) {
+      const deps = pkg.data.optionalDependencies;
+      for (const key of Object.keys(deps)) {
+        deps[key] = newVersion;
+      }
+    }
+    await writeFile3(pkg.path, JSON.stringify(pkg.data, null, 2) + `
+`);
+  }
+  console.log(`
+${styleText("green", "✔")} Updated ${packagesToUpdate.length} packages to ${styleText("bold", newVersion)}`);
+}
+
+// src/index.ts
+var cli = cac("napi");
+cli.command("build", "Compile Zig native addon and generate npm packages").option("-r, --release", "Cross-compile all targets and generate npm package tree").option("-o, --output-dir <dir>", "Directory for generated npm packages (release only)", {
+  default: "npm"
+}).option("-s, --scoped", "Scope binding packages: @name/suffix instead of name-suffix").option("-d, --delimiter <char>", "Separator between package name and target suffix", {
+  default: "-"
+}).action(build);
+cli.command("version", "Interactively bump version for all generated npm packages").option("-o, --output-dir <dir>", "Directory containing generated npm packages", {
+  default: "npm"
+}).option("-n, --name <name>", "Only update packages for a specific project name").action(version2);
+cli.help();
+cli.version(version);
+cli.parse();

package/package.json

@@ -1,37 +1,47 @@
 {
-	"name": "napi-zig",
-	"version": "0.1.0",
-	"description": "CLI for napi-zig, publish Zig libraries to npm in minutes.",
-	"homepage": "https://github.com/yuku-toolchain/napi-zig/tree/main/packages/cli#readme",
-	"license": "MIT",
-	"files": [
-		"dist"
-	],
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/yuku-toolchain/napi-zig.git"
-	},
-	"scripts": {
-		"type-check": "tsc --noEmit"
-	},
-	"peerDependencies": {
-		"typescript": ">=4.5.0"
-	},
-	"peerDependenciesMeta": {
-		"typescript": {
-			"optional": true
-		}
-	},
-	"type": "module",
-	"exports": {
-		".": {
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			}
-		},
-		"./package.json": "./package.json"
-	},
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts"
+  "name": "napi-zig",
+  "version": "0.1.1",
+  "description": "CLI for napi-zig, publish Zig libraries to npm in minutes.",
+  "license": "MIT",
+  "bin": {
+    "napi": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bunup --dts.infer-types",
+    "dev": "bun run build --watch"
+  },
+  "dependencies": {
+    "cac": "^7.0.0",
+    "listr2": "^10.2.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "@types/prompts": "^2.4.9",
+    "bunup": "^0.16.31",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.5.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  }
 }

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-declare function greet(name: string): string;
-export { greet };