@mongez/pkgist 1.0.0

package/src/commands/build-all.ts

@@ -0,0 +1,88 @@
+import type { Command } from "commander";
+import { loadConfig, findDefaultConfigPath } from "../config/index.js";
+import { buildPackage } from "../build/package-builder.js";
+import { buildFamily } from "../build/family-builder.js";
+import { runParallel } from "../build/parallel-builder.js";
+import { logger } from "../utils/logger.js";
+import type { BuildOptions } from "../types/index.js";
+import type { BuildResult } from "../build/package-builder.js";
+
+interface BuildAllOptions {
+  dryRun?: boolean;
+  noPublish?: boolean;
+  noGit?: boolean;
+  config?: string;
+  concurrency?: string;
+}
+
+export function registerBuildAllCommand(program: Command): void {
+  program
+    .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: BuildAllOptions) => {
+      const configPath =
+        opts.config ?? findDefaultConfigPath(process.cwd());
+
+      const { config, configDir } = await loadConfig(configPath);
+
+      const rawOpts = opts as Record<string, unknown>;
+      const shouldPublish = rawOpts["publish"] !== false;
+
+      const buildOptions: BuildOptions = {
+        dryRun: opts.dryRun ?? false,
+        noPublish: !shouldPublish,
+        noGit: opts.noGit ?? false,
+        concurrency: opts.concurrency ? parseInt(opts.concurrency, 10) : undefined,
+        configPath,
+      };
+
+      const concurrency = buildOptions.concurrency ?? config.settings.concurrency ?? 4;
+
+      const allResults: BuildResult[] = [];
+
+      // Build all standalone packages in parallel
+      const standalone = config.standalone ?? [];
+      if (standalone.length > 0) {
+        logger.info(`Building ${standalone.length} standalone package(s)…`);
+        const standaloneTasks = standalone.map(
+          (pkg) => () =>
+            buildPackage(
+              pkg,
+              pkg.version ?? "auto",
+              config.settings,
+              buildOptions,
+              configDir,
+            ),
+        );
+        const standaloneResults = await runParallel(standaloneTasks, concurrency);
+        allResults.push(...standaloneResults);
+      }
+
+      // Build all families sequentially (families share a version; running
+      // multiple families in parallel is fine since they're independent)
+      const families = config.families ?? [];
+      if (families.length > 0) {
+        logger.info(`Building ${families.length} famil${families.length === 1 ? "y" : "ies"}…`);
+        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(`\nSummary: ${succeeded} succeeded, ${failed} failed out of ${allResults.length} total`);
+      process.exit(failed > 0 ? 1 : 0);
+    });
+}

package/src/commands/build-family.ts

@@ -0,0 +1,55 @@
+import type { Command } from "commander";
+import { loadConfig, findDefaultConfigPath } from "../config/index.js";
+import { buildFamily } from "../build/family-builder.js";
+import { logger } from "../utils/logger.js";
+import type { BuildOptions } from "../types/index.js";
+
+interface BuildFamilyOptions {
+  dryRun?: boolean;
+  noPublish?: boolean;
+  noGit?: boolean;
+  config?: string;
+  concurrency?: string;
+}
+
+export function registerBuildFamilyCommand(program: Command): void {
+  program
+    .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: string, opts: BuildFamilyOptions) => {
+      const configPath =
+        opts.config ?? findDefaultConfigPath(process.cwd());
+
+      const { config, configDir } = await loadConfig(configPath);
+
+      const rawOpts = opts as Record<string, unknown>;
+      const shouldPublish = rawOpts["publish"] !== false;
+
+      const buildOptions: BuildOptions = {
+        dryRun: opts.dryRun ?? false,
+        noPublish: !shouldPublish,
+        noGit: opts.noGit ?? false,
+        concurrency: opts.concurrency ? parseInt(opts.concurrency, 10) : undefined,
+        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);
+    });
+}

package/src/commands/build.ts

@@ -0,0 +1,84 @@
+import type { Command } from "commander";
+import { loadConfig, findDefaultConfigPath } from "../config/index.js";
+import { buildPackage } from "../build/package-builder.js";
+import { runParallel } from "../build/parallel-builder.js";
+import { logger } from "../utils/logger.js";
+import type { BuildOptions } from "../types/index.js";
+
+interface BuildCommandOptions {
+  all?: boolean;
+  dryRun?: boolean;
+  noPublish?: boolean;
+  noGit?: boolean;
+  config?: string;
+  concurrency?: string;
+}
+
+export function registerBuildCommand(program: Command): void {
+  program
+    .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: string[], opts: BuildCommandOptions) => {
+      const configPath =
+        opts.config ?? findDefaultConfigPath(process.cwd());
+
+      const { config, configDir } = await loadConfig(configPath);
+
+      const buildOptions: 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) : undefined,
+        configPath,
+      };
+
+      // Fix: commander's --no-publish sets opts.publish = false (not opts.noPublish)
+      // We need to check for the raw value
+      const rawOpts = opts as Record<string, unknown>;
+      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);
+    });
+}

package/src/commands/index.ts

@@ -0,0 +1,5 @@
+export { registerBuildCommand } from "./build.js";
+export { registerBuildFamilyCommand } from "./build-family.js";
+export { registerBuildAllCommand } from "./build-all.js";
+export { registerListCommand } from "./list.js";
+export { registerValidateCommand } from "./validate.js";

package/src/commands/list.ts

@@ -0,0 +1,74 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig, findDefaultConfigPath } from "../config/index.js";
+import { readSourcePackageJson } from "../files/package-json.js";
+import { resolvePath } from "../utils/paths.js";
+
+interface ListOptions {
+  config?: string;
+}
+
+export function registerListCommand(program: Command): void {
+  program
+    .command("list")
+    .description("List all registered standalone packages and families.")
+    .option("--config <path>", "Path to config file")
+    .action(async (opts: ListOptions) => {
+      const configPath = opts.config ?? findDefaultConfigPath(process.cwd());
+      const { config, configDir } = await loadConfig(configPath);
+
+      const standalone = config.standalone ?? [];
+      const families = config.families ?? [];
+
+      console.log(chalk.bold("\n=== Standalone Packages ==="));
+      if (standalone.length === 0) {
+        console.log(chalk.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 = chalk.red("(package.json missing)");
+          }
+          const type = pkg.type ?? "typescript";
+          const formats = (pkg.formats ?? ["esm", "cjs"]).join(", ");
+          console.log(
+            `  ${chalk.cyan(pkg.name)} ${chalk.yellow(`v${version}`)}` +
+              chalk.gray(` [${type}] [${formats}]`),
+          );
+          console.log(chalk.gray(`    root: ${root}`));
+        }
+      }
+
+      console.log(chalk.bold("\n=== Families ==="));
+      if (families.length === 0) {
+        console.log(chalk.gray("  (none)"));
+      } else {
+        for (const family of families) {
+          console.log(chalk.bold(`\n  Family: ${chalk.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 = chalk.red("(package.json missing)");
+            }
+            const type = pkg.type ?? "typescript";
+            const formats = (pkg.formats ?? ["esm", "cjs"]).join(", ");
+            console.log(
+              `    ${chalk.cyan(pkg.name)} ${chalk.yellow(`v${version}`)}` +
+                chalk.gray(` [${type}] [${formats}]`),
+            );
+            console.log(chalk.gray(`      root: ${root}`));
+          }
+        }
+      }
+
+      console.log("");
+    });
+}

package/src/commands/validate.ts

@@ -0,0 +1,125 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import fs from "fs";
+import { loadConfig, findDefaultConfigPath } from "../config/index.js";
+import { resolvePath } from "../utils/paths.js";
+import { logger } from "../utils/logger.js";
+
+interface ValidateOptions {
+  config?: string;
+}
+
+interface ValidationIssue {
+  level: "error" | "warn";
+  message: string;
+}
+
+export function registerValidateCommand(program: Command): void {
+  program
+    .command("validate")
+    .description("Validate the config file and check that all package roots exist.")
+    .option("--config <path>", "Path to config file")
+    .action(async (opts: ValidateOptions) => {
+      const configPath = opts.config ?? findDefaultConfigPath(process.cwd());
+
+      let config: Awaited<ReturnType<typeof loadConfig>>["config"];
+      let configDir: string;
+
+      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: ValidationIssue[] = [];
+
+      // Check all package roots exist
+      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 (!fs.existsSync(abs)) {
+          issues.push({
+            level: "error",
+            message: `[${context}] "${name}": root does not exist — ${abs}`,
+          });
+          continue;
+        }
+
+        const pkgJsonPath = resolvePath(abs, "package.json");
+        if (!fs.existsSync(pkgJsonPath)) {
+          issues.push({
+            level: "error",
+            message: `[${context}] "${name}": package.json not found at ${pkgJsonPath}`,
+          });
+          continue;
+        }
+
+        try {
+          const raw = fs.readFileSync(pkgJsonPath, "utf-8");
+          const parsed = JSON.parse(raw) as Record<string, unknown>;
+          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 — ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          });
+        }
+      }
+
+      // Check buildDir
+      const buildDir = resolvePath(configDir, config.settings.buildDir);
+      if (!fs.existsSync(buildDir)) {
+        issues.push({
+          level: "warn",
+          message: `settings.buildDir does not exist yet and will be created on first build: ${buildDir}`,
+        });
+      }
+
+      // Print results
+      if (issues.length === 0) {
+        console.log(chalk.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(chalk.yellow(`WARN  ${issue.message}`));
+        }
+        for (const issue of errors) {
+          console.log(chalk.red(`ERROR ${issue.message}`));
+        }
+
+        console.log(
+          `\n${errors.length} error(s), ${warnings.length} warning(s) found.`,
+        );
+        process.exit(errors.length > 0 ? 1 : 0);
+      }
+    });
+}

package/src/compile/index.ts

@@ -0,0 +1 @@
+export { compilePackage } from "./tsdown-compiler.js";