@smoothbricks/cli 0.1.1 → 0.3.0

package/src/devenv/index.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'bun:test';
+import type { DevenvCommandShell } from './index.js';
+import { reloadDevenv, updateDevenv, updateNixpkgsOverlay } from './index.js';
+
+describe('devenv commands', () => {
+  it('runs devenv update in tooling/direnv', async () => {
+    const shell = new RecordingShell();
+
+    await updateDevenv('/repo', shell);
+
+    expect(shell.commands).toEqual([{ command: 'devenv', args: ['update'], cwd: '/repo/tooling/direnv' }]);
+  });
+
+  it('clears cached devenv directories before reloading direnv', async () => {
+    const shell = new RecordingShell();
+
+    await reloadDevenv('/repo', shell);
+
+    expect(shell.removals).toEqual(['/repo/tooling/direnv/.direnv', '/repo/tooling/direnv/.devenv']);
+    expect(shell.commands).toEqual([{ command: 'direnv', args: ['reload'], cwd: '/repo/tooling/direnv' }]);
+  });
+
+  it('runs nvfetcher through nix shell in the overlay directory', async () => {
+    const shell = new RecordingShell();
+
+    await updateNixpkgsOverlay('/repo', shell);
+
+    expect(shell.commands).toEqual([
+      {
+        command: 'nix',
+        args: ['shell', 'nixpkgs#nvfetcher', '-c', 'nvfetcher', '-o', '_sources'],
+        cwd: '/repo/tooling/direnv/nixpkgs-overlay',
+      },
+    ]);
+  });
+});
+
+class RecordingShell implements DevenvCommandShell {
+  readonly commands: { command: string; args: string[]; cwd: string }[] = [];
+  readonly removals: string[] = [];
+
+  async run(command: string, args: string[], cwd: string): Promise<void> {
+    this.commands.push({ command, args, cwd });
+  }
+
+  async remove(path: string): Promise<void> {
+    this.removals.push(path);
+  }
+}

package/src/devenv/index.ts

@@ -0,0 +1,38 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { run } from '../lib/run.js';
+
+export interface DevenvCommandShell {
+  run(command: string, args: string[], cwd: string): Promise<void>;
+  remove(path: string): Promise<void>;
+}
+
+const defaultShell: DevenvCommandShell = {
+  run,
+  async remove(path) {
+    await rm(path, { recursive: true, force: true });
+  },
+};
+
+export async function updateDevenv(root: string, shell: DevenvCommandShell = defaultShell): Promise<void> {
+  await shell.run('devenv', ['update'], direnvRoot(root));
+}
+
+export async function reloadDevenv(root: string, shell: DevenvCommandShell = defaultShell): Promise<void> {
+  const cwd = direnvRoot(root);
+  await shell.remove(join(cwd, '.direnv'));
+  await shell.remove(join(cwd, '.devenv'));
+  await shell.run('direnv', ['reload'], cwd);
+}
+
+export async function updateNixpkgsOverlay(root: string, shell: DevenvCommandShell = defaultShell): Promise<void> {
+  await shell.run('nix', ['shell', 'nixpkgs#nvfetcher', '-c', 'nvfetcher', '-o', '_sources'], nixpkgsOverlayRoot(root));
+}
+
+export function direnvRoot(root: string): string {
+  return join(root, 'tooling', 'direnv');
+}
+
+export function nixpkgsOverlayRoot(root: string): string {
+  return join(direnvRoot(root), 'nixpkgs-overlay');
+}

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/cli-package.ts

@@ -0,0 +1,18 @@
+import { fileURLToPath } from 'node:url';
+import { readJsonObject, stringProperty } from './json.js';
+
+export const smoothBricksCodebasePackageName = '@smoothbricks/codebase';
+export const cliPackageVersion = readCliPackageVersion();
+
+function readCliPackageVersion(): string {
+  const pkg = readJsonObject(fileURLToPath(new URL('../../package.json', import.meta.url)));
+  const version = pkg ? stringProperty(pkg, 'version') : null;
+  if (!version) {
+    throw new Error('Unable to read @smoothbricks/cli package version.');
+  }
+  return version;
+}
+
+export function isSmoothBricksCodebasePackageName(name: string | undefined): boolean {
+  return name === smoothBricksCodebasePackageName;
+}

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,49 @@ 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[],
+  cwd: string,
+  env?: Record<string, string>,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  const invocation = resolveCommandInvocation(cwd, command, args);
+  let shell = $`${invocation.command} ${invocation.args}`.cwd(cwd).nothrow().quiet();
+  if (env) {
+    shell = shell.env(mergeEnv(env));
+  }
+  const result = await shell;
+  return {
+    exitCode: result.exitCode,
+    stdout: decode(result.stdout),
+    stderr: decode(result.stderr),
+  };
+}
+
 function mergeEnv(env: Record<string, string>): Record<string, string> {
   const merged: Record<string, string> = {};
   for (const [key, value] of Object.entries(process.env)) {

package/src/lib/workspace.ts

@@ -1,9 +1,11 @@
 import { readdirSync, statSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
+import { isSmoothBricksCodebasePackageName } from './cli-package.js';
 import { hasOwn, hasOwnString, isRecord, readJson, readJsonObject, stringProperty } from './json.js';
 
 export interface PackageInfo {
   name: string;
+  projectName: string;
   version: string;
   private: boolean;
   tags: string[];
@@ -12,12 +14,37 @@ 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;
+  private?: boolean;
+  workspaces?: unknown;
+  devDependencies?: unknown;
+  dependencies?: unknown;
+  nx?: unknown;
+  repository?: unknown;
+}
+
 export interface RepositoryInfo {
   type: string;
   url: string;
 }
 
-export const workspaceDependencyFields = ['dependencies', 'devDependencies', 'optionalDependencies'] as const;
+export const workspaceDependencyFields = [
+  'dependencies',
+  'devDependencies',
+  'peerDependencies',
+  'optionalDependencies',
+] as const;
 
 export function listPublicPackages(root: string): PackageInfo[] {
   return getWorkspacePackages(root).filter((pkg) => !pkg.private && pkg.tags.includes('npm:public'));
@@ -44,6 +71,15 @@ export function rootRepositoryInfo(root: string): RepositoryInfo | null {
   return rootPackage ? repositoryInfo(rootPackage) : null;
 }
 
+export function rootPackageName(root: string): string | null {
+  const rootPackage = readPackageJsonObject(join(root, 'package.json'));
+  return rootPackage ? stringProperty(rootPackage, 'name') : null;
+}
+
+export function isSmoothBricksCodebase(root: string): boolean {
+  return isSmoothBricksCodebasePackageName(rootPackageName(root) ?? undefined);
+}
+
 export function packageRepositoryInfo(pkg: PackageInfo): RepositoryInfo | null {
   return repositoryInfo(pkg.json);
 }
@@ -61,34 +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,
-        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[] {
@@ -122,7 +190,7 @@ function getWorkspacePatternsFromPackageJson(pkg: Record<string, unknown>): stri
 }
 
 export function readPackageJson(path: string): PackageInfo | null {
-  const parsed = readJsonObject(path);
+  const parsed = readPackageJsonObject(path);
   if (!isRecord(parsed) || !hasOwnString(parsed, 'name') || !hasOwnString(parsed, 'version')) {
     return null;
   }
@@ -130,6 +198,7 @@ export function readPackageJson(path: string): PackageInfo | null {
   const tags = getNxTags(parsed);
   return {
     name: parsed.name,
+    projectName: packageNxProjectName(parsed),
     version: parsed.version,
     private: privateValue,
     tags,
@@ -139,6 +208,32 @@ 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') ?? '';
+}
+
+export function readPackageJsonObject(path: string): PackageJson | null {
+  const parsed = readJsonObject(path);
+  return parsed;
+}
+
 export function getNxTags(pkg: Record<string, unknown>): string[] {
   if (!hasOwn(pkg, 'nx') || !isRecord(pkg.nx) || !hasOwn(pkg.nx, 'tags') || !Array.isArray(pkg.nx.tags)) {
     return [];

package/src/monorepo/__tests__/publish-workflow.test.ts

@@ -20,6 +20,14 @@ describe('publish workflow definition', () => {
     );
   });
 
+  it('does not wire npm token secrets into repair or publish steps', () => {
+    const rendered = renderPublishWorkflowYaml({ repoName: '@smoothbricks/codebase' });
+
+    expect(rendered).not.toContain('NODE_AUTH_TOKEN');
+    expect(rendered).not.toContain('secrets.NPM_TOKEN');
+    expect(rendered).toContain('packages must already exist on npm and use trusted publishing/OIDC');
+  });
+
   it('bootstraps the self-hosted CLI before release commands only for the SmoothBricks repo', async () => {
     const smoothbricks = await publishWorkflowScenario({
       repoName: '@smoothbricks/codebase',
@@ -79,16 +87,16 @@ describe('publish workflow definition', () => {
       ],
       bump: 'patch',
       dryRun: false,
-      version: { mode: 'new', projects: ['@scope/a', '@scope/b'] },
+      version: { mode: 'new', projects: ['a', 'b'] },
     });
 
     const outcome = await scenario.run();
 
     expect(outcome.validation).toEqual({
       checks: 1,
-      builds: ['@scope/a', '@scope/b'],
-      lints: ['@scope/a', '@scope/b'],
-      tests: ['@scope/a', '@scope/b'],
+      builds: ['a', 'b'],
+      lints: ['a', 'b'],
+      tests: ['a', 'b'],
       validates: 1,
     });
     expect(outcome.publishSawValidatedRelease).toBe(true);
@@ -102,7 +110,7 @@ describe('publish workflow definition', () => {
       current: [{ tag: '@scope/a@1.2.0', npmMissing: true, githubMissing: true }],
       bump: 'prerelease',
       dryRun: true,
-      version: { mode: 'new', projects: ['@scope/a'] },
+      version: { mode: 'new', projects: ['a'] },
     });
 
     const outcome = await scenario.run();
@@ -112,9 +120,9 @@ describe('publish workflow definition', () => {
     expect(outcome.repairBuildArtifacts).toEqual([]);
     expect(outcome.validation).toEqual({
       checks: 1,
-      builds: ['@scope/a'],
-      lints: ['@scope/a'],
-      tests: ['@scope/a'],
+      builds: ['a'],
+      lints: ['a'],
+      tests: ['a'],
       validates: 1,
     });
     expect(outcome.publishRan).toBe(true);
@@ -164,7 +172,6 @@ function publishWorkflowScenario(config: WorkflowScenarioConfig): { run(): Promi
       const state = new WorkflowScenarioState(config);
       await runPublishWorkflow(definePublishWorkflow({ repoName: config.repoName }), {
         inputs: { bump: config.bump, dryRun: config.dryRun },
-        nodeAuthToken: true,
         callbacks: state.callbacks(),
       });
       return state.outcome();

package/src/monorepo/commit-msg.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'bun:test';
+import { formatCommitMessage, validateCommitMessage } from './commit-msg.js';
+
+describe('commit message validation', () => {
+  it('accepts Nx conventional commit types and configured scopes', () => {
+    expect(validateCommitMessage('types(cli): expose public API\n', { validScopes: new Set(['cli']) })).toBeNull();
+  });
+
+  it('rejects scopes outside configured Nx names', () => {
+    expect(
+      validateCommitMessage('fix(@smoothbricks/cli): repair release\n', { validScopes: new Set(['cli']) }),
+    ).toContain('Invalid conventional commit scope');
+  });
+});
+
+describe('commit message formatting', () => {
+  it('wraps prose and preserves markdown blocks', () => {
+    const message = formatCommitMessage(
+      [
+        'fix(cli): wrap commit bodies   ',
+        '',
+        'This paragraph is intentionally long enough to be wrapped by the injected formatter callback while preserving non-prose markdown sections.',
+        '',
+        '```',
+        'long log errors should stay exactly as they are because this is a fenced block',
+        '```',
+        '',
+        '> quoted markdown should also stay as a single untouched line even when it is long enough to otherwise need wrapping',
+      ].join('\n'),
+      { wrapBody: (paragraph) => paragraph.replace(' while ', '\nwhile ') },
+    );
+
+    expect(message).toBe(`fix(cli): wrap commit bodies
+
+This paragraph is intentionally long enough to be wrapped by the injected formatter callback
+while preserving non-prose markdown sections.
+
+\`\`\`
+long log errors should stay exactly as they are because this is a fenced block
+\`\`\`
+
+> quoted markdown should also stay as a single untouched line even when it is long enough to otherwise need wrapping
+`);
+  });
+});