@dbx-tools/projen 0.9.31 → 0.9.36

package/src/watch.ts

@@ -90,19 +90,13 @@ export interface WatchLoopOptions {
   check?: (changed: string[]) => boolean | Promise<boolean>;
 }
 
-function resolveWatchLoopOptions(config?: IgnoreGroupOptions | WatchLoopOptions): WatchLoopOptions {
-  if (!config) return {};
-  if ("check" in config || "ignoreOptions" in config) return config as WatchLoopOptions;
-  return { ignoreOptions: config as IgnoreGroupOptions };
-}
-
 export function watchLoop(
   tag: string,
   paths: string[],
   onBatch: (changed: string[]) => void | Promise<void>,
-  config?: IgnoreGroupOptions | WatchLoopOptions,
+  config: WatchLoopOptions = {},
 ): void {
-  const { ignoreOptions, check } = resolveWatchLoopOptions(config);
+  const { ignoreOptions, check } = config;
   const pending = new Set<string>();
   let timer: ReturnType<typeof setTimeout> | undefined;
   let running = false;

package/src/workspace-version.ts

@@ -110,17 +110,12 @@ export function syncWorkspaceManifestVersion(manifestPath: string, version: stri
   return true;
 }
 
-/** The checked-in version a release increment starts from. */
-export function resolveBaseVersion(root: string): string {
-  return readWorkspaceVersion(root);
-}
-
 /** Resolve the next release version without mutating the workspace. */
 export function resolveNextVersion(
   root: string,
   level: VersionLevel,
 ): { base: string; version: string } {
-  const base = resolveBaseVersion(root);
+  const base = readWorkspaceVersion(root);
   const parsed = parseSemver(base) ?? [0, 0, 1];
   return {
     base: parsed.join("."),

package/tasks/barrels.ts

@@ -7,14 +7,6 @@ import { recordedPackages } from "../src/packages.ts";
 import { watchLoop, watchRoots } from "../src/watch.ts";
 
 const logger = log.logger("projen:barrels");
-const { values } = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    watch: { type: "boolean" },
-    dir: { type: "string", multiple: true },
-  },
-  strict: false,
-});
 
 /** The recorded package dir that owns `abs`, if any (for a targeted barrel rebuild). */
 function ownerPackageDir(
@@ -45,36 +37,49 @@ function warnUnownedChanges(changed: readonly string[]): void {
   }
 }
 
-if (values.watch) {
-  // Watch the package roots; a source edit inside a package rebuilds just that
-  // package's `index.ts` barrel (no re-synth - the projenrc watcher owns that).
-  // watchLoop already drops generated paths, so a barrel write never re-triggers us.
-  watchLoop(
-    "barrels",
-    watchRoots(),
-    (changed) => {
-      const n = generateBarrels({ dirs: [...changedBarrelTargets(changed)] });
-      if (n) logger.success(`rebuilt ${stringUtils.pluralize(n, "barrel")}`);
+export function main(args: string[] = process.argv.slice(2)): void {
+  const { values } = parseArgs({
+    args,
+    options: {
+      watch: { type: "boolean" },
+      dir: { type: "string", multiple: true },
     },
-    {
-      check: (changed) => {
-        const targets = changedBarrelTargets(changed);
-        // A change under a package root that no recorded package owns is a new
-        // folder: only a re-synth can create its barrel, so this watcher skips.
-        if (!targets.some(() => true)) {
-          warnUnownedChanges(changed);
-          return false;
-        }
-        return true;
+    strict: false,
+  });
+
+  if (values.watch) {
+    // Watch the package roots; a source edit inside a package rebuilds just that
+    // package's `index.ts` barrel (no re-synth - the projenrc watcher owns that).
+    // watchLoop already drops generated paths, so a barrel write never re-triggers us.
+    watchLoop(
+      "barrels",
+      watchRoots(),
+      (changed) => {
+        const n = generateBarrels({ dirs: [...changedBarrelTargets(changed)] });
+        if (n) logger.success(`rebuilt ${stringUtils.pluralize(n, "barrel")}`);
       },
-    },
-  );
-} else {
-  const dirs = Array.isArray(values.dir)
-    ? values.dir.filter((value): value is string => typeof value === "string")
-    : [];
-  const n = generateBarrels(dirs.length ? { dirs } : undefined);
-  logger.success(
-    n === 0 ? "barrels already up to date" : `updated ${stringUtils.pluralize(n, "barrel")}`,
-  );
+      {
+        check: (changed) => {
+          const targets = changedBarrelTargets(changed);
+          // A change under a package root that no recorded package owns is a new
+          // folder: only a re-synth can create its barrel, so this watcher skips.
+          if (!targets.some(() => true)) {
+            warnUnownedChanges(changed);
+            return false;
+          }
+          return true;
+        },
+      },
+    );
+  } else {
+    const dirs = Array.isArray(values.dir)
+      ? values.dir.filter((value): value is string => typeof value === "string")
+      : [];
+    const n = generateBarrels(dirs.length ? { dirs } : undefined);
+    logger.success(
+      n === 0 ? "barrels already up to date" : `updated ${stringUtils.pluralize(n, "barrel")}`,
+    );
+  }
 }
+
+if (import.meta.main) main();

package/tasks/bump.ts

@@ -16,26 +16,30 @@ import {
 
 const logger = log.logger("projen:bump");
 
-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 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);
 
-    logger.info(`bump ${next.base} -> ${next.version} (${opts.level})`);
-    writeWorkspaceVersion(root, next.version);
+      logger.info(`bump ${next.base} -> ${next.version} (${opts.level})`);
+      writeWorkspaceVersion(root, next.version);
 
-    if (opts.synth) {
-      runTaskCommand(root, process.execPath, [".projenrc.ts"]);
-    }
-    logger.success(`workspace version synchronized at ${next.version}`);
-  });
+      if (opts.synth) {
+        runTaskCommand(root, process.execPath, [".projenrc.ts"]);
+      }
+      logger.success(`workspace version synchronized at ${next.version}`);
+    });
 
-await program.parseAsync();
+  await program.parseAsync();
+}
+
+if (import.meta.main) await main();

package/tasks/clean.ts

@@ -5,63 +5,67 @@ import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/cle
 import { repoRoot, toPosix } from "../src/packages.ts";
 
 const logger = log.logger("projen:clean");
-const yes = process.argv.includes("-y") || process.argv.includes("--yes");
+export async function main(args: string[] = process.argv.slice(2)): Promise<void> {
+  const yes = args.includes("-y") || args.includes("--yes");
 
-const files = listGeneratedFiles();
-const nodeModules = listNodeModulesDirs();
-const targets = [...files, ...nodeModules];
+  const files = listGeneratedFiles();
+  const nodeModules = listNodeModulesDirs();
+  const targets = [...files, ...nodeModules];
 
-if (targets.length === 0) {
-  logger.success("nothing to remove (no generated files or node_modules)");
-  process.exit(0);
-}
+  if (targets.length === 0) {
+    logger.success("nothing to remove (no generated files or node_modules)");
+    process.exit(0);
+  }
 
-const regenHint = (removedNodeModules: boolean): string =>
-  removedNodeModules
-    ? "reinstall with `bun install`, then `bun run default`"
-    : "regenerate with `bun run default`";
+  const regenHint = (removedNodeModules: boolean): string =>
+    removedNodeModules
+      ? "reinstall with `bun install`, then `bun run default`"
+      : "regenerate with `bun run default`";
 
-if (yes) {
-  const n = removePaths(targets);
-  logger.success(
-    `removed ${stringUtils.pluralize(n, "path")} (${files.length} generated + ${nodeModules.length} node_modules) - ${regenHint(nodeModules.length > 0)}`,
-  );
-  process.exit(0);
-}
+  if (yes) {
+    const n = removePaths(targets);
+    logger.success(
+      `removed ${stringUtils.pluralize(n, "path")} (${files.length} generated + ${nodeModules.length} node_modules) - ${regenHint(nodeModules.length > 0)}`,
+    );
+    process.exit(0);
+  }
 
-if (!process.stdin.isTTY) {
-  logger.warn(
-    `non-interactive shell: re-run with -y to remove all ${targets.length} paths (${files.length} generated + ${nodeModules.length} node_modules), or run in a terminal to pick`,
-  );
-  process.exit(1);
-}
+  if (!process.stdin.isTTY) {
+    logger.warn(
+      `non-interactive shell: re-run with -y to remove all ${targets.length} paths (${files.length} generated + ${nodeModules.length} node_modules), or run in a terminal to pick`,
+    );
+    process.exit(1);
+  }
 
-const clack = await import("@clack/prompts");
-clack.intro("projen clean");
-const label = (f: string): string => toPosix(relative(repoRoot, f));
-const picked = await clack.multiselect<string>({
-  message: `Select paths to remove (${files.length} generated + ${nodeModules.length} node_modules, all preselected)`,
-  options: [
-    ...files.map((f) => ({ value: f, label: label(f) })),
-    ...nodeModules.map((d) => ({
-      value: d,
-      label: `${label(d)} (directory)`,
-    })),
-  ],
-  initialValues: [...targets],
-  required: false,
-});
+  const clack = await import("@clack/prompts");
+  clack.intro("projen clean");
+  const label = (f: string): string => toPosix(relative(repoRoot, f));
+  const picked = await clack.multiselect<string>({
+    message: `Select paths to remove (${files.length} generated + ${nodeModules.length} node_modules, all preselected)`,
+    options: [
+      ...files.map((f) => ({ value: f, label: label(f) })),
+      ...nodeModules.map((d) => ({
+        value: d,
+        label: `${label(d)} (directory)`,
+      })),
+    ],
+    initialValues: [...targets],
+    required: false,
+  });
 
-if (typeof picked === "symbol") {
-  clack.cancel("clean cancelled - nothing removed");
-  process.exit(0);
-}
+  if (typeof picked === "symbol") {
+    clack.cancel("clean cancelled - nothing removed");
+    process.exit(0);
+  }
+
+  if (picked.length === 0) {
+    clack.outro("nothing selected - nothing removed");
+    process.exit(0);
+  }
 
-if (picked.length === 0) {
-  clack.outro("nothing selected - nothing removed");
-  process.exit(0);
+  const removedNodeModules = picked.some((p) => nodeModules.includes(p));
+  const n = removePaths(picked);
+  clack.outro(`removed ${stringUtils.pluralize(n, "path")} - ${regenHint(removedNodeModules)}`);
 }
 
-const removedNodeModules = picked.some((p) => nodeModules.includes(p));
-const n = removePaths(picked);
-clack.outro(`removed ${stringUtils.pluralize(n, "path")} - ${regenHint(removedNodeModules)}`);
+if (import.meta.main) await main();

package/tasks/compile-workspace.ts

@@ -1,121 +1,6 @@
 #!/usr/bin/env -S bun
-/** Compile source-first workspace packages in a few TypeScript processes. */
-import { existsSync, readFileSync } from "node:fs";
-import { availableParallelism } from "node:os";
-import { join, resolve } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
+import { main } from "./lib/compile-workspace.ts";
 
-interface PackageManifest {
-  readonly name?: string;
-  readonly scripts?: Record<string, string>;
-  readonly workspaces?: string[];
-}
-
-interface TaskManifest {
-  readonly tasks?: {
-    readonly compile?: {
-      readonly steps?: Array<{ readonly execArgs?: string[] }>;
-    };
-  };
-}
-
-export interface CompilePlan {
-  readonly typescriptConfigs: string[];
-  readonly customPackages: Array<{ readonly name: string; readonly directory: string }>;
-}
-
-function readJson<T>(path: string): T {
-  return JSON.parse(readFileSync(path, "utf8")) as T;
-}
-
-function plainTypeScriptBuild(steps: unknown): boolean {
-  if (!Array.isArray(steps) || steps.length !== 1) return false;
-  const step = steps[0] as { execArgs?: string[] };
-  if (!step || typeof step !== "object") return false;
-  return (
-    Object.keys(step).length === 1 &&
-    step.execArgs?.length === 2 &&
-    step.execArgs[0] === "tsc" &&
-    step.execArgs[1] === "--build"
-  );
-}
-
-/** Read the root's concrete workspace paths on every run, including newly added members. */
-export function compilePlan(root: string): CompilePlan {
-  const workspace = readJson<PackageManifest>(join(root, "package.json"));
-  const typescriptConfigs: string[] = [];
-  const customPackages: CompilePlan["customPackages"] = [];
-  for (const member of workspace.workspaces ?? []) {
-    const directory = resolve(root, member);
-    const manifest = readJson<PackageManifest>(join(directory, "package.json"));
-    const script = manifest.scripts?.compile;
-    if (!script) continue;
-    const taskPath = join(directory, ".projen", "tasks.json");
-    const steps = existsSync(taskPath)
-      ? readJson<TaskManifest>(taskPath).tasks?.compile?.steps
-      : undefined;
-    if (
-      script === "projen compile" &&
-      !manifest.scripts?.precompile &&
-      !manifest.scripts?.postcompile &&
-      plainTypeScriptBuild(steps)
-    ) {
-      typescriptConfigs.push(join(directory, "tsconfig.json"));
-    } else {
-      customPackages.push({ name: manifest.name ?? member, directory });
-    }
-  }
-  return { typescriptConfigs, customPackages };
-}
-
-const emoji = /[\p{Extended_Pictographic}\uFE0F\u200D]/gu;
-
-async function main(): Promise<void> {
-  const root = process.cwd();
-  const plan = compilePlan(root);
-  const jobs: Array<{ name: string; result: Promise<exec.ExecResult> }> = [];
-  if (plan.typescriptConfigs.length > 0) {
-    const batchCount = Math.min(4, availableParallelism(), plan.typescriptConfigs.length);
-    const batches = Array.from({ length: batchCount }, () => [] as string[]);
-    plan.typescriptConfigs.forEach((config, index) => batches[index % batchCount]!.push(config));
-    console.log(
-      `Type-checking ${plan.typescriptConfigs.length} workspaces in ${batchCount} batches`,
-    );
-    for (const [index, batch] of batches.entries()) {
-      jobs.push({
-        name: `TypeScript batch ${index + 1}`,
-        result: exec.spawn("bunx", ["tsc", "--build", ...batch], {
-          cwd: root,
-          stdin: "ignore",
-          stdout: "inherit",
-          stderr: "inherit",
-        }),
-      });
-    }
-  }
-  for (const pkg of plan.customPackages) {
-    jobs.push({
-      name: pkg.name,
-      result: exec.spawn("bun", ["run", "compile"], {
-        cwd: pkg.directory,
-        stdin: "ignore",
-        stdout: (line) => console.log(`${pkg.name}: ${line.replace(emoji, "")}`),
-        stderr: (line) => console.error(`${pkg.name}: ${line.replace(emoji, "")}`),
-      }),
-    });
-  }
-  const results = await Promise.allSettled(jobs.map((job) => job.result));
-  let failed = false;
-  for (const [index, result] of results.entries()) {
-    if (result.status === "rejected") {
-      console.error(`${jobs[index]!.name} compile failed:`, result.reason);
-      failed = true;
-    } else if (result.value.exitCode !== 0) {
-      console.error(`${jobs[index]!.name} compile exited with ${result.value.exitCode}`);
-      failed = true;
-    }
-  }
-  if (failed) process.exitCode = 1;
-}
+export { compilePlan, main } from "./lib/compile-workspace.ts";
 
 if (import.meta.main) await main();

package/tasks/lib/compile-workspace.ts

@@ -0,0 +1,119 @@
+#!/usr/bin/env -S bun
+/** Compile source-first workspace packages in a few TypeScript processes. */
+import { existsSync, readFileSync } from "node:fs";
+import { availableParallelism } from "node:os";
+import { join, resolve } from "node:path";
+import * as exec from "@dbx-tools/core/exec";
+
+interface PackageManifest {
+  readonly name?: string;
+  readonly scripts?: Record<string, string>;
+  readonly workspaces?: string[];
+}
+
+interface TaskManifest {
+  readonly tasks?: {
+    readonly compile?: {
+      readonly steps?: Array<{ readonly execArgs?: string[] }>;
+    };
+  };
+}
+
+export interface CompilePlan {
+  readonly typescriptConfigs: string[];
+  readonly customPackages: Array<{ readonly name: string; readonly directory: string }>;
+}
+
+function readJson<T>(path: string): T {
+  return JSON.parse(readFileSync(path, "utf8")) as T;
+}
+
+function plainTypeScriptBuild(steps: unknown): boolean {
+  if (!Array.isArray(steps) || steps.length !== 1) return false;
+  const step = steps[0] as { execArgs?: string[] };
+  if (!step || typeof step !== "object") return false;
+  return (
+    Object.keys(step).length === 1 &&
+    step.execArgs?.length === 2 &&
+    step.execArgs[0] === "tsc" &&
+    step.execArgs[1] === "--build"
+  );
+}
+
+/** Read the root's concrete workspace paths on every run, including newly added members. */
+export function compilePlan(root: string): CompilePlan {
+  const workspace = readJson<PackageManifest>(join(root, "package.json"));
+  const typescriptConfigs: string[] = [];
+  const customPackages: CompilePlan["customPackages"] = [];
+  for (const member of workspace.workspaces ?? []) {
+    const directory = resolve(root, member);
+    const manifest = readJson<PackageManifest>(join(directory, "package.json"));
+    const script = manifest.scripts?.compile;
+    if (!script) continue;
+    const taskPath = join(directory, ".projen", "tasks.json");
+    const steps = existsSync(taskPath)
+      ? readJson<TaskManifest>(taskPath).tasks?.compile?.steps
+      : undefined;
+    if (
+      script === "projen compile" &&
+      !manifest.scripts?.precompile &&
+      !manifest.scripts?.postcompile &&
+      plainTypeScriptBuild(steps)
+    ) {
+      typescriptConfigs.push(join(directory, "tsconfig.json"));
+    } else {
+      customPackages.push({ name: manifest.name ?? member, directory });
+    }
+  }
+  return { typescriptConfigs, customPackages };
+}
+
+const emoji = /[\p{Extended_Pictographic}\uFE0F\u200D]/gu;
+
+export async function main(): Promise<void> {
+  const root = process.cwd();
+  const plan = compilePlan(root);
+  const jobs: Array<{ name: string; result: Promise<exec.ExecResult> }> = [];
+  if (plan.typescriptConfigs.length > 0) {
+    const batchCount = Math.min(4, availableParallelism(), plan.typescriptConfigs.length);
+    const batches = Array.from({ length: batchCount }, () => [] as string[]);
+    plan.typescriptConfigs.forEach((config, index) => batches[index % batchCount]!.push(config));
+    console.log(
+      `Type-checking ${plan.typescriptConfigs.length} workspaces in ${batchCount} batches`,
+    );
+    for (const [index, batch] of batches.entries()) {
+      jobs.push({
+        name: `TypeScript batch ${index + 1}`,
+        result: exec.spawn("bunx", ["tsc", "--build", ...batch], {
+          cwd: root,
+          stdin: "ignore",
+          stdout: "inherit",
+          stderr: "inherit",
+        }),
+      });
+    }
+  }
+  for (const pkg of plan.customPackages) {
+    jobs.push({
+      name: pkg.name,
+      result: exec.spawn("bun", ["run", "compile"], {
+        cwd: pkg.directory,
+        stdin: "ignore",
+        stdout: (line) => console.log(`${pkg.name}: ${line.replace(emoji, "")}`),
+        stderr: (line) => console.error(`${pkg.name}: ${line.replace(emoji, "")}`),
+      }),
+    });
+  }
+  const results = await Promise.allSettled(jobs.map((job) => job.result));
+  let failed = false;
+  for (const [index, result] of results.entries()) {
+    if (result.status === "rejected") {
+      console.error(`${jobs[index]!.name} compile failed:`, result.reason);
+      failed = true;
+    } else if (result.value.exitCode !== 0) {
+      console.error(`${jobs[index]!.name} compile exited with ${result.value.exitCode}`);
+      failed = true;
+    }
+  }
+  if (failed) process.exitCode = 1;
+}

package/tasks/lib/local-publish.ts

@@ -0,0 +1,122 @@
+/** Build and publish the current workspace to configured loopback registries. */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { log, net } from "@dbx-tools/shared-core";
+import { Command } from "commander";
+import { activePythonIndexes, resolveLocalPypi } from "./python-registry.ts";
+import { runTaskCommandAsync } from "../../src/_task-command.ts";
+
+const logger = log.logger("projen:local-publish");
+
+/** Options for publishing the current workspace to local registries. */
+export interface LocalPublishOptions {
+  readonly localPypi: string;
+  readonly localRegistry: string;
+  readonly pythonRoot: string;
+  readonly root: string;
+  readonly version: string;
+}
+
+export function resolveLocalRegistry(value: string): string | undefined {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toLowerCase() === "false") return undefined;
+  if (trimmed.toLowerCase() === "auto") {
+    const registry = projectUtils.npmRegistry();
+    return registry && net.isLoopbackHost(registry) ? registry.href : undefined;
+  }
+  return trimmed;
+}
+
+/** Outcome of a local publish: which ecosystems were deployed to a local registry. */
+export interface LocalPublishResult {
+  readonly npm: boolean;
+  readonly python: boolean;
+}
+
+/** Build and publish the current workspace directly to local registries. */
+export async function publishLocalRelease(
+  options: LocalPublishOptions,
+): Promise<LocalPublishResult> {
+  const root = resolve(options.root);
+  const localRegistry = resolveLocalRegistry(options.localRegistry);
+  const activeIndexes = activePythonIndexes();
+  const localPypi = resolveLocalPypi(options.localPypi, activeIndexes);
+  const publishes: Promise<unknown>[] = [];
+
+  if (
+    options.localPypi.toLowerCase() === "auto" &&
+    activeIndexes.some((index) => net.isLoopbackHost(index)) &&
+    !localPypi
+  ) {
+    logger.info(
+      `skipped local Python publish: no active index (${activeIndexes.join(", ")}) is a devpi +simple index`,
+    );
+  }
+
+  if (localRegistry) {
+    const publishNpmScript = fileURLToPath(new URL("../publish.ts", import.meta.url));
+    logger.info(`building and publishing npm workspace to ${localRegistry}`);
+    publishes.push(
+      runTaskCommandAsync(root, process.execPath, [
+        publishNpmScript,
+        options.version,
+        "--registry",
+        localRegistry,
+      ]),
+    );
+  }
+
+  if (localPypi) {
+    const publishPythonScript = fileURLToPath(new URL("../publish-python.ts", import.meta.url));
+    logger.info(`building and publishing Python workspace to ${localPypi.publishUrl}`);
+    publishes.push(
+      runTaskCommandAsync(root, process.execPath, [
+        publishPythonScript,
+        options.version,
+        "--root",
+        options.pythonRoot,
+        "--index-url",
+        localPypi.indexUrl,
+        "--publish-url",
+        localPypi.publishUrl,
+      ]),
+    );
+  }
+
+  if (publishes.length === 0) {
+    logger.info("no local registries configured; skipping local publish");
+    return { npm: false, python: false };
+  }
+
+  await Promise.all(publishes);
+  logger.success(`published local workspace ${options.version}`);
+  return { npm: Boolean(localRegistry), python: Boolean(localPypi) };
+}
+
+export async function main(): Promise<void> {
+  await new Command()
+    .requiredOption("--version <version>", "release version")
+    .option("--root <path>", "repository root")
+    .option("--python-root <path>", "Python package root", "packages/py")
+    .option("--local-registry <url>", "local npm registry", "auto")
+    .option("--local-pypi <url>", "local devpi index", "auto")
+    .action(
+      async (options: {
+        version: string;
+        root?: string;
+        pythonRoot: string;
+        localRegistry: string;
+        localPypi: string;
+      }) => {
+        await publishLocalRelease({
+          localPypi: options.localPypi,
+          localRegistry: options.localRegistry,
+          pythonRoot: options.pythonRoot,
+          root: options.root ?? projectUtils.root() ?? process.cwd(),
+          version: options.version,
+        });
+      },
+    )
+    .parseAsync();
+}