@smoothbricks/cli 0.1.0

package/src/github-ci/index.ts

@@ -0,0 +1,196 @@
+import { existsSync } from 'node:fs';
+import { appendFile, mkdtemp, realpath, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { $ } from 'bun';
+import { decode, run, runStatus } from '../lib/run.js';
+
+export async function cleanupGithubCiCache(root: string): Promise<void> {
+  const githubOutput = process.env.GITHUB_OUTPUT;
+  const markCacheReady = async (ready: boolean): Promise<void> => {
+    if (githubOutput) {
+      await appendFile(githubOutput, `cache-ready=${ready ? 'true' : 'false'}\n`);
+    }
+  };
+
+  const nar = process.env.NIX_STORE_NAR;
+  if (!nar) {
+    console.warn('NIX_STORE_NAR is not set; skipping Nix cache save.');
+    await markCacheReady(false);
+    return;
+  }
+  const nixStore = '/nix/var/nix/profiles/default/bin/nix-store';
+  const devenvProfile = `${root}/tooling/direnv/.devenv/profile`;
+  if (!existsSync(devenvProfile)) {
+    console.warn(`${devenvProfile} is missing; skipping Nix cache save.`);
+    await markCacheReady(false);
+    return;
+  }
+  await runStatus(nixStore, ['--verify', '--check-contents', '--repair'], root);
+  await exportNixStoreCache(root, nar, nixStore, devenvProfile);
+  await markCacheReady(true);
+}
+
+async function exportNixStoreCache(root: string, nar: string, nixStore: string, devenvProfile: string): Promise<void> {
+  const gcRootDir = '/nix/var/nix/gcroots/smoothbricks-cache-roots';
+  const tmpDir = await mkdtemp(join(dirname(nar), '.smoo-nix-cache-'));
+  const tmpNar = join(tmpDir, 'nix-store.nar');
+  const roots = new Set<string>();
+
+  try {
+    await $`rm -f ${nar}`.cwd(root);
+    await $`sudo rm -rf ${gcRootDir}`.cwd(root);
+    await $`sudo mkdir -p ${gcRootDir}`.cwd(root);
+
+    // The Nix cache must include every live store path referenced by the
+    // restored shell state, not just the devenv profile. .direnv stores paths to
+    // derivations like devenv-shell.drv; omitting those makes a cache hit restore
+    // metadata that points at missing store paths.
+    await addRoot(roots, devenvProfile);
+    const home = process.env.HOME;
+    if (home) {
+      const nixProfile = join(home, '.nix-profile');
+      await addRoot(roots, nixProfile);
+      await addReferencesFrom(roots, nixProfile, root);
+    }
+    await addReferencesFrom(roots, join(root, 'tooling/direnv/.devenv'), root);
+    await addReferencesFrom(roots, join(root, 'tooling/direnv/.direnv'), root);
+
+    const rootLinks: string[] = [];
+    let index = 0;
+    for (const target of roots) {
+      const link = `${gcRootDir}/root-${index}`;
+      await $`sudo ln -s ${target} ${link}`.cwd(root);
+      rootLinks.push(link);
+      index += 1;
+    }
+
+    if (rootLinks.length === 0) {
+      throw new Error('No live Nix store roots found; skipping Nix cache save.');
+    }
+
+    await $`nix-collect-garbage --quiet`.cwd(root);
+    const closureOutput = await $`sudo ${nixStore} -qR ${rootLinks}`.cwd(root).quiet();
+    const closure = decode(closureOutput.stdout)
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+    if (closure.length === 0) {
+      throw new Error('No Nix store closure paths found; skipping Nix cache save.');
+    }
+
+    await $`sudo ${nixStore} --export --quiet ${closure} > ${tmpNar}`.cwd(root);
+    await $`test -s ${tmpNar}`.cwd(root);
+    await rename(tmpNar, nar);
+  } finally {
+    await $`sudo rm -rf ${gcRootDir}`.cwd(root).nothrow();
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+async function addRoot(roots: Set<string>, candidate: string): Promise<void> {
+  if (!existsSync(candidate)) {
+    return;
+  }
+  const target = await realpath(candidate);
+  if (existsSync(target)) {
+    roots.add(target);
+  }
+}
+
+async function addReferencesFrom(roots: Set<string>, path: string, cwd: string): Promise<void> {
+  if (!existsSync(path)) {
+    return;
+  }
+  const storePathPattern = '/nix/store/[a-z0-9]{32}-[A-Za-z0-9+._?=-]+';
+  const result = await $`grep -rahoE ${storePathPattern} ${path}`.cwd(cwd).quiet().nothrow();
+  for (const line of decode(result.stdout).split('\n')) {
+    const candidate = line.trim();
+    if (candidate && existsSync(candidate)) {
+      roots.add(candidate);
+    }
+  }
+}
+
+export async function githubCiNxSmart(
+  root: string,
+  options: { target: string; name?: string; step?: string },
+): Promise<void> {
+  const name = options.name ?? options.target;
+  const step = options.step ?? '';
+  await createGithubStatus(name, step);
+  const mode =
+    process.env.GITHUB_EVENT_NAME === 'push' && process.env.GITHUB_REF_NAME === 'main' ? 'run-many' : 'affected';
+  const nxArgs =
+    mode === 'run-many'
+      ? ['run-many', '-t', options.target, '--parallel=5']
+      : ['affected', '-t', options.target, '--parallel=5'];
+  const status = await runStatus('nx', nxArgs, root);
+  await updateGithubStatus(name, status === 0 ? 'success' : 'failure', step);
+  if (status !== 0) {
+    throw new Error(`nx ${nxArgs.join(' ')} failed with exit code ${status}`);
+  }
+}
+
+export async function githubCiNxRunMany(root: string, options: { targets: string; projects?: string }): Promise<void> {
+  const nxArgs = ['run-many', '-t', options.targets, '--parallel=5'];
+  if (options.projects) {
+    nxArgs.push(`--projects=${options.projects}`);
+  }
+  await run('nx', nxArgs, root);
+}
+
+async function createGithubStatus(name: string, step: string): Promise<void> {
+  await postGithubStatus(name, 'pending', `Running ${name}...`, step);
+}
+
+async function updateGithubStatus(name: string, state: 'success' | 'failure' | 'error', step: string): Promise<void> {
+  const suffix = state === 'success' ? 'passed' : state === 'failure' ? 'failed' : 'errored';
+  await postGithubStatus(name, state, `${name} ${suffix}`, step);
+}
+
+async function postGithubStatus(name: string, state: string, description: string, step: string): Promise<void> {
+  const repository = process.env.GITHUB_REPOSITORY;
+  const sha = process.env.GITHUB_SHA;
+  if (!repository || !sha) {
+    return;
+  }
+  const targetUrl = await getGithubStepUrl(step);
+  const args = [
+    'api',
+    '--method',
+    'POST',
+    '-H',
+    'Accept: application/vnd.github+json',
+    `/repos/${repository}/statuses/${sha}`,
+    '-f',
+    `state=${state}`,
+    '-f',
+    `context=${name}`,
+    '-f',
+    `description=${description}`,
+  ];
+  if (targetUrl) {
+    args.push('-f', `target_url=${targetUrl}`);
+  }
+  await run('gh', args, process.cwd());
+}
+
+async function getGithubStepUrl(step: string): Promise<string | null> {
+  const repository = process.env.GITHUB_REPOSITORY;
+  const runId = process.env.GITHUB_RUN_ID;
+  const job = process.env.GITHUB_JOB;
+  if (!repository || !runId || !job) {
+    return null;
+  }
+  const result =
+    await $`gh api -H ${'Accept: application/vnd.github+json'} ${`/repos/${repository}/actions/runs/${runId}/jobs`} --jq ${`.jobs[] | select(.name == "${job}") | .id`}`
+      .quiet()
+      .nothrow();
+  const jobId = decode(result.stdout).trim();
+  if (!jobId) {
+    return `https://github.com/${repository}/actions/runs/${runId}`;
+  }
+  return step
+    ? `https://github.com/${repository}/actions/runs/${runId}/job/${jobId}#step:${step}:1`
+    : `https://github.com/${repository}/actions/runs/${runId}/job/${jobId}`;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { runCli } from './cli.js';

package/src/lib/json.ts

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { hasOwn, hasOwnString, isRecord } from '@smoothbricks/validation';
+
+export { hasOwn, hasOwnString, isRecord };
+
+export function stringProperty(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key];
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+export function recordProperty(record: Record<string, unknown>, key: string): Record<string, unknown> | null {
+  const value = record[key];
+  return isRecord(value) ? value : null;
+}
+
+export function getOrCreateRecord(record: Record<string, unknown>, key: string): Record<string, unknown> {
+  const value = record[key];
+  if (isRecord(value)) {
+    return value;
+  }
+  const next: Record<string, unknown> = {};
+  record[key] = next;
+  return next;
+}
+
+export function setStringProperty(record: Record<string, unknown>, key: string, value: string): boolean {
+  if (record[key] === value) {
+    return false;
+  }
+  record[key] = value;
+  return true;
+}
+
+export function setMissingStringProperty(record: Record<string, unknown>, key: string, value: string): boolean {
+  if (typeof record[key] === 'string') {
+    return false;
+  }
+  record[key] = value;
+  return true;
+}
+
+export function requiredJsonObject(path: string): Record<string, unknown> {
+  const json = readJsonObject(path);
+  if (!json) {
+    throw new Error(`${path} not found or invalid`);
+  }
+  return json;
+}
+
+export function readJsonObject(path: string): Record<string, unknown> | null {
+  const json = readJson(path);
+  return isRecord(json) ? json : null;
+}
+
+export function writeJsonObject(path: string, value: Record<string, unknown>): void {
+  writeFileSync(path, jsonObjectText(value));
+}
+
+export function jsonObjectText(value: Record<string, unknown>): string {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+export function readJson(path: string): unknown {
+  if (!existsSync(path)) {
+    return null;
+  }
+  return JSON.parse(readFileSync(path, 'utf8'));
+}

package/src/lib/run.ts

@@ -0,0 +1,76 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { $ } from 'bun';
+
+export async function run(command: string, args: string[], cwd: string, env?: Record<string, string>): Promise<void> {
+  const status = await runStatus(command, args, cwd, false, env);
+  if (status !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed with exit code ${status}`);
+  }
+}
+
+export async function runStatus(
+  command: string,
+  args: string[],
+  cwd: string,
+  quiet = false,
+  env?: Record<string, string>,
+): Promise<number> {
+  const invocation = resolveCommandInvocation(cwd, command, args);
+  let shell = $`${invocation.command} ${invocation.args}`.cwd(cwd).nothrow();
+  if (env) {
+    shell = shell.env(mergeEnv(env));
+  }
+  const result = quiet ? await shell.quiet() : await shell;
+  return result.exitCode;
+}
+
+function mergeEnv(env: Record<string, string>): Record<string, string> {
+  const merged: Record<string, string> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined) {
+      merged[key] = value;
+    }
+  }
+  return { ...merged, ...env };
+}
+
+function resolveCommandInvocation(root: string, command: string, args: string[]): { command: string; args: string[] } {
+  const localCommand = join(root, 'node_modules', '.bin', command);
+  if (existsSync(localCommand)) {
+    return { command: localCommand, args };
+  }
+  const bundledCommand = resolveBundledCommand(command);
+  if (bundledCommand) {
+    return { command: 'bun', args: [bundledCommand, ...args] };
+  }
+  return { command, args };
+}
+
+function resolveBundledCommand(command: string): string | null {
+  try {
+    if (command === 'sherif') {
+      return fileURLToPath(import.meta.resolve('sherif'));
+    }
+    if (command === 'attw') {
+      const packageJson = fileURLToPath(import.meta.resolve('@arethetypeswrong/cli/package.json'));
+      return join(dirname(packageJson), 'dist', 'index.js');
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+export async function findRepoRoot(): Promise<string> {
+  const result = await $`git rev-parse --show-toplevel`.cwd(process.cwd()).quiet().nothrow();
+  if (result.exitCode === 0) {
+    return decode(result.stdout).trim();
+  }
+  return process.cwd();
+}
+
+export function decode(bytes: Uint8Array): string {
+  return new TextDecoder().decode(bytes);
+}

package/src/lib/workspace.ts

@@ -0,0 +1,125 @@
+import { readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { hasOwn, hasOwnString, isRecord, readJson, readJsonObject, stringProperty } from './json.js';
+
+export interface PackageInfo {
+  name: string;
+  version: string;
+  private: boolean;
+  tags: string[];
+  path: string;
+  packageJsonPath: string;
+  json: Record<string, unknown>;
+}
+
+export interface RepositoryInfo {
+  type: string;
+  url: string;
+}
+
+export const workspaceDependencyFields = ['dependencies', 'devDependencies', 'optionalDependencies'] as const;
+
+export function listPublicPackages(root: string): PackageInfo[] {
+  return getWorkspacePackages(root).filter((pkg) => !pkg.private && pkg.tags.includes('npm:public'));
+}
+
+export function getWorkspacePackages(root: string): PackageInfo[] {
+  if (!readPackageJson(join(root, 'package.json'))) {
+    throw new Error('package.json not found or invalid');
+  }
+  const workspacePatterns = getWorkspacePatterns(root);
+  const packages: PackageInfo[] = [];
+  for (const pattern of workspacePatterns) {
+    if (!pattern.endsWith('/*')) {
+      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,
+      });
+    }
+  }
+  return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function listPackageJsonRecords(root: string): PackageInfo[] {
+  const rootPackage = readPackageJson(join(root, 'package.json'));
+  if (!rootPackage) {
+    throw new Error('package.json not found or invalid');
+  }
+  return [{ ...rootPackage, path: '.' }, ...getWorkspacePackages(root)];
+}
+
+export function getWorkspacePatterns(root: string): string[] {
+  const raw = readJson(join(root, 'package.json'));
+  if (!isRecord(raw) || !hasOwn(raw, 'workspaces')) {
+    return ['packages/*'];
+  }
+  const workspaces = raw.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((entry): entry is string => typeof entry === 'string');
+  }
+  if (isRecord(workspaces) && hasOwn(workspaces, 'packages') && Array.isArray(workspaces.packages)) {
+    return workspaces.packages.filter((entry): entry is string => typeof entry === 'string');
+  }
+  return ['packages/*'];
+}
+
+export function readPackageJson(path: string): PackageInfo | null {
+  const parsed = readJsonObject(path);
+  if (!isRecord(parsed) || !hasOwnString(parsed, 'name') || !hasOwnString(parsed, 'version')) {
+    return null;
+  }
+  const privateValue = hasOwn(parsed, 'private') && typeof parsed.private === 'boolean' ? parsed.private : false;
+  const tags = getNxTags(parsed);
+  return {
+    name: parsed.name,
+    version: parsed.version,
+    private: privateValue,
+    tags,
+    path: dirname(path),
+    packageJsonPath: path,
+    json: 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 [];
+  }
+  return pkg.nx.tags.filter((tag): tag is string => typeof tag === 'string');
+}
+
+export function repositoryInfo(pkg: Record<string, unknown>): RepositoryInfo | null {
+  const repository = pkg.repository;
+  if (typeof repository === 'string') {
+    return { type: 'git', url: repository };
+  }
+  if (!isRecord(repository)) {
+    return null;
+  }
+  const url = stringProperty(repository, 'url');
+  if (!url) {
+    return null;
+  }
+  return { type: stringProperty(repository, 'type') ?? 'git', url };
+}
+
+export function escapeRegex(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/monorepo/commit-msg.ts

@@ -0,0 +1,35 @@
+const validCommitTypes = new Set([
+  'build',
+  'chore',
+  'ci',
+  'docs',
+  'feat',
+  'fix',
+  'perf',
+  'refactor',
+  'revert',
+  'style',
+  'test',
+]);
+
+export function validateCommitMessage(message: string): string | null {
+  const subject = message.split('\n', 1)[0]?.trim() ?? '';
+  if (!subject) {
+    return 'Commit message subject is empty.';
+  }
+  if (/^(Merge|Revert ")/.test(subject) || /^(fixup|squash)! /.test(subject)) {
+    return null;
+  }
+  const match = /^(?<type>[a-z]+)(\([a-z0-9._/-]+\))?(?<breaking>!)?: .+$/.exec(subject);
+  const type = match?.groups?.type;
+  if (type && validCommitTypes.has(type)) {
+    return null;
+  }
+  return `Invalid conventional commit subject: ${subject}
+
+Expected examples:
+  feat(statebus-core): add optimistic transactions
+  fix(money): round negative amounts consistently
+  chore(release): publish 1.2.3
+  feat!: remove deprecated API`;
+}

package/src/monorepo/git-config.ts

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { $ } from 'bun';
+import { decode } from '../lib/run.js';
+
+export async function applyWorkspaceGitConfig(root: string): Promise<void> {
+  const gitDirResult = await $`git rev-parse --git-dir`.cwd(root).quiet().nothrow();
+  if (gitDirResult.exitCode !== 0) {
+    throw new Error('Not in a git repository');
+  }
+
+  const gitDir = resolve(root, decode(gitDirResult.stdout).trim());
+  const tooling = join(root, 'tooling');
+
+  await $`git config --local include.path ${join(tooling, 'workspace.gitconfig')}`.cwd(root);
+  linkHook(gitDir, tooling, 'pre-commit');
+  linkHook(gitDir, tooling, 'commit-msg');
+}
+
+function linkHook(gitDir: string, tooling: string, name: string): void {
+  const source = join(tooling, 'git-hooks', `${name}.sh`);
+  if (!existsSync(source)) {
+    throw new Error(`Missing ${name} hook source: ${source}`);
+  }
+
+  const target = join(gitDir, 'hooks', name);
+  if (readLinkOrNull(target) === source) {
+    return;
+  }
+
+  console.log(`[!] Linking ${name} hook in ${gitDir}`);
+  mkdirSync(dirname(target), { recursive: true });
+  rmSync(target, { force: true });
+  symlinkSync(source, target);
+}
+
+function readLinkOrNull(path: string): string | null {
+  try {
+    return readlinkSync(path);
+  } catch {
+    return null;
+  }
+}

package/src/monorepo/index.ts

@@ -0,0 +1,78 @@
+import { readFileSync } from 'node:fs';
+import { listPublicPackages } from '../lib/workspace.js';
+import { validateCommitMessage } from './commit-msg.js';
+import { applyWorkspaceGitConfig } from './git-config.js';
+import { syncBunLockfileVersions } from './lockfile.js';
+import { applyManagedFiles, printResults } from './managed-files.js';
+import { validatePublicTags } from './package-policy.js';
+import { runInitPacks, runValidatePacks } from './packs/index.js';
+import { syncRootRuntimeVersions } from './runtime.js';
+
+export interface InitOptions {
+  runtimeOnly?: boolean;
+  syncRuntime?: boolean;
+}
+
+export interface ValidateOptions {
+  failFast?: boolean;
+}
+
+export async function initMonorepo(root: string, options: InitOptions): Promise<void> {
+  if (options.runtimeOnly) {
+    await syncRootRuntimeVersions(root);
+    return;
+  }
+
+  printResults(applyManagedFiles(root, 'update'));
+  await runInitPacks({ root, syncRuntime: process.env.DEVENV_ROOT !== undefined || options.syncRuntime === true });
+}
+
+export async function validateMonorepo(root: string, options: ValidateOptions = {}): Promise<void> {
+  const failures = await runValidatePacks({ root, syncRuntime: false }, options);
+  if (failures > 0) {
+    throw new Error(`Monorepo validation failed with ${failures} problem(s).`);
+  }
+  console.log('\n== summary ==');
+  console.log('Monorepo configuration is valid.');
+}
+
+export function updateManagedFiles(root: string): void {
+  printResults(applyManagedFiles(root, 'update'));
+}
+
+export function checkManagedFiles(root: string): void {
+  const results = applyManagedFiles(root, 'check');
+  printResults(results);
+  if (results.some((result) => result.action === 'drifted')) {
+    throw new Error('Managed monorepo files are out of date. Run: smoo monorepo update');
+  }
+}
+
+export function diffManagedFiles(root: string): void {
+  printResults(applyManagedFiles(root, 'diff'));
+}
+
+export function validateCommitMessageFile(path: string | undefined): void {
+  if (!path) {
+    throw new Error('Usage: smoo monorepo validate-commit-msg <commit-msg-file>');
+  }
+  const message = readFileSync(path, 'utf8');
+  const error = validateCommitMessage(message);
+  if (error) {
+    throw new Error(error);
+  }
+}
+
+export function listPublicProjects(root: string): string {
+  return listPublicPackages(root)
+    .map((pkg) => pkg.name)
+    .join(',');
+}
+
+export function validatePublicPackageTags(root: string): void {
+  if (validatePublicTags(root) > 0) {
+    throw new Error('npm:public tag validation failed.');
+  }
+}
+
+export { applyWorkspaceGitConfig, syncBunLockfileVersions };

package/src/monorepo/lockfile.ts

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { escapeRegex, getWorkspacePackages } from '../lib/workspace.js';
+
+export function syncBunLockfileVersions(root: string): void {
+  const lockfilePath = join(root, 'bun.lock');
+  if (!existsSync(lockfilePath)) {
+    throw new Error('bun.lock not found');
+  }
+  const packages = getWorkspacePackages(root);
+  let lockfile = readFileSync(lockfilePath, 'utf8');
+  let updated = 0;
+  for (const pkg of packages) {
+    const relativePath = pkg.path.replaceAll('\\', '/');
+    const escaped = escapeRegex(relativePath);
+    const pattern = new RegExp(`("${escaped}":\\s*\\{[^}]*"version":\\s*")([^"]+)(")`);
+    const match = lockfile.match(pattern);
+    if (!match) {
+      console.log(`skip: ${relativePath} (not found in lockfile)`);
+      continue;
+    }
+    const lockVersion = match[2];
+    if (lockVersion === pkg.version) {
+      console.log(`ok:   ${relativePath} = ${pkg.version}`);
+      continue;
+    }
+    lockfile = lockfile.replace(pattern, `$1${pkg.version}$3`);
+    console.log(`fix:  ${relativePath}: ${lockVersion} -> ${pkg.version}`);
+    updated++;
+  }
+  if (updated > 0) {
+    writeFileSync(lockfilePath, lockfile);
+  }
+  console.log(
+    updated > 0 ? `Updated ${updated} workspace version(s) in bun.lock` : 'All workspace versions already in sync.',
+  );
+}