@smoothbricks/cli 0.1.1 → 0.3.0

package/src/monorepo/package-policy.ts

@@ -1,4 +1,25 @@
 import { join } from 'node:path';
+import {
+  applyWorkspaceBoundedTestTargetPolicy,
+  checkWorkspaceBoundedTestTargetPolicy,
+} from '@smoothbricks/nx-plugin/bounded-test-policy';
+import {
+  applyPackageTargetPolicy,
+  checkPackageTargetPolicy,
+  type PackageTargetPolicyOptions,
+  type ResolvedProjectTargets,
+} from '@smoothbricks/nx-plugin/package-target-policy';
+import {
+  applyReleaseConfigPolicy,
+  checkReleaseConfigPolicy,
+  SMOO_NX_RELEASE_TAG_PATTERN,
+  SMOO_NX_VERSION_ACTIONS,
+} from '@smoothbricks/nx-plugin/release-config-policy';
+import { applyTypecheckTestPolicy, checkTypecheckTestPolicy } from '@smoothbricks/nx-plugin/typecheck-test-policy';
+import {
+  applyWorkspaceConfigPolicy,
+  checkWorkspaceConfigPolicy,
+} from '@smoothbricks/nx-plugin/workspace-config-policy';
 import {
   getOrCreateRecord,
   hasOwnString,
@@ -12,6 +33,7 @@ import {
   writeJsonObject,
 } from '../lib/json.js';
 import {
+  getWorkspacePackageManifests,
   getWorkspacePackages,
   listPackageJsonRecords,
   listPublicPackages,
@@ -21,8 +43,55 @@ import {
   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 type { PackageTargetPolicyOptions as WorkspaceDependencyDefaultOptions, ResolvedProjectTargets };
+export { SMOO_NX_RELEASE_TAG_PATTERN, SMOO_NX_VERSION_ACTIONS };
+
+const extraCommitScopes = ['release'];
+const rootScriptPolicy: Record<string, string> = {
+  lint: 'nx run-many -t lint',
+  'lint:fix': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --unstaged',
+  'format:staged': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml',
+  'format:changed': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --also-unstaged',
+};
+
+export function applyFixableMonorepoDefaults(root: string): void {
+  applyRootScriptDefaults(root);
+  applyNxPluginDefaults(root);
+  applyNxProjectNameDefaults(root);
+}
+
+export function applyRootScriptDefaults(root: string): void {
+  const rootPackagePath = join(root, 'package.json');
+  const rootPackage = readJsonObject(rootPackagePath);
+  if (!rootPackage) {
+    return;
+  }
+  const scripts = getOrCreateRecord(rootPackage, 'scripts');
+  let changed = false;
+  for (const [name, command] of Object.entries(rootScriptPolicy)) {
+    changed = setStringProperty(scripts, name, command) || changed;
+  }
+  const nx = getOrCreateRecord(rootPackage, 'nx');
+  if (!Array.isArray(nx.includedScripts) || nx.includedScripts.length !== 0) {
+    nx.includedScripts = [];
+    changed = true;
+  }
+  changed = sortRecordInPlace(scripts) || changed;
+  if (changed) {
+    writeJsonObject(rootPackagePath, rootPackage);
+    console.log('updated        package.json root smoo scripts');
+  } else {
+    console.log('unchanged      package.json root smoo scripts');
+  }
+}
+
+export function applyNxPluginDefaults(root: string): void {
+  if (applyWorkspaceConfigPolicy(root)) {
+    console.log('updated        nx.json smoo plugin config');
+  } else {
+    console.log('unchanged      nx.json smoo plugin config');
+  }
+}
 
 export function applyPublicPackageDefaults(root: string): void {
   const rootPackage = requiredJsonObject(join(root, 'package.json'));
@@ -65,58 +134,83 @@ export function applyPublicPackageDefaults(root: string): void {
   }
 }
 
-export function applyWorkspaceDependencyDefaults(root: string): void {
+export function applyWorkspaceDependencyDefaults(root: string, options: PackageTargetPolicyOptions = {}): void {
   const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
   for (const pkg of listPackageJsonRecords(root)) {
     const changed = fixWorkspaceDependencyRanges(pkg.json, workspaceNames);
     if (changed) {
       writeJsonObject(pkg.packageJsonPath, pkg.json);
       console.log(`updated        ${pkg.path}/package.json workspace dependency ranges`);
-    } else {
-      console.log(`unchanged      ${pkg.path}/package.json workspace dependency ranges`);
     }
   }
-}
-
-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;
+  if (applyPackageTargetPolicy(root, options)) {
+    console.log('updated        package Nx target policy');
+  } else {
+    console.log('unchanged      package Nx target policy');
   }
-  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 (applyTypecheckTestPolicy(root)) {
+    console.log('updated        tsconfig.test.json policy');
+  } else {
+    console.log('unchanged      tsconfig.test.json policy');
   }
-  if (typeof renderOptions.applyUsernameToAuthors !== 'boolean') {
-    renderOptions.applyUsernameToAuthors = true;
-    changed = true;
+  if (applyWorkspaceBoundedTestTargetPolicy(root)) {
+    console.log('updated        package test targets bounded execution policy');
+  } else {
+    console.log('unchanged      package test targets bounded execution policy');
   }
+}
 
-  if (changed) {
-    writeJsonObject(nxJsonPath, nxJson);
+export function applyNxReleaseDefaults(root: string): void {
+  if (applyReleaseConfigPolicy(root)) {
     console.log('updated        nx.json release config');
   } else {
     console.log('unchanged      nx.json release config');
   }
 }
 
+export function applyNxProjectNameDefaults(root: string): void {
+  const rootPackage = requiredJsonObject(join(root, 'package.json'));
+  const rootName = stringProperty(rootPackage, 'name');
+  if (!rootName) {
+    return;
+  }
+  for (const pkg of getWorkspacePackageManifests(root)) {
+    const suggestedName = suggestNxProjectName(rootName, pkg.name);
+    if (!suggestedName) {
+      continue;
+    }
+    const nx = getOrCreateRecord(pkg.json, 'nx');
+    const changed = setStringProperty(nx, 'name', suggestedName);
+    if (changed) {
+      writeJsonObject(pkg.packageJsonPath, pkg.json);
+      console.log(`updated        ${pkg.path}/package.json nx.name`);
+    } else {
+      console.log(`unchanged      ${pkg.path}/package.json nx.name`);
+    }
+  }
+}
+
+export function listValidCommitScopes(root: string): ReadonlySet<string> {
+  return new Set([...listNxProjectNames(root), ...extraCommitScopes]);
+}
+
+export function listNxProjectNames(root: string): string[] {
+  const rootPackage = readJsonObject(join(root, 'package.json'));
+  const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+  const names: string[] = [];
+  for (const pkg of getWorkspacePackageManifests(root)) {
+    const nx = recordProperty(pkg.json, 'nx');
+    const configuredName = nx ? stringProperty(nx, 'name') : null;
+    const suggestedName = rootName ? suggestNxProjectName(rootName, pkg.name) : null;
+    if (configuredName) {
+      names.push(configuredName);
+    } else if (suggestedName) {
+      names.push(suggestedName);
+    }
+  }
+  return names;
+}
+
 export function validateRootPackagePolicy(root: string): number {
   const rootPackage = readJsonObject(join(root, 'package.json'));
   if (!rootPackage) {
@@ -136,6 +230,8 @@ export function validateRootPackagePolicy(root: string): number {
     console.error('package.json must define repository.url');
     failures++;
   }
+  failures += validateRootScripts(rootPackage);
+  failures += validateRootNxScriptInference(rootPackage);
   const packageManager = stringProperty(rootPackage, 'packageManager');
   if (!packageManager?.startsWith('bun@')) {
     console.error('package.json packageManager must use bun@<version>');
@@ -156,85 +252,41 @@ export function validateRootPackagePolicy(root: string): number {
 }
 
 export function validateNxReleaseConfig(root: string): number {
-  const nxJson = readJsonObject(join(root, 'nx.json'));
-  if (!nxJson) {
-    console.error('nx.json not found or invalid');
-    return 1;
-  }
-  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');
-    failures++;
-  }
-  if (release && stringProperty(release, 'projectsRelationship') !== 'independent') {
-    console.error('nx.json release.projectsRelationship must be independent');
-    failures++;
-  }
-  if (!version) {
-    console.error('nx.json release.version config is missing');
-    failures++;
-  }
-  if (version && stringProperty(version, 'specifierSource') !== 'conventional-commits') {
-    console.error('nx.json release.version.specifierSource must be conventional-commits');
-    failures++;
-  }
-  // Nx requires git-tag as the primary resolver when deriving versions from
-  // conventional commits. Disk is only a fallback for initial untagged packages.
-  if (version && stringProperty(version, 'currentVersionResolver') !== 'git-tag') {
-    console.error('nx.json release.version.currentVersionResolver must be git-tag');
+  for (const issue of checkWorkspaceConfigPolicy(root)) {
+    console.error(issue.message);
     failures++;
   }
-  if (version && stringProperty(version, 'fallbackCurrentVersionResolver') !== 'disk') {
-    console.error('nx.json release.version.fallbackCurrentVersionResolver must be disk');
+  for (const issue of checkReleaseConfigPolicy(root)) {
+    console.error(issue.message);
     failures++;
   }
-  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++;
+  return failures;
+}
+
+export function validateNxProjectNames(root: string): number {
+  const rootPackage = readJsonObject(join(root, 'package.json'));
+  const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+  if (!rootName) {
+    return 0;
   }
-  if (projectChangelogs && projectChangelogs.file !== false) {
-    console.error('nx.json release.changelog.projectChangelogs.file must be false');
-    failures++;
+  let failures = 0;
+  for (const pkg of getWorkspacePackageManifests(root)) {
+    const suggestedName = suggestNxProjectName(rootName, pkg.name);
+    if (!suggestedName) {
+      continue;
+    }
+    const nx = recordProperty(pkg.json, 'nx');
+    const configuredName = nx ? stringProperty(nx, 'name') : null;
+    if (configuredName !== suggestedName) {
+      console.error(
+        `${pkg.path}: package.json nx.name must be "${suggestedName}" so fix(${suggestedName}): maps to this project`,
+      );
+      failures++;
+    }
   }
-  if (!renderOptions) {
-    console.error('nx.json release.changelog.projectChangelogs.renderOptions config is missing');
-    failures++;
+  if (failures === 0) {
+    console.log('Nx project names are valid.');
   }
   return failures;
 }
@@ -315,9 +367,9 @@ export function validatePublicPackageMetadata(root: string): number {
   return failures;
 }
 
-export function validateWorkspaceDependencies(root: string): number {
-  const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
+export function validateWorkspaceDependencies(root: string, options: PackageTargetPolicyOptions = {}): number {
   let failures = 0;
+  const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
   for (const pkg of listPackageJsonRecords(root)) {
     for (const field of workspaceDependencyFields) {
       const dependencies = recordProperty(pkg.json, field);
@@ -332,12 +384,28 @@ export function validateWorkspaceDependencies(root: string): number {
       }
     }
   }
+  for (const issue of checkPackageTargetPolicy(root, options)) {
+    console.error(`${issue.path}: ${issue.message}`);
+    failures++;
+  }
+  for (const issue of checkTypecheckTestPolicy(root)) {
+    console.error(`${issue.path}: ${issue.message}`);
+    failures++;
+  }
+  for (const issue of checkWorkspaceBoundedTestTargetPolicy(root)) {
+    console.error(`${issue.path}: ${issue.message}`);
+    failures++;
+  }
   if (failures === 0) {
-    console.log('Workspace dependency ranges are valid.');
+    console.log('Workspace dependency policy is valid.');
   }
   return failures;
 }
 
+// ---------------------------------------------------------------------------
+// Helpers kept in CLI (not Nx-specific)
+// ---------------------------------------------------------------------------
+
 function fixWorkspaceDependencyRanges(pkg: Record<string, unknown>, workspaceNames: Set<string>): boolean {
   let changed = false;
   for (const field of workspaceDependencyFields) {
@@ -355,11 +423,66 @@ function fixWorkspaceDependencyRanges(pkg: Record<string, unknown>, workspaceNam
   return changed;
 }
 
-function setBooleanProperty(record: Record<string, unknown>, key: string, value: boolean): boolean {
-  if (record[key] === value) {
+function validateRootScripts(rootPackage: Record<string, unknown>): number {
+  const scripts = recordProperty(rootPackage, 'scripts');
+  let failures = 0;
+  for (const [name, command] of Object.entries(rootScriptPolicy)) {
+    if (scripts?.[name] !== command) {
+      console.error(`package.json scripts.${name} must be ${command}`);
+      failures++;
+    }
+  }
+  if (scripts && !recordKeysAreSorted(scripts)) {
+    console.error(
+      'package.json scripts must be sorted alphabetically so root command policy stays stable across fixes.',
+    );
+    failures++;
+  }
+  return failures;
+}
+
+function validateRootNxScriptInference(rootPackage: Record<string, unknown>): number {
+  const nx = recordProperty(rootPackage, 'nx');
+  if (nx && Array.isArray(nx.includedScripts) && nx.includedScripts.length === 0) {
+    return 0;
+  }
+  console.error('package.json nx.includedScripts must be [] so root scripts do not become recursive Nx targets.');
+  return 1;
+}
+
+function suggestNxProjectName(rootPackageName: string, packageName: string): string | null {
+  const rootScope = npmScope(rootPackageName);
+  if (!rootScope || npmScope(packageName) !== rootScope) {
+    return null;
+  }
+  return unscopedPackageName(packageName);
+}
+
+function npmScope(packageName: string): string | null {
+  const match = /^(@[^/]+)\//.exec(packageName);
+  return match?.[1] ?? null;
+}
+
+function unscopedPackageName(packageName: string): string {
+  return packageName.startsWith('@') ? packageName.slice(packageName.indexOf('/') + 1) : packageName;
+}
+
+function recordKeysAreSorted(record: Record<string, unknown>): boolean {
+  const keys = Object.keys(record);
+  return keys.every((key, index) => index === 0 || keys[index - 1] <= key);
+}
+
+function sortRecordInPlace(record: Record<string, unknown>): boolean {
+  if (recordKeysAreSorted(record)) {
     return false;
   }
-  record[key] = value;
+  const entries = Object.entries(record).sort(([a], [b]) => a.localeCompare(b));
+  for (const key of Object.keys(record)) {
+    delete record[key];
+  }
+  for (const [key, value] of entries) {
+    record[key] = value;
+  }
   return true;
 }
 

package/src/monorepo/packed-package.ts

@@ -3,67 +3,119 @@ import { join } from 'node:path';
 import { publint } from 'publint';
 import { formatMessage } from 'publint/utils';
 import { isRecord } from '../lib/json.js';
-import { runStatus } from '../lib/run.js';
+import { runResult, 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> {
+  return (
+    (await validatePackedPublicPackagePublint(root)) +
+    (await validatePackedPublicPackageManifest(root)) +
+    (await validatePackedPublicPackageTypes(root))
+  );
+}
+
+export async function validatePackedPublicPackagePublint(root: string): Promise<number> {
   let failures = 0;
   for (const pkg of listPublicPackages(root)) {
-    failures += await validatePackedPublicPackage(root, pkg);
+    failures += await validatePackedPublicPackageTool(root, pkg, validatePublint);
   }
   return failures;
 }
 
-async function validatePackedPublicPackage(root: string, pkg: PackageInfo): Promise<number> {
+export async function validatePackedPublicPackageManifest(root: string): Promise<number> {
   let failures = 0;
-  const packed = await packPackage(root, pkg);
-  try {
-    const lint = await publint({ pack: { tarball: packed.arrayBuffer }, level: 'warning', strict: true });
-    for (const message of lint.messages) {
-      console.error(`${pkg.path}: publint ${message.type} ${message.code}: ${formatMessage(message, lint.pkg)}`);
-      failures++;
-    }
+  for (const pkg of listPublicPackages(root)) {
+    failures += await validatePackedPublicPackageTool(root, pkg, validatePackedManifest);
+  }
+  return failures;
+}
 
-    const packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
-    for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
-      console.error(message);
-      failures++;
-    }
+export async function validatePackedPublicPackageTypes(root: string): Promise<number> {
+  let failures = 0;
+  for (const pkg of listPublicPackages(root)) {
+    failures += await validatePackedPublicPackageTool(root, pkg, validateAttw);
+  }
+  return failures;
+}
 
-    const attwArgs = [
-      packed.path,
-      '--format',
-      'ascii',
-      '--no-color',
-      '--profile',
-      'node16',
-      '--ignore-rules',
-      'cjs-resolves-to-esm',
-      ...attwExcludedEntrypointArgs(pkg),
-    ];
-    const attwStatus = await runStatus('attw', ['--quiet', ...attwArgs], root, true);
-    if (attwStatus !== 0) {
-      await runStatus('attw', attwArgs, root);
-      console.error(`${pkg.path}: are-the-types-wrong validation failed`);
-      failures++;
-    } else {
-      console.log(`${pkg.path}: are-the-types-wrong valid.`);
-    }
+async function validatePackedPublicPackageTool(
+  root: string,
+  pkg: PackageInfo,
+  validate: (root: string, pkg: PackageInfo, packed: { path: string; arrayBuffer: ArrayBuffer }) => Promise<number>,
+): Promise<number> {
+  const packed = await packPackage(root, pkg);
+  try {
+    return await validate(root, pkg, packed);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`${pkg.path}: packed package validation failed: ${message}`);
-    failures++;
+    return 1;
   } finally {
     unlinkSync(packed.path);
   }
-  if (failures === 0) {
-    console.log(`${pkg.path}: packed package is valid.`);
+}
+
+async function validatePublint(
+  _root: string,
+  pkg: PackageInfo,
+  packed: { path: string; arrayBuffer: ArrayBuffer },
+): Promise<number> {
+  let failures = 0;
+  const lint = await publint({ pack: { tarball: packed.arrayBuffer }, level: 'warning', strict: true });
+  for (const message of lint.messages) {
+    console.error(`${pkg.path}: publint ${message.type} ${message.code}: ${formatMessage(message, lint.pkg)}`);
+    failures++;
+  }
+  return failures;
+}
+
+async function validatePackedManifest(
+  root: string,
+  pkg: PackageInfo,
+  packed: { path: string; arrayBuffer: ArrayBuffer },
+): Promise<number> {
+  let failures = 0;
+  const packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
+  for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
+    console.error(message);
+    failures++;
   }
   return failures;
 }
 
+async function validateAttw(root: string, pkg: PackageInfo, packed: { path: string }): Promise<number> {
+  const attwArgs = [
+    packed.path,
+    '--format',
+    'ascii',
+    '--no-color',
+    '--profile',
+    'node16',
+    '--ignore-rules',
+    'cjs-resolves-to-esm',
+    ...attwExcludedEntrypointArgs(pkg),
+  ];
+  const attw = await runResult('attw', attwArgs, root);
+  if (attw.exitCode === 0) {
+    return 0;
+  }
+  printAttwOutput(attw.stdout);
+  printAttwOutput(attw.stderr);
+  console.error(`${pkg.path}: are-the-types-wrong validation failed`);
+  return 1;
+}
+
+function printAttwOutput(output: string): void {
+  for (const line of output.split('\n')) {
+    if (!line || line.includes('(ignored)')) {
+      continue;
+    }
+    console.error(line);
+  }
+}
+
 function attwExcludedEntrypointArgs(pkg: PackageInfo): string[] {
   const excluded = wasmExportEntrypoints(pkg.json.exports);
   return excluded.length === 0 ? [] : ['--exclude-entrypoints', ...excluded];