@dbx-tools/projen 0.9.105 → 0.9.108

package/README.md

@@ -584,30 +584,37 @@ release [options]
 
 #### Options
 
-| Option                                | Description                                                                                   |
-| ------------------------------------- | --------------------------------------------------------------------------------------------- |
-| `--root <path>`                       | repository root                                                                               |
-| `--branch <name>`                     | release branch (default: "main")                                                              |
-| `--prefix <prefix>`                   | release tag prefix (default: "v")                                                             |
-| `--remote <name>`                     | git remote (default: "origin")                                                                |
-| `--python-root <path>`                | Python package root for local publish (default: "packages/py")                                |
-| `--validate <task>`                   | task to run before pushing (default: [])                                                      |
-| `--no-bump`                           | use an existing synchronized local version bump                                               |
-| `--publish <target>`                  | publication scope (choices: "auto", "npm", "pypi", "local", "none", default: "auto")          |
-| `--install <mode>`                    | local workspace dependency installation (choices: "auto", "always", "never", default: "auto") |
-| `--no-npm`                            | skip npm build and publication, including local npm publication                               |
-| `--no-pypi`                           | skip Python build and publication, including local Python publication                         |
-| `--docs`                              | build and deploy docs for a selected scope                                                    |
-| `--no-docs`                           | skip documentation build and deployment                                                       |
-| `--no-validation`                     | skip optional release validation tasks; workspace version checks remain mandatory             |
-| `--no-release-notes`                  | skip writing docs/releases notes (Genie and git-log fallback)                                 |
-| `--release-notes-text <markdown>`     | write supplied markdown without invoking Genie                                                |
-| `--release-notes-file <path>`         | copy supplied markdown without invoking Genie                                                 |
-| `--release-notes-instructions <text>` | append custom instructions to the Genie release-notes prompt                                  |
-| `--demo-deploy`                       | after tagging, stage and deploy the AppKit demo app (off by default)                          |
-| `--profile <name>`                    | Databricks CLI profile for --demo-deploy                                                      |
-| `--no-local-publish`                  | skip publishing to configured local registries                                                |
-| `--local-registry <auto\|false\|url>` | local npm registry selection (default: "auto")                                                |
-| `--local-pypi <auto\|false\|url>`     | local devpi registry selection (default: "auto")                                              |
+| Option                                 | Description                                                                                                                |
+| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `--root <value>`                       | Repository or workspace root (env: PROJEN_RELEASE_ROOT)                                                                    |
+| `--branch <value>`                     | Release branch (default: "main", env: PROJEN_RELEASE_BRANCH)                                                               |
+| `--prefix <value>`                     | Release tag prefix (default: "v", env: PROJEN_RELEASE_PREFIX)                                                              |
+| `--remote <value>`                     | Git remote (default: "origin", env: PROJEN_RELEASE_REMOTE)                                                                 |
+| `--python-root <value>`                | Python package root for local publish (default: "packages/py", env: PROJEN_RELEASE_PYTHON_ROOT)                            |
+| `--validate <value>`                   | Repeatable task to run before pushing (default: [], env: PROJEN_RELEASE_VALIDATE)                                          |
+| `--bump`                               | Create and synchronize a patch version bump (default: true, env: PROJEN_RELEASE_BUMP)                                      |
+| `--no-bump`                            | Disable create and synchronize a patch version bump                                                                        |
+| `--publish <value>`                    | Publication scope (choices: "auto", "npm", "pypi", "local", "none", default: "auto", env: PROJEN_RELEASE_PUBLISH)          |
+| `-i, --install <value>`                | Local workspace dependency installation (choices: "auto", "always", "never", default: "auto", env: PROJEN_RELEASE_INSTALL) |
+| `-n, --npm`                            | Build and publish npm packages (default: true, env: PROJEN_RELEASE_NPM)                                                    |
+| `--no-npm`                             | Disable build and publish npm packages                                                                                     |
+| `--pypi`                               | Build and publish Python packages (default: true, env: PROJEN_RELEASE_PYPI)                                                |
+| `--no-pypi`                            | Disable build and publish python packages                                                                                  |
+| `--docs`                               | Build and deploy documentation (env: PROJEN_RELEASE_DOCS)                                                                  |
+| `--no-docs`                            | Disable build and deploy documentation                                                                                     |
+| `--validation`                         | Run optional release validation tasks before publishing (default: true, env: PROJEN_RELEASE_VALIDATION)                    |
+| `--no-validation`                      | Disable run optional release validation tasks before publishing                                                            |
+| `--release-notes`                      | Write release notes before tagging (default: true, env: PROJEN_RELEASE_RELEASE_NOTES)                                      |
+| `--no-release-notes`                   | Disable write release notes before tagging                                                                                 |
+| `--release-notes-text <value>`         | Write supplied release-note Markdown without invoking Genie (env: PROJEN_RELEASE_RELEASE_NOTES_TEXT)                       |
+| `--release-notes-file <value>`         | Copy release-note Markdown from this file without invoking Genie (env: PROJEN_RELEASE_RELEASE_NOTES_FILE)                  |
+| `--release-notes-instructions <value>` | Append instructions to the Genie release-note prompt (env: PROJEN_RELEASE_RELEASE_NOTES_INSTRUCTIONS)                      |
+| `--demo-deploy`                        | Deploy the AppKit demo after tagging and local publication (env: PROJEN_RELEASE_DEMO_DEPLOY)                               |
+| `--no-demo-deploy`                     | Disable deploy the appkit demo after tagging and local publication                                                         |
+| `--profile <value>`                    | Explicit Databricks CLI profile for demo deployment                                                                        |
+| `--local-publish`                      | Publish to configured local registries (default: true, env: PROJEN_RELEASE_LOCAL_PUBLISH)                                  |
+| `--no-local-publish`                   | Disable publish to configured local registries                                                                             |
+| `--local-registry <value>`             | Local npm registry selection: auto, false, or URL (default: "auto", env: PROJEN_RELEASE_LOCAL_REGISTRY)                    |
+| `--local-pypi <value>`                 | Local devpi registry selection: auto, false, or URL (default: "auto", env: PROJEN_RELEASE_LOCAL_PYPI)                      |
 
 <!-- cli-reference:end -->

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
-export const PACKAGE_VERSION = "0.9.105";
+export const PACKAGE_VERSION = "0.9.108";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";

package/package.json

@@ -30,9 +30,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "^0.9.105",
-    "@dbx-tools/path": "^0.9.105",
-    "@dbx-tools/shared-core": "^0.9.105",
+    "@dbx-tools/cli-args": "^0.9.108",
+    "@dbx-tools/core": "^0.9.108",
+    "@dbx-tools/path": "^0.9.108",
+    "@dbx-tools/shared-core": "^0.9.108",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -44,7 +45,7 @@
     "ts-to-zod": "^5.1.0",
     "typescript": "^5.9.3",
     "yaml": "^2.9.0",
-    "zod": "^4.3.6"
+    "zod": "4.3.6"
   },
   "devEngines": {
     "packageManager": {
@@ -54,7 +55,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.9.105",
+  "version": "0.9.108",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/project-py.ts

@@ -613,7 +613,9 @@ export class DBXToolsPythonWorkspace extends Component {
         run: [
           'bun node_modules/@dbx-tools/projen/tasks/publish-python.ts "$RELEASE_VERSION"',
           `--root ${JSON.stringify(this.repository.root)}`,
-          `--package ${allPublications.map((publication) => JSON.stringify(publication.directory)).join(" ")}`,
+          allPublications
+            .map((publication) => `--package ${JSON.stringify(publication.directory)}`)
+            .join(" "),
           "--output .release/python --package-directories",
         ].join(" \\\n  "),
       },

package/tasks/barrels.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env -S bun
 /** Generate package barrels once or keep affected barrels current in watch mode. */
 import { sep } from "node:path";
-import { parseArgs } from "node:util";
 import { log, object, stringUtils } from "@dbx-tools/shared-core";
+import { z } from "zod";
+import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
+import { TaskDirectoriesOptionSchema, TaskWatchOptionSchema } from "./options.ts";
 import { generateBarrels } from "../src/barrels.ts";
 import { recordedPackages } from "../src/packages.ts";
 import { watchLoop, watchRoots } from "../src/watch.ts";
@@ -35,15 +37,21 @@ function warnUnownedChanges(changed: readonly string[]): void {
   }
 }
 
-export function main(args: string[] = process.argv.slice(2)): void {
-  const { values } = parseArgs({
+export const BarrelsOptionsSchema = z.object({
+  watch: TaskWatchOptionSchema,
+  dir: TaskDirectoriesOptionSchema.describe("Repeatable package directory to rebuild"),
+});
+
+export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
+  const values = await taskOptions(
+    taskCommand(
+      import.meta.url,
+      "Generate package barrels once or keep them current",
+      BarrelsOptionsSchema,
+    ),
+    BarrelsOptionsSchema,
     args,
-    options: {
-      watch: { type: "boolean" },
-      dir: { type: "string", multiple: true },
-    },
-    strict: false,
-  });
+  );
 
   if (values.watch) {
     // Watch the package roots; a source edit inside a package rebuilds just that
@@ -70,9 +78,7 @@ export function main(args: string[] = process.argv.slice(2)): void {
       },
     );
   } else {
-    const dirs = Array.isArray(values.dir)
-      ? values.dir.filter((value): value is string => typeof value === "string")
-      : [];
+    const dirs = values.dir;
     const n = generateBarrels(dirs.length ? { dirs } : undefined);
     logger.success(
       n === 0 ? "barrels already up to date" : `updated ${stringUtils.pluralize(n, "barrel")}`,
@@ -80,4 +86,4 @@ export function main(args: string[] = process.argv.slice(2)): void {
   }
 }
 
-if (import.meta.main) main();
+await runTaskMain(import.meta, main);

package/tasks/bump.ts

@@ -6,7 +6,9 @@
  */
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { log } from "@dbx-tools/shared-core";
-import { Command, Option } from "commander";
+import { z } from "zod";
+import { runTaskMain, taskCommand, taskOptions, taskRoot } from "./cli.ts";
+import { TaskRootOptionSchema } from "./options.ts";
 import { runTaskCommand } from "../src/_task-command.ts";
 import {
   resolveNextVersion,
@@ -16,35 +18,38 @@ import {
 
 const logger = log.logger("projen:bump");
 
-export async function main(): Promise<void> {
-  const program = new Command();
-  program
-    .description("Increment VERSION and synchronize generated workspace versions")
-    .addOption(
-      new Option("-l, --level <level>", "semver increment")
-        .choices(["patch", "minor", "major"])
-        .default("patch"),
-    )
-    .option("--no-synth", "write VERSION without synchronizing generated files")
-    .action((opts: { level: VersionLevel; synth: boolean }) => {
-      const root = projectUtils.root() ?? process.cwd();
-      const next = resolveNextVersion(root, opts.level);
+export const BumpOptionsSchema = z.object({
+  root: TaskRootOptionSchema,
+  level: z
+    .enum(["patch", "minor", "major"])
+    .default("patch")
+    .describe("Semantic version increment")
+    .meta({ short: "l" }),
+  synth: z.boolean().default(true).describe("Synchronize generated workspace versions"),
+});
 
-      logger.info(`bump ${next.base} -> ${next.version} (${opts.level})`);
-      writeWorkspaceVersion(root, next.version);
+export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
+  const options = await taskOptions(
+    taskCommand(
+      import.meta.url,
+      "Increment VERSION and synchronize generated workspace versions",
+      BumpOptionsSchema,
+    ),
+    BumpOptionsSchema,
+    args,
+  );
+  const root = taskRoot(options.root ?? projectUtils.root());
+  const level: VersionLevel = options.level;
+  const next = resolveNextVersion(root, level);
 
-      if (opts.synth) {
-        runTaskCommand(root, process.execPath, [".projenrc.ts"]);
-        // Package manifests are generated during the first synthesis, while
-        // cross-package derived artifacts can read those manifests earlier in
-        // the same pass. A second pass makes the new version visible to every
-        // generator and leaves release validation on a converged tree.
-        runTaskCommand(root, process.execPath, [".projenrc.ts"]);
-      }
-      logger.success(`workspace version synchronized at ${next.version}`);
-    });
+  logger.info(`bump ${next.base} -> ${next.version} (${level})`);
+  writeWorkspaceVersion(root, next.version);
 
-  await program.parseAsync();
+  if (options.synth) {
+    runTaskCommand(root, process.execPath, [".projenrc.ts"]);
+    runTaskCommand(root, process.execPath, [".projenrc.ts"]);
+  }
+  logger.success(`workspace version synchronized at ${next.version}`);
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);

package/tasks/clean.ts

@@ -2,12 +2,30 @@
 /** Interactively remove generated files and installed dependency directories. */
 import { relative } from "node:path";
 import { log, stringUtils } from "@dbx-tools/shared-core";
+import { z } from "zod";
+import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
 import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
 import { repoRoot, toPosix } from "../src/packages.ts";
 
 const logger = log.logger("projen:clean");
+export const CleanOptionsSchema = z.object({
+  yes: z
+    .boolean()
+    .default(false)
+    .describe("Remove every generated and dependency path without prompting")
+    .meta({ short: "y", env: [] }),
+});
+
 export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
-  const yes = args.includes("-y") || args.includes("--yes");
+  const { yes } = await taskOptions(
+    taskCommand(
+      import.meta.url,
+      "Remove generated files and dependency directories",
+      CleanOptionsSchema,
+    ),
+    CleanOptionsSchema,
+    args,
+  );
 
   const files = listGeneratedFiles();
   const nodeModules = listNodeModulesDirs();
@@ -69,4 +87,4 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   clack.outro(`removed ${stringUtils.pluralize(n, "path")} - ${regenHint(removedNodeModules)}`);
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);

package/tasks/cli.ts

@@ -0,0 +1,80 @@
+/** Shared Commander and entrypoint integration for Projen task CLIs. */
+import { basename, extname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { addArgs, parseArgs, type CliArgsOptions } from "@dbx-tools/cli-args";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { stringUtils } from "@dbx-tools/shared-core";
+import { Command } from "commander";
+import { z } from "zod";
+
+/** Stable task name derived from its source filename. */
+export function taskName(moduleUrl: string): string {
+  const file = basename(fileURLToPath(moduleUrl));
+  return file.slice(0, -extname(file).length);
+}
+
+/** Config resolution shared by task schemas. */
+export function taskCliArgsOptions(moduleUrl: string): CliArgsOptions {
+  const prefix = [...stringUtils.tokenize(taskName(moduleUrl))].join("_").toUpperCase();
+  return {
+    cwd: process.cwd(),
+    prefix: `PROJEN_${prefix}`,
+    sources: ["env", "dotenv"],
+  };
+}
+
+/** Create a task command and bind every Zod-owned option through cli-args. */
+export function taskCommand<T extends z.ZodRawShape>(
+  moduleUrl: string,
+  description: string,
+  schema: z.ZodObject<T>,
+): Command {
+  return addArgs(
+    new Command().name(taskName(moduleUrl)).description(description),
+    schema,
+    taskCliArgsOptions(moduleUrl),
+  );
+}
+
+/** Parse one task's flags and layered environment values through its schema. */
+export async function taskOptions<T extends z.ZodRawShape>(
+  command: Command,
+  schema: z.ZodObject<T>,
+  argv: readonly string[] = process.argv.slice(2),
+): Promise<z.output<z.ZodObject<T>>> {
+  await command.parseAsync([...argv], { from: "user" });
+  return parseArgs(command, schema);
+}
+
+/** Read one already-parsed task command through its owning Zod schema. */
+export function parsedTaskOptions<T extends z.ZodRawShape>(
+  command: Command,
+  schema: z.ZodObject<T>,
+): z.output<z.ZodObject<T>> {
+  return parseArgs(command, schema);
+}
+
+/** Read positional arguments after Commander has parsed one task command. */
+export function taskPositionals(command: Command): readonly unknown[] {
+  return command.processedArgs;
+}
+
+/** Resolve the explicit task root or discover the current project root. */
+export function taskRoot(root?: string): string {
+  return resolve(root ?? projectUtils.root() ?? process.cwd());
+}
+
+/** True when an imported task module is the active Bun or Node entrypoint. */
+export function isTaskMain(meta: ImportMeta): boolean {
+  if (meta.main) return true;
+  const entry = process.argv[1];
+  return Boolean(entry && pathToFileURL(resolve(entry)).href === meta.url);
+}
+
+/** Run a task only when its module is the active process entrypoint. */
+export async function runTaskMain(
+  meta: ImportMeta,
+  main: () => void | Promise<void>,
+): Promise<void> {
+  if (isTaskMain(meta)) await main();
+}

package/tasks/compile-workspace.ts

@@ -5,6 +5,7 @@ import { availableParallelism } from "node:os";
 import { join, resolve } from "node:path";
 import * as exec from "@dbx-tools/core/exec";
 import { log } from "@dbx-tools/shared-core";
+import { runTaskMain } from "./cli.ts";
 
 const logger = log.logger("projen:compile");
 
@@ -142,4 +143,4 @@ async function compileCustomPackage(pkg: {
   return result!;
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);

package/tasks/dev-watch.ts

@@ -1,11 +1,12 @@
 #!/usr/bin/env -S bun
 /** Restart a development command after relevant workspace changes settle. */
 import { isAbsolute, relative, resolve } from "node:path";
-import { configUtils } from "@dbx-tools/core";
 import * as exec from "@dbx-tools/core/exec";
 import { watch as pathWatch } from "@dbx-tools/path";
 import { log } from "@dbx-tools/shared-core";
-import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
+import { CommanderError } from "commander";
+import { z } from "zod";
+import { parsedTaskOptions, runTaskMain, taskCommand, taskPositionals } from "./cli.ts";
 import {
   DEV_RESTART_DEBOUNCE_MS,
   DEV_RESTART_KEY,
@@ -30,73 +31,57 @@ export interface DevWatchOptions {
   readonly serverWatchDisabled: boolean;
 }
 
+export const DevWatchOptionsSchema = z.object({
+  debounceMs: z.coerce
+    .number()
+    .int()
+    .nonnegative("Debounce must be a non-negative number of milliseconds")
+    .default(DEV_RESTART_DEBOUNCE_MS)
+    .describe("Quiet period before restarting the command"),
+  restartKey: z
+    .string()
+    .refine((value) => Array.from(value).length === 1, "Restart key must be exactly one character")
+    .default(DEV_RESTART_KEY)
+    .describe("Interactive immediate-restart key"),
+  serverWatchDisabled: z
+    .boolean()
+    .default(false)
+    .describe("Run the command once without watching")
+    .meta({ env: SERVER_WATCH_DISABLED_ENV }),
+});
+
 interface WorkspacePackage {
   readonly dir: string;
   readonly name?: string;
 }
 
-function debounceMilliseconds(value: string): number {
-  const parsed = configUtils.toNumber(value);
-  if (parsed === undefined || parsed < 0) {
-    throw new InvalidArgumentError("must be a non-negative number of milliseconds");
-  }
-  return parsed;
-}
-
-function singleKey(value: string): string {
-  if (Array.from(value).length !== 1) {
-    throw new InvalidArgumentError("must be exactly one character");
-  }
-  return value;
-}
-
 /** Parse watcher flags while passing every token after the command through unchanged. */
-export function parseDevWatchOptions(args: string[]): DevWatchOptions {
-  const program = new Command()
+export function parseDevWatchOptions(args: readonly string[]): DevWatchOptions {
+  const program = taskCommand(
+    import.meta.url,
+    "Restart a development command after watched changes settle",
+    DevWatchOptionsSchema,
+  )
     .name(DEV_WATCH_TASK)
-    .description("Restart a development command after watched changes settle")
     .exitOverride()
     .configureOutput({
       writeErr: (message) => {
-        if (import.meta.main) process.stderr.write(message);
+        if (process.argv[1]) process.stderr.write(message);
       },
     })
     .enablePositionalOptions()
     .passThroughOptions()
-    .addOption(
-      new Option("--debounce-ms <milliseconds>", "quiet period before restart")
-        .default(DEV_RESTART_DEBOUNCE_MS)
-        .argParser(debounceMilliseconds),
-    )
-    .addOption(
-      new Option("--restart-key <key>", "interactive immediate-restart key")
-        .default(DEV_RESTART_KEY)
-        .argParser(singleKey),
-    )
-    .addOption(
-      new Option(
-        "--server-watch-disabled",
-        `run the command once without watching (${SERVER_WATCH_DISABLED_ENV})`,
-      ),
-    )
     .argument("<command>")
     .argument("[args...]")
-    .parse(["bun", DEV_WATCH_TASK, ...args]);
-  const options = program.opts<{
-    debounceMs: number;
-    restartKey: string;
-    serverWatchDisabled?: boolean;
-  }>();
-  const [command, commandArgs = []] = program.processedArgs as [string, string[]?];
-  const serverWatchDisabled =
-    options.serverWatchDisabled === true ||
-    configUtils.boolean(undefined, SERVER_WATCH_DISABLED_ENV, configUtils.ENV_ONLY) === true;
-  if (serverWatchDisabled) process.env[SERVER_WATCH_DISABLED_ENV] = "1";
+    .parse([...args], { from: "user" });
+  const options = parsedTaskOptions(program, DevWatchOptionsSchema);
+  const [command, commandArgs = []] = taskPositionals(program) as [string, string[]?];
+  if (options.serverWatchDisabled) process.env[SERVER_WATCH_DISABLED_ENV] = "1";
   return {
     command: [command, ...commandArgs],
     debounceMs: options.debounceMs,
     restartKey: options.restartKey,
-    serverWatchDisabled,
+    serverWatchDisabled: options.serverWatchDisabled,
   };
 }
 
@@ -336,4 +321,4 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   await complete;
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);

package/tasks/options.ts

@@ -0,0 +1,59 @@
+/** Shared Zod option fields for Projen task CLIs. */
+import { z } from "zod";
+
+/** Optional repository or workspace root. */
+export const TaskRootOptionSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .optional()
+  .describe("Repository or workspace root");
+
+/** Required project directory. */
+export const TaskProjectOptionSchema = z.string().trim().min(1).describe("Project directory");
+
+/** Check generated state without writing changes. */
+export const TaskCheckOptionSchema = z
+  .boolean()
+  .default(false)
+  .describe("Check generated state without writing changes");
+
+/** Force work even when fingerprints or generated state appear current. */
+export const TaskForceOptionSchema = z
+  .boolean()
+  .default(false)
+  .describe("Force regeneration even when outputs appear current");
+
+/** Keep a task running and react to changes. */
+export const TaskWatchOptionSchema = z
+  .boolean()
+  .default(false)
+  .describe("Watch inputs and keep generated state current");
+
+/** Validate publication artifacts without uploading them. */
+export const TaskDryRunOptionSchema = z
+  .boolean()
+  .default(false)
+  .describe("Validate artifacts without publishing them");
+
+/** Optional output directory. */
+export const TaskOutputOptionSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .optional()
+  .describe("Output directory");
+
+/** Positive worker concurrency. */
+export const TaskConcurrencyOptionSchema = z.coerce
+  .number()
+  .int()
+  .positive()
+  .optional()
+  .describe("Maximum concurrent workers");
+
+/** Repeatable package or directory selection. */
+export const TaskDirectoriesOptionSchema = z
+  .array(z.string().trim().min(1))
+  .default([])
+  .describe("Repeatable package or directory selection");

package/tasks/projenrc.ts

@@ -2,6 +2,7 @@
 /** Resynthesize when the root definition or configured generator inputs change. */
 import { resolve } from "node:path";
 import { log } from "@dbx-tools/shared-core";
+import { runTaskMain } from "./cli.ts";
 import { repoRoot, syncResynthPaths } from "../src/packages.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { watchLoop } from "../src/watch.ts";
@@ -38,4 +39,4 @@ export function main(): void {
   );
 }
 
-if (import.meta.main) main();
+await runTaskMain(import.meta, main);

package/tasks/publish-npm.ts

@@ -16,7 +16,9 @@ import { join, relative, resolve } from "node:path";
 import * as exec from "@dbx-tools/core/exec";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { log } from "@dbx-tools/shared-core";
-import { Command } from "commander";
+import { z } from "zod";
+import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
+import { TaskDryRunOptionSchema } from "./options.ts";
 import { runTaskCommand } from "../src/_task-command.ts";
 
 const DEFAULT_REGISTRY = "https://registry.npmjs.org";
@@ -451,18 +453,27 @@ export async function publishNpmArchives(options: {
 }
 
 /** Parse npm archive publication options and execute the publisher. */
-export async function main(): Promise<void> {
-  const program = new Command();
-  program
-    .requiredOption("--directory <path>", "Directory containing npm archives")
-    .option("--version <version>", "Expected npm release version")
-    .option("--registry <url>", "npm registry URL")
-    .option("--dry-run", "Validate archives without publishing")
-    .action(
-      (options: { directory: string; dryRun?: boolean; registry?: string; version?: string }) =>
-        publishNpmArchives(options),
-    );
-  await program.parseAsync();
+export const PublishNpmOptionsSchema = z.object({
+  directory: z.string().trim().min(1).describe("Directory containing npm archives"),
+  version: z.string().trim().min(1).optional().describe("Expected npm release version"),
+  registry: z
+    .string()
+    .trim()
+    .min(1)
+    .optional()
+    .describe("npm registry URL")
+    .meta({ env: "NPM_CONFIG_REGISTRY" }),
+  dryRun: TaskDryRunOptionSchema,
+});
+
+/** Parse task options and publish validated npm release archives. */
+export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
+  const options = await taskOptions(
+    taskCommand(import.meta.url, "Publish validated npm release archives", PublishNpmOptionsSchema),
+    PublishNpmOptionsSchema,
+    args,
+  );
+  await publishNpmArchives(options);
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);