@smoothbricks/cli 0.1.1 → 0.2.0

package/src/release/__tests__/orchestration.test.ts

@@ -8,9 +8,15 @@ import {
   runReleaseVersion,
 } from '../orchestration.js';
 
-const stable: ReleasePackageInfo = { name: '@scope/stable', path: 'packages/stable', version: '1.0.0' };
+const stable: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.0.0',
+};
 const prerelease: ReleasePackageInfo = {
   name: '@scope/prerelease',
+  projectName: 'prerelease',
   path: 'packages/prerelease',
   version: '2.0.0-beta.1',
 };
@@ -84,15 +90,43 @@ describe('release orchestration', () => {
   });
 
   it('runs forced Nx versioning for an untagged HEAD and reports a new release commit', async () => {
-    const shell = new RecordingVersionShell({ releasePackagesAtHead: [[], [stable]], heads: ['before', 'after'] });
+    const shell = new RecordingVersionShell({
+      releasePackagesAtHead: [[], [stable]],
+      releaseVersionPackages: [stable, prerelease],
+      heads: ['before', 'after'],
+    });
 
     const result = await runReleaseVersion(shell, { bump: 'patch', dryRun: false });
 
     expect(result).toEqual({ mode: 'new', packages: [stable], status: 'new-release' });
-    expect(shell.nxRuns).toEqual([{ bump: 'patch', dryRun: false }]);
+    expect(shell.nxRuns).toEqual([{ packages: ['@scope/stable', '@scope/prerelease'], bump: 'patch', dryRun: false }]);
     expect(shell.cleanChecks).toBe(1);
     expect(shell.ensureCalls).toEqual([['@scope/stable']]);
   });
+
+  it('skips auto Nx versioning when no package-local candidates exist', async () => {
+    const shell = new RecordingVersionShell({ releasePackagesAtHead: [[]], releaseVersionPackages: [] });
+
+    const result = await runReleaseVersion(shell, { bump: 'auto', dryRun: false });
+
+    expect(result).toEqual({ mode: 'none', packages: [], status: 'no-release-needed' });
+    expect(shell.nxRuns).toEqual([]);
+    expect(shell.cleanChecks).toBe(0);
+    expect(shell.ensureCalls).toEqual([]);
+  });
+
+  it('runs auto Nx versioning only for selected package-local candidates', async () => {
+    const shell = new RecordingVersionShell({
+      releasePackagesAtHead: [[], [stable]],
+      releaseVersionPackages: [stable],
+      heads: ['before', 'after'],
+    });
+
+    const result = await runReleaseVersion(shell, { bump: 'auto', dryRun: false });
+
+    expect(result).toEqual({ mode: 'new', packages: [stable], status: 'new-release' });
+    expect(shell.nxRuns).toEqual([{ packages: ['@scope/stable'], bump: 'auto', dryRun: false }]);
+  });
 });
 
 function releaseTarget(
@@ -166,13 +200,19 @@ class RecordingRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
 
 class RecordingVersionShell implements ReleaseVersionShell<ReleasePackageInfo> {
   readonly ensureCalls: string[][] = [];
-  readonly nxRuns: Array<{ bump: string; dryRun: boolean }> = [];
+  readonly nxRuns: Array<{ packages: string[]; bump: string; dryRun: boolean }> = [];
   cleanChecks = 0;
   private readonly releaseBatches: ReleasePackageInfo[][];
+  private readonly versionPackages: ReleasePackageInfo[];
   private readonly heads: string[];
 
-  constructor(options: { releasePackagesAtHead: ReleasePackageInfo[][]; heads?: string[] }) {
+  constructor(options: {
+    releasePackagesAtHead: ReleasePackageInfo[][];
+    releaseVersionPackages?: ReleasePackageInfo[];
+    heads?: string[];
+  }) {
     this.releaseBatches = [...options.releasePackagesAtHead];
+    this.versionPackages = options.releaseVersionPackages ?? [stable, prerelease];
     this.heads = [...(options.heads ?? [])];
   }
 
@@ -180,6 +220,10 @@ class RecordingVersionShell implements ReleaseVersionShell<ReleasePackageInfo> {
     return this.releaseBatches.shift() ?? [];
   }
 
+  async releaseVersionPackages(): Promise<ReleasePackageInfo[]> {
+    return this.versionPackages;
+  }
+
   async ensureLocalReleaseTags(packages: ReleasePackageInfo[]): Promise<void> {
     this.ensureCalls.push(packageNames(packages));
   }
@@ -188,8 +232,8 @@ class RecordingVersionShell implements ReleaseVersionShell<ReleasePackageInfo> {
     return this.heads.shift() ?? 'head';
   }
 
-  async runNxReleaseVersion(bump: string, dryRun: boolean): Promise<void> {
-    this.nxRuns.push({ bump, dryRun });
+  async runNxReleaseVersion(packages: ReleasePackageInfo[], bump: string, dryRun: boolean): Promise<void> {
+    this.nxRuns.push({ packages: packageNames(packages), bump, dryRun });
   }
 
   async assertCleanGitTree(): Promise<void> {

package/src/release/__tests__/publish-plan.test.ts

@@ -2,9 +2,15 @@ import { describe, expect, it } from 'bun:test';
 import type { ReleasePackageInfo } from '../core.js';
 import { planPublishActions } from '../publish-plan.js';
 
-const stable: ReleasePackageInfo = { name: '@scope/stable', path: 'packages/stable', version: '1.0.0' };
+const stable: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.0.0',
+};
 const prerelease: ReleasePackageInfo = {
   name: '@scope/prerelease',
+  projectName: 'prerelease',
   path: 'packages/prerelease',
   version: '2.0.0-beta.1',
 };
@@ -27,7 +33,7 @@ describe('publish plan', () => {
       githubMissingPackages: [],
     });
 
-    expect(plan.buildProjects).toEqual(['@scope/stable']);
+    expect(plan.buildProjects).toEqual(['stable']);
     expect(plan.publishPackages).toEqual([{ pkg: stable, distTag: 'latest' }]);
     expect(plan.githubReleasePackages).toEqual([]);
   });
@@ -51,7 +57,7 @@ describe('publish plan', () => {
       githubMissingPackages: [],
     });
 
-    expect(plan.buildProjects).toEqual(['@scope/stable', '@scope/prerelease']);
+    expect(plan.buildProjects).toEqual(['stable', 'prerelease']);
     expect(plan.publishPackages).toEqual([
       { pkg: stable, distTag: 'latest' },
       { pkg: prerelease, distTag: 'next' },

package/src/release/__tests__/retag-unpublished.test.ts

@@ -7,7 +7,7 @@ import {
   retagUnpublished,
 } from '../retag-unpublished.js';
 
-const pkg: ReleasePackageInfo = { name: '@scope/pkg', path: 'packages/pkg', version: '1.2.3' };
+const pkg: ReleasePackageInfo = { name: '@scope/pkg', projectName: 'pkg', path: 'packages/pkg', version: '1.2.3' };
 
 describe('retag unpublished releases', () => {
   it('moves unpublished owned tags, pushes with a remote lease, and dispatches publish auto', async () => {

package/src/release/__tests__/trust-publisher.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'bun:test';
+import type { BootstrapNpmPackagesOptions } from '../bootstrap-npm-packages.js';
+import type { ReleasePackageInfo } from '../core.js';
+import { configureTrustedPublishers, type TrustPublisherShell } from '../index.js';
+
+const stable: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.2.3',
+};
+const missing: ReleasePackageInfo = {
+  name: '@scope/missing',
+  projectName: 'missing',
+  path: 'packages/missing',
+  version: '2.0.0',
+};
+
+describe('trusted publisher setup', () => {
+  it('bootstraps missing npm packages before configuring trust', async () => {
+    const shell = new RecordingTrustPublisherShell({ packages: [stable, missing], existing: [stable.name] });
+
+    await configureTrustedPublishers(shell, { bootstrap: true, skipLogin: false, otp: '123456' });
+
+    expect(shell.events).toEqual([
+      'bootstrap:false:false',
+      `exists:${stable.name}`,
+      `exists:${missing.name}`,
+      `trust:${stable.name}:false:123456`,
+      `trust:${missing.name}:false:123456`,
+    ]);
+    expect(shell.logins).toBe(0);
+  });
+
+  it('directs missing packages to trust-publisher --bootstrap', async () => {
+    const shell = new RecordingTrustPublisherShell({ packages: [missing], existing: [] });
+
+    await expect(configureTrustedPublishers(shell, { otp: '123456' })).rejects.toThrow(
+      'Run smoo release trust-publisher --bootstrap locally',
+    );
+    expect(shell.events).toEqual([`exists:${missing.name}`]);
+  });
+
+  it('still logs in for trust when bootstrap finds no missing packages', async () => {
+    const shell = new RecordingTrustPublisherShell({ packages: [stable], existing: [stable.name] });
+
+    await configureTrustedPublishers(shell, { bootstrap: true, otp: '123456' });
+
+    expect(shell.events).toEqual([
+      'bootstrap:false:false',
+      `exists:${stable.name}`,
+      `trust:${stable.name}:false:123456`,
+    ]);
+    expect(shell.logins).toBe(1);
+  });
+
+  it('treats npm trust conflicts as already configured', async () => {
+    const shell = new RecordingTrustPublisherShell({
+      packages: [stable],
+      existing: [stable.name],
+      alreadyTrusted: [stable.name],
+    });
+
+    await configureTrustedPublishers(shell, { skipLogin: true, otp: '123456' });
+
+    expect(shell.events).toEqual([`exists:${stable.name}`, `trust:${stable.name}:false:123456`]);
+    expect(shell.logs).toContain(`${stable.name}: npm trusted publisher is already configured; skipping.`);
+  });
+});
+
+class RecordingTrustPublisherShell implements TrustPublisherShell<ReleasePackageInfo> {
+  readonly repository = 'scope/repo';
+  readonly workflow = 'publish.yml';
+  readonly events: string[] = [];
+  readonly logs: string[] = [];
+  readonly errors: string[] = [];
+  logins = 0;
+  private readonly packages: ReleasePackageInfo[];
+  private readonly existing: Set<string>;
+  private readonly alreadyTrusted: Set<string>;
+
+  constructor(options: { packages: ReleasePackageInfo[]; existing: string[]; alreadyTrusted?: string[] }) {
+    this.packages = options.packages;
+    this.existing = new Set(options.existing);
+    this.alreadyTrusted = new Set(options.alreadyTrusted ?? []);
+  }
+
+  listReleasePackages(): ReleasePackageInfo[] {
+    return this.packages;
+  }
+
+  async packageExists(name: string): Promise<boolean> {
+    this.events.push(`exists:${name}`);
+    return this.existing.has(name);
+  }
+
+  async bootstrapNpmPackages(options: BootstrapNpmPackagesOptions): Promise<ReleasePackageInfo[]> {
+    this.events.push(`bootstrap:${options.dryRun}:${options.skipLogin}`);
+    const missingPackages = this.packages.filter((pkg) => !this.existing.has(pkg.name));
+    for (const pkg of missingPackages) {
+      this.existing.add(pkg.name);
+    }
+    return missingPackages;
+  }
+
+  async login(): Promise<void> {
+    this.logins += 1;
+  }
+
+  async trustPublisher(
+    pkg: ReleasePackageInfo,
+    dryRun: boolean,
+    env?: Record<string, string>,
+  ): Promise<'configured' | 'already-configured'> {
+    this.events.push(`trust:${pkg.name}:${dryRun}:${env?.NPM_CONFIG_OTP ?? ''}`);
+    if (this.alreadyTrusted.has(pkg.name)) {
+      return 'already-configured';
+    }
+    return 'configured';
+  }
+
+  async promptOtp(packageName: string): Promise<string> {
+    throw new Error(`unexpected OTP prompt for ${packageName}`);
+  }
+
+  log(message: string): void {
+    this.logs.push(message);
+  }
+
+  error(message: string): void {
+    this.errors.push(message);
+  }
+}

package/src/release/bootstrap-npm-packages.ts

@@ -0,0 +1,88 @@
+import type { ReleasePackageInfo } from './core.js';
+
+export const NPM_BOOTSTRAP_VERSION = '0.0.0-bootstrap.0';
+export const NPM_BOOTSTRAP_DIST_TAG = 'bootstrap';
+
+export interface BootstrapNpmPackagesOptions {
+  dryRun: boolean;
+  skipLogin: boolean;
+  packages: string[];
+  otp?: string;
+}
+
+export interface BootstrapNpmPackagesShell<Package extends ReleasePackageInfo = ReleasePackageInfo> {
+  listReleasePackages(): Package[];
+  packageExists(name: string): Promise<boolean>;
+  login(): Promise<void>;
+  publishPlaceholder(pkg: Package, env?: Record<string, string>): Promise<void>;
+  promptOtp(packageName: string): Promise<string>;
+  log(message: string): void;
+}
+
+export async function bootstrapNpmPackages<Package extends ReleasePackageInfo>(
+  shell: BootstrapNpmPackagesShell<Package>,
+  options: BootstrapNpmPackagesOptions,
+): Promise<Package[]> {
+  const packages = selectedReleasePackages(shell.listReleasePackages(), options.packages);
+  if (packages.length === 0) {
+    throw new Error('No owned release packages found.');
+  }
+
+  const missing: Package[] = [];
+  for (const pkg of packages) {
+    if (await shell.packageExists(pkg.name)) {
+      shell.log(`${pkg.name}: already exists on npm; skipping placeholder bootstrap.`);
+    } else {
+      missing.push(pkg);
+    }
+  }
+
+  if (missing.length === 0) {
+    shell.log('All selected owned release packages already exist on npm.');
+    return [];
+  }
+
+  shell.log(
+    `Bootstrap npm placeholders (${NPM_BOOTSTRAP_VERSION}, dist-tag ${NPM_BOOTSTRAP_DIST_TAG}): ${missing
+      .map((pkg) => pkg.name)
+      .join(', ')}`,
+  );
+  if (options.dryRun) {
+    return missing;
+  }
+
+  if (!options.skipLogin) {
+    await shell.login();
+  }
+  for (const pkg of missing) {
+    shell.log(`${pkg.name}: publishing npm placeholder.`);
+    const otp = options.otp ?? (await shell.promptOtp(pkg.name));
+    await shell.publishPlaceholder(pkg, { NPM_CONFIG_OTP: otp });
+  }
+  shell.log('Bootstrap complete. Run smoo release trust-publisher before the first CI publish.');
+  return missing;
+}
+
+function selectedReleasePackages<Package extends ReleasePackageInfo>(
+  packages: Package[],
+  selections: string[],
+): Package[] {
+  if (selections.length === 0) {
+    return packages;
+  }
+  const byName = new Map(packages.map((pkg) => [pkg.name, pkg]));
+  const selected: Package[] = [];
+  const unknown: string[] = [];
+  for (const name of selections) {
+    const pkg = byName.get(name);
+    if (pkg) {
+      selected.push(pkg);
+    } else {
+      unknown.push(name);
+    }
+  }
+  if (unknown.length > 0) {
+    throw new Error(`Unknown owned release package selection: ${unknown.join(', ')}`);
+  }
+  return selected;
+}

package/src/release/candidates.ts

@@ -0,0 +1,225 @@
+import { isRecord } from '../lib/json.js';
+import type { ReleasePackageInfo } from './core.js';
+import { releaseTag } from './core.js';
+
+export interface AutoReleaseCandidateShell {
+  gitRefExists(ref: string): Promise<boolean>;
+  packageChangedFilesSince(ref: string, packagePath: string): Promise<string[]>;
+  packageJsonAtRef(ref: string, packagePath: string): Promise<Record<string, unknown> | null>;
+  currentPackageJson(packagePath: string): Promise<Record<string, unknown> | null>;
+  packageBuildInputPatterns(projectName: string, packagePath: string): Promise<string[]>;
+  packageHasHistory(packagePath: string): Promise<boolean>;
+}
+
+const releasableManifestKeys = [
+  'author',
+  'bin',
+  'browser',
+  'bugs',
+  'cpu',
+  'dependencies',
+  'description',
+  'engines',
+  'exports',
+  'files',
+  'funding',
+  'homepage',
+  'imports',
+  'keywords',
+  'license',
+  'main',
+  'module',
+  'name',
+  'optionalDependencies',
+  'os',
+  'peerDependencies',
+  'peerDependenciesMeta',
+  'publishConfig',
+  'repository',
+  'sideEffects',
+  'types',
+  'typesVersions',
+] as const;
+
+export async function autoReleaseCandidatePackages<Package extends ReleasePackageInfo>(
+  shell: AutoReleaseCandidateShell,
+  packages: Package[],
+): Promise<Package[]> {
+  const candidates: Package[] = [];
+  for (const pkg of packages) {
+    if (await isAutoReleaseCandidate(shell, pkg)) {
+      candidates.push(pkg);
+    }
+  }
+  return candidates;
+}
+
+async function isAutoReleaseCandidate<Package extends ReleasePackageInfo>(
+  shell: AutoReleaseCandidateShell,
+  pkg: Package,
+): Promise<boolean> {
+  const tagRef = `refs/tags/${releaseTag(pkg)}`;
+  if (await shell.gitRefExists(tagRef)) {
+    return packageHasReleasableChangesSince(shell, tagRef, pkg);
+  }
+  return shell.packageHasHistory(pkg.path);
+}
+
+async function packageHasReleasableChangesSince<Package extends ReleasePackageInfo>(
+  shell: AutoReleaseCandidateShell,
+  ref: string,
+  pkg: Package,
+): Promise<boolean> {
+  const changedFiles = await shell.packageChangedFilesSince(ref, pkg.path);
+  if (changedFiles.length === 0) {
+    return false;
+  }
+  const currentManifest = await shell.currentPackageJson(pkg.path);
+  const buildInputPatterns = await shell.packageBuildInputPatterns(pkg.projectName, pkg.path);
+  for (const changedFile of changedFiles) {
+    if (changedFile === 'package.json') {
+      const previousManifest = await shell.packageJsonAtRef(ref, pkg.path);
+      if (!previousManifest || !currentManifest || releasableManifestChanged(previousManifest, currentManifest)) {
+        return true;
+      }
+      continue;
+    }
+    if (isReleasablePackagePath(changedFile, currentManifest, buildInputPatterns)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function releasableManifestChanged(
+  previousManifest: Record<string, unknown>,
+  currentManifest: Record<string, unknown>,
+): boolean {
+  for (const key of releasableManifestKeys) {
+    if (!stableJsonEqual(previousManifest[key], currentManifest[key])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isReleasablePackagePath(
+  path: string,
+  manifest: Record<string, unknown> | null,
+  buildInputPatterns: string[],
+): boolean {
+  return (
+    isBuildInputPath(path, buildInputPatterns) || isPackageMetadataPath(path) || isManifestFilesPath(path, manifest)
+  );
+}
+
+function isBuildInputPath(path: string, patterns: string[]): boolean {
+  if (isReleaseIgnoredBuildInputPath(path)) {
+    return false;
+  }
+  let matched = false;
+  for (const pattern of patterns) {
+    const excluded = pattern.startsWith('!');
+    const rawPattern = excluded ? pattern.slice(1) : pattern;
+    if (matchesBuildInputPattern(path, rawPattern)) {
+      matched = !excluded;
+    }
+  }
+  return matched;
+}
+
+function matchesBuildInputPattern(path: string, pattern: string): boolean {
+  const normalized = pattern.replace(/^\.\//, '').replace(/\/$/, '');
+  if (!normalized) {
+    return false;
+  }
+  return globPatternToRegExp(normalized).test(path);
+}
+
+function globPatternToRegExp(pattern: string): RegExp {
+  let source = '^';
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === '*') {
+      if (pattern[index + 1] === '*') {
+        if (pattern[index + 2] === '/') {
+          source += '(?:.*/)?';
+          index += 2;
+        } else {
+          source += '.*';
+          index += 1;
+        }
+      } else {
+        source += '[^/]*';
+      }
+    } else {
+      source += escapeRegExpChar(char);
+    }
+  }
+  return new RegExp(`${source}$`);
+}
+
+function escapeRegExpChar(char: string | undefined): string {
+  if (!char) {
+    return '';
+  }
+  return /[\\^$+?.()|[\]{}]/.test(char) ? `\\${char}` : char;
+}
+
+function isReleaseIgnoredBuildInputPath(path: string): boolean {
+  return (
+    path === 'package.json' ||
+    path === 'tsconfig.test.json' ||
+    path.includes('/__tests__/') ||
+    path.endsWith('.test.ts') ||
+    path.endsWith('.test.tsx') ||
+    path.endsWith('.spec.ts') ||
+    path.endsWith('.spec.tsx')
+  );
+}
+
+function isPackageMetadataPath(path: string): boolean {
+  return /^(README|LICENSE|CHANGELOG)(\.|$)/.test(path);
+}
+
+function isManifestFilesPath(path: string, manifest: Record<string, unknown> | null): boolean {
+  const files = manifest?.files;
+  if (!Array.isArray(files)) {
+    return false;
+  }
+  for (const entry of files) {
+    if (typeof entry !== 'string' || entry.length === 0 || entry.startsWith('!')) {
+      continue;
+    }
+    if (matchesManifestFilesEntry(path, entry)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function matchesManifestFilesEntry(path: string, entry: string): boolean {
+  const normalized = entry.replace(/^\.\//, '').replace(/\/$/, '');
+  if (!normalized || normalized.includes('*')) {
+    return false;
+  }
+  return path === normalized || path.startsWith(`${normalized}/`);
+}
+
+function stableJsonEqual(left: unknown, right: unknown): boolean {
+  return JSON.stringify(stableJson(left)) === JSON.stringify(stableJson(right));
+}
+
+function stableJson(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(stableJson);
+  }
+  if (isRecord(value)) {
+    const normalized: Record<string, unknown> = {};
+    for (const key of Object.keys(value).sort()) {
+      normalized[key] = stableJson(value[key]);
+    }
+    return normalized;
+  }
+  return value;
+}

package/src/release/core.ts

@@ -1,5 +1,6 @@
 export interface ReleasePackageInfo {
   name: string;
+  projectName: string;
   path: string;
   version: string;
 }

package/src/release/github-release.ts

@@ -39,7 +39,7 @@ export async function renderNxProjectChangelogContents(input: RenderNxProjectCha
       nxRenderOnlyReleaseConfig,
       false,
     )(nxProjectChangelogArgs(input.pkg, input.previousTag, input.dryRun));
-    return projectChangelogContents(result, input.pkg.name);
+    return projectChangelogContents(result, input.pkg.projectName);
   });
 }
 
@@ -65,7 +65,7 @@ export async function createOrUpdateGithubRelease(
 export function nxProjectChangelogArgs(pkg: ReleasePackageInfo, previousTag: string | null, dryRun: boolean) {
   const base = {
     version: pkg.version,
-    projects: [pkg.name],
+    projects: [pkg.projectName],
     gitCommit: false,
     gitTag: false,
     gitPush: false,