pubz 0.1.0

package/README.md

@@ -0,0 +1,17 @@
+# `pubz`
+
+```bash
+bunx pubz
+```
+
+`pubz` publishes multiple packages in one command, with some useful steps:
+
+1. Prompts you to bump version number of packages.
+2. Prompts you for where you want to publish (e.g. `npm` or private registry).
+3. Prompts you to create a `git tag` and push it.
+
+# Example
+
+```bash
+bunx pubz
+```

package/dist/cli.js

@@ -0,0 +1,645 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/discovery.ts
+import { readFile, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { join as join2, resolve } from "node:path";
+
+// src/glob.ts
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+async function glob(pattern, cwd) {
+  const results = [];
+  const basePattern = pattern.replace(/\/\*\*?$/, "");
+  const isRecursive = pattern.endsWith("/**");
+  const basePath = join(cwd, basePattern);
+  try {
+    const entries = await readdir(basePath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const entryPath = join(basePattern, entry.name);
+        const fullPath = join(cwd, entryPath);
+        try {
+          await stat(join(fullPath, "package.json"));
+          results.push(entryPath);
+        } catch {
+          if (isRecursive) {
+            const subResults = await glob(`${entryPath}/*`, cwd);
+            results.push(...subResults);
+          }
+        }
+      }
+    }
+  } catch {}
+  return results;
+}
+
+// src/discovery.ts
+async function findRootPackageJson(cwd) {
+  const packageJsonPath = join2(cwd, "package.json");
+  try {
+    await stat2(packageJsonPath);
+    return packageJsonPath;
+  } catch {
+    return null;
+  }
+}
+async function readPackageJson(path) {
+  const content = await readFile(path, "utf-8");
+  return JSON.parse(content);
+}
+function getWorkspacePatterns(packageJson) {
+  if (!packageJson.workspaces) {
+    return [];
+  }
+  if (Array.isArray(packageJson.workspaces)) {
+    return packageJson.workspaces;
+  }
+  return packageJson.workspaces.packages || [];
+}
+async function discoverPackages(cwd) {
+  const rootPackageJsonPath = await findRootPackageJson(cwd);
+  if (!rootPackageJsonPath) {
+    throw new Error("No package.json found in current directory");
+  }
+  const rootPackageJson = await readPackageJson(rootPackageJsonPath);
+  const workspacePatterns = getWorkspacePatterns(rootPackageJson);
+  let packageDirs = [];
+  if (workspacePatterns.length > 0) {
+    for (const pattern of workspacePatterns) {
+      const matches = await glob(pattern, cwd);
+      packageDirs.push(...matches);
+    }
+  } else {
+    const packagesDir = join2(cwd, "packages");
+    try {
+      const entries = await readdir2(packagesDir, { withFileTypes: true });
+      packageDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => join2("packages", entry.name));
+    } catch {
+      if (!rootPackageJson.private) {
+        return [
+          await packageFromPath(cwd, rootPackageJsonPath, rootPackageJson, [])
+        ];
+      }
+      return [];
+    }
+  }
+  const packages = [];
+  const packageNames = new Set;
+  for (const dir of packageDirs) {
+    const pkgPath = resolve(cwd, dir);
+    const pkgJsonPath = join2(pkgPath, "package.json");
+    try {
+      const pkgJson = await readPackageJson(pkgJsonPath);
+      packageNames.add(pkgJson.name);
+      packages.push(await packageFromPath(pkgPath, pkgJsonPath, pkgJson, []));
+    } catch {}
+  }
+  for (const pkg of packages) {
+    pkg.localDependencies = findLocalDependencies(pkg, packageNames);
+  }
+  return packages;
+}
+async function packageFromPath(path, packageJsonPath, packageJson, localDependencies) {
+  return {
+    name: packageJson.name,
+    version: packageJson.version,
+    path,
+    packageJsonPath,
+    isPrivate: packageJson.private === true,
+    localDependencies
+  };
+}
+function findLocalDependencies(pkg, packageNames) {
+  const deps = [];
+  const pkgJson = JSON.parse(__require("node:fs").readFileSync(pkg.packageJsonPath, "utf-8"));
+  const allDeps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies,
+    ...pkgJson.peerDependencies
+  };
+  for (const depName of Object.keys(allDeps)) {
+    if (packageNames.has(depName)) {
+      deps.push(depName);
+    }
+  }
+  return deps;
+}
+function sortByDependencyOrder(packages) {
+  const packageMap = new Map(packages.map((p) => [p.name, p]));
+  const sorted = [];
+  const visited = new Set;
+  function visit(pkg) {
+    if (visited.has(pkg.name))
+      return;
+    visited.add(pkg.name);
+    for (const depName of pkg.localDependencies) {
+      const dep = packageMap.get(depName);
+      if (dep) {
+        visit(dep);
+      }
+    }
+    sorted.push(pkg);
+  }
+  for (const pkg of packages) {
+    visit(pkg);
+  }
+  return sorted;
+}
+
+// src/prompts.ts
+import * as readline from "node:readline";
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+function prompt(question) {
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      resolve2(answer.trim());
+    });
+  });
+}
+function closePrompt() {
+  rl.close();
+}
+async function confirm(message, defaultNo = true) {
+  const hint = defaultNo ? "[y/N]" : "[Y/n]";
+  const answer = await prompt(`${message} ${hint} `);
+  if (answer === "") {
+    return !defaultNo;
+  }
+  return answer.toLowerCase() === "y";
+}
+async function select(message, options, defaultIndex = 0) {
+  console.log(message);
+  console.log("");
+  for (let i = 0;i < options.length; i++) {
+    const marker = i === defaultIndex ? ">" : " ";
+    console.log(`  ${marker} ${i + 1}) ${options[i].label}`);
+  }
+  console.log("");
+  const answer = await prompt(`Enter choice [1-${options.length}] (default: ${defaultIndex + 1}): `);
+  if (answer === "") {
+    return options[defaultIndex].value;
+  }
+  const index = Number.parseInt(answer, 10) - 1;
+  if (index >= 0 && index < options.length) {
+    return options[index].value;
+  }
+  console.log(`Invalid choice. Using default: ${options[defaultIndex].label}`);
+  return options[defaultIndex].value;
+}
+
+// src/publish.ts
+import { spawn } from "node:child_process";
+import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+function run(command, args, cwd) {
+  return new Promise((resolve2) => {
+    const proc = spawn(command, args, {
+      cwd,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: true
+    });
+    let output = "";
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+      process.stdout.write(data);
+    });
+    proc.stderr?.on("data", (data) => {
+      output += data.toString();
+      process.stderr.write(data);
+    });
+    proc.on("close", (code) => {
+      resolve2({ code: code ?? 1, output });
+    });
+  });
+}
+async function runBuild(cwd, dryRun) {
+  if (dryRun) {
+    console.log("[DRY RUN] Would run: bun run build");
+    return { success: true };
+  }
+  console.log("Running build...");
+  console.log("");
+  const result = await run("bun", ["run", "build"], cwd);
+  if (result.code !== 0) {
+    return { success: false, error: "Build failed" };
+  }
+  console.log("");
+  console.log("Build completed successfully");
+  return { success: true };
+}
+async function verifyBuild(pkg) {
+  const content = await readFile2(pkg.packageJsonPath, "utf-8");
+  const packageJson = JSON.parse(content);
+  const filesToCheck = [];
+  if (packageJson.main) {
+    filesToCheck.push(packageJson.main);
+  }
+  if (packageJson.bin) {
+    if (typeof packageJson.bin === "string") {
+      filesToCheck.push(packageJson.bin);
+    } else {
+      filesToCheck.push(...Object.values(packageJson.bin));
+    }
+  }
+  if (packageJson.exports) {
+    if (typeof packageJson.exports === "string") {
+      filesToCheck.push(packageJson.exports);
+    } else if (typeof packageJson.exports["."] === "string") {
+      filesToCheck.push(packageJson.exports["."]);
+    }
+  }
+  if (filesToCheck.length === 0) {
+    filesToCheck.push("./dist/index.js");
+  }
+  for (const file of filesToCheck) {
+    const filePath = join3(pkg.path, file);
+    try {
+      await stat3(filePath);
+    } catch {
+      return { success: false, error: `Missing ${file} in ${pkg.name}` };
+    }
+  }
+  return { success: true };
+}
+async function publishPackage(pkg, registry, otp, dryRun) {
+  if (dryRun) {
+    console.log(`  [DRY RUN] Would publish ${pkg.name}@${pkg.version} to ${registry}`);
+    return { success: true };
+  }
+  console.log(`Publishing ${pkg.name}@${pkg.version}...`);
+  const args = ["publish", "--registry", registry, "--access", "public"];
+  if (otp) {
+    args.push("--otp", otp);
+  }
+  const result = await run("bun", args, pkg.path);
+  if (result.code !== 0) {
+    return { success: false, error: `Failed to publish ${pkg.name}` };
+  }
+  console.log(`  ${pkg.name} published successfully`);
+  return { success: true };
+}
+async function createGitTag(version, cwd, dryRun) {
+  const tagName = `v${version}`;
+  if (dryRun) {
+    console.log(`[DRY RUN] Would create git tag: ${tagName}`);
+    return { success: true };
+  }
+  const statusResult = await run("git", ["status", "--porcelain"], cwd);
+  if (statusResult.output.trim()) {
+    console.log("Uncommitted changes detected. Committing...");
+    await run("git", ["add", "-A"], cwd);
+    await run("git", ["commit", "-m", `chore: release ${tagName}`], cwd);
+    console.log("  Changes committed");
+  }
+  const tagResult = await run("git", ["tag", tagName], cwd);
+  if (tagResult.code !== 0) {
+    return {
+      success: false,
+      error: `Failed to create tag ${tagName} (may already exist)`
+    };
+  }
+  console.log(`  Tag ${tagName} created`);
+  return { success: true };
+}
+async function pushGitTag(version, cwd, dryRun) {
+  const tagName = `v${version}`;
+  if (dryRun) {
+    console.log(`[DRY RUN] Would push git tag: ${tagName}`);
+    return { success: true };
+  }
+  const result = await run("git", ["push", "origin", tagName], cwd);
+  if (result.code !== 0) {
+    return { success: false, error: `Failed to push tag ${tagName}` };
+  }
+  console.log(`  Tag ${tagName} pushed to origin`);
+  return { success: true };
+}
+
+// src/version.ts
+import { readFile as readFile3, writeFile } from "node:fs/promises";
+function bumpVersion(version, type) {
+  if (type === "none")
+    return version;
+  const [major, minor, patch] = version.split(".").map(Number);
+  switch (type) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+function previewBump(version, type) {
+  const newVersion = bumpVersion(version, type);
+  return `${version} -> ${newVersion}`;
+}
+async function updatePackageVersion(pkg, newVersion, dryRun) {
+  const content = await readFile3(pkg.packageJsonPath, "utf-8");
+  const packageJson = JSON.parse(content);
+  packageJson.version = newVersion;
+  if (dryRun) {
+    console.log(`  [DRY RUN] Would update ${pkg.name}: ${pkg.version} -> ${newVersion}`);
+    return;
+  }
+  await writeFile(pkg.packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+  console.log(`  Updated ${pkg.name}: ${pkg.version} -> ${newVersion}`);
+}
+async function updateLocalDependencyVersions(packages, newVersion, dryRun) {
+  const packageNames = new Set(packages.map((p) => p.name));
+  for (const pkg of packages) {
+    const content = await readFile3(pkg.packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    let modified = false;
+    for (const depType of [
+      "dependencies",
+      "devDependencies",
+      "peerDependencies"
+    ]) {
+      const deps = packageJson[depType];
+      if (!deps)
+        continue;
+      for (const depName of Object.keys(deps)) {
+        if (packageNames.has(depName)) {
+          const oldVersion = deps[depName];
+          const newVersionSpec = oldVersion.startsWith("^") ? `^${newVersion}` : oldVersion.startsWith("~") ? `~${newVersion}` : newVersion;
+          if (deps[depName] !== newVersionSpec) {
+            if (dryRun) {
+              console.log(`  [DRY RUN] Would update ${pkg.name} ${depType}.${depName}: ${oldVersion} -> ${newVersionSpec}`);
+            } else {
+              deps[depName] = newVersionSpec;
+              modified = true;
+            }
+          }
+        }
+      }
+    }
+    if (modified && !dryRun) {
+      await writeFile(pkg.packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+      console.log(`  Updated local dependency versions in ${pkg.name}`);
+    }
+  }
+}
+
+// src/cli.ts
+var REGISTRIES = {
+  npm: "https://registry.npmjs.org",
+  github: "https://npm.pkg.github.com"
+};
+function printUsage() {
+  console.log(`
+pubz - Interactive npm package publisher
+
+Usage: pubz [options]
+
+Options:
+  --dry-run              Show what would be published without actually publishing
+  --registry <url>       Specify npm registry URL (default: public npm)
+  --otp <code>           One-time password for 2FA
+  --skip-build           Skip the build step
+  --yes, -y              Skip confirmation prompts (use defaults)
+  -h, --help             Show this help message
+
+Examples:
+  pubz                                           # Interactive publish
+  pubz --dry-run                                 # Preview what would happen
+  pubz --registry https://npm.pkg.github.com    # Publish to GitHub Packages
+`);
+}
+function parseArgs(args) {
+  const options = {
+    dryRun: false,
+    registry: "",
+    otp: "",
+    skipBuild: false,
+    skipPrompts: false,
+    help: false
+  };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--dry-run":
+        options.dryRun = true;
+        break;
+      case "--registry":
+        options.registry = args[++i] || "";
+        break;
+      case "--otp":
+        options.otp = args[++i] || "";
+        break;
+      case "--skip-build":
+        options.skipBuild = true;
+        break;
+      case "--yes":
+      case "-y":
+        options.skipPrompts = true;
+        break;
+      case "-h":
+      case "--help":
+        options.help = true;
+        break;
+    }
+  }
+  return options;
+}
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printUsage();
+    process.exit(0);
+  }
+  const cwd = process.cwd();
+  if (options.dryRun) {
+    console.log("DRY RUN MODE - No actual changes will be made");
+    console.log("");
+  }
+  console.log("pubz - npm package publisher");
+  console.log("=============================");
+  console.log("");
+  console.log("Discovering packages...");
+  console.log("");
+  let packages = await discoverPackages(cwd);
+  const publishablePackages = packages.filter((p) => !p.isPrivate);
+  if (publishablePackages.length === 0) {
+    console.log("No publishable packages found.");
+    console.log("");
+    console.log("Make sure your packages:");
+    console.log('  - Have a package.json with a "name" field');
+    console.log('  - Do not have "private": true');
+    console.log("");
+    process.exit(1);
+  }
+  packages = sortByDependencyOrder(publishablePackages);
+  console.log(`Found ${packages.length} publishable package(s):`);
+  console.log("");
+  for (const pkg of packages) {
+    const deps = pkg.localDependencies.length > 0 ? ` (depends on: ${pkg.localDependencies.join(", ")})` : "";
+    console.log(`  - ${pkg.name}@${pkg.version}${deps}`);
+  }
+  console.log("");
+  const currentVersion = packages[0].version;
+  console.log("Step 1: Version Management");
+  console.log("--------------------------");
+  console.log("");
+  console.log(`Current version: ${currentVersion}`);
+  console.log("");
+  let newVersion = currentVersion;
+  if (!options.skipPrompts) {
+    const shouldBump = await confirm("Bump version before publishing?");
+    if (shouldBump) {
+      const bumpType = await select("Select version bump type:", [
+        {
+          label: `patch (${previewBump(currentVersion, "patch")})`,
+          value: "patch"
+        },
+        {
+          label: `minor (${previewBump(currentVersion, "minor")})`,
+          value: "minor"
+        },
+        {
+          label: `major (${previewBump(currentVersion, "major")})`,
+          value: "major"
+        }
+      ]);
+      newVersion = bumpVersion(currentVersion, bumpType);
+      console.log("");
+      console.log(`Updating version to ${newVersion} in all packages...`);
+      console.log("");
+      for (const pkg of packages) {
+        await updatePackageVersion(pkg, newVersion, options.dryRun);
+      }
+      await updateLocalDependencyVersions(packages, newVersion, options.dryRun);
+      for (const pkg of packages) {
+        pkg.version = newVersion;
+      }
+      console.log("");
+    }
+  }
+  let registry = options.registry;
+  if (!registry && !options.skipPrompts) {
+    registry = await select("Select publish target:", [
+      {
+        label: "Public npm registry (https://registry.npmjs.org)",
+        value: REGISTRIES.npm
+      },
+      {
+        label: "GitHub Packages (https://npm.pkg.github.com)",
+        value: REGISTRIES.github
+      }
+    ]);
+  }
+  registry = registry || REGISTRIES.npm;
+  console.log("");
+  console.log(`Publishing to: ${registry}`);
+  console.log("");
+  if (!options.skipBuild) {
+    console.log("Step 2: Building Packages");
+    console.log("-------------------------");
+    console.log("");
+    const buildResult = await runBuild(cwd, options.dryRun);
+    if (!buildResult.success) {
+      console.error(`Build failed: ${buildResult.error}`);
+      closePrompt();
+      process.exit(1);
+    }
+    console.log("");
+    console.log("Verifying builds...");
+    console.log("");
+    let allBuildsVerified = true;
+    for (const pkg of packages) {
+      const result = await verifyBuild(pkg);
+      if (result.success) {
+        console.log(`  ${pkg.name} build verified`);
+      } else {
+        console.error(`  ${pkg.name}: ${result.error}`);
+        allBuildsVerified = false;
+      }
+    }
+    console.log("");
+    if (!allBuildsVerified) {
+      console.error("Build verification failed. Please fix the issues and try again.");
+      closePrompt();
+      process.exit(1);
+    }
+  }
+  console.log("Step 3: Publishing to npm");
+  console.log("-------------------------");
+  console.log("");
+  if (options.dryRun) {
+    console.log(`[DRY RUN] Would publish the following packages to ${registry}:`);
+    console.log("");
+    for (const pkg of packages) {
+      console.log(`  ${pkg.name}@${newVersion}`);
+    }
+    console.log("");
+    console.log("Run without --dry-run to actually publish.");
+  } else {
+    console.log("About to publish the following packages:");
+    console.log("");
+    for (const pkg of packages) {
+      console.log(`  ${pkg.name}@${newVersion}`);
+    }
+    console.log("");
+    console.log(`Registry: ${registry}`);
+    console.log("");
+    if (!options.skipPrompts) {
+      const shouldContinue = await confirm("Continue?");
+      if (!shouldContinue) {
+        console.log("Publish cancelled.");
+        closePrompt();
+        process.exit(0);
+      }
+    }
+    console.log("");
+    console.log("Publishing packages...");
+    console.log("");
+    for (const pkg of packages) {
+      const result = await publishPackage(pkg, registry, options.otp, options.dryRun);
+      if (!result.success) {
+        console.error(`Failed to publish ${pkg.name}: ${result.error}`);
+        console.log("");
+        console.log("Stopping publish process.");
+        closePrompt();
+        process.exit(1);
+      }
+    }
+  }
+  console.log("");
+  console.log("==================================");
+  console.log("Publishing complete!");
+  console.log("");
+  console.log(`Published version: ${newVersion}`);
+  console.log("");
+  if (!options.dryRun && !options.skipPrompts) {
+    const shouldTag = await confirm(`Create a git tag for v${newVersion}?`);
+    if (shouldTag) {
+      console.log("");
+      const tagResult = await createGitTag(newVersion, cwd, options.dryRun);
+      if (tagResult.success) {
+        const shouldPush = await confirm("Push tag to origin?");
+        if (shouldPush) {
+          await pushGitTag(newVersion, cwd, options.dryRun);
+        } else {
+          console.log(`Tag created locally. Push manually with: git push origin v${newVersion}`);
+        }
+      } else {
+        console.error(tagResult.error);
+      }
+      console.log("");
+    }
+  }
+  console.log("Done!");
+  closePrompt();
+}
+main().catch((error) => {
+  console.error("Error:", error.message);
+  closePrompt();
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pubz",
+  "version": "0.1.0",
+  "description": "Interactive CLI for publishing npm packages (single or monorepo)",
+  "type": "module",
+  "bin": {
+    "pubz": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build src/cli.ts --outdir dist --target node",
+    "dev": "bun run src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "bunx biome check src/",
+    "lint:fix": "bunx biome check --write src/"
+  },
+  "keywords": [
+    "npm",
+    "publish",
+    "monorepo",
+    "cli",
+    "release"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "^1.1.14",
+    "typescript": "^5.7.2"
+  }
+}