@dbx-tools/projen 0.9.106 → 0.9.108

package/tasks/release.ts

@@ -4,8 +4,11 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import * as projectUtils from "@dbx-tools/core/project-utils";
 import { log } from "@dbx-tools/shared-core";
-import { Command, Option } from "commander";
+import type { Command } from "commander";
+import { z } from "zod";
+import { parsedTaskOptions, runTaskMain, taskCommand } from "./cli.ts";
 import { publishLocalRelease } from "./local-publish.ts";
+import { TaskDirectoriesOptionSchema, TaskRootOptionSchema } from "./options.ts";
 import { writeReleaseNotes } from "./release-notes.ts";
 import { assertReleaseVersion } from "./release-version.ts";
 import { captureTaskCommand, runTaskCommand, taskCommandSucceeds } from "../src/_task-command.ts";
@@ -368,101 +371,105 @@ export async function runRelease(
   return tag;
 }
 
-/** Build the release task's native parser without executing git or registry operations. */
+export const ReleaseOptionsSchema = z.object({
+  root: TaskRootOptionSchema,
+  branch: z.string().trim().min(1).default("main").describe("Release branch"),
+  prefix: z.string().default("v").describe("Release tag prefix"),
+  remote: z.string().trim().min(1).default("origin").describe("Git remote"),
+  pythonRoot: z
+    .string()
+    .trim()
+    .min(1)
+    .default("packages/py")
+    .describe("Python package root for local publish"),
+  validate: TaskDirectoriesOptionSchema.describe("Repeatable task to run before pushing"),
+  bump: z.boolean().default(true).describe("Create and synchronize a patch version bump"),
+  publish: z.enum(RELEASE_PUBLISH_TARGETS).default("auto").describe("Publication scope"),
+  install: z
+    .enum(RELEASE_INSTALL_MODES)
+    .default("auto")
+    .describe("Local workspace dependency installation"),
+  npm: z.boolean().default(true).describe("Build and publish npm packages"),
+  pypi: z.boolean().default(true).describe("Build and publish Python packages"),
+  docs: z.boolean().optional().describe("Build and deploy documentation"),
+  validation: z
+    .boolean()
+    .default(true)
+    .describe("Run optional release validation tasks before publishing"),
+  releaseNotes: z.boolean().default(true).describe("Write release notes before tagging"),
+  releaseNotesText: z
+    .string()
+    .optional()
+    .describe("Write supplied release-note Markdown without invoking Genie"),
+  releaseNotesFile: z
+    .string()
+    .trim()
+    .min(1)
+    .optional()
+    .describe("Copy release-note Markdown from this file without invoking Genie"),
+  releaseNotesInstructions: z
+    .string()
+    .optional()
+    .describe("Append instructions to the Genie release-note prompt"),
+  demoDeploy: z
+    .boolean()
+    .optional()
+    .describe("Deploy the AppKit demo after tagging and local publication"),
+  profile: z
+    .string()
+    .trim()
+    .min(1)
+    .optional()
+    .describe("Explicit Databricks CLI profile for demo deployment")
+    .meta({ env: [], helpDefault: false }),
+  localPublish: z.boolean().default(true).describe("Publish to configured local registries"),
+  localRegistry: z
+    .string()
+    .trim()
+    .min(1)
+    .default("auto")
+    .describe("Local npm registry selection: auto, false, or URL"),
+  localPypi: z
+    .string()
+    .trim()
+    .min(1)
+    .default("auto")
+    .describe("Local devpi registry selection: auto, false, or URL"),
+});
+
+/** Build the release task's schema-driven parser without executing release operations. */
 export function createReleaseCommand(): Command {
-  return new Command()
-    .name("release")
-    .description("Prepare an annotated release and select its build and publication steps")
-    .option("--root <path>", "repository root")
-    .option("--branch <name>", "release branch", "main")
-    .option("--prefix <prefix>", "release tag prefix", "v")
-    .option("--remote <name>", "git remote", "origin")
-    .option("--python-root <path>", "Python package root for local publish", "packages/py")
-    .option(
-      "--validate <task>",
-      "task to run before pushing",
-      (task, tasks: string[]) => [...tasks, task],
-      [],
-    )
-    .option("--no-bump", "use an existing synchronized local version bump")
-    .addOption(
-      new Option("--publish <target>", "publication scope")
-        .choices([...RELEASE_PUBLISH_TARGETS])
-        .default("auto"),
-    )
-    .addOption(
-      new Option("--install <mode>", "local workspace dependency installation")
-        .choices([...RELEASE_INSTALL_MODES])
-        .default("auto"),
-    )
-    .option("--no-npm", "skip npm build and publication, including local npm publication")
-    .option("--no-pypi", "skip Python build and publication, including local Python publication")
-    .option("--docs", "build and deploy docs for a selected scope")
-    .option("--no-docs", "skip documentation build and deployment")
-    .option(
-      "--no-validation",
-      "skip optional release validation tasks; workspace version checks remain mandatory",
-    )
-    .option("--no-release-notes", "skip writing docs/releases notes (Genie and git-log fallback)")
-    .option("--release-notes-text <markdown>", "write supplied markdown without invoking Genie")
-    .option("--release-notes-file <path>", "copy supplied markdown without invoking Genie")
-    .option(
-      "--release-notes-instructions <text>",
-      "append custom instructions to the Genie release-notes prompt",
-    )
-    .option("--demo-deploy", "after tagging, stage and deploy the AppKit demo app (off by default)")
-    .option("--profile <name>", "Databricks CLI profile for --demo-deploy")
-    .option("--no-local-publish", "skip publishing to configured local registries")
-    .option("--local-registry <auto|false|url>", "local npm registry selection", "auto")
-    .option("--local-pypi <auto|false|url>", "local devpi registry selection", "auto")
-    .action(
-      async (
-        options: ReleaseSelectionOptions & {
-          root?: string;
-          branch: string;
-          bump: boolean;
-          prefix: string;
-          remote: string;
-          pythonRoot: string;
-          localPublish: boolean;
-          localRegistry: string;
-          localPypi: string;
-          install: ReleaseInstallMode;
-          validate: string[];
-          demoDeploy?: boolean;
-          profile?: string;
-          releaseNotes?: boolean;
-          releaseNotesInstructions?: string;
-          releaseNotesText?: string;
-          releaseNotesFile?: string;
-        },
-      ) => {
-        await runRelease({
-          root: options.root ?? projectUtils.root() ?? process.cwd(),
-          branch: options.branch,
-          bump: options.bump,
-          prefix: options.prefix,
-          remote: options.remote,
-          pythonRoot: options.pythonRoot,
-          localPublish: options.localPublish,
-          localRegistry: options.localRegistry,
-          localPypi: options.localPypi,
-          install: options.install,
-          publish: options.publish,
-          npm: options.npm,
-          pypi: options.pypi,
-          docs: options.docs,
-          validation: options.validation,
-          validationTasks: options.validate,
-          demoDeploy: options.demoDeploy,
-          demoProfile: options.profile,
-          releaseNotes: options.releaseNotes,
-          releaseNotesInstructions: options.releaseNotesInstructions,
-          releaseNotesText: options.releaseNotesText,
-          releaseNotesFile: options.releaseNotesFile,
-        });
-      },
-    );
+  return taskCommand(
+    import.meta.url,
+    "Prepare an annotated release and select its build and publication steps",
+    ReleaseOptionsSchema,
+  ).action(async (_options: unknown, command: Command) => {
+    const options = parsedTaskOptions(command, ReleaseOptionsSchema);
+    await runRelease({
+      root: options.root ?? projectUtils.root() ?? process.cwd(),
+      branch: options.branch,
+      bump: options.bump,
+      prefix: options.prefix,
+      remote: options.remote,
+      pythonRoot: options.pythonRoot,
+      localPublish: options.localPublish,
+      localRegistry: options.localRegistry,
+      localPypi: options.localPypi,
+      install: options.install,
+      publish: options.publish,
+      npm: options.npm,
+      pypi: options.pypi,
+      docs: options.docs,
+      validation: options.validation,
+      validationTasks: options.validate,
+      demoDeploy: options.demoDeploy,
+      demoProfile: options.profile,
+      releaseNotes: options.releaseNotes,
+      releaseNotesInstructions: options.releaseNotesInstructions,
+      releaseNotesText: options.releaseNotesText,
+      releaseNotesFile: options.releaseNotesFile,
+    });
+  });
 }
 
 /** Execute the native release task parser. */
@@ -470,4 +477,4 @@ export async function main(): Promise<void> {
   await createReleaseCommand().parseAsync();
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);

package/tasks/shared-core-usage.ts

@@ -1,5 +1,10 @@
 #!/usr/bin/env -S bun
 /** Print shared-core runtime-export usage by caller kind. */
+import { runTaskMain } from "./cli.ts";
 import { formatSharedCoreUsage, sharedCoreExportUsage } from "../src/shared-core-usage.ts";
 
-process.stdout.write(formatSharedCoreUsage(sharedCoreExportUsage()));
+export function main(): void {
+  process.stdout.write(formatSharedCoreUsage(sharedCoreExportUsage()));
+}
+
+await runTaskMain(import.meta, main);

package/tasks/sync.ts

@@ -3,6 +3,9 @@
 import { fileURLToPath } from "node:url";
 import { log } from "@dbx-tools/shared-core";
 import concurrently from "concurrently";
+import { z } from "zod";
+import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
+import { TaskWatchOptionSchema } from "./options.ts";
 import { repoRoot, syncWatchTasks } from "../src/packages.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { withWorkspaceMutationLock } from "../src/workspace-lock.ts";
@@ -45,8 +48,19 @@ function taskWatcher(task: string) {
   };
 }
 
+export const SyncOptionsSchema = z.object({ watch: TaskWatchOptionSchema });
+
 export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
-  if (!args.includes("--watch")) {
+  const { watch } = await taskOptions(
+    taskCommand(
+      import.meta.url,
+      "Synthesize once or supervise focused generators",
+      SyncOptionsSchema,
+    ),
+    SyncOptionsSchema,
+    args,
+  );
+  if (!watch) {
     // One-shot: full synth (+install + barrels via the post-synth component). This is
     // the scriptable path, so a failed synth stays a failed exit code.
     logger.start("synthesizing");
@@ -123,4 +137,4 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   }
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);

package/tasks/test-workspace.ts

@@ -2,6 +2,9 @@ import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join, relative, resolve, sep } from "node:path";
 import * as exec from "@dbx-tools/core/exec";
 import { log, object } from "@dbx-tools/shared-core";
+import { z } from "zod";
+import { runTaskMain, taskCommand, taskOptions, taskPositionals, taskRoot } from "./cli.ts";
+import { TaskRootOptionSchema } from "./options.ts";
 
 const logger = log.logger("projen:test");
 
@@ -26,6 +29,12 @@ export interface WorkspaceGraph {
 }
 
 type TestMode = "focused" | "changed" | "unit" | "integration" | "all" | "graph";
+const TEST_MODES = ["focused", "changed", "unit", "integration", "all", "graph"] as const;
+
+export const TestWorkspaceOptionsSchema = z.object({
+  root: TaskRootOptionSchema,
+  base: z.string().trim().min(1).optional().describe("Git base used for changed-test selection"),
+});
 
 const PROJEN_INTEGRATION_TEST =
   /(?:local-publish|npm-release|packed-consumer|project-py|publish|python-sync|release|root-install|sdk-boundary).*\.test\.ts$/;
@@ -155,7 +164,8 @@ function selectedTests(
   root: string,
   graph: WorkspaceGraph,
   mode: TestMode,
-  args: readonly string[],
+  selections: readonly string[],
+  base?: string,
 ): string[] {
   const all = [
     ...graph.packages.flatMap((pkg) => testFiles(join(root, pkg.path, "test"))),
@@ -167,14 +177,13 @@ function selectedTests(
 
   let names: Set<string>;
   if (mode === "changed") {
-    const baseIndex = args.indexOf("--base");
-    const changed = changedFiles(root, baseIndex >= 0 ? args[baseIndex + 1] : undefined);
+    const changed = changedFiles(root, base);
     if (changed.length === 0) return [];
     names = affectedPackages(graph, changed);
   } else {
-    if (args.length === 0) throw new Error("test:focused requires a package name or path");
+    if (selections.length === 0) throw new Error("test:focused requires a package name or path");
     names = new Set<string>();
-    for (const value of args) {
+    for (const value of selections) {
       const direct = graph.packages.find((pkg) => pkg.name === value);
       const byPath = direct ?? packageForPath(graph, toPosix(relative(root, resolve(root, value))));
       if (!byPath) throw new Error(`Unknown workspace package or path: ${value}`);
@@ -239,15 +248,21 @@ async function runTests(root: string, files: readonly string[]): Promise<void> {
 }
 
 export async function main(argv: readonly string[] = process.argv.slice(2)): Promise<void> {
-  const root = process.cwd();
-  const mode = (argv[0] ?? "all") as TestMode;
-  if (!["focused", "changed", "unit", "integration", "all", "graph"].includes(mode)) {
-    throw new Error(`Unknown test mode: ${mode}`);
-  }
+  const command = taskCommand(
+    import.meta.url,
+    "Select and run workspace tests by dependency graph",
+    TestWorkspaceOptionsSchema,
+  )
+    .argument(`[mode]`, `Test mode: ${TEST_MODES.join(", ")}`, "all")
+    .argument("[selection...]", "Workspace package names or paths for focused mode");
+  const options = await taskOptions(command, TestWorkspaceOptionsSchema, argv);
+  const [modeValue = "all", selections = []] = taskPositionals(command) as [string?, string[]?];
+  const mode = z.enum(TEST_MODES).parse(modeValue);
+  const root = taskRoot(options.root);
   const graph = workspaceGraph(root);
   writeGraph(root, graph);
   if (mode === "graph") return;
-  await runTests(root, selectedTests(root, graph, mode, argv.slice(1)));
+  await runTests(root, selectedTests(root, graph, mode, selections, options.base));
 }
 
-if (import.meta.main) await main();
+await runTaskMain(import.meta, main);

package/tasks/ui-bundle-sizes.ts

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { runTaskMain } from "./cli.ts";
 
 const entries = {
   auth: "packages/js/ui/appkit/src/auth/react/index.ts",
@@ -6,17 +7,21 @@ const entries = {
   search: "packages/js/ui/appkit/src/search/react/index.ts",
 } as const;
 
-for (const [name, entry] of Object.entries(entries)) {
-  const result = await Bun.build({
-    entrypoints: [resolve(entry)],
-    target: "browser",
-    minify: true,
-    sourcemap: "none",
-    external: ["react", "react-dom", "@databricks/*", "@dbx-tools/shared-*", "lucide-react"],
-  });
-  if (!result.success) {
-    throw new AggregateError(result.logs, `Could not build the ${name} UI subpath`);
+export async function main(): Promise<void> {
+  for (const [name, entry] of Object.entries(entries)) {
+    const result = await Bun.build({
+      entrypoints: [resolve(entry)],
+      target: "browser",
+      minify: true,
+      sourcemap: "none",
+      external: ["react", "react-dom", "@databricks/*", "@dbx-tools/shared-*", "lucide-react"],
+    });
+    if (!result.success) {
+      throw new AggregateError(result.logs, `Could not build the ${name} UI subpath`);
+    }
+    const bytes = result.outputs.reduce((total, output) => total + output.size, 0);
+    console.log(`${name}: ${bytes} bytes`);
   }
-  const bytes = result.outputs.reduce((total, output) => total + output.size, 0);
-  console.log(`${name}: ${bytes} bytes`);
 }
+
+await runTaskMain(import.meta, main);

package/tasks/version-check.ts

@@ -6,6 +6,7 @@ import * as projectUtils from "@dbx-tools/core/project-utils";
 import { find } from "@dbx-tools/path";
 import { json, log } from "@dbx-tools/shared-core";
 import { parse } from "smol-toml";
+import { runTaskMain } from "./cli.ts";
 import { recordedPackages } from "../src/packages.ts";
 import { readWorkspaceVersion } from "../src/workspace-version.ts";
 
@@ -45,4 +46,4 @@ export function main(): void {
   logger.success(`all workspace package versions match ${version}`);
 }
 
-if (import.meta.main) main();
+await runTaskMain(import.meta, main);