@mongez/pkgist 1.0.0

package/dist/cli.js

@@ -0,0 +1,1125 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path5 from "path";
+
+// src/config/load-config.ts
+import path2 from "path";
+import { pathToFileURL } from "url";
+import fs from "fs";
+
+// src/utils/paths.ts
+import path from "path";
+function toForwardSlash(p) {
+  return p.replace(/\\/g, "/");
+}
+function joinPath(...segments) {
+  return toForwardSlash(path.join(...segments));
+}
+function resolvePath(...segments) {
+  return toForwardSlash(path.resolve(...segments));
+}
+function scopelessName(packageName) {
+  const slash = packageName.indexOf("/");
+  return slash === -1 ? packageName : packageName.slice(slash + 1);
+}
+function buildOutputPath(buildDir, packageName, version) {
+  return joinPath(buildDir, scopelessName(packageName), version);
+}
+function sourceSnapshotPath(sourcesDir, packageName) {
+  return joinPath(sourcesDir, scopelessName(packageName));
+}
+
+// src/utils/errors.ts
+var BundlerError = class extends Error {
+  constructor(step, packageName, message, cause) {
+    super(message);
+    this.step = step;
+    this.packageName = packageName;
+    this.cause = cause;
+    this.name = "BundlerError";
+    if (cause instanceof Error && cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+    }
+  }
+  step;
+  packageName;
+  cause;
+};
+function wrapError(step, packageName, error) {
+  if (error instanceof BundlerError) return error;
+  const msg = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error);
+  return new BundlerError(step, packageName, `[${step}] ${packageName}: ${msg}`, error);
+}
+
+// src/config/load-config.ts
+async function loadConfig(configFilePath) {
+  const absolute = resolvePath(configFilePath);
+  if (!fs.existsSync(absolute)) {
+    throw new Error(`Config file not found: ${absolute}`);
+  }
+  let mod;
+  try {
+    const fileUrl = pathToFileURL(absolute).href;
+    mod = await import(fileUrl);
+  } catch (err) {
+    throw wrapError("load-config", absolute, err);
+  }
+  const config = mod.default;
+  if (!config || typeof config !== "object") {
+    throw new Error(
+      `Config file ${absolute} must export a default object from defineConfig(). Got: ${typeof config}`
+    );
+  }
+  validateConfig(config, absolute);
+  return {
+    config,
+    configPath: absolute,
+    configDir: resolvePath(path2.dirname(absolute))
+  };
+}
+function validateConfig(config, filePath) {
+  if (!config.settings) {
+    throw new Error(`Config "${filePath}" must have a "settings" object.`);
+  }
+  if (!config.settings.buildDir) {
+    throw new Error(`Config "${filePath}" settings.buildDir is required.`);
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const pkg of config.standalone ?? []) {
+    if (!pkg.name) throw new Error(`Standalone package is missing "name" in ${filePath}`);
+    if (!pkg.root) throw new Error(`Standalone package "${pkg.name}" is missing "root"`);
+    if (names.has(pkg.name)) throw new Error(`Duplicate package name: "${pkg.name}"`);
+    names.add(pkg.name);
+  }
+  for (const family of config.families ?? []) {
+    if (!family.name) throw new Error(`A family is missing "name" in ${filePath}`);
+    for (const pkg of family.packages) {
+      if (!pkg.name) throw new Error(`Package inside family "${family.name}" is missing "name"`);
+      if (!pkg.root) throw new Error(`Package "${pkg.name}" in family "${family.name}" is missing "root"`);
+      if (names.has(pkg.name)) throw new Error(`Duplicate package name: "${pkg.name}"`);
+      names.add(pkg.name);
+    }
+  }
+}
+function findDefaultConfigPath(cwd) {
+  const candidates = ["builder.ts", "builder.js", "mongez.ts", "mongez.js"];
+  for (const candidate of candidates) {
+    const full = path2.join(cwd, candidate);
+    if (fs.existsSync(full)) return full;
+  }
+  throw new Error(
+    `No config file found in ${cwd}. Tried: ${candidates.join(", ")}. Use --config <path> to specify a custom location.`
+  );
+}
+
+// src/files/file-manager.ts
+import fs2 from "fs";
+import path3 from "path";
+function ensureDir(dir) {
+  try {
+    fs2.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    throw wrapError("ensure-dir", dir, err);
+  }
+}
+function copyFile(src, dest) {
+  ensureDir(path3.dirname(dest));
+  try {
+    fs2.copyFileSync(src, dest);
+  } catch (err) {
+    throw wrapError("copy-file", src, err);
+  }
+}
+var COPY_EXCLUDES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", ".turbo", ".cache"]);
+function copyDir(src, dest) {
+  ensureDir(dest);
+  const entries = fs2.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (COPY_EXCLUDES.has(entry.name)) continue;
+    const srcPath = joinPath(src, entry.name);
+    const destPath = joinPath(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFile(srcPath, destPath);
+    }
+  }
+}
+function readFile(filePath, packageName = filePath) {
+  try {
+    return fs2.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw wrapError("read-file", packageName, err);
+  }
+}
+function writeFile(filePath, content, packageName = filePath) {
+  ensureDir(path3.dirname(filePath));
+  try {
+    fs2.writeFileSync(filePath, content, "utf-8");
+  } catch (err) {
+    throw wrapError("write-file", packageName, err);
+  }
+}
+function moveFile(src, dest, packageName = src) {
+  ensureDir(path3.dirname(dest));
+  try {
+    fs2.renameSync(src, dest);
+  } catch (err) {
+    try {
+      fs2.copyFileSync(src, dest);
+      fs2.unlinkSync(src);
+    } catch (fallbackErr) {
+      throw wrapError("move-file", packageName, fallbackErr);
+    }
+  }
+}
+function pathExists(p) {
+  return fs2.existsSync(p);
+}
+
+// src/files/package-json.ts
+var KEPT_FIELDS = [
+  "name",
+  "description",
+  "keywords",
+  "author",
+  "license",
+  "repository",
+  "homepage",
+  "bugs",
+  "dependencies",
+  "peerDependencies",
+  "sideEffects",
+  "bin",
+  "engines"
+];
+function readSourcePackageJson(packageRoot, packageName) {
+  const pkgPath = joinPath(packageRoot, "package.json");
+  let raw;
+  try {
+    raw = readFile(pkgPath, packageName);
+  } catch {
+    throw wrapError(
+      "read-package-json",
+      packageName,
+      new Error(`package.json not found at ${pkgPath}`)
+    );
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed.version) {
+      throw new Error(`package.json at ${pkgPath} is missing "version" field`);
+    }
+    return parsed;
+  } catch (err) {
+    throw wrapError("parse-package-json", packageName, err);
+  }
+}
+function writeSourceVersion(packageRoot, packageName, newVersion) {
+  const pkgPath = joinPath(packageRoot, "package.json");
+  const raw = readFile(pkgPath, packageName);
+  const parsed = JSON.parse(raw);
+  parsed.version = newVersion;
+  writeFile(pkgPath, JSON.stringify(parsed, null, 2) + "\n", packageName);
+}
+function writeBuildPackageJson(pkg, sourceJson, buildPath, newVersion) {
+  const formats = pkg.formats ?? ["esm", "cjs"];
+  const hasEsm = formats.includes("esm");
+  const hasCjs = formats.includes("cjs");
+  const esmOnly = hasEsm && !hasCjs;
+  const preserve = pkg.preserveModules !== false;
+  const esmExt = preserve ? ".mjs" : ".js";
+  const cjsExt = preserve ? ".cjs" : ".js";
+  const esmDts = preserve ? ".d.mts" : ".d.ts";
+  const cjsDts = preserve ? ".d.cts" : ".d.ts";
+  const rawEntries = pkg.entries ?? ["index.ts"];
+  const entryList = Array.isArray(rawEntries) ? rawEntries : [rawEntries];
+  function entryPaths(entry) {
+    const basePath = entry.replace(/\.tsx?$/, "");
+    const parts = basePath.split("/");
+    const last = parts[parts.length - 1];
+    let exportPath;
+    if (last === "index") {
+      const dir = parts.slice(0, -1).join("/");
+      exportPath = dir ? `./${dir}` : ".";
+    } else {
+      exportPath = `./${basePath}`;
+    }
+    return { basePath, exportPath };
+  }
+  const { basePath: primaryBase } = entryPaths(entryList[0]);
+  const exportsMap = {};
+  for (const entry of entryList) {
+    const { basePath, exportPath } = entryPaths(entry);
+    const conditions = {};
+    if (hasEsm) {
+      conditions["import"] = {
+        types: `./esm/${basePath}${esmDts}`,
+        default: `./esm/${basePath}${esmExt}`
+      };
+    }
+    if (hasCjs) {
+      const cjsTypes = preserve && hasEsm ? `./esm/${basePath}${esmDts}` : `./cjs/${basePath}${cjsDts}`;
+      conditions["require"] = {
+        types: cjsTypes,
+        default: `./cjs/${basePath}${cjsExt}`
+      };
+    }
+    exportsMap[exportPath] = conditions;
+  }
+  const output = {};
+  for (const field of KEPT_FIELDS) {
+    if (field in sourceJson && sourceJson[field] !== void 0) {
+      output[field] = sourceJson[field];
+    }
+  }
+  output["name"] = pkg.name;
+  output["version"] = newVersion;
+  if (esmOnly) {
+    output["type"] = "module";
+  }
+  const mainType = pkg.mainType ?? "cjs";
+  if (mainType === "esm" || esmOnly) {
+    output["main"] = `./esm/${primaryBase}${esmExt}`;
+  } else {
+    output["main"] = `./cjs/${primaryBase}${cjsExt}`;
+  }
+  if (hasEsm) {
+    output["module"] = `./esm/${primaryBase}${esmExt}`;
+  }
+  output["types"] = `./esm/${primaryBase}${esmDts}`;
+  output["exports"] = exportsMap;
+  const pkgPath = joinPath(buildPath, "package.json");
+  writeFile(pkgPath, JSON.stringify(output, null, 2) + "\n", pkg.name);
+}
+
+// src/files/clone-files.ts
+import fs3 from "fs";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var _verbose = false;
+function setVerbose(v) {
+  _verbose = v;
+}
+function log(level, message) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace("Z", "");
+  switch (level) {
+    case "info":
+      console.log(chalk.cyan(`[${ts}] INFO  ${message}`));
+      break;
+    case "success":
+      console.log(chalk.green(`[${ts}] OK    ${message}`));
+      break;
+    case "warn":
+      console.warn(chalk.yellow(`[${ts}] WARN  ${message}`));
+      break;
+    case "error":
+      console.error(chalk.red(`[${ts}] ERROR ${message}`));
+      break;
+    case "step":
+      console.log(chalk.blueBright(`[${ts}] STEP  ${message}`));
+      break;
+    case "debug":
+      if (_verbose) {
+        console.log(chalk.gray(`[${ts}] DEBUG ${message}`));
+      }
+      break;
+  }
+}
+var logger = {
+  info: (msg) => log("info", msg),
+  success: (msg) => log("success", msg),
+  warn: (msg) => log("warn", msg),
+  error: (msg) => log("error", msg),
+  step: (msg) => log("step", msg),
+  debug: (msg) => log("debug", msg)
+};
+
+// src/files/clone-files.ts
+function cloneFiles(packageRoot, buildDir, cloneList, packageName, dryRun) {
+  for (const entry of cloneList) {
+    const [srcRel, destRel] = typeof entry === "string" ? [entry, entry] : entry;
+    const src = joinPath(packageRoot, srcRel);
+    const dest = joinPath(buildDir, destRel);
+    if (!pathExists(src)) {
+      logger.warn(`[clone-files] ${packageName}: source file not found, skipping \u2014 ${src}`);
+      continue;
+    }
+    if (dryRun) {
+      logger.info(`[dry-run] clone ${src} \u2192 ${dest}`);
+      continue;
+    }
+    const stat = fs3.statSync(src);
+    if (stat.isDirectory()) {
+      copyDir(src, dest);
+    } else {
+      copyFile(src, dest);
+    }
+    logger.debug(`Cloned ${src} \u2192 ${dest}`);
+  }
+}
+
+// src/compile/tsdown-compiler.ts
+import path4 from "path";
+import fs4 from "fs";
+import { build } from "tsdown";
+function collectExternals(sourceJson) {
+  const deps = Object.keys(sourceJson["dependencies"] ?? {});
+  const peers = Object.keys(sourceJson["peerDependencies"] ?? {});
+  return [.../* @__PURE__ */ new Set([...deps, ...peers])];
+}
+function resolveEntries(pkg, packageRoot) {
+  const srcDir = pkg.srcDir ?? "src";
+  const rawEntries = pkg.entries ?? ["index.ts"];
+  const entryList = Array.isArray(rawEntries) ? rawEntries : [rawEntries];
+  return entryList.map((e) => toForwardSlash(resolvePath(packageRoot, srcDir, e)));
+}
+function findTsconfig(packageRoot) {
+  const local = joinPath(packageRoot, "tsconfig.json");
+  return pathExists(local) ? local : void 0;
+}
+async function compilePackage(pkg, packageRoot, buildPath, sourceJson, dryRun) {
+  if (dryRun) {
+    logger.info(`[dry-run] compile ${pkg.name} \u2192 ${buildPath}`);
+    return;
+  }
+  const entries = resolveEntries(pkg, packageRoot);
+  const formats = pkg.formats ?? ["esm", "cjs"];
+  const externals = collectExternals(sourceJson);
+  const tsconfig = findTsconfig(packageRoot);
+  const shouldPreserveModules = pkg.preserveModules !== false;
+  const srcDir = toForwardSlash(resolvePath(packageRoot, pkg.srcDir ?? "src"));
+  logger.step(`Compiling ${pkg.name} (${formats.join(", ")}) \u2192 ${buildPath}`);
+  logger.debug(`  entries:   ${entries.join(", ")}`);
+  logger.debug(`  externals: ${externals.slice(0, 8).join(", ")}${externals.length > 8 ? "\u2026" : ""}`);
+  for (const subDir of ["esm", "cjs"]) {
+    const dir = resolvePath(buildPath, subDir);
+    if (fs4.existsSync(dir)) {
+      fs4.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+  const rolldownInputOptions = pkg.type === "react" ? {
+    transform: {
+      jsx: "react-jsx"
+      // automatic runtime — works with React 17+
+    }
+  } : void 0;
+  const sharedOptions = {
+    entry: entries,
+    deps: { neverBundle: externals },
+    sourcemap: pkg.sourcemap !== false,
+    clean: true,
+    minify: pkg.minify ?? false,
+    tsconfig: tsconfig ?? true,
+    ...rolldownInputOptions ? { inputOptions: rolldownInputOptions } : {}
+  };
+  try {
+    if (shouldPreserveModules && formats.includes("esm") && formats.includes("cjs")) {
+      const tmpEsm = toForwardSlash(resolvePath(buildPath, "_tmp_esm"));
+      const tmpCjs = toForwardSlash(resolvePath(buildPath, "_tmp_cjs"));
+      ensureDir(tmpEsm);
+      ensureDir(tmpCjs);
+      await Promise.all([
+        build({
+          ...sharedOptions,
+          format: ["esm"],
+          dts: pkg.dts !== false,
+          outDir: tmpEsm,
+          outputOptions: {
+            preserveModules: true,
+            preserveModulesRoot: srcDir
+          }
+        }),
+        build({
+          ...sharedOptions,
+          format: ["cjs"],
+          // CJS skips DTS — types are served from ESM declarations (see package-json.ts).
+          dts: false,
+          outDir: tmpCjs
+        })
+      ]);
+      reorganiseOutput(tmpEsm, buildPath, ["esm"], pkg, true);
+      reorganiseOutput(tmpCjs, buildPath, ["cjs"], pkg, false, true);
+      rmTmp(tmpEsm);
+      rmTmp(tmpCjs);
+    } else {
+      const tmpDir = toForwardSlash(resolvePath(buildPath, "_tmp"));
+      ensureDir(tmpDir);
+      await build({
+        ...sharedOptions,
+        format: formats,
+        dts: pkg.dts !== false,
+        outDir: tmpDir,
+        ...shouldPreserveModules && formats.includes("esm") ? { outputOptions: { preserveModules: true, preserveModulesRoot: srcDir } } : {}
+      });
+      reorganiseOutput(tmpDir, buildPath, formats, pkg, shouldPreserveModules);
+      rmTmp(tmpDir);
+    }
+  } catch (err) {
+    throw wrapError("tsdown-build", pkg.name, err);
+  }
+  logger.success(`Compiled ${pkg.name}`);
+}
+function rmTmp(dir) {
+  try {
+    fs4.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function reorganiseOutput(tmpDir, buildPath, formats, pkg, preserveModules, keepNativeExtension = false) {
+  const esmDir = joinPath(buildPath, "esm");
+  const cjsDir = joinPath(buildPath, "cjs");
+  if (formats.includes("esm")) ensureDir(esmDir);
+  if (formats.includes("cjs")) ensureDir(cjsDir);
+  const mainType = pkg.mainType ?? (formats.includes("cjs") ? "cjs" : "esm");
+  processDirectory(tmpDir, { esmDir, cjsDir, formats, mainType, pkg, tmpDir, preserveModules, keepNativeExtension });
+}
+function processDirectory(dir, ctx) {
+  if (!fs4.existsSync(dir)) return;
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = joinPath(dir, entry.name);
+    if (entry.isDirectory()) {
+      processDirectory(fullPath, ctx);
+    } else {
+      processFile(fullPath, entry.name, ctx);
+    }
+  }
+}
+function processFile(filePath, name, ctx) {
+  const { esmDir, cjsDir, formats, mainType, pkg, tmpDir, preserveModules } = ctx;
+  const relDir = toForwardSlash(path4.relative(tmpDir, path4.dirname(filePath)));
+  if (preserveModules) {
+    if (isEsmFile(name)) {
+      if (formats.includes("esm")) {
+        moveFile(filePath, joinPath(esmDir, relDir, name), pkg.name);
+      }
+    } else if (isCjsFile(name)) {
+      if (formats.includes("cjs")) {
+        moveFile(filePath, joinPath(cjsDir, relDir, name), pkg.name);
+      }
+    } else if (isDtsFile(name)) {
+      const targetDir = formats.includes("esm") ? esmDir : cjsDir;
+      moveFile(filePath, joinPath(targetDir, relDir, name), pkg.name);
+    }
+    return;
+  }
+  const { keepNativeExtension } = ctx;
+  if (isEsmFile(name)) {
+    if (formats.includes("esm")) {
+      const destName = keepNativeExtension ? name : normaliseEsmName(name);
+      moveFile(filePath, joinPath(esmDir, relDir, destName), pkg.name);
+    }
+  } else if (isCjsFile(name)) {
+    if (formats.includes("cjs")) {
+      const destName = keepNativeExtension ? name : normaliseCjsName(name);
+      moveFile(filePath, joinPath(cjsDir, relDir, destName), pkg.name);
+    }
+  } else if (isDtsFile(name)) {
+    const targetDir = formats.includes("esm") ? esmDir : cjsDir;
+    moveFile(filePath, joinPath(targetDir, relDir, name), pkg.name);
+  } else if (isJsFile(name)) {
+    const targetDir = mainType === "esm" ? esmDir : cjsDir;
+    if (formats.includes(mainType)) {
+      const destName = targetDir === cjsDir ? name.replace(/\.js\.map$/, ".cjs.map").replace(/\.js$/, ".cjs") : name;
+      moveFile(filePath, joinPath(targetDir, relDir, destName), pkg.name);
+    }
+  }
+}
+function isEsmFile(name) {
+  return name.endsWith(".mjs") || name.endsWith(".mjs.map") || name.endsWith(".d.mts") || name.endsWith(".d.mts.map");
+}
+function isCjsFile(name) {
+  return name.endsWith(".cjs") || name.endsWith(".cjs.map") || name.endsWith(".d.cts") || name.endsWith(".d.cts.map");
+}
+function isDtsFile(name) {
+  return name.endsWith(".d.ts") || name.endsWith(".d.ts.map");
+}
+function isJsFile(name) {
+  return (name.endsWith(".js") || name.endsWith(".js.map")) && !name.endsWith(".d.ts") && !name.endsWith(".d.ts.map");
+}
+function normaliseEsmName(name) {
+  return name.replace(/\.mjs\.map$/, ".js.map").replace(/\.mjs$/, ".js").replace(/\.d\.mts\.map$/, ".d.ts.map").replace(/\.d\.mts$/, ".d.ts");
+}
+function normaliseCjsName(name) {
+  return name.replace(/\.cjs\.map$/, ".js.map").replace(/\.cjs$/, ".js").replace(/\.d\.cts\.map$/, ".d.ts.map").replace(/\.d\.cts$/, ".d.ts");
+}
+
+// src/version/increment.ts
+import semver from "semver";
+function resolveVersion(currentVersion, strategy = "auto", packageName) {
+  const bumpType = strategy === "auto" || strategy === "patch" ? "patch" : strategy === "minor" ? "minor" : strategy === "major" ? "major" : null;
+  if (bumpType) {
+    const bumped = semver.inc(currentVersion, bumpType);
+    if (!bumped) {
+      throw wrapError(
+        "version-increment",
+        packageName,
+        new Error(
+          `Cannot ${bumpType}-bump invalid semver version "${currentVersion}" for package "${packageName}"`
+        )
+      );
+    }
+    return bumped;
+  }
+  const cleaned = semver.valid(semver.coerce(strategy) ?? strategy);
+  if (!cleaned) {
+    throw wrapError(
+      "version-increment",
+      packageName,
+      new Error(
+        `Explicit version "${strategy}" is not a valid semver string for package "${packageName}"`
+      )
+    );
+  }
+  return cleaned;
+}
+
+// src/git/operations.ts
+import simpleGit from "simple-git";
+async function isGitRepo(dir) {
+  try {
+    const git = simpleGit(dir);
+    const result = await git.checkIsRepo();
+    return result;
+  } catch {
+    return false;
+  }
+}
+async function gitCommitTagPush(packageRoot, packageName, version, commitMessage, branch, dryRun) {
+  const isRepo = await isGitRepo(packageRoot);
+  if (!isRepo) {
+    logger.warn(`[git] ${packageName}: directory is not a git repo \u2014 skipping git operations`);
+    return;
+  }
+  const tag = `v${version}`;
+  logger.step(`[git] ${packageName}: commit "${commitMessage}", tag ${tag}, push to ${branch}`);
+  if (dryRun) {
+    logger.info(`[dry-run] git add + commit "${commitMessage}" + tag ${tag} + push`);
+    return;
+  }
+  const git = simpleGit(packageRoot);
+  try {
+    await git.add("-A");
+    await git.commit(commitMessage);
+    await git.push("origin", branch);
+    await git.addTag(tag);
+    await git.pushTags("origin");
+    logger.success(`[git] ${packageName}: pushed ${branch}, tagged ${tag}`);
+  } catch (err) {
+    throw wrapError("git-operations", packageName, err);
+  }
+}
+async function currentBranch(dir) {
+  try {
+    const git = simpleGit(dir);
+    const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+    return branch.trim() || "main";
+  } catch {
+    return "main";
+  }
+}
+
+// src/utils/exec.ts
+import { execa } from "execa";
+async function exec(step, packageName, command, args, cwd) {
+  try {
+    const result = await execa(command, args, {
+      cwd,
+      all: true,
+      reject: false
+    });
+    if (result.exitCode !== 0) {
+      const combined = result.all ?? result.stderr ?? "";
+      throw new Error(
+        `Command "${command} ${args.join(" ")}" exited with code ${result.exitCode}.
+${combined}`
+      );
+    }
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: result.exitCode
+    };
+  } catch (err) {
+    throw wrapError(step, packageName, err);
+  }
+}
+
+// src/publish/npm-publisher.ts
+async function publishPackage(pkg, buildPath, dryRun) {
+  if (pkg.publish === false) {
+    logger.info(`[publish] ${pkg.name}: publish=false, skipping`);
+    return;
+  }
+  const access = pkg.access ?? "public";
+  if (dryRun) {
+    logger.info(`[dry-run] npm publish --access ${access} from ${buildPath}`);
+    return;
+  }
+  logger.step(`Publishing ${pkg.name}@... to npm (access: ${access})`);
+  await exec(
+    "npm-publish",
+    pkg.name,
+    "npm",
+    ["publish", "--access", access],
+    buildPath
+  );
+  logger.success(`Published ${pkg.name}`);
+}
+
+// src/build/package-builder.ts
+async function buildPackage(pkg, versionStrategy = "auto", settings, options, configDir, overrideCommit, forcedVersion) {
+  const step = "package-builder";
+  try {
+    const packageRoot = resolvePath(configDir, pkg.root);
+    const sourceJson = readSourcePackageJson(packageRoot, pkg.name);
+    const currentVersion = sourceJson.version;
+    const newVersion = forcedVersion ?? resolveVersion(currentVersion, versionStrategy, pkg.name);
+    logger.info(`Building ${pkg.name}: ${currentVersion} \u2192 ${newVersion}`);
+    const absoluteBuildDir = resolvePath(configDir, settings.buildDir);
+    const buildPath = buildOutputPath(absoluteBuildDir, pkg.name, newVersion);
+    if (!options.dryRun) {
+      ensureDir(buildPath);
+    }
+    if (settings.sourcesDir) {
+      const absoluteSourcesDir = resolvePath(configDir, settings.sourcesDir);
+      const snapshotPath = sourceSnapshotPath(absoluteSourcesDir, pkg.name);
+      if (options.dryRun) {
+        logger.info(`[dry-run] snapshot ${packageRoot} \u2192 ${snapshotPath}`);
+      } else {
+        ensureDir(snapshotPath);
+        copyDir(packageRoot, snapshotPath);
+        logger.debug(`Snapshot: ${packageRoot} \u2192 ${snapshotPath}`);
+      }
+    }
+    await compilePackage(pkg, packageRoot, buildPath, sourceJson, options.dryRun);
+    if (pkg.clone && pkg.clone.length > 0) {
+      cloneFiles(packageRoot, buildPath, pkg.clone, pkg.name, options.dryRun);
+    }
+    if (!options.dryRun) {
+      writeBuildPackageJson(pkg, sourceJson, buildPath, newVersion);
+      logger.debug(`Wrote build package.json for ${pkg.name}@${newVersion}`);
+    } else {
+      logger.info(`[dry-run] write build package.json for ${pkg.name}@${newVersion}`);
+    }
+    if (!options.dryRun) {
+      writeSourceVersion(packageRoot, pkg.name, newVersion);
+      logger.debug(`Updated source version ${pkg.name} \u2192 ${newVersion}`);
+    } else {
+      logger.info(`[dry-run] update source package.json version \u2192 ${newVersion}`);
+    }
+    const commitMessage = overrideCommit ?? pkg.commit;
+    if (commitMessage && !options.noGit) {
+      const branch = pkg.branch ?? await currentBranch(packageRoot);
+      await gitCommitTagPush(
+        packageRoot,
+        pkg.name,
+        newVersion,
+        commitMessage,
+        branch,
+        options.dryRun
+      );
+    } else if (!commitMessage) {
+      logger.debug(`[git] ${pkg.name}: no commit message set \u2014 skipping git`);
+    }
+    if (!options.noPublish) {
+      await publishPackage(pkg, buildPath, options.dryRun);
+    } else {
+      logger.info(`[publish] ${pkg.name}: --no-publish, skipping`);
+    }
+    return { packageName: pkg.name, version: newVersion, buildPath, success: true };
+  } catch (err) {
+    const wrapped = wrapError(step, pkg.name, err);
+    logger.error(`Failed to build ${pkg.name}: ${wrapped.message}`);
+    return {
+      packageName: pkg.name,
+      version: "",
+      buildPath: "",
+      success: false,
+      error: wrapped
+    };
+  }
+}
+
+// src/build/parallel-builder.ts
+import pLimit from "p-limit";
+async function runParallel(tasks, concurrency) {
+  if (tasks.length === 0) return [];
+  const limit = pLimit(Math.max(1, concurrency));
+  logger.info(`Running ${tasks.length} task(s) with concurrency=${concurrency}`);
+  const results = await Promise.all(
+    tasks.map((task) => limit(task))
+  );
+  const succeeded = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  if (failed > 0) {
+    logger.warn(`${succeeded} succeeded, ${failed} failed`);
+    for (const r of results.filter((r2) => !r2.success)) {
+      logger.error(`  FAILED: ${r.packageName} \u2014 ${r.error?.message ?? "unknown error"}`);
+    }
+  } else {
+    logger.success(`All ${succeeded} package(s) built successfully`);
+  }
+  return results;
+}
+
+// src/commands/build.ts
+function registerBuildCommand(program2) {
+  program2.command("build [packages...]").description("Build standalone packages by name. Use --all to build all standalone packages.").option("--all", "Build all standalone packages").option("--dry-run", "Print what would happen without making any changes").option("--no-publish", "Skip npm publish").option("--no-git", "Skip git operations").option("--config <path>", "Path to config file").option("--concurrency <n>", "Override concurrency").action(async (packageNames, opts) => {
+    const configPath = opts.config ?? findDefaultConfigPath(process.cwd());
+    const { config, configDir } = await loadConfig(configPath);
+    const buildOptions = {
+      dryRun: opts.dryRun ?? false,
+      noPublish: !opts.noPublish,
+      // commander flips --no-publish to noPublish=false
+      noGit: opts.noGit ?? false,
+      concurrency: opts.concurrency ? parseInt(opts.concurrency, 10) : void 0,
+      configPath
+    };
+    const rawOpts = opts;
+    const shouldPublish = rawOpts["publish"] !== false;
+    buildOptions.noPublish = !shouldPublish;
+    const standalone = config.standalone ?? [];
+    let targets = standalone;
+    if (!opts.all && packageNames.length > 0) {
+      targets = standalone.filter((p) => packageNames.includes(p.name));
+      const missing = packageNames.filter(
+        (n) => !standalone.some((p) => p.name === n)
+      );
+      if (missing.length > 0) {
+        logger.warn(`Unknown package names: ${missing.join(", ")}`);
+      }
+    }
+    if (targets.length === 0) {
+      logger.warn("No standalone packages matched. Use --all or specify package names.");
+      process.exit(0);
+    }
+    const concurrency = buildOptions.concurrency ?? config.settings.concurrency ?? 4;
+    const tasks = targets.map(
+      (pkg) => () => buildPackage(
+        pkg,
+        pkg.version ?? "auto",
+        config.settings,
+        buildOptions,
+        configDir
+      )
+    );
+    const results = await runParallel(tasks, concurrency);
+    const anyFailed = results.some((r) => !r.success);
+    process.exit(anyFailed ? 1 : 0);
+  });
+}
+
+// src/build/family-builder.ts
+import semver2 from "semver";
+async function buildFamily(family, settings, options, configDir) {
+  if (family.packages.length === 0) {
+    logger.warn(`Family "${family.name}" has no packages \u2014 nothing to build`);
+    return [];
+  }
+  let newVersion;
+  try {
+    const strategy = family.version ?? "auto";
+    const isBumpKeyword = strategy === "auto" || strategy === "patch" || strategy === "minor" || strategy === "major";
+    if (!isBumpKeyword && semver2.valid(semver2.coerce(strategy) ?? strategy)) {
+      newVersion = strategy;
+    } else {
+      let highestVersion = "0.0.0";
+      for (const pkg of family.packages) {
+        const root = resolvePath(configDir, pkg.root);
+        const sourceJson = readSourcePackageJson(root, pkg.name);
+        const v = sourceJson.version ?? "0.0.0";
+        if (semver2.gt(v, highestVersion)) {
+          highestVersion = v;
+        }
+      }
+      newVersion = resolveVersion(highestVersion, strategy, family.name);
+    }
+  } catch (err) {
+    throw wrapError("family-version", family.name, err);
+  }
+  logger.info(`Family "${family.name}": shared version \u2192 ${newVersion} (${family.packages.length} packages)`);
+  const concurrency = options.concurrency ?? settings.concurrency ?? 4;
+  const familyCommit = family.commit;
+  const tasks = family.packages.map(
+    (pkg) => () => buildPackage(
+      pkg,
+      "auto",
+      // not used — forcedVersion overrides
+      settings,
+      options,
+      configDir,
+      familyCommit ?? pkg.commit,
+      newVersion
+      // all packages use the same version
+    )
+  );
+  return runParallel(tasks, concurrency);
+}
+
+// src/commands/build-family.ts
+function registerBuildFamilyCommand(program2) {
+  program2.command("build:family <name>").description("Build all packages in a named family with a single shared version.").option("--dry-run", "Print what would happen without making any changes").option("--no-publish", "Skip npm publish").option("--no-git", "Skip git operations").option("--config <path>", "Path to config file").option("--concurrency <n>", "Override concurrency").action(async (familyName, opts) => {
+    const configPath = opts.config ?? findDefaultConfigPath(process.cwd());
+    const { config, configDir } = await loadConfig(configPath);
+    const rawOpts = opts;
+    const shouldPublish = rawOpts["publish"] !== false;
+    const buildOptions = {
+      dryRun: opts.dryRun ?? false,
+      noPublish: !shouldPublish,
+      noGit: opts.noGit ?? false,
+      concurrency: opts.concurrency ? parseInt(opts.concurrency, 10) : void 0,
+      configPath
+    };
+    const family = (config.families ?? []).find((f) => f.name === familyName);
+    if (!family) {
+      const available = (config.families ?? []).map((f) => f.name).join(", ");
+      logger.error(
+        `Family "${familyName}" not found. Available families: ${available || "(none)"}`
+      );
+      process.exit(1);
+    }
+    const results = await buildFamily(family, config.settings, buildOptions, configDir);
+    const anyFailed = results.some((r) => !r.success);
+    process.exit(anyFailed ? 1 : 0);
+  });
+}
+
+// src/commands/build-all.ts
+function registerBuildAllCommand(program2) {
+  program2.command("build:all").description("Build all standalone packages and all families.").option("--dry-run", "Print what would happen without making any changes").option("--no-publish", "Skip npm publish").option("--no-git", "Skip git operations").option("--config <path>", "Path to config file").option("--concurrency <n>", "Override concurrency").action(async (opts) => {
+    const configPath = opts.config ?? findDefaultConfigPath(process.cwd());
+    const { config, configDir } = await loadConfig(configPath);
+    const rawOpts = opts;
+    const shouldPublish = rawOpts["publish"] !== false;
+    const buildOptions = {
+      dryRun: opts.dryRun ?? false,
+      noPublish: !shouldPublish,
+      noGit: opts.noGit ?? false,
+      concurrency: opts.concurrency ? parseInt(opts.concurrency, 10) : void 0,
+      configPath
+    };
+    const concurrency = buildOptions.concurrency ?? config.settings.concurrency ?? 4;
+    const allResults = [];
+    const standalone = config.standalone ?? [];
+    if (standalone.length > 0) {
+      logger.info(`Building ${standalone.length} standalone package(s)\u2026`);
+      const standaloneTasks = standalone.map(
+        (pkg) => () => buildPackage(
+          pkg,
+          pkg.version ?? "auto",
+          config.settings,
+          buildOptions,
+          configDir
+        )
+      );
+      const standaloneResults = await runParallel(standaloneTasks, concurrency);
+      allResults.push(...standaloneResults);
+    }
+    const families = config.families ?? [];
+    if (families.length > 0) {
+      logger.info(`Building ${families.length} famil${families.length === 1 ? "y" : "ies"}\u2026`);
+      for (const family of families) {
+        const familyResults = await buildFamily(
+          family,
+          config.settings,
+          buildOptions,
+          configDir
+        );
+        allResults.push(...familyResults);
+      }
+    }
+    const succeeded = allResults.filter((r) => r.success).length;
+    const failed = allResults.filter((r) => !r.success).length;
+    logger.info(`
+Summary: ${succeeded} succeeded, ${failed} failed out of ${allResults.length} total`);
+    process.exit(failed > 0 ? 1 : 0);
+  });
+}
+
+// src/commands/list.ts
+import chalk2 from "chalk";
+function registerListCommand(program2) {
+  program2.command("list").description("List all registered standalone packages and families.").option("--config <path>", "Path to config file").action(async (opts) => {
+    const configPath = opts.config ?? findDefaultConfigPath(process.cwd());
+    const { config, configDir } = await loadConfig(configPath);
+    const standalone = config.standalone ?? [];
+    const families = config.families ?? [];
+    console.log(chalk2.bold("\n=== Standalone Packages ==="));
+    if (standalone.length === 0) {
+      console.log(chalk2.gray("  (none)"));
+    } else {
+      for (const pkg of standalone) {
+        const root = resolvePath(configDir, pkg.root);
+        let version = "?";
+        try {
+          const json = readSourcePackageJson(root, pkg.name);
+          version = json.version;
+        } catch {
+          version = chalk2.red("(package.json missing)");
+        }
+        const type = pkg.type ?? "typescript";
+        const formats = (pkg.formats ?? ["esm", "cjs"]).join(", ");
+        console.log(
+          `  ${chalk2.cyan(pkg.name)} ${chalk2.yellow(`v${version}`)}` + chalk2.gray(` [${type}] [${formats}]`)
+        );
+        console.log(chalk2.gray(`    root: ${root}`));
+      }
+    }
+    console.log(chalk2.bold("\n=== Families ==="));
+    if (families.length === 0) {
+      console.log(chalk2.gray("  (none)"));
+    } else {
+      for (const family of families) {
+        console.log(chalk2.bold(`
+  Family: ${chalk2.magenta(family.name)}`));
+        for (const pkg of family.packages) {
+          const root = resolvePath(configDir, pkg.root);
+          let version = "?";
+          try {
+            const json = readSourcePackageJson(root, pkg.name);
+            version = json.version;
+          } catch {
+            version = chalk2.red("(package.json missing)");
+          }
+          const type = pkg.type ?? "typescript";
+          const formats = (pkg.formats ?? ["esm", "cjs"]).join(", ");
+          console.log(
+            `    ${chalk2.cyan(pkg.name)} ${chalk2.yellow(`v${version}`)}` + chalk2.gray(` [${type}] [${formats}]`)
+          );
+          console.log(chalk2.gray(`      root: ${root}`));
+        }
+      }
+    }
+    console.log("");
+  });
+}
+
+// src/commands/validate.ts
+import chalk3 from "chalk";
+import fs5 from "fs";
+function registerValidateCommand(program2) {
+  program2.command("validate").description("Validate the config file and check that all package roots exist.").option("--config <path>", "Path to config file").action(async (opts) => {
+    const configPath = opts.config ?? findDefaultConfigPath(process.cwd());
+    let config;
+    let configDir;
+    try {
+      const loaded = await loadConfig(configPath);
+      config = loaded.config;
+      configDir = loaded.configDir;
+    } catch (err) {
+      logger.error(
+        `Config load failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+    const issues = [];
+    const allPackages = [
+      ...(config.standalone ?? []).map((p) => ({
+        name: p.name,
+        root: p.root,
+        context: "standalone"
+      })),
+      ...(config.families ?? []).flatMap(
+        (f) => f.packages.map((p) => ({
+          name: p.name,
+          root: p.root,
+          context: `family:${f.name}`
+        }))
+      )
+    ];
+    for (const { name, root, context } of allPackages) {
+      const abs = resolvePath(configDir, root);
+      if (!fs5.existsSync(abs)) {
+        issues.push({
+          level: "error",
+          message: `[${context}] "${name}": root does not exist \u2014 ${abs}`
+        });
+        continue;
+      }
+      const pkgJsonPath = resolvePath(abs, "package.json");
+      if (!fs5.existsSync(pkgJsonPath)) {
+        issues.push({
+          level: "error",
+          message: `[${context}] "${name}": package.json not found at ${pkgJsonPath}`
+        });
+        continue;
+      }
+      try {
+        const raw = fs5.readFileSync(pkgJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed["version"]) {
+          issues.push({
+            level: "error",
+            message: `[${context}] "${name}": package.json is missing "version" field`
+          });
+        }
+      } catch (err) {
+        issues.push({
+          level: "error",
+          message: `[${context}] "${name}": failed to parse package.json \u2014 ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
+    const buildDir = resolvePath(configDir, config.settings.buildDir);
+    if (!fs5.existsSync(buildDir)) {
+      issues.push({
+        level: "warn",
+        message: `settings.buildDir does not exist yet and will be created on first build: ${buildDir}`
+      });
+    }
+    if (issues.length === 0) {
+      console.log(chalk3.green(`Config is valid. ${allPackages.length} package(s) found.`));
+      process.exit(0);
+    } else {
+      const errors = issues.filter((i) => i.level === "error");
+      const warnings = issues.filter((i) => i.level === "warn");
+      for (const issue of warnings) {
+        console.log(chalk3.yellow(`WARN  ${issue.message}`));
+      }
+      for (const issue of errors) {
+        console.log(chalk3.red(`ERROR ${issue.message}`));
+      }
+      console.log(
+        `
+${errors.length} error(s), ${warnings.length} warning(s) found.`
+      );
+      process.exit(errors.length > 0 ? 1 : 0);
+    }
+  });
+}
+
+// src/cli.ts
+var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+var cliVersion = "1.0.0";
+try {
+  const pkgPath = path5.resolve(__dirname2, "../package.json");
+  const raw = readFileSync(pkgPath, "utf-8");
+  const pkg = JSON.parse(raw);
+  cliVersion = pkg.version ?? "1.0.0";
+} catch {
+}
+var program = new Command();
+program.name("pkgist").description("Build, version, and publish TypeScript npm packages using tsdown.").version(cliVersion).option("--verbose", "Enable verbose debug logging", false).hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.verbose) {
+    setVerbose(true);
+  }
+});
+registerBuildCommand(program);
+registerBuildFamilyCommand(program);
+registerBuildAllCommand(program);
+registerListCommand(program);
+registerValidateCommand(program);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map