@smoothbricks/cli 0.1.0 → 0.1.1

package/src/monorepo/lockfile.ts

@@ -2,7 +2,12 @@ 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 {
+export interface SyncBunLockfileVersionsOptions {
+  log?: boolean;
+}
+
+export function syncBunLockfileVersions(root: string, options: SyncBunLockfileVersionsOptions = {}): number {
+  const log = options.log ?? true;
   const lockfilePath = join(root, 'bun.lock');
   if (!existsSync(lockfilePath)) {
     throw new Error('bun.lock not found');
@@ -16,22 +21,62 @@ export function syncBunLockfileVersions(root: string): void {
     const pattern = new RegExp(`("${escaped}":\\s*\\{[^}]*"version":\\s*")([^"]+)(")`);
     const match = lockfile.match(pattern);
     if (!match) {
-      console.log(`skip: ${relativePath} (not found in lockfile)`);
+      if (log) {
+        console.log(`skip: ${relativePath} (not found in lockfile)`);
+      }
       continue;
     }
     const lockVersion = match[2];
     if (lockVersion === pkg.version) {
-      console.log(`ok:   ${relativePath} = ${pkg.version}`);
+      if (log) {
+        console.log(`ok:   ${relativePath} = ${pkg.version}`);
+      }
       continue;
     }
     lockfile = lockfile.replace(pattern, `$1${pkg.version}$3`);
-    console.log(`fix:  ${relativePath}: ${lockVersion} -> ${pkg.version}`);
+    if (log) {
+      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.',
-  );
+  if (log) {
+    console.log(
+      updated > 0 ? `Updated ${updated} workspace version(s) in bun.lock` : 'All workspace versions already in sync.',
+    );
+  }
+  return updated;
+}
+
+export function validateBunLockfileVersions(root: string): number {
+  const lockfilePath = join(root, 'bun.lock');
+  if (!existsSync(lockfilePath)) {
+    console.error('bun.lock not found');
+    return 1;
+  }
+  const packages = getWorkspacePackages(root);
+  const lockfile = readFileSync(lockfilePath, 'utf8');
+  let failures = 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.error(`bun.lock missing workspace entry for ${relativePath}`);
+      failures++;
+      continue;
+    }
+    const lockVersion = match[2];
+    if (lockVersion !== pkg.version) {
+      console.error(`${relativePath}: bun.lock workspace version must be ${pkg.version}, got ${lockVersion}`);
+      failures++;
+    }
+  }
+  if (failures === 0) {
+    console.log('bun.lock workspace versions are valid.');
+  }
+  return failures;
 }

package/src/monorepo/managed-files.ts

@@ -1,20 +1,28 @@
 import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { readPackageJson } from '../lib/workspace.js';
+import { listReleasePackages, readPackageJson } from '../lib/workspace.js';
+import { renderPublishWorkflowYaml } from './publish-workflow.js';
 
-type ManagedKind = 'raw' | 'template';
+type ManagedKind = 'raw' | 'template' | 'generated';
 
 interface ManagedFile {
   kind: ManagedKind;
   source: string;
   target: string;
   executable?: boolean;
+  releasePackagesOnly?: boolean;
 }
 
 export interface FileResult {
   target: string;
-  action: 'created' | 'updated' | 'unchanged' | 'skipped-symlink' | 'drifted' | 'ok-symlink';
+  action: 'created' | 'updated' | 'unchanged' | 'skipped' | 'skipped-symlink' | 'drifted' | 'ok-symlink';
+}
+
+interface ManagedFileContext {
+  hasReleasePackages: boolean;
+  nodeModulesCacheKey: string;
+  repoName: string;
 }
 
 const managedFiles: ManagedFile[] = [
@@ -47,9 +55,10 @@ const managedFiles: ManagedFile[] = [
     target: '.github/workflows/ci.yml',
   },
   {
-    kind: 'template',
-    source: 'github/workflows/publish.yml',
+    kind: 'generated',
+    source: 'publish-workflow',
     target: '.github/workflows/publish.yml',
+    releasePackagesOnly: true,
   },
   {
     kind: 'template',
@@ -81,12 +90,21 @@ const managedFiles: ManagedFile[] = [
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 
 export function applyManagedFiles(root: string, mode: 'update' | 'check' | 'diff'): FileResult[] {
-  return managedFiles.map((file) => applyManagedFile(root, file, mode));
+  const context = getManagedFileContext(root);
+  return managedFiles.map((file) => applyManagedFile(root, file, mode, context));
 }
 
-function applyManagedFile(root: string, file: ManagedFile, mode: 'update' | 'check' | 'diff'): FileResult {
+function applyManagedFile(
+  root: string,
+  file: ManagedFile,
+  mode: 'update' | 'check' | 'diff',
+  context: ManagedFileContext,
+): FileResult {
+  if (file.releasePackagesOnly === true && !context.hasReleasePackages) {
+    return { target: file.target, action: 'skipped' };
+  }
   const target = resolve(root, file.target);
-  const content = getManagedContent(root, file);
+  const content = getManagedContent(file, context);
   if (existsSync(target)) {
     const info = lstatSync(target);
     if (info.isSymbolicLink()) {
@@ -112,23 +130,35 @@ function applyManagedFile(root: string, file: ManagedFile, mode: 'update' | 'che
   return { target: file.target, action: 'created' };
 }
 
-function getManagedContent(root: string, file: ManagedFile): string {
+function getManagedContent(file: ManagedFile, context: ManagedFileContext): string {
+  if (file.kind === 'generated') {
+    if (file.source === 'publish-workflow') {
+      return renderPublishWorkflowYaml({ repoName: context.repoName });
+    }
+    throw new Error(`Unknown generated managed file source ${file.source}`);
+  }
   const sourceRoot = file.kind === 'raw' ? 'managed/raw' : 'managed/templates';
   const sourcePath = join(packageRoot, sourceRoot, file.source);
   const content = readFileSync(sourcePath, 'utf8');
   if (file.kind === 'raw') {
     return content;
   }
-  return renderTemplate(root, content);
+  return renderTemplate(context, content);
 }
 
-function renderTemplate(root: string, template: string): string {
+function getManagedFileContext(root: string): ManagedFileContext {
   const packageJson = readPackageJson(join(root, 'package.json'));
   const repoName = packageJson?.name ?? 'monorepo';
   const nodeModulesCacheKey = existsSync(join(root, 'bun.lock'))
     ? `$${"{{ hashFiles('bun.lock', 'package.json', 'packages/*/package.json') }}"}`
     : `$${"{{ hashFiles('bun.lockb', 'package.json', 'packages/*/package.json') }}"}`;
-  return template.replaceAll('{{REPO_NAME}}', repoName).replaceAll('{{NODE_MODULES_CACHE_KEY}}', nodeModulesCacheKey);
+  return { hasReleasePackages: listReleasePackages(root, packageJson).length > 0, nodeModulesCacheKey, repoName };
+}
+
+function renderTemplate(context: ManagedFileContext, template: string): string {
+  return template
+    .replaceAll('{{REPO_NAME}}', context.repoName)
+    .replaceAll('{{NODE_MODULES_CACHE_KEY}}', context.nodeModulesCacheKey);
 }
 
 function writeManagedFile(path: string, content: string, executable: boolean): void {

package/src/monorepo/package-hygiene.ts

@@ -5,7 +5,7 @@ export async function fixPackageHygiene(root: string): Promise<void> {
 }
 
 export async function validatePackageHygiene(root: string): Promise<number> {
-  const status = await runStatus('sherif', [], root);
+  const status = await runStatus('sherif', ['--fail-on-warnings'], root);
   if (status !== 0) {
     console.error('sherif package hygiene validation failed');
     return 1;

package/src/monorepo/package-policy.ts

@@ -15,30 +15,41 @@ import {
   getWorkspacePackages,
   listPackageJsonRecords,
   listPublicPackages,
+  packageRepositoryInfo,
   repositoryInfo,
+  sameRepositoryAfterNormalization,
   workspaceDependencyFields,
 } from '../lib/workspace.js';
 
+export const SMOO_NX_VERSION_ACTIONS = '@smoothbricks/cli/nx-version-actions';
+export const SMOO_NX_RELEASE_TAG_PATTERN = '{projectName}@{version}';
+
 export function applyPublicPackageDefaults(root: string): void {
   const rootPackage = requiredJsonObject(join(root, 'package.json'));
   const rootLicense = stringProperty(rootPackage, 'license');
   const rootRepository = repositoryInfo(rootPackage);
-  if (!rootLicense) {
-    throw new Error('Root package.json must define license before public package defaults can be applied.');
-  }
-  if (!rootRepository) {
-    throw new Error('Root package.json must define repository.url before public package defaults can be applied.');
-  }
 
   for (const pkg of listPublicPackages(root)) {
     let changed = false;
-    changed = setMissingStringProperty(pkg.json, 'license', rootLicense) || changed;
+    const existingRepository = packageRepositoryInfo(pkg);
+    if (
+      existingRepository &&
+      rootRepository &&
+      existingRepository.url === rootRepository.url &&
+      rootLicense &&
+      rootLicense !== 'UNLICENSED'
+    ) {
+      changed = setMissingStringProperty(pkg.json, 'license', rootLicense) || changed;
+    }
     const publishConfig = getOrCreateRecord(pkg.json, 'publishConfig');
     changed = setStringProperty(publishConfig, 'access', 'public') || changed;
 
     const repository = getOrCreateRecord(pkg.json, 'repository');
-    changed = setStringProperty(repository, 'type', rootRepository.type) || changed;
-    changed = setStringProperty(repository, 'url', rootRepository.url) || changed;
+    changed =
+      setStringProperty(repository, 'type', existingRepository?.type ?? rootRepository?.type ?? 'git') || changed;
+    if (existingRepository && !stringProperty(repository, 'url')) {
+      changed = setStringProperty(repository, 'url', existingRepository.url) || changed;
+    }
     changed = setStringProperty(repository, 'directory', pkg.path.replaceAll('\\', '/')) || changed;
     changed = normalizeExportConditionOrder(pkg.json.exports) || changed;
     if (hasDevelopmentSourceExport(pkg.json.exports)) {
@@ -67,6 +78,45 @@ export function applyWorkspaceDependencyDefaults(root: string): void {
   }
 }
 
+export function applyNxReleaseDefaults(root: string): void {
+  const nxJsonPath = join(root, 'nx.json');
+  const nxJson = requiredJsonObject(nxJsonPath);
+  let changed = false;
+  const release = getOrCreateRecord(nxJson, 'release');
+  changed = setStringProperty(release, 'projectsRelationship', 'independent') || changed;
+  const version = getOrCreateRecord(release, 'version');
+  changed = setStringProperty(version, 'specifierSource', 'conventional-commits') || changed;
+  changed = setStringProperty(version, 'currentVersionResolver', 'git-tag') || changed;
+  changed = setStringProperty(version, 'fallbackCurrentVersionResolver', 'disk') || changed;
+  changed = setStringProperty(version, 'versionActions', SMOO_NX_VERSION_ACTIONS) || changed;
+  if (delete version.preVersionCommand) {
+    changed = true;
+  }
+  const releaseTag = getOrCreateRecord(release, 'releaseTag');
+  changed = setStringProperty(releaseTag, 'pattern', SMOO_NX_RELEASE_TAG_PATTERN) || changed;
+  const changelog = getOrCreateRecord(release, 'changelog');
+  changed = setBooleanProperty(changelog, 'workspaceChangelog', false) || changed;
+  const projectChangelogs = getOrCreateRecord(changelog, 'projectChangelogs');
+  changed = setBooleanProperty(projectChangelogs, 'createRelease', false) || changed;
+  changed = setBooleanProperty(projectChangelogs, 'file', false) || changed;
+  const renderOptions = getOrCreateRecord(projectChangelogs, 'renderOptions');
+  if (typeof renderOptions.authors !== 'boolean') {
+    renderOptions.authors = true;
+    changed = true;
+  }
+  if (typeof renderOptions.applyUsernameToAuthors !== 'boolean') {
+    renderOptions.applyUsernameToAuthors = true;
+    changed = true;
+  }
+
+  if (changed) {
+    writeJsonObject(nxJsonPath, nxJson);
+    console.log('updated        nx.json release config');
+  } else {
+    console.log('unchanged      nx.json release config');
+  }
+}
+
 export function validateRootPackagePolicy(root: string): number {
   const rootPackage = readJsonObject(join(root, 'package.json'));
   if (!rootPackage) {
@@ -113,6 +163,10 @@ export function validateNxReleaseConfig(root: string): number {
   }
   const release = recordProperty(nxJson, 'release');
   const version = release ? recordProperty(release, 'version') : null;
+  const releaseTag = release ? recordProperty(release, 'releaseTag') : null;
+  const changelog = release ? recordProperty(release, 'changelog') : null;
+  const projectChangelogs = changelog ? recordProperty(changelog, 'projectChangelogs') : null;
+  const renderOptions = projectChangelogs ? recordProperty(projectChangelogs, 'renderOptions') : null;
   let failures = 0;
   if (!release) {
     console.error('nx.json release config is missing');
@@ -140,8 +194,46 @@ export function validateNxReleaseConfig(root: string): number {
     console.error('nx.json release.version.fallbackCurrentVersionResolver must be disk');
     failures++;
   }
-  if (version && !stringProperty(version, 'preVersionCommand')) {
-    console.error('nx.json release.version.preVersionCommand must be defined');
+  if (version && stringProperty(version, 'versionActions') !== SMOO_NX_VERSION_ACTIONS) {
+    console.error(`nx.json release.version.versionActions must be ${SMOO_NX_VERSION_ACTIONS}`);
+    failures++;
+  }
+  if (version && stringProperty(version, 'preVersionCommand')) {
+    console.error(
+      'nx.json release.version.preVersionCommand must not be defined; smoo builds npm-missing packages before publish',
+    );
+    failures++;
+  }
+  if (!releaseTag) {
+    console.error('nx.json release.releaseTag config is missing');
+    failures++;
+  }
+  if (releaseTag && stringProperty(releaseTag, 'pattern') !== SMOO_NX_RELEASE_TAG_PATTERN) {
+    console.error(`nx.json release.releaseTag.pattern must be ${SMOO_NX_RELEASE_TAG_PATTERN}`);
+    failures++;
+  }
+  if (!changelog) {
+    console.error('nx.json release.changelog config is missing');
+    failures++;
+  }
+  if (changelog && changelog.workspaceChangelog !== false) {
+    console.error('nx.json release.changelog.workspaceChangelog must be false');
+    failures++;
+  }
+  if (!projectChangelogs) {
+    console.error('nx.json release.changelog.projectChangelogs config is missing');
+    failures++;
+  }
+  if (projectChangelogs && projectChangelogs.createRelease !== false) {
+    console.error('nx.json release.changelog.projectChangelogs.createRelease must be false');
+    failures++;
+  }
+  if (projectChangelogs && projectChangelogs.file !== false) {
+    console.error('nx.json release.changelog.projectChangelogs.file must be false');
+    failures++;
+  }
+  if (!renderOptions) {
+    console.error('nx.json release.changelog.projectChangelogs.renderOptions config is missing');
     failures++;
   }
   return failures;
@@ -155,10 +247,6 @@ export function validatePublicTags(root: string): number {
       console.error(`${pkg.path}: private package must not have nx tag npm:public`);
       failures++;
     }
-    if (!pkg.private && !hasPublicTag) {
-      console.error(`${pkg.path}: public package must have nx tag npm:public`);
-      failures++;
-    }
   }
   if (failures > 0) {
     return failures;
@@ -172,6 +260,10 @@ export function validatePublicPackageMetadata(root: string): number {
   const rootRepository = rootPackage ? repositoryInfo(rootPackage) : null;
   let failures = 0;
   for (const pkg of listPublicPackages(root)) {
+    if (pkg.private) {
+      console.error(`${pkg.path}: npm:public package must not be private`);
+      failures++;
+    }
     if (!stringProperty(pkg.json, 'license')) {
       console.error(`${pkg.path}: public package must define license`);
       failures++;
@@ -182,9 +274,25 @@ export function validatePublicPackageMetadata(root: string): number {
       failures++;
     }
     const repository = recordProperty(pkg.json, 'repository');
-    const packageRepository = repository ? repositoryInfo(pkg.json) : null;
-    if (!rootRepository || !packageRepository || packageRepository.url !== rootRepository.url) {
-      console.error(`${pkg.path}: public package repository.url must match root package.json repository.url`);
+    const packageRepository = packageRepositoryInfo(pkg);
+    if (!packageRepository) {
+      console.error(`${pkg.path}: public package must define repository.url`);
+      failures++;
+    }
+    if (
+      rootRepository &&
+      packageRepository &&
+      packageRepository.url !== rootRepository.url &&
+      sameRepositoryAfterNormalization(packageRepository.url, rootRepository.url)
+    ) {
+      console.error(
+        `${pkg.path}: repository.url refers to the root repository but is not an exact match. ` +
+          `Use ${rootRepository.url}`,
+      );
+      failures++;
+    }
+    if (!repository || !stringProperty(repository, 'type')) {
+      console.error(`${pkg.path}: public package must define repository.type`);
       failures++;
     }
     if (!repository || stringProperty(repository, 'directory') !== pkg.path.replaceAll('\\', '/')) {
@@ -247,6 +355,14 @@ function fixWorkspaceDependencyRanges(pkg: Record<string, unknown>, workspaceNam
   return changed;
 }
 
+function setBooleanProperty(record: Record<string, unknown>, key: string, value: boolean): boolean {
+  if (record[key] === value) {
+    return false;
+  }
+  record[key] = value;
+  return true;
+}
+
 function normalizeExportConditionOrder(value: unknown): boolean {
   if (!isRecord(value)) {
     return false;

package/src/monorepo/packed-manifest.ts

@@ -0,0 +1,67 @@
+import { $ } from 'bun';
+import { isRecord, recordProperty } from '../lib/json.js';
+import { decode } from '../lib/run.js';
+import type { PackageInfo } from '../lib/workspace.js';
+import { getWorkspacePackages, workspaceDependencyFields } from '../lib/workspace.js';
+
+export async function readPackedPackageJson(
+  root: string,
+  tarball: string,
+  packageName: string,
+): Promise<Record<string, unknown>> {
+  const result = await $`tar -xOf ${tarball} package/package.json`.cwd(root).quiet().nothrow();
+  if (result.exitCode !== 0) {
+    throw new Error(`${packageName}: unable to inspect packed package.json.`);
+  }
+  const parsed = JSON.parse(decode(result.stdout));
+  if (!isRecord(parsed)) {
+    throw new Error(`${packageName}: packed package.json is not an object.`);
+  }
+  return parsed;
+}
+
+export function validatePackedWorkspaceDependencies(
+  root: string,
+  sourcePackage: PackageInfo,
+  packedPackage: Record<string, unknown>,
+): string[] {
+  const workspaceVersions = new Map(getWorkspacePackages(root).map((pkg) => [pkg.name, pkg.version]));
+  const failures: string[] = [];
+  for (const field of workspaceDependencyFields) {
+    const sourceDependencies = recordProperty(sourcePackage.json, field);
+    const packedDependencies = recordProperty(packedPackage, field);
+    if (!sourceDependencies && !packedDependencies) {
+      continue;
+    }
+
+    for (const [name, range] of Object.entries(packedDependencies ?? {})) {
+      if (typeof range === 'string' && range.startsWith('workspace:')) {
+        failures.push(`${sourcePackage.path}: packed ${field}.${name} must not contain ${range}`);
+      }
+    }
+
+    if (!sourceDependencies) {
+      continue;
+    }
+    for (const [name, sourceRange] of Object.entries(sourceDependencies)) {
+      const workspaceVersion = workspaceVersions.get(name);
+      if (!workspaceVersion) {
+        continue;
+      }
+      const packedRange = packedDependencies?.[name];
+      if (sourceRange !== 'workspace:*') {
+        failures.push(`${sourcePackage.path}: source ${field}.${name} must use workspace:*`);
+      }
+      if (packedRange !== workspaceVersion) {
+        failures.push(
+          `${sourcePackage.path}: packed ${field}.${name} must be ${workspaceVersion}, got ${formatRange(packedRange)}`,
+        );
+      }
+    }
+  }
+  return failures;
+}
+
+function formatRange(value: unknown): string {
+  return typeof value === 'string' ? value : '<missing>';
+}

package/src/monorepo/packed-package.ts

@@ -6,6 +6,7 @@ import { isRecord } from '../lib/json.js';
 import { runStatus } from '../lib/run.js';
 import type { PackageInfo } from '../lib/workspace.js';
 import { listPublicPackages } from '../lib/workspace.js';
+import { readPackedPackageJson, validatePackedWorkspaceDependencies } from './packed-manifest.js';
 
 export async function validatePackedPublicPackages(root: string): Promise<number> {
   let failures = 0;
@@ -25,6 +26,12 @@ async function validatePackedPublicPackage(root: string, pkg: PackageInfo): Prom
       failures++;
     }
 
+    const packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
+    for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
+      console.error(message);
+      failures++;
+    }
+
     const attwArgs = [
       packed.path,
       '--format',

package/src/monorepo/packs/index.ts

@@ -1,9 +1,11 @@
 import { chmodSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { validateBunLockfileVersions } from '../lockfile.js';
 import { validateManagedFiles } from '../managed-files.js';
 import { validateNxSync } from '../nx-sync.js';
 import { fixPackageHygiene, validatePackageHygiene } from '../package-hygiene.js';
 import {
+  applyNxReleaseDefaults,
   applyPublicPackageDefaults,
   applyWorkspaceDependencyDefaults,
   validateNxReleaseConfig,
@@ -35,6 +37,7 @@ const packs: MonorepoPack[] = [
     name: 'core',
     async init(ctx) {
       ensureLocalSmooShim(ctx.root);
+      applyNxReleaseDefaults(ctx.root);
       if (ctx.syncRuntime) {
         await syncRootRuntimeVersions(ctx.root);
       } else {
@@ -46,6 +49,7 @@ const packs: MonorepoPack[] = [
         validateManagedFiles(ctx.root) +
         validateRootPackagePolicy(ctx.root) +
         validateNxReleaseConfig(ctx.root) +
+        validateBunLockfileVersions(ctx.root) +
         (await validateNxSync(ctx.root))
       );
     },