@smoothbricks/cli 0.2.0 → 0.3.0

package/managed/templates/github/workflows/ci.yml

@@ -17,6 +17,7 @@ defaults:
 
 jobs:
   main:
+    name: Validate
     runs-on: ubuntu-latest
     timeout-minutes: 45
     env:
@@ -81,8 +82,8 @@ jobs:
 
       # Step 10
       - name: 📎 Upload trace DBs
-        if: ${{ failure() }}
-        uses: actions/upload-artifact@v4
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v7.0.1
         with:
           name: trace-results-${{ github.run_id }}
           path: packages/*/.trace-results.db

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@smoothbricks/cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "SmoothBricks monorepo automation CLI",
   "bin": {
     "smoo": "./bin/smoo"
   },
   "scripts": {
-    "test": "nx run cli:test"
+    "test": "nx run cli:test --tui=false --outputStyle=stream"
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -33,11 +33,6 @@
       "development": "./src/monorepo/git-config.ts",
       "import": "./dist/monorepo/git-config.js",
       "default": "./dist/monorepo/git-config.js"
-    },
-    "./nx-version-actions": {
-      "types": "./dist/nx-version-actions.d.cts",
-      "require": "./dist/nx-version-actions.cjs",
-      "default": "./dist/nx-version-actions.cjs"
     }
   },
   "files": [
@@ -50,6 +45,7 @@
   ],
   "dependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
+    "@smoothbricks/nx-plugin": "0.2.0",
     "@smoothbricks/validation": "0.1.1",
     "commander": "^14.0.3",
     "publint": "^0.3.18",
@@ -74,13 +70,12 @@
         ]
       },
       "test": {
-        "executor": "nx:run-commands",
-        "dependsOn": [
-          "^build"
-        ],
+        "executor": "@smoothbricks/nx-plugin:bounded-exec",
         "options": {
           "command": "bun test",
-          "cwd": "{projectRoot}"
+          "cwd": "{projectRoot}",
+          "timeoutMs": 120000,
+          "killAfterMs": 1e4
         }
       }
     },

package/src/cli.ts

@@ -1,4 +1,5 @@
 import { Command, CommanderError } from 'commander';
+import { variants } from './generate/index.js';
 import { cliPackageVersion } from './lib/cli-package.js';
 import { findRepoRoot } from './lib/run.js';
 
@@ -116,6 +117,22 @@ function buildProgram(): Command {
         await setupTestTracing(await findRepoRoot(), options);
       },
     );
+  // `smoo g` / `smoo generate` — subcommands are driven by the variant
+  // registry in src/generate/index.ts. To add a new variant, add an entry
+  // there; the CLI wiring below picks it up automatically.
+  const g = program.command('g').alias('generate').description('Scaffold workspace packages and components');
+  for (const [variantName, variant] of Object.entries(variants)) {
+    const sub = g.command(`${variantName} <name>`).description(variant.description);
+    for (const opt of variant.options ?? []) {
+      sub.option(opt.flag, opt.description);
+    }
+    sub.option('--dry-run', 'preview changes without writing');
+    sub.action(async (name: string, options: Record<string, unknown>) => {
+      const { generate } = await import('./generate/index.js');
+      await generate(await findRepoRoot(), variantName, name, options);
+    });
+  }
+
   const release = program.command('release').description('Version, publish, and create GitHub Releases');
   release.command('npm-status').action(async () => {
     const { printReleaseState } = await import('./release/index.js');
@@ -206,24 +223,24 @@ function buildProgram(): Command {
     .description('Configure npm trusted publishing for owned release packages')
     .option('--dry-run [dryRun]', 'show npm trust changes without saving them')
     .option('--bootstrap', 'publish missing npm placeholder packages before configuring trust')
-    .option('--otp <otp>', 'npm one-time password for trust operations')
     .option('--bootstrap-otp <otp>', 'npm one-time password for placeholder publishes during --bootstrap')
-    .option('--skip-login', 'skip npm browser login before configuring trust')
+    .option('--skip-login', 'skip npm browser login before publishing placeholders during --bootstrap')
+    .option('--package <name...>', 'only configure the selected owned release package names')
     .action(
       async (options: {
         dryRun?: string | boolean;
         bootstrap?: boolean;
-        otp?: string;
         bootstrapOtp?: string;
         skipLogin?: boolean;
+        package?: string[];
       }) => {
         const { releaseTrustPublisher } = await import('./release/index.js');
         await releaseTrustPublisher(await findRepoRoot(), {
           dryRun: booleanOption(options.dryRun),
           bootstrap: options.bootstrap === true,
-          otp: options.otp,
           bootstrapOtp: options.bootstrapOtp,
           skipLogin: options.skipLogin === true,
+          packages: options.package ?? [],
         });
       },
     );

package/src/generate/index.ts

@@ -0,0 +1,92 @@
+import { run } from '../lib/run.js';
+
+const plugin = '@smoothbricks/nx-plugin';
+
+// Variant registry — drives both CLI subcommands and dispatch.
+//
+// Each entry maps a `smoo g <variant>` subcommand to an Nx generator in
+// @smoothbricks/nx-plugin. cli.ts iterates this record to register
+// commander subcommands, so adding a variant here wires it end-to-end.
+//
+// Generator implementations:
+//   create-package  packages/nx-plugin/src/generators/create-package/generator.ts
+//   make-public     packages/nx-plugin/src/generators/make-public/generator.ts
+//
+// To add a new variant:
+//   1. Add/extend a generator in packages/nx-plugin/src/generators/
+//   2. Register it in packages/nx-plugin/generators.json
+//   3. Add a variants entry below
+
+export interface GenerateVariant {
+  /** Nx generator name inside @smoothbricks/nx-plugin (e.g. 'create-package'). */
+  generator: string;
+  /** One-line description shown in `smoo g --help`. */
+  description: string;
+  /** Build the generator-specific args from the positional <name>. */
+  args: (name: string) => string[];
+  /** Extra CLI flags beyond the universal --dry-run. */
+  options?: readonly VariantOption[];
+}
+
+interface VariantOption {
+  /** Commander flag syntax (e.g. '--public'). */
+  flag: string;
+  /** Help text for this flag. */
+  description: string;
+}
+
+export const variants: Record<string, GenerateVariant> = {
+  'ts-lib': {
+    generator: 'create-package',
+    description: 'Create a TypeScript library package',
+    args: (name) => ['--name', name, '--variant', 'ts-lib'],
+    options: [{ flag: '--public', description: 'configure for npm publication' }],
+  },
+  'ts-zig': {
+    generator: 'create-package',
+    description: 'Create a TypeScript + Zig/WASM hybrid package',
+    args: (name) => ['--name', name, '--variant', 'ts-zig'],
+    options: [{ flag: '--public', description: 'configure for npm publication' }],
+  },
+  'make-public': {
+    generator: 'make-public',
+    description: 'Promote a private package to npm publication',
+    args: (name) => ['--project', name],
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Dispatch
+// ---------------------------------------------------------------------------
+
+export async function generate(
+  root: string,
+  variantName: string,
+  name: string,
+  options: Record<string, unknown>,
+): Promise<void> {
+  const variant = variants[variantName];
+  if (!variant) {
+    const known = Object.keys(variants).join(', ');
+    throw new Error(`Unknown generator variant "${variantName}". Available: ${known}`);
+  }
+
+  const args = ['g', `${plugin}:${variant.generator}`, ...variant.args(name)];
+  for (const opt of variant.options ?? []) {
+    const key = opt.flag.replace(/^--/, '');
+    if (options[key]) {
+      args.push(opt.flag);
+    }
+  }
+  if (options.dryRun) {
+    args.push('--dry-run');
+  }
+
+  await run('nx', args, root);
+
+  // Sync TypeScript project references so the new package is immediately
+  // visible in the build graph without a manual `nx sync` step.
+  if (!options.dryRun) {
+    await run('nx', ['sync'], root);
+  }
+}

package/src/lib/run.ts

@@ -1,3 +1,4 @@
+import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -26,6 +27,30 @@ export async function runStatus(
   return result.exitCode;
 }
 
+export async function runInteractiveStatus(
+  command: string,
+  args: string[],
+  cwd: string,
+  env?: Record<string, string>,
+): Promise<number> {
+  const invocation = resolveCommandInvocation(cwd, command, args);
+  return new Promise((resolve, reject) => {
+    const child = spawn(invocation.command, invocation.args, {
+      cwd,
+      env: env ? mergeEnv(env) : process.env,
+      stdio: 'inherit',
+    });
+    child.on('error', reject);
+    child.on('close', (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} ${args.join(' ')} terminated by signal ${signal}`));
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}
+
 export async function runResult(
   command: string,
   args: string[],

package/src/lib/workspace.ts

@@ -14,6 +14,15 @@ export interface PackageInfo {
   json: Record<string, unknown>;
 }
 
+export interface WorkspacePackageManifest {
+  name: string;
+  projectName: string;
+  private: boolean;
+  path: string;
+  packageJsonPath: string;
+  json: Record<string, unknown>;
+}
+
 export interface PackageJson extends Record<string, unknown> {
   name?: string;
   version?: string;
@@ -88,35 +97,66 @@ export function getWorkspacePackages(root: string): PackageInfo[] {
   return getWorkspacePackagesForPatterns(root, getWorkspacePatternsFromPackageJson(rootPackage.json));
 }
 
+export function getWorkspacePackageManifests(root: string): WorkspacePackageManifest[] {
+  const rootPackage = readPackageJsonObject(join(root, 'package.json'));
+  if (!rootPackage) {
+    throw new Error('package.json not found or invalid');
+  }
+  return getWorkspacePackageManifestsForPatterns(root, getWorkspacePatternsFromPackageJson(rootPackage));
+}
+
 function getWorkspacePackagesForPatterns(root: string, workspacePatterns: string[]): PackageInfo[] {
   const packages: PackageInfo[] = [];
+  for (const pkgPath of listWorkspacePackageJsonPaths(root, workspacePatterns)) {
+    const pkg = readPackageJson(pkgPath);
+    if (!pkg?.name || !pkg.version) {
+      continue;
+    }
+    packages.push({
+      name: pkg.name,
+      projectName: pkg.projectName,
+      version: pkg.version,
+      private: pkg.private,
+      tags: pkg.tags,
+      path: relative(root, dirname(pkgPath)),
+      packageJsonPath: pkg.packageJsonPath,
+      json: pkg.json,
+    });
+  }
+  return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function getWorkspacePackageManifestsForPatterns(
+  root: string,
+  workspacePatterns: string[],
+): WorkspacePackageManifest[] {
+  const manifests: WorkspacePackageManifest[] = [];
+  for (const pkgPath of listWorkspacePackageJsonPaths(root, workspacePatterns)) {
+    const pkg = readWorkspacePackageManifest(pkgPath);
+    if (pkg) {
+      manifests.push(pkg);
+    }
+  }
+  return manifests.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function listWorkspacePackageJsonPaths(root: string, workspacePatterns: string[]): string[] {
+  const paths: string[] = [];
   for (const pattern of workspacePatterns) {
     if (!pattern.endsWith('/*')) {
+      paths.push(join(root, pattern, 'package.json'));
       continue;
     }
+
     const parent = join(root, pattern.slice(0, -2));
     if (!statSync(parent, { throwIfNoEntry: false })?.isDirectory()) {
       continue;
     }
     for (const entry of readdirSync(parent)) {
-      const pkgPath = join(parent, entry, 'package.json');
-      const pkg = readPackageJson(pkgPath);
-      if (!pkg?.name || !pkg.version) {
-        continue;
-      }
-      packages.push({
-        name: pkg.name,
-        projectName: pkg.projectName,
-        version: pkg.version,
-        private: pkg.private,
-        tags: pkg.tags,
-        path: relative(root, dirname(pkgPath)),
-        packageJsonPath: pkg.packageJsonPath,
-        json: pkg.json,
-      });
+      paths.push(join(parent, entry, 'package.json'));
     }
   }
-  return packages.sort((a, b) => a.name.localeCompare(b.name));
+  return paths;
 }
 
 export function listPackageJsonRecords(root: string): PackageInfo[] {
@@ -168,6 +208,22 @@ export function readPackageJson(path: string): PackageInfo | null {
   };
 }
 
+export function readWorkspacePackageManifest(path: string): WorkspacePackageManifest | null {
+  const parsed = readPackageJsonObject(path);
+  if (!isRecord(parsed) || !hasOwnString(parsed, 'name')) {
+    return null;
+  }
+  const privateValue = hasOwn(parsed, 'private') && typeof parsed.private === 'boolean' ? parsed.private : false;
+  return {
+    name: parsed.name,
+    projectName: packageNxProjectName(parsed),
+    private: privateValue,
+    path: dirname(path),
+    packageJsonPath: path,
+    json: parsed,
+  };
+}
+
 function packageNxProjectName(pkg: Record<string, unknown>): string {
   const nx = isRecord(pkg.nx) ? pkg.nx : null;
   return (nx ? stringProperty(nx, 'name') : null) ?? stringProperty(pkg, 'name') ?? '';

package/src/monorepo/lockfile.ts

@@ -6,6 +6,15 @@ export interface SyncBunLockfileVersionsOptions {
   log?: boolean;
 }
 
+// Temporary Bun workaround. Delete this sync function, validateBunLockfileVersions,
+// the `smoo monorepo sync-bun-lockfile-versions` command, and the matching Nx
+// versionActions hook once supported Bun versions stop leaving workspace package
+// versions stale in bun.lock after manifest bumps. Until then, `bun pm pack`
+// rewrites `workspace:*` dependencies using those stale lockfile versions instead
+// of the current package.json versions. Track removal against:
+// - https://github.com/oven-sh/bun/issues/18906
+// - https://github.com/oven-sh/bun/issues/20477
+// - https://github.com/oven-sh/bun/issues/20829
 export function syncBunLockfileVersions(root: string, options: SyncBunLockfileVersionsOptions = {}): number {
   const log = options.log ?? true;
   const lockfilePath = join(root, 'bun.lock');