@smoothbricks/cli 0.10.4 → 0.10.6

package/src/monorepo/tool-validation.test.ts

@@ -13,13 +13,20 @@ import {
 const registryVersions: Record<string, string[]> = {
   '@biomejs/biome': ['2.3.5'],
   '@nx/js': ['23.1.0'],
+  '@smoothbricks/cli': ['0.10.3', '0.10.4'],
   '@smoothbricks/nx-plugin': ['0.3.0'],
   eslint: ['9.39.1'],
   'eslint-stdout': ['1.1.1', '1.1.2'],
   nx: ['23.1.0'],
   prettier: ['3.6.1'],
-  ttsc: ['0.18.4'],
-  typescript: ['5.9.3'],
+  ttsc: ['0.19.3'],
+  typescript: ['6.0.3'],
+  // alias package is not fetched from registry under this name when using fallback
+  '@typescript/native': ['7.0.2'],
+};
+
+const registryLatestTags: Record<string, string> = {
+  '@smoothbricks/cli': '0.10.4',
 };
 
 const realFetch = globalThis.fetch;
@@ -58,9 +65,9 @@ describe('tool configuration validation', () => {
 `,
       );
 
-      expect(validateToolConfig(root)).toBeGreaterThan(0);
+      expect(await validateToolConfig(root)).toBeGreaterThan(0);
       await applyToolConfigDefaults(root);
-      expect(validateToolConfig(root)).toBe(0);
+      expect(await validateToolConfig(root)).toBe(0);
 
       const rootPackage = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
       const toolingPackage = JSON.parse(await readFile(join(root, 'tooling/package.json'), 'utf8'));
@@ -69,6 +76,10 @@ describe('tool configuration validation', () => {
       expect(rootPackage.devDependencies['@smoothbricks/nx-plugin']).toBe('workspace:*');
       expect(rootPackage.devDependencies['eslint-stdout']).toBe('workspace:*');
       expect(rootPackage.devDependencies.nx).toBe('23.1.0');
+      expect(rootPackage.devDependencies.ttsc).toBe('0.19.3');
+      expect(rootPackage.devDependencies.typescript).toBe('^6.0.3');
+      expect(rootPackage.devDependencies['@typescript/native']).toBe('npm:typescript@^7.0.2');
+      expect(rootPackage.patchedDependencies['ttsc@0.19.3']).toBe('patches/ttsc@0.19.3.patch');
       expect(rootPackage.workspaces).toContain('tooling');
       expect(toolingPackage.name).toBe('@smoothbricks/tooling');
       expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe('workspace:*');
@@ -97,8 +108,12 @@ describe('tool configuration validation', () => {
           'eslint-stdout': await currentEslintStdoutRange(),
           nx: '24.0.0',
           prettier: '^3.7.0',
-          ttsc: '^0.19.0',
+          ttsc: '0.19.3',
           typescript: '^6.0.0',
+          '@typescript/native': 'npm:typescript@^7.0.2',
+        },
+        patchedDependencies: {
+          'ttsc@0.19.3': 'patches/ttsc@0.19.3.patch',
         },
       });
       await writeJson(join(root, 'tooling/package.json'), {
@@ -128,18 +143,17 @@ describe('tool configuration validation', () => {
 `,
       );
 
-      expect(validateToolConfig(root)).toBe(0);
+      expect(await validateToolConfig(root)).toBe(0);
     } finally {
       await rm(root, { recursive: true, force: true });
     }
   });
 
-  it('preserves an installable CLI range when the running CLI is a linked prerelease', async () => {
+  it('bumps consumer CLI pin to npm latest even when the running CLI is a linked prerelease', async () => {
     const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
     try {
       const configuredRange = '^0.10.1';
-      const runningRange = await currentCliRange();
-      const expectedRange = runningRange.includes('-') ? configuredRange : runningRange;
+      const expectedRange = `^${registryLatestTags['@smoothbricks/cli']}`;
       await writeJson(join(root, 'package.json'), {
         name: '@fixture/app',
         version: '0.0.0',
@@ -152,7 +166,7 @@ describe('tool configuration validation', () => {
         dependencies: { '@smoothbricks/cli': configuredRange },
       });
 
-      const context = readToolContext(root);
+      const context = await readToolContext(root);
       expect(context.policy.cliDependencyRange).toBe(expectedRange);
       applyToolingPackageDefaults(root, context.policy);
 
@@ -172,7 +186,7 @@ describe('tool configuration validation', () => {
         private: true,
         workspaces: ['packages/*', 'tooling'],
       });
-      applyToolingPackageDefaults(root, readToolContext(root).policy);
+      applyToolingPackageDefaults(root, (await readToolContext(root)).policy);
 
       const toolingPackage = JSON.parse(await readFile(join(root, 'tooling/package.json'), 'utf8'));
       expect(toolingPackage.name).toBe('@smoothbricks/tooling');
@@ -196,12 +210,12 @@ describe('tool configuration validation', () => {
           eslint: '^10.0.0',
           nx: '24.0.0',
           prettier: '^3.7.0',
-          ttsc: '^0.19.0',
+          ttsc: '0.19.3',
           typescript: '^6.0.0',
         },
       });
 
-      const context = readToolContext(root);
+      const context = await readToolContext(root);
       await applyRootDevDependencyDefaults(root, context);
       applyToolingPackageDefaults(root, context.policy);
 
@@ -209,6 +223,8 @@ describe('tool configuration validation', () => {
       const toolingPackage = JSON.parse(await readFile(join(root, 'tooling/package.json'), 'utf8'));
       expect(rootPackage.devDependencies['eslint-stdout']).toBe(await currentEslintStdoutRange());
       expect(rootPackage.devDependencies['@smoothbricks/nx-plugin']).toBe(await currentNxPluginRange());
+      expect(rootPackage.devDependencies['@typescript/native']).toBe('npm:typescript@^7.0.2');
+      expect(rootPackage.patchedDependencies?.['ttsc@0.19.3']).toBe('patches/ttsc@0.19.3.patch');
       expect(toolingPackage.name).toBe('@fixture/tooling');
       expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe(await currentCliRange());
     } finally {
@@ -218,8 +234,7 @@ describe('tool configuration validation', () => {
 });
 
 async function currentCliRange(): Promise<string> {
-  const pkg = JSON.parse(await readFile(new URL('../../package.json', import.meta.url), 'utf8'));
-  return `^${pkg.version}`;
+  return `^${registryLatestTags['@smoothbricks/cli']}`;
 }
 
 async function currentEslintStdoutRange(): Promise<string> {
@@ -235,8 +250,15 @@ const mockRegistryFetch = Object.assign(
     if (!versions) {
       return Promise.resolve(new Response('{}', { status: 404 }));
     }
+    const body: Record<string, unknown> = {
+      versions: Object.fromEntries(versions.map((version) => [version, {}])),
+    };
+    const latest = registryLatestTags[packageName];
+    if (latest) {
+      body['dist-tags'] = { latest };
+    }
     return Promise.resolve(
-      new Response(JSON.stringify({ versions: Object.fromEntries(versions.map((version) => [version, {}])) }), {
+      new Response(JSON.stringify(body), {
         status: 200,
         headers: { 'content-type': 'application/json' },
       }),

package/src/monorepo/tool-validation.ts

@@ -32,6 +32,7 @@ export interface ToolContext {
 
 interface RegistryPackument {
   versions: Record<string, unknown>;
+  'dist-tags'?: Record<string, string>;
 }
 
 const isRegistryPackument = typia.createIs<RegistryPackument>();
@@ -55,10 +56,14 @@ const rootDevDependencies: RequiredDependency[] = [
   },
   { name: 'nx', fallbackVersion: '23.1.0', minimumVersion: '23.1.0' },
   { name: 'prettier', fallbackVersion: '^3.6.1', minimumVersion: '3.6.0', prefix: '^' },
-  { name: 'ttsc', fallbackVersion: '^0.18.4', minimumVersion: '0.18.4', prefix: '^' },
+  // Exact pin: Bun patchedDependencies keys are version-locked (see patches/ttsc@0.19.3.patch).
+  { name: 'ttsc', fallbackVersion: '0.19.3' },
   // Nx and typescript-eslint still load the TypeScript JS API (6.x).
   // Compilation is exclusively delegated to ttsc by the Nx plugin targets.
-  { name: 'typescript', fallbackVersion: '^5.9.3', minimumVersion: '5.9.0', prefix: '^' },
+  { name: 'typescript', fallbackVersion: '^6.0.3', minimumVersion: '6.0.0', prefix: '^' },
+  // TS7 native compiler for ttsc (TTSC_TSGO_BINARY). Not the unscoped API package.
+  // npm alias form required — Bun cannot install @typescript/typescript6 cleanly (bun#33834).
+  { name: '@typescript/native', fallbackVersion: 'npm:typescript@^7.0.2' },
 ];
 
 const cliPackageName = '@smoothbricks/cli';
@@ -70,17 +75,21 @@ const requiredDevenvPackages = ['bun', 'git', 'git-format-staged', 'jq', 'alejan
 // never against a version template here.
 const nodePackagePattern = /(^|\s)nodejs(_\d+|_latest)?(\s|#|$)/m;
 
+const TTSC_PATCHED_DEPENDENCY_KEY = 'ttsc@0.19.3';
+const TTSC_PATCH_PATH = 'patches/ttsc@0.19.3.patch';
+
 export async function applyToolConfigDefaults(root: string): Promise<void> {
-  const context = readToolContext(root);
+  const context = await readToolContext(root);
   await applyRootPackageToolDefaults(root, context);
   applyToolingPackageDefaults(root, context.policy);
   applyDevenvPackageDefaults(root);
 }
 
-export function validateToolConfig(root: string): number {
-  const context = readToolContext(root);
+export async function validateToolConfig(root: string): Promise<number> {
+  const context = await readToolContext(root);
   return (
     validateRootDevDependencies(context.policy, context.rootPackage) +
+    validateTtscPatchedDependency(context.rootPackage) +
     validateToolingPackage(root, context.policy) +
     validateToolingWorkspace(context.rootPackage) +
     validateDevenvPackages(root)
@@ -104,6 +113,7 @@ export async function applyRootDevDependencyDefaults(root: string, context: Tool
   if (delete devDependencies['@smoothbricks/cli']) {
     changed = true;
   }
+  changed = ensureTtscPatchedDependency(pkg) || changed;
   if (changed) {
     writeJsonObject(join(root, 'package.json'), pkg);
     console.log('updated        package.json workspace tool dependencies');
@@ -119,6 +129,7 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
   }
   let dependencyChanged = false;
   let workspaceChanged = false;
+  let patchChanged = false;
   const devDependencies = ensureDependencyMap(pkg, 'devDependencies');
   for (const dependency of rootDevDependencies) {
     const current = devDependencies[dependency.name];
@@ -131,7 +142,8 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
     dependencyChanged = true;
   }
   workspaceChanged = addWorkspacePattern(pkg, 'tooling');
-  if (dependencyChanged || workspaceChanged) {
+  patchChanged = ensureTtscPatchedDependency(pkg);
+  if (dependencyChanged || workspaceChanged || patchChanged) {
     writeJsonObject(join(root, 'package.json'), pkg);
   }
   console.log(
@@ -144,6 +156,11 @@ async function applyRootPackageToolDefaults(root: string, context: ToolContext):
       ? 'updated        package.json tooling workspace'
       : 'unchanged      package.json tooling workspace',
   );
+  console.log(
+    patchChanged
+      ? 'updated        package.json patchedDependencies for ttsc'
+      : 'unchanged      package.json patchedDependencies for ttsc',
+  );
 }
 
 export function applyToolingPackageDefaults(root: string, policy: ToolPolicy): void {
@@ -235,6 +252,26 @@ export function validateRootDevDependencies(policy: ToolPolicy, rootPackage: Pac
   return failures;
 }
 
+function ensureTtscPatchedDependency(pkg: PackageJson): boolean {
+  const patched = ensureDependencyMap(pkg, 'patchedDependencies');
+  return setStringProperty(patched, TTSC_PATCHED_DEPENDENCY_KEY, TTSC_PATCH_PATH);
+}
+
+function validateTtscPatchedDependency(rootPackage: PackageJson | null): number {
+  if (!rootPackage) {
+    return 0;
+  }
+  const actual = rootPackage.patchedDependencies?.[TTSC_PATCHED_DEPENDENCY_KEY];
+  if (actual === TTSC_PATCH_PATH) {
+    return 0;
+  }
+  console.error(
+    `package.json patchedDependencies.${TTSC_PATCHED_DEPENDENCY_KEY} must be ${TTSC_PATCH_PATH}` +
+      (typeof actual === 'string' ? `; found ${actual}` : ' (required for declaration-emit fix)'),
+  );
+  return 1;
+}
+
 export function validateToolingPackage(root: string, policy: ToolPolicy): number {
   const path = join(root, 'tooling', 'package.json');
   const pkg = readJsonObject(path);
@@ -331,6 +368,10 @@ function satisfiesDependencyPolicy(policy: ToolPolicy, version: string, dependen
   if (workspaceDependencyExpected(policy, dependency)) {
     return version === 'workspace:*';
   }
+  // Dual-package native compiler: must stay an npm:typescript@7 alias, never unscoped "typescript".
+  if (dependency.name === '@typescript/native') {
+    return isTypeScriptNativeAlias(version);
+  }
   if (dependency.minimumVersion === undefined) {
     return version === dependency.fallbackVersion;
   }
@@ -342,37 +383,41 @@ function satisfiesDependencyPolicy(policy: ToolPolicy, version: string, dependen
   return compareVersions(parsed, minimum) >= 0;
 }
 
+function isTypeScriptNativeAlias(version: string): boolean {
+  // Accept npm:typescript@7, npm:typescript@^7.0.2, npm:typescript@~7.0.2, etc.
+  return /^npm:typescript@(?:\^|~)?7(?:\.|$)/.test(version.trim());
+}
+
 function formatExpectedDependency(policy: ToolPolicy, dependency: RequiredDependency): string {
   if (workspaceDependencyExpected(policy, dependency)) {
     return 'workspace:*';
   }
+  if (dependency.name === '@typescript/native') {
+    return 'npm:typescript@^7 (TypeScript 7 native compiler alias for ttsc)';
+  }
   return dependency.minimumVersion ? `>= ${dependency.minimumVersion}` : dependency.fallbackVersion;
 }
 
-export function readToolContext(root: string): ToolContext {
+export async function readToolContext(root: string): Promise<ToolContext> {
   const rootPackage = readPackageJsonObject(join(root, 'package.json'));
   const toolingPackage = readJsonObject(join(root, 'tooling', 'package.json'));
   const configuredCliRange = toolingPackage?.dependencies?.[cliPackageName];
   return {
     rootPackage,
-    policy: toolPolicy(rootPackage, typeof configuredCliRange === 'string' ? configuredCliRange : null),
+    policy: await toolPolicy(rootPackage, typeof configuredCliRange === 'string' ? configuredCliRange : null),
   };
 }
 
-function toolPolicy(rootPackage: PackageJson | null, configuredCliRange: string | null): ToolPolicy {
+async function toolPolicy(rootPackage: PackageJson | null, configuredCliRange: string | null): Promise<ToolPolicy> {
   const name = rootPackage?.name ?? null;
   const isCodebase = isSmoothBricksCodebasePackageName(name ?? undefined);
   const toolingName = toolingPackageName(name);
-  // A locally linked prerelease can be newer than every published CLI. Keep an existing
-  // installable range instead of rewriting the consumer manifest to an unpublished version.
-  const publishedCliRange =
-    cliPackageVersion.includes('-') && configuredCliRange && parseVersion(configuredCliRange)
-      ? configuredCliRange
-      : `^${cliPackageVersion}`;
   return {
     isSmoothBricksCodebase: isCodebase,
     toolingPackageName: toolingName,
-    cliDependencyRange: isCodebase ? 'workspace:*' : publishedCliRange,
+    // Consumers pin the latest *published* CLI. Running a linked prerelease must not
+    // freeze tooling/package.json on an older range or rewrite it to an unpublished -next.
+    cliDependencyRange: isCodebase ? 'workspace:*' : await resolvePublishedCliDependencyRange(configuredCliRange),
   };
 }
 
@@ -397,6 +442,59 @@ async function resolveDependencyVersion(policy: ToolPolicy, dependency: Required
   return `${dependency.prefix ?? ''}${latest ?? stripRangePrefix(dependency.fallbackVersion)}`;
 }
 
+/**
+ * Consumer monorepos pin `@smoothbricks/cli` to the latest stable release.
+ * Prefer npm `dist-tags.latest`. Never write a running `-next` package version into
+ * consumer manifests; never leave an older pin just because the running CLI is prerelease.
+ */
+async function resolvePublishedCliDependencyRange(configuredCliRange: string | null): Promise<string> {
+  const latest = await fetchLatestStableVersion(cliPackageName);
+  if (latest) {
+    return `^${latest}`;
+  }
+  // Registry unavailable: if the running CLI is a stable publish, use it.
+  if (!cliPackageVersion.includes('-')) {
+    return `^${cliPackageVersion}`;
+  }
+  // Linked prerelease + offline down: keep an existing installable stable pin.
+  if (configuredCliRange && parseVersion(configuredCliRange)) {
+    return configuredCliRange;
+  }
+  // Last resort: caret of the prerelease base (0.10.5-next.0 → ^0.10.5) so manifests stay valid.
+  const base = parseVersion(cliPackageVersion);
+  return base ? `^${base.major}.${base.minor}.${base.patch}` : `^${cliPackageVersion}`;
+}
+
+async function fetchLatestStableVersion(packageName: string): Promise<string | null> {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace('%40', '@')}`;
+  const response = await fetch(url, { headers: { accept: 'application/vnd.npm.install-v1+json' } });
+  if (!response.ok) {
+    return null;
+  }
+  const body: unknown = await response.json();
+  if (!isRegistryPackument(body)) {
+    return null;
+  }
+  const tagged = body['dist-tags']?.latest;
+  if (typeof tagged === 'string' && parseVersion(tagged) && !tagged.includes('-')) {
+    return tagged;
+  }
+  let latest: Version | null = null;
+  for (const raw of Object.keys(body.versions)) {
+    if (raw.includes('-')) {
+      continue;
+    }
+    const version = parseVersion(raw);
+    if (!version) {
+      continue;
+    }
+    if (!latest || compareVersions(version, latest) > 0) {
+      latest = version;
+    }
+  }
+  return latest ? `${latest.major}.${latest.minor}.${latest.patch}` : null;
+}
+
 async function fetchLatestPatchVersion(packageName: string, minimumVersion: string): Promise<string | null> {
   const minorRange = sameMajorMinorRange(minimumVersion);
   const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace('%40', '@')}`;

package/src/release/index.ts

@@ -20,6 +20,7 @@ import {
 } from '../lib/json.js';
 import { decode, run, runInteractiveStatus, runResult } from '../lib/run.js';
 import { listReleasePackages, readPackageJson, repositoryInfo } from '../lib/workspace.js';
+import { syncBunLockfileVersions } from '../monorepo/lockfile.js';
 import { readPackedPackageJson, validatePackedWorkspaceDependencies } from '../monorepo/packed-manifest.js';
 import {
   type BootstrapNpmPackagesOptions,
@@ -529,6 +530,10 @@ async function listUnpublishedPackages(root: string, packages: ReleasePackage[])
 async function publishPackedPackage(root: string, pkg: ReleasePackage, tag: string, dryRun: boolean): Promise<void> {
   const tempDir = await mkdtemp(join(tmpdir(), 'smoo-publish-'));
   const tarball = join(tempDir, `${safeTarballPrefix(pkg.name)}-${pkg.version}.tgz`);
+  // bun pm pack resolves workspace:* from bun.lock. Day-to-day lock keeps -next
+  // (install/CI). For publish, temporarily rewrite unpublished -next entries to
+  // the last stable tag so the tarball embeds installable versions, then restore.
+  syncBunLockfileVersions(root, { mode: 'publish', log: true });
   try {
     console.log(`${pkg.name}@${pkg.version}: packing with bun pm pack`);
     await run('bun', ['pm', 'pack', '--filename', tarball, '--ignore-scripts', '--quiet'], join(root, pkg.path));
@@ -560,6 +565,7 @@ async function publishPackedPackage(root: string, pkg: ReleasePackage, tag: stri
       },
     );
   } finally {
+    syncBunLockfileVersions(root, { mode: 'install', log: true });
     await rm(tempDir, { recursive: true, force: true });
   }
 }