@smoothbricks/cli 0.1.1 → 0.2.0

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

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  type BootstrapNpmPackagesShell,
+  bootstrapNpmPackages,
+  NPM_BOOTSTRAP_DIST_TAG,
+  NPM_BOOTSTRAP_VERSION,
+} from '../bootstrap-npm-packages.js';
+import type { ReleasePackageInfo } from '../core.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('bootstrap npm packages', () => {
+  it('publishes placeholders only for selected packages missing from npm', async () => {
+    const shell = new RecordingBootstrapShell({
+      packages: [stable, missing],
+      existing: [stable.name],
+      otps: ['123456'],
+    });
+
+    const bootstrapped = await bootstrapNpmPackages(shell, {
+      dryRun: false,
+      skipLogin: false,
+      packages: [missing.name],
+    });
+
+    expect(bootstrapped.map((pkg) => pkg.name)).toEqual([missing.name]);
+    expect(shell.logins).toBe(1);
+    expect(shell.published).toEqual([{ name: missing.name, otp: '123456' }]);
+    expect(shell.logs.join('\n')).toContain(NPM_BOOTSTRAP_VERSION);
+    expect(shell.logs.join('\n')).toContain(NPM_BOOTSTRAP_DIST_TAG);
+  });
+
+  it('dry-run reports missing packages without login or publish', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [stable, missing], existing: [stable.name] });
+
+    const bootstrapped = await bootstrapNpmPackages(shell, { dryRun: true, skipLogin: false, packages: [] });
+
+    expect(bootstrapped.map((pkg) => pkg.name)).toEqual([missing.name]);
+    expect(shell.logins).toBe(0);
+    expect(shell.published).toEqual([]);
+    expect(shell.logs).toContain(`${stable.name}: already exists on npm; skipping placeholder bootstrap.`);
+  });
+
+  it('supports skipping npm login when an existing session is already authenticated', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [missing], existing: [], otps: ['654321'] });
+
+    await bootstrapNpmPackages(shell, { dryRun: false, skipLogin: true, packages: [] });
+
+    expect(shell.logins).toBe(0);
+    expect(shell.published).toEqual([{ name: missing.name, otp: '654321' }]);
+  });
+
+  it('passes explicit OTP to placeholder publishes without prompting', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [missing], existing: [] });
+
+    await bootstrapNpmPackages(shell, { dryRun: false, skipLogin: true, packages: [], otp: '111222' });
+
+    expect(shell.published).toEqual([{ name: missing.name, otp: '111222' }]);
+    expect(shell.prompts).toEqual([]);
+  });
+
+  it('rejects unknown package selections before npm login', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [stable], existing: [] });
+
+    await expect(
+      bootstrapNpmPackages(shell, { dryRun: false, skipLogin: false, packages: ['@scope/unknown'] }),
+    ).rejects.toThrow('Unknown owned release package selection: @scope/unknown');
+    expect(shell.logins).toBe(0);
+    expect(shell.published).toEqual([]);
+  });
+});
+
+class RecordingBootstrapShell implements BootstrapNpmPackagesShell<ReleasePackageInfo> {
+  readonly logs: string[] = [];
+  readonly published: Array<{ name: string; otp: string }> = [];
+  readonly prompts: string[] = [];
+  logins = 0;
+  private readonly packages: ReleasePackageInfo[];
+  private readonly existing: Set<string>;
+  private readonly otps: string[];
+
+  constructor(options: { packages: ReleasePackageInfo[]; existing: string[]; otps?: string[] }) {
+    this.packages = options.packages;
+    this.existing = new Set(options.existing);
+    this.otps = [...(options.otps ?? [])];
+  }
+
+  listReleasePackages(): ReleasePackageInfo[] {
+    return this.packages;
+  }
+
+  async packageExists(name: string): Promise<boolean> {
+    return this.existing.has(name);
+  }
+
+  async login(): Promise<void> {
+    this.logins += 1;
+  }
+
+  async publishPlaceholder(pkg: ReleasePackageInfo, env?: Record<string, string>): Promise<void> {
+    this.published.push({ name: pkg.name, otp: env?.NPM_CONFIG_OTP ?? '' });
+  }
+
+  async promptOtp(packageName: string): Promise<string> {
+    this.prompts.push(packageName);
+    const otp = this.otps.shift();
+    if (!otp) {
+      throw new Error(`unexpected OTP prompt for ${packageName}`);
+    }
+    return otp;
+  }
+
+  log(message: string): void {
+    this.logs.push(message);
+  }
+}

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

@@ -0,0 +1,217 @@
+import { describe, expect, it } from 'bun:test';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { $ } from 'bun';
+import { isRecord } from '../../lib/json.js';
+import { type AutoReleaseCandidateShell, autoReleaseCandidatePackages } from '../candidates.js';
+import type { ReleasePackageInfo } from '../core.js';
+import { git, tag, withFixtureRepo, writePackage } from './helpers/fixture-repo.js';
+
+const a: ReleasePackageInfo = { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '1.0.0' };
+const b: ReleasePackageInfo = { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '1.0.0' };
+const c: ReleasePackageInfo = { name: '@scope/c', projectName: 'c', path: 'packages/c', version: '0.1.0' };
+const d: ReleasePackageInfo = { name: '@scope/d', projectName: 'd', path: 'packages/d', version: '0.1.0' };
+
+describe('auto release candidate filtering', () => {
+  it('selects tagged packages only when their package path changed', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await writePackage(root, b.name, b.path, b.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial packages']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, '@scope/b@1.0.0', '2025-01-01T00:00:01Z');
+
+      await writeFile(join(root, 'README.md'), 'root-only change\n');
+      await git(root, ['add', 'README.md']);
+      await git(root, ['commit', '-m', 'docs: root only']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a, b])).resolves.toEqual([]);
+
+      await mkdir(join(root, a.path, 'src'), { recursive: true });
+      await writeFile(join(root, a.path, 'src/index.ts'), 'export const changed = true;\n');
+      await git(root, ['add', join(a.path, 'src/index.ts')]);
+      await git(root, ['commit', '-m', 'feat(a): package local']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a, b])).resolves.toEqual([a]);
+    });
+  });
+
+  it('ignores package-local config changes that do not affect published users', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await mkdir(join(root, a.path), { recursive: true });
+      await writeFile(
+        join(root, a.path, 'package.json'),
+        `${JSON.stringify(
+          {
+            name: a.name,
+            version: a.version,
+            scripts: { test: 'nx run a:test' },
+            devDependencies: { typescript: '^5.9.3' },
+            nx: { name: 'a' },
+          },
+          null,
+          2,
+        )}\n`,
+      );
+      await writeFile(join(root, a.path, 'tsconfig.test.json'), `${JSON.stringify({ compilerOptions: {} })}\n`);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(a): normalize package config']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a])).resolves.toEqual([]);
+    });
+  });
+
+  it('selects package manifest changes that affect published users', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await writeFile(
+        join(root, a.path, 'package.json'),
+        `${JSON.stringify(
+          {
+            name: a.name,
+            version: a.version,
+            exports: { '.': './dist/index.js' },
+            dependencies: { '@scope/shared': '^1.0.0' },
+          },
+          null,
+          2,
+        )}\n`,
+      );
+      await git(root, ['add', join(a.path, 'package.json')]);
+      await git(root, ['commit', '-m', 'fix(a): update public entrypoint']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a])).resolves.toEqual([a]);
+    });
+  });
+
+  it('selects files included by package manifest files entries', async () => {
+    await withFixtureRepo(async (root) => {
+      await mkdir(join(root, a.path), { recursive: true });
+      await writeFile(
+        join(root, a.path, 'package.json'),
+        `${JSON.stringify({ name: a.name, version: a.version, files: ['schema'] }, null, 2)}\n`,
+      );
+      await mkdir(join(root, a.path, 'schema'), { recursive: true });
+      await writeFile(join(root, a.path, 'schema/index.json'), '{}\n');
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await writeFile(join(root, a.path, 'schema/index.json'), '{"changed":true}\n');
+      await git(root, ['add', join(a.path, 'schema/index.json')]);
+      await git(root, ['commit', '-m', 'fix(a): update shipped schema']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a])).resolves.toEqual([a]);
+    });
+  });
+
+  it('selects package changes from Nx build input patterns', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await mkdir(join(root, a.path, 'generated'), { recursive: true });
+      await writeFile(join(root, a.path, 'generated/schema.ts'), 'export const schema = 1;\n');
+      await git(root, ['add', join(a.path, 'generated/schema.ts')]);
+      await git(root, ['commit', '-m', 'fix(a): update generated build input']);
+
+      await expect(
+        autoReleaseCandidatePackages(gitCandidateShell(root, { buildInputPatterns: ['generated/**/*'] }), [a]),
+      ).resolves.toEqual([a]);
+    });
+  });
+
+  it('uses precise Nx production inputs to ignore config and test-only package paths', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      const shell = gitCandidateShell(root, { buildInputPatterns: ['src/**/*.ts', '!src/**/*.test.ts'] });
+
+      await mkdir(join(root, a.path, 'src'), { recursive: true });
+      await writeFile(join(root, a.path, 'vite.config.ts'), 'export default {};\n');
+      await writeFile(join(root, a.path, 'src/index.test.ts'), 'export const testOnly = true;\n');
+      await git(root, ['add', join(a.path, 'vite.config.ts'), join(a.path, 'src/index.test.ts')]);
+      await git(root, ['commit', '-m', 'test(a): update local-only inputs']);
+
+      await expect(autoReleaseCandidatePackages(shell, [a])).resolves.toEqual([]);
+
+      await writeFile(join(root, a.path, 'src/index.ts'), 'export const shipped = true;\n');
+      await git(root, ['add', join(a.path, 'src/index.ts')]);
+      await git(root, ['commit', '-m', 'fix(a): update production input']);
+
+      await expect(autoReleaseCandidatePackages(shell, [a])).resolves.toEqual([a]);
+    });
+  });
+
+  it('includes untagged packages only when their package path has history', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, c.name, c.path, c.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'feat(c): add package']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [c, d])).resolves.toEqual([c]);
+    });
+  });
+});
+
+function gitCandidateShell(root: string, options: { buildInputPatterns?: string[] } = {}): AutoReleaseCandidateShell {
+  return {
+    gitRefExists: async (ref) => {
+      const result = await $`git rev-parse --verify ${ref}`.cwd(root).quiet().nothrow();
+      return result.exitCode === 0;
+    },
+    packageChangedFilesSince: async (ref, packagePath) => {
+      const result = await $`git diff --name-only ${`${ref}..HEAD`} -- ${packagePath}`.cwd(root).quiet().nothrow();
+      if (result.exitCode === 0) {
+        const packagePrefix = `${packagePath}/`;
+        return new TextDecoder()
+          .decode(result.stdout)
+          .split('\n')
+          .map((path) => path.trim())
+          .filter(Boolean)
+          .map((path) => (path.startsWith(packagePrefix) ? path.slice(packagePrefix.length) : path));
+      }
+      throw new Error(`Unable to inspect package changes under ${packagePath}.`);
+    },
+    packageJsonAtRef: async (ref, packagePath) => {
+      const result = await $`git show ${`${ref}:${packagePath}/package.json`}`.cwd(root).quiet().nothrow();
+      if (result.exitCode !== 0) {
+        return null;
+      }
+      return parseJsonObject(new TextDecoder().decode(result.stdout));
+    },
+    currentPackageJson: async (packagePath) =>
+      parseJsonObject(await readFile(join(root, packagePath, 'package.json'), 'utf8')),
+    packageBuildInputPatterns: async () => options.buildInputPatterns ?? ['**/*'],
+    packageHasHistory: async (packagePath) => {
+      const result = await $`git log --format=%H -- ${packagePath}`.cwd(root).quiet().nothrow();
+      if (result.exitCode !== 0) {
+        throw new Error(`Unable to inspect package history under ${packagePath}.`);
+      }
+      return new TextDecoder().decode(result.stdout).trim().length > 0;
+    },
+  };
+}
+
+function parseJsonObject(text: string): Record<string, unknown> {
+  const parsed = JSON.parse(text);
+  if (!isRecord(parsed)) {
+    throw new Error('expected JSON object');
+  }
+  return parsed;
+}

package/src/release/__tests__/core-properties.test.ts

@@ -4,9 +4,9 @@ import { groupReleaseTargets, pendingReleaseTargets, type ReleasePackageInfo, ty
 import { planPublishActions } from '../publish-plan.js';
 
 const packages: ReleasePackageInfo[] = [
-  { name: '@scope/a', path: 'packages/a', version: '1.0.0' },
-  { name: '@scope/b', path: 'packages/b', version: '2.0.0-beta.1' },
-  { name: '@scope/c', path: 'packages/c', version: '3.0.0' },
+  { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '1.0.0' },
+  { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '2.0.0-beta.1' },
+  { name: '@scope/c', projectName: 'c', path: 'packages/c', version: '3.0.0' },
 ];
 
 describe('release core properties', () => {
@@ -77,7 +77,7 @@ describe('release core properties', () => {
       fc.property(packageSubset(), packageSubset(), (npmMissingPackages, githubMissingPackages) => {
         const plan = planPublishActions({ releasePackages: packages, npmMissingPackages, githubMissingPackages });
 
-        expect(plan.buildProjects).toEqual(npmMissingPackages.map((pkg) => pkg.name));
+        expect(plan.buildProjects).toEqual(npmMissingPackages.map((pkg) => pkg.projectName));
         expect(plan.publishPackages.map((action) => action.pkg.name)).toEqual(
           npmMissingPackages.map((pkg) => pkg.name),
         );

package/src/release/__tests__/core-scenarios.test.ts

@@ -10,9 +10,15 @@ import {
   type ReleaseTagRecord,
 } from '../core.js';
 
-const stablePackage: ReleasePackageInfo = { name: '@scope/stable', path: 'packages/stable', version: '1.0.0' };
+const stablePackage: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.0.0',
+};
 const prereleasePackage: ReleasePackageInfo = {
   name: '@scope/prerelease',
+  projectName: 'prerelease',
   path: 'packages/prerelease',
   version: '2.0.0-beta.1',
 };
@@ -109,7 +115,7 @@ describe('release core scenario coverage', () => {
     };
 
     const records = await collectOwnedReleaseTagRecords(
-      [{ name: stablePackage.name, path: stablePackage.path }],
+      [{ name: stablePackage.name, projectName: stablePackage.projectName, path: stablePackage.path }],
       'selected-ref',
       shell,
     );
@@ -142,8 +148,8 @@ describe('release core scenario coverage', () => {
 
     const records = await collectOwnedReleaseTagRecords(
       [
-        { name: stablePackage.name, path: stablePackage.path },
-        { name: prereleasePackage.name, path: prereleasePackage.path },
+        { name: stablePackage.name, projectName: stablePackage.projectName, path: stablePackage.path },
+        { name: prereleasePackage.name, projectName: prereleasePackage.projectName, path: prereleasePackage.path },
       ],
       'selected-ref',
       shell,
@@ -165,7 +171,11 @@ describe('release core scenario coverage', () => {
     };
 
     await expect(
-      collectOwnedReleaseTagRecords([{ name: stablePackage.name, path: stablePackage.path }], 'selected-ref', shell),
+      collectOwnedReleaseTagRecords(
+        [{ name: stablePackage.name, projectName: stablePackage.projectName, path: stablePackage.path }],
+        'selected-ref',
+        shell,
+      ),
     ).rejects.toThrow(
       'Release tag @scope/stable@1.0.0 points at mismatch, but packages/stable/package.json has version 1.0.1.',
     );

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

@@ -8,8 +8,8 @@ import {
   releasePackageForTag,
 } from '../core.js';
 
-const a: ReleasePackageInfo = { name: '@scope/a', path: 'packages/a', version: '1.0.0' };
-const b: ReleasePackageInfo = { name: '@scope/b', path: 'packages/b', version: '2.0.0-beta.1' };
+const a: ReleasePackageInfo = { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '1.0.0' };
+const b: ReleasePackageInfo = { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '2.0.0-beta.1' };
 
 function record(
   pkg: ReleasePackageInfo,

package/src/release/__tests__/fixture-repo.test.ts

@@ -44,8 +44,8 @@ describe('release planning with fixture git repositories', () => {
       const githubReleases = new Set(['@scope/a@1.0.0']);
       const records = await collectOwnedReleaseTagRecords(
         [
-          { name: '@scope/a', path: 'packages/a' },
-          { name: '@scope/b', path: 'packages/b' },
+          { name: '@scope/a', projectName: 'a', path: 'packages/a' },
+          { name: '@scope/b', projectName: 'b', path: 'packages/b' },
         ],
         head,
         {
@@ -83,12 +83,16 @@ describe('release planning with fixture git repositories', () => {
       await git(checkout, ['fetch', '--tags', 'origin', 'main']);
       const head = await gitOutput(checkout, ['rev-parse', 'HEAD']);
 
-      const records = await collectOwnedReleaseTagRecords([{ name: '@scope/a', path: 'packages/a' }], head, {
-        listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(checkout),
-        isAncestor: (ancestor, descendant) => gitIsAncestor(checkout, ancestor, descendant),
-        packageVersionAtRef: (packagePath, ref) => packageVersionAtRef(checkout, packagePath, ref),
-        durableTagState: async () => ({ npmPublished: false, githubReleaseExists: false }),
-      });
+      const records = await collectOwnedReleaseTagRecords(
+        [{ name: '@scope/a', projectName: 'a', path: 'packages/a' }],
+        head,
+        {
+          listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(checkout),
+          isAncestor: (ancestor, descendant) => gitIsAncestor(checkout, ancestor, descendant),
+          packageVersionAtRef: (packagePath, ref) => packageVersionAtRef(checkout, packagePath, ref),
+          durableTagState: async () => ({ npmPublished: false, githubReleaseExists: false }),
+        },
+      );
 
       expect(records.map((record) => record.tag)).toEqual(['@scope/a@1.0.0']);
       expect(pendingReleaseTargets(records, 'not-head').map((target) => target.sha)).toEqual([head]);
@@ -101,7 +105,7 @@ describe('release planning with fixture git repositories', () => {
       await writeBuildablePackage(root, '@scope/a', 'packages/a');
       await writeBuildablePackage(root, '@scope/b', 'packages/b');
 
-      await $`nx run-many -t build --projects=${'@scope/a,@scope/b'}`.cwd(root).quiet();
+      await $`nx run-many -t build --projects=${'a,b'}`.cwd(root).quiet();
 
       await expect(readFile(join(root, 'packages/a/dist/index.js'), 'utf8')).resolves.toBe('{}\n');
       await expect(readFile(join(root, 'packages/b/dist/index.js'), 'utf8')).resolves.toBe('{}\n');
@@ -197,7 +201,12 @@ describe('release planning with fixture git repositories', () => {
       const runner = join(author, 'runner');
       await git(runner, ['config', 'user.name', 'Test User']);
       await git(runner, ['config', 'user.email', 'test@example.com']);
-      const pkg: ReleasePackageInfo = { name: '@scope/pushed', path: 'packages/pushed', version: '1.0.0' };
+      const pkg: ReleasePackageInfo = {
+        name: '@scope/pushed',
+        projectName: 'pushed',
+        path: 'packages/pushed',
+        version: '1.0.0',
+      };
       const shell = new LocalGitRepairShell(runner);
 
       const summary = await completeReleaseAtHead(shell, [pkg], false, false);
@@ -216,8 +225,8 @@ describe('release planning with fixture git repositories', () => {
 
 function releaseFixturePackages(): ReleasePackageInfo[] {
   return [
-    { name: '@scope/a', path: 'packages/a', version: '0.0.0' },
-    { name: '@scope/b', path: 'packages/b', version: '0.0.0' },
+    { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '0.0.0' },
+    { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '0.0.0' },
   ];
 }
 
@@ -265,7 +274,7 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
 
   async buildReleaseCandidate(packages: ReleasePackageInfo[]): Promise<void> {
     this.builds.push(packages.map((pkg) => pkg.name));
-    await $`nx run-many -t build --projects=${packages.map((pkg) => pkg.name).join(',')}`.cwd(this.root).quiet();
+    await $`nx run-many -t build --projects=${packages.map((pkg) => pkg.projectName).join(',')}`.cwd(this.root).quiet();
   }
 
   async publishPackage(pkg: ReleasePackageInfo, distTag: string, dryRun: boolean): Promise<void> {

package/src/release/__tests__/github-release.test.ts

@@ -8,14 +8,19 @@ import {
   projectChangelogContents,
 } from '../github-release.js';
 
-const stable: ReleasePackageInfo = { name: '@scope/pkg', path: 'packages/pkg', version: '1.2.3' };
-const prerelease: ReleasePackageInfo = { name: '@scope/pkg', path: 'packages/pkg', version: '2.0.0-beta.1' };
+const stable: ReleasePackageInfo = { name: '@scope/pkg', projectName: 'pkg', path: 'packages/pkg', version: '1.2.3' };
+const prerelease: ReleasePackageInfo = {
+  name: '@scope/pkg',
+  projectName: 'pkg',
+  path: 'packages/pkg',
+  version: '2.0.0-beta.1',
+};
 
 describe('GitHub release helpers', () => {
   it('configures the Nx changelog API for render-only project changelogs', () => {
     expect(nxProjectChangelogArgs(stable, '@scope/pkg@1.2.2', false)).toEqual({
       version: '1.2.3',
-      projects: ['@scope/pkg'],
+      projects: ['pkg'],
       gitCommit: false,
       gitTag: false,
       gitPush: false,
@@ -30,7 +35,7 @@ describe('GitHub release helpers', () => {
   it('marks the Nx changelog request as a first release when there is no previous tag', () => {
     expect(nxProjectChangelogArgs(stable, null, true)).toEqual({
       version: '1.2.3',
-      projects: ['@scope/pkg'],
+      projects: ['pkg'],
       gitCommit: false,
       gitTag: false,
       gitPush: false,
@@ -47,17 +52,17 @@ describe('GitHub release helpers', () => {
       projectChangelogContents(
         {
           projectChangelogs: {
-            '@scope/pkg': { contents: 'generated release notes' },
+            pkg: { contents: 'generated release notes' },
           },
         },
-        '@scope/pkg',
+        'pkg',
       ),
     ).toBe('generated release notes');
   });
 
   it('fails when Nx omits the requested project changelog', () => {
-    expect(() => projectChangelogContents({ projectChangelogs: {} }, '@scope/pkg')).toThrow(
-      'Nx did not generate a project changelog for @scope/pkg.',
+    expect(() => projectChangelogContents({ projectChangelogs: {} }, 'pkg')).toThrow(
+      'Nx did not generate a project changelog for pkg.',
     );
   });
 

package/src/release/__tests__/helpers/fixture-repo.ts

@@ -47,6 +47,7 @@ export async function writeBuildablePackage(
         name,
         version,
         nx: {
+          name: name.startsWith('@') ? name.slice(name.indexOf('/') + 1) : name,
           targets: {
             build: {
               executor: 'nx:run-commands',

package/src/release/__tests__/npm-auth.test.ts

@@ -12,12 +12,10 @@ const pkg: Pick<ReleasePackageInfo, 'name' | 'version'> = { name: '@scope/pkg',
 describe('npm publish auth diagnostics', () => {
   it('explains trusted publishing setup when an existing package publish is unauthenticated', () => {
     const message = npmPublishAuthFailureMessage(pkg, {
-      useBootstrapToken: false,
       tokenPresent: true,
       repository: 'smoothbricks/codebase',
     });
     const markdown = npmPublishAuthFailureMarkdown(pkg, {
-      useBootstrapToken: false,
       tokenPresent: true,
       repository: 'smoothbricks/codebase',
     });
@@ -32,16 +30,12 @@ describe('npm publish auth diagnostics', () => {
     expect(markdown).toContain('repository `smoothbricks/codebase` and workflow `publish.yml`');
   });
 
-  it('explains the bootstrap token path for first package publishes', () => {
-    const message = npmPublishAuthFailureMessage(pkg, { useBootstrapToken: true, tokenPresent: false });
-    const markdown = npmPublishAuthFailureMarkdown(pkg, { useBootstrapToken: true, tokenPresent: false });
+  it('points first package publishes to local placeholder bootstrap', () => {
+    const message = npmPublishAuthFailureMessage(pkg, { tokenPresent: false });
+    const markdown = npmPublishAuthFailureMarkdown(pkg, { tokenPresent: false });
 
-    expect(message).toContain('temporary npm automation token');
-    expect(message).toContain('NODE_AUTH_TOKEN/NPM_TOKEN is not set');
-    expect(message).toContain('After the first successful publish, run:');
-    expect(message).toContain('smoo release trust-publisher');
-    expect(markdown).toContain('Add a temporary `NPM_TOKEN` repository secret');
-    expect(markdown).toContain('After the first successful publish, run `smoo release trust-publisher`');
+    expect(message).toContain('smoo release trust-publisher --bootstrap');
+    expect(markdown).toContain('smoo release trust-publisher --bootstrap');
   });
 
   it('reports trusted-publishing guidance and writes it to the publish summary after existing package auth failure', async () => {
@@ -49,7 +43,6 @@ describe('npm publish auth diagnostics', () => {
 
     await expect(
       publishWithAuthDiagnostics(pkg, shell, {
-        useBootstrapToken: false,
         tokenPresent: true,
         repository: 'smoothbricks/codebase',
       }),
@@ -66,26 +59,24 @@ describe('npm publish auth diagnostics', () => {
     expect(shell.logs).toEqual([]);
   });
 
-  it('reports bootstrap token guidance and writes it to the publish summary after first-publish auth failure', async () => {
+  it('reports bootstrap command guidance and writes it to the publish summary after first-publish auth failure', async () => {
     const shell = new RecordingPublishShell({ publishFails: true });
 
-    await expect(
-      publishWithAuthDiagnostics(pkg, shell, { useBootstrapToken: true, tokenPresent: false }),
-    ).rejects.toThrow('@scope/pkg@1.2.3: npm publish authentication failed');
+    await expect(publishWithAuthDiagnostics(pkg, shell, { tokenPresent: false })).rejects.toThrow(
+      '@scope/pkg@1.2.3: npm publish authentication failed',
+    );
 
     expect(shell.errors).toHaveLength(1);
-    expect(shell.errors[0]).toContain('temporary npm automation token');
-    expect(shell.errors[0]).toContain('NODE_AUTH_TOKEN/NPM_TOKEN is not set');
-    expect(shell.errors[0]).toContain('smoo release trust-publisher');
+    expect(shell.errors[0]).toContain('smoo release trust-publisher --bootstrap');
     expect(shell.summaries).toHaveLength(1);
-    expect(shell.summaries[0]).toContain('Add a temporary `NPM_TOKEN` repository secret');
+    expect(shell.summaries[0]).toContain('smoo release trust-publisher --bootstrap');
     expect(shell.logs).toEqual([]);
   });
 
   it('continues without auth warning when the package version appears on npm after publish failure', async () => {
     const shell = new RecordingPublishShell({ publishFails: true, versionVisibleAfterFailure: true });
 
-    await publishWithAuthDiagnostics(pkg, shell, { useBootstrapToken: false, tokenPresent: true });
+    await publishWithAuthDiagnostics(pkg, shell, { tokenPresent: true });
 
     expect(shell.errors).toEqual([]);
     expect(shell.summaries).toEqual([]);