@smoothbricks/cli 0.3.4 → 0.4.0

package/src/monorepo/ci-workflow.ts

@@ -0,0 +1,229 @@
+export enum CiWorkflowStepKind {
+  Checkout = 'checkout',
+  SetupDevenv = 'setup-devenv',
+  SetNxShas = 'set-nx-shas',
+  RestoreNxCache = 'restore-nx-cache',
+  Build = 'build',
+  Lint = 'lint',
+  UnitTests = 'unit-tests',
+  Deploy = 'deploy',
+  SaveNxCache = 'save-nx-cache',
+  UploadTraceDbs = 'upload-trace-dbs',
+  SaveNixDevenv = 'save-nix-devenv',
+}
+
+export interface CiWorkflowStep {
+  kind: CiWorkflowStepKind;
+  name: string;
+  number: number;
+}
+
+export interface CiWorkflowDefinitionOptions {
+  deploy: boolean;
+  deployProvider?: 'cloudflare';
+  pushBranches: string[];
+}
+
+type CiWorkflowStepInput = Omit<CiWorkflowStep, 'number'>;
+
+export function defineCiWorkflow(options: CiWorkflowDefinitionOptions): CiWorkflowStep[] {
+  const steps: CiWorkflowStepInput[] = [
+    { kind: CiWorkflowStepKind.Checkout, name: '📥 Checkout' },
+    { kind: CiWorkflowStepKind.SetupDevenv, name: '🧱 Setup Nix/devenv' },
+    { kind: CiWorkflowStepKind.SetNxShas, name: '🧭 Set Nx SHAs' },
+    { kind: CiWorkflowStepKind.RestoreNxCache, name: '🧠 Restore Nx cache' },
+    { kind: CiWorkflowStepKind.Build, name: '🔨 Build' },
+    { kind: CiWorkflowStepKind.Lint, name: '🔍 Lint' },
+    { kind: CiWorkflowStepKind.UnitTests, name: '🧪 Unit Tests' },
+  ];
+  if (options.deploy) {
+    steps.push({ kind: CiWorkflowStepKind.Deploy, name: '🚀 Deploy Staging' });
+  }
+  steps.push(
+    { kind: CiWorkflowStepKind.SaveNxCache, name: '💾 Save Nx cache' },
+    { kind: CiWorkflowStepKind.UploadTraceDbs, name: '📎 Upload trace DBs' },
+    { kind: CiWorkflowStepKind.SaveNixDevenv, name: '🧹 Cleanup and cache Nix/devenv' },
+  );
+  return steps.map((step, index) => ({ ...step, number: index + 2 }));
+}
+
+export function renderCiWorkflowYaml(options: CiWorkflowDefinitionOptions): string {
+  const steps = defineCiWorkflow(options);
+  return `${renderCiWorkflowHeader(options)}${renderCiWorkflowSteps(steps, options)}`;
+}
+
+function renderCiWorkflowHeader(options: CiWorkflowDefinitionOptions): string {
+  return `name: CI
+
+on:
+  push:
+    branches:
+${renderYamlList(options.pushBranches, 6)}
+  pull_request:
+
+permissions:
+  actions: read
+  contents: read
+  statuses: write
+
+defaults:
+  run:
+    working-directory: tooling/direnv
+
+jobs:
+  main:
+    name: Validate
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    env:
+      NIX_STORE_NAR: ${githubExpression('github.workspace')}/nix-store.nar
+      GH_TOKEN: ${githubExpression('github.token')}
+    steps:
+`;
+}
+
+function githubExpression(expression: string): string {
+  return `$${`{{ ${expression} }}`}`;
+}
+
+function renderCiWorkflowSteps(steps: CiWorkflowStep[], options: CiWorkflowDefinitionOptions): string {
+  const lines: string[] = [];
+  for (const step of steps) {
+    lines.push(...sectionLinesBefore(step));
+    lines.push(...commentLinesForStep(step));
+    lines.push(...yamlLinesForStep(step, options));
+    lines.push('');
+  }
+  return `${lines.join('\n').trimEnd()}\n`;
+}
+
+function sectionLinesBefore(step: CiWorkflowStep): string[] {
+  if (step.kind === CiWorkflowStepKind.SetNxShas) {
+    return ['      # --- Nx -----------------------------------------------------------------', ''];
+  }
+  if (step.kind === CiWorkflowStepKind.SaveNixDevenv) {
+    return ['      # --- Cleanup ------------------------------------------------------------', ''];
+  }
+  return [];
+}
+
+function commentLinesForStep(step: CiWorkflowStep): string[] {
+  if (step.kind === CiWorkflowStepKind.Checkout) {
+    return ['      # Step 1: GitHub adds "Set up job" automatically', '      # Step 2'];
+  }
+  if (step.kind === CiWorkflowStepKind.SetupDevenv) {
+    return [
+      '      # Step 3. Composite action internals do not affect top-level job step',
+      '      # anchors; update the nx-smart --step values below if top-level steps move.',
+    ];
+  }
+  if (step.kind === CiWorkflowStepKind.SetNxShas) {
+    return [`      # Step ${step.number}`, '      # Sets the base and head SHAs required for the nx affected commands'];
+  }
+  if (step.kind === CiWorkflowStepKind.SaveNxCache) {
+    return [
+      `      # Step ${step.number}`,
+      "      # Nx's database cache needs artifact files and .nx/workspace-data DB",
+      '      # metadata restored together; GitHub Actions cache is only the archive',
+      '      # transport. Save runs only after prior required steps succeed on the default',
+      '      # branch, so PRs may restore shared cache but cannot publish it.',
+    ];
+  }
+  return [`      # Step ${step.number}`];
+}
+
+function yamlLinesForStep(step: CiWorkflowStep, options: CiWorkflowDefinitionOptions): string[] {
+  switch (step.kind) {
+    case CiWorkflowStepKind.Checkout:
+      return [
+        `      - name: ${step.name}`,
+        '        uses: actions/checkout@v6.0.2',
+        '        with:',
+        '          filter: blob:none',
+        '          fetch-depth: 0',
+      ];
+    case CiWorkflowStepKind.SetupDevenv:
+      return [`      - name: ${step.name}`, '        id: setup', '        uses: ./.github/actions/setup-devenv'];
+    case CiWorkflowStepKind.SetNxShas:
+      return [
+        `      - name: ${step.name}`,
+        '        uses: nrwl/nx-set-shas@v5.0.1',
+        '        with:',
+        '          workflow-id: ci.yml',
+      ];
+    case CiWorkflowStepKind.RestoreNxCache:
+      return [`      - name: ${step.name}`, '        id: nx-cache', '        uses: ./.github/actions/cache-nx'];
+    case CiWorkflowStepKind.Build:
+      return nxSmartStep(step, 'build', 'Build');
+    case CiWorkflowStepKind.Lint:
+      return nxSmartStep(step, 'lint', 'Lint');
+    case CiWorkflowStepKind.UnitTests:
+      return nxSmartStep(step, 'test', 'Unit Tests');
+    case CiWorkflowStepKind.Deploy:
+      return [
+        `      - name: ${step.name}`,
+        '        if:',
+        "          ${{ github.event_name == 'push' && github.ref == format('refs/heads/{0}',",
+        '          github.event.repository.default_branch) }}',
+        ...deployEnvLines(options),
+        `        run: smoo github-ci nx-deploy --configuration staging --mode affected --name "Deploy Staging" --step ${step.number}`,
+      ];
+    case CiWorkflowStepKind.SaveNxCache:
+      return [
+        `      - name: ${step.name}`,
+        '        if:',
+        "          ${{ github.event_name == 'push' && github.ref == format('refs/heads/{0}',",
+        "          github.event.repository.default_branch) && steps.nx-cache.outputs.cache-hit != 'true' }}",
+        '        uses: actions/cache/save@v5.0.5',
+        '        with:',
+        '          path: |',
+        '            .nx/cache',
+        '            .nx/workspace-data/*.db*',
+        '          key: ${{ runner.os }}-nx-db-v1-${{ github.sha }}',
+      ];
+    case CiWorkflowStepKind.UploadTraceDbs:
+      return [
+        `      - name: ${step.name}`,
+        '        if: ${{ always() }}',
+        '        uses: actions/upload-artifact@v7.0.1',
+        '        with:',
+        '          name: trace-results-${{ github.run_id }}',
+        '          path: packages/*/.trace-results.db',
+        '          if-no-files-found: ignore',
+        '          retention-days: 14',
+        '          include-hidden-files: true',
+      ];
+    case CiWorkflowStepKind.SaveNixDevenv:
+      return [
+        `      - name: ${step.name}`,
+        '        if: ${{ always() }}',
+        '        uses: ./.github/actions/save-nix-devenv',
+        '        with:',
+        '          nix-cache-hit: ${{ steps.setup.outputs.nix-cache-hit }}',
+        '          devenv-cache-hit: ${{ steps.setup.outputs.devenv-cache-hit }}',
+      ];
+  }
+}
+
+function deployEnvLines(options: CiWorkflowDefinitionOptions): string[] {
+  if (options.deployProvider !== 'cloudflare') {
+    return [];
+  }
+  return [
+    '        env:',
+    '          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}',
+    '          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}',
+  ];
+}
+
+function nxSmartStep(step: CiWorkflowStep, target: string, name: string): string[] {
+  return [
+    `      - name: ${step.name}`,
+    `        run: smoo github-ci nx-smart --target ${target} --name "${name}" --step ${step.number}`,
+  ];
+}
+
+function renderYamlList(values: string[], spaces: number): string {
+  const indent = ' '.repeat(spaces);
+  return values.map((value) => `${indent}- ${value}`).join('\n');
+}

package/src/monorepo/managed-files.ts

@@ -1,7 +1,9 @@
+import { execFileSync } from 'node:child_process';
 import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { listReleasePackages, readPackageJson } from '../lib/workspace.js';
+import { renderCiWorkflowYaml } from './ci-workflow.js';
 import { renderPublishWorkflowYaml } from './publish-workflow.js';
 
 type ManagedKind = 'raw' | 'template' | 'generated';
@@ -21,10 +23,20 @@ export interface FileResult {
 
 interface ManagedFileContext {
   hasReleasePackages: boolean;
+  hasStagingDeployTargets: boolean;
+  hasProductionDeployTargets: boolean;
+  stagingDeployProvider?: 'cloudflare';
+  productionDeployProvider?: 'cloudflare';
+  ciPushBranches: string[];
   nodeModulesCacheKey: string;
   repoName: string;
 }
 
+interface DeployTargetInfo {
+  exists: boolean;
+  provider?: 'cloudflare';
+}
+
 const managedFiles: ManagedFile[] = [
   {
     kind: 'raw',
@@ -56,8 +68,8 @@ const managedFiles: ManagedFile[] = [
     target: '.git-format-staged.yml',
   },
   {
-    kind: 'template',
-    source: 'github/workflows/ci.yml',
+    kind: 'generated',
+    source: 'ci-workflow',
     target: '.github/workflows/ci.yml',
   },
   {
@@ -106,7 +118,7 @@ function applyManagedFile(
   mode: 'update' | 'check' | 'diff',
   context: ManagedFileContext,
 ): FileResult {
-  if (file.releasePackagesOnly === true && !context.hasReleasePackages) {
+  if (file.releasePackagesOnly === true && !context.hasReleasePackages && !context.hasProductionDeployTargets) {
     return { target: file.target, action: 'skipped' };
   }
   const target = resolve(root, file.target);
@@ -138,8 +150,19 @@ function applyManagedFile(
 
 function getManagedContent(file: ManagedFile, context: ManagedFileContext): string {
   if (file.kind === 'generated') {
+    if (file.source === 'ci-workflow') {
+      return renderCiWorkflowYaml({
+        deploy: context.hasStagingDeployTargets,
+        deployProvider: context.stagingDeployProvider,
+        pushBranches: context.ciPushBranches,
+      });
+    }
     if (file.source === 'publish-workflow') {
-      return renderPublishWorkflowYaml({ repoName: context.repoName });
+      return renderPublishWorkflowYaml({
+        deploy: context.hasProductionDeployTargets,
+        deployProvider: context.productionDeployProvider,
+        repoName: context.repoName,
+      });
     }
     throw new Error(`Unknown generated managed file source ${file.source}`);
   }
@@ -155,18 +178,105 @@ function getManagedContent(file: ManagedFile, context: ManagedFileContext): stri
 function getManagedFileContext(root: string): ManagedFileContext {
   const packageJson = readPackageJson(join(root, 'package.json'));
   const repoName = packageJson?.name ?? 'monorepo';
+  const ciPushBranches = getCiPushBranches(packageJson?.json);
+  const stagingDeploy = getDeployTargetInfo(root, 'staging');
+  const productionDeploy = getDeployTargetInfo(root, 'production');
   const nodeModulesCacheKey = existsSync(join(root, 'bun.lock'))
     ? `$${"{{ hashFiles('bun.lock', 'package.json', 'packages/*/package.json') }}"}`
     : `$${"{{ hashFiles('bun.lockb', 'package.json', 'packages/*/package.json') }}"}`;
-  return { hasReleasePackages: listReleasePackages(root, packageJson).length > 0, nodeModulesCacheKey, repoName };
+  return {
+    hasReleasePackages: listReleasePackages(root, packageJson).length > 0,
+    hasStagingDeployTargets: stagingDeploy.exists,
+    hasProductionDeployTargets: productionDeploy.exists,
+    stagingDeployProvider: stagingDeploy.provider,
+    productionDeployProvider: productionDeploy.provider,
+    ciPushBranches,
+    nodeModulesCacheKey,
+    repoName,
+  };
 }
 
 function renderTemplate(context: ManagedFileContext, template: string): string {
   return template
     .replaceAll('{{REPO_NAME}}', context.repoName)
+    .replaceAll('__SMOO_CI_PUSH_BRANCHES__', renderYamlFlowList(context.ciPushBranches))
     .replaceAll('{{NODE_MODULES_CACHE_KEY}}', context.nodeModulesCacheKey);
 }
 
+function getDeployTargetInfo(root: string, configuration: string): DeployTargetInfo {
+  const output = execFileSync('nx', ['show', 'projects', '--withTarget', 'deploy', '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'inherit'],
+  });
+  const projects: unknown = JSON.parse(output);
+  if (!Array.isArray(projects) || !projects.every((project) => typeof project === 'string')) {
+    return { exists: false };
+  }
+  let exists = false;
+  let provider: DeployTargetInfo['provider'];
+  for (const project of projects) {
+    const target = nxDeployTarget(root, project, configuration);
+    if (!target.exists) {
+      continue;
+    }
+    exists = true;
+    provider ??= target.provider;
+  }
+  return { exists, provider };
+}
+
+function nxDeployTarget(root: string, project: string, configuration: string): DeployTargetInfo {
+  const output = execFileSync('nx', ['show', 'project', project, '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'inherit'],
+  });
+  const parsed: unknown = JSON.parse(output);
+  const projectJson = recordValue(parsed);
+  const targets = recordValue(projectJson?.targets);
+  const deploy = recordValue(targets?.deploy);
+  const configurations = recordValue(deploy?.configurations);
+  const config = recordValue(configurations?.[configuration]);
+  if (!config) {
+    return { exists: false };
+  }
+  const command = deployCommand(deploy, config);
+  return { exists: true, provider: command.includes('wrangler ') ? 'cloudflare' : undefined };
+}
+
+function deployCommand(deploy: Record<string, unknown> | undefined, config: Record<string, unknown>): string {
+  const command = stringValue(config.command) ?? stringValue(recordValue(config.options)?.command);
+  return command ?? stringValue(recordValue(deploy?.options)?.command) ?? '';
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function getCiPushBranches(packageJson: unknown): string[] {
+  const configured = readCiPushBranches(packageJson);
+  return configured.length > 0 ? configured : ['main'];
+}
+
+function readCiPushBranches(packageJson: unknown): string[] {
+  const rootPackage = recordValue(packageJson);
+  const smoo = recordValue(rootPackage?.smoo);
+  const github = recordValue(smoo?.github);
+  const branches = Array.isArray(github?.pushBranches) ? github.pushBranches : [];
+  return branches.filter((branch): branch is string => typeof branch === 'string' && branch.length > 0);
+}
+
+function recordValue(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function renderYamlFlowList(values: string[]): string {
+  return JSON.stringify(values);
+}
+
 function writeManagedFile(path: string, content: string, executable: boolean): void {
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, content, { mode: executable ? 0o755 : 0o644 });

package/src/monorepo/package-policy.test.ts

@@ -51,14 +51,17 @@ describe('root smoo monorepo policy', () => {
       );
       await writeJson(join(root, 'nx.json'), validNxJson());
 
-      expect(validateRootPackagePolicy(root)).toBe(5);
-      expect(validateNxReleaseConfig(root)).toBe(6);
+      expect(validateRootPackagePolicy(root)).toBe(7);
+      expect(validateNxReleaseConfig(root)).toBe(8);
 
       applyFixableMonorepoDefaults(root);
 
       const rootPackage = await readJson(join(root, 'package.json'));
       const nxJson = await readJson(join(root, 'nx.json'));
       expect(rootPackage.scripts).toEqual({
+        clean: 'nx run-many -t clean; nx reset',
+        'clean:node_modules':
+          'rm -rf node_modules && find e* t* p* -type d -name node_modules -print0 | xargs -0 rm -rvf',
         'format:changed': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --also-unstaged',
         'format:staged': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml',
         lint: 'nx run-many -t lint',
@@ -66,7 +69,7 @@ describe('root smoo monorepo policy', () => {
       });
       expect(rootPackage).toMatchObject({ nx: { includedScripts: [] } });
       expect(nxJson.namedInputs).toEqual(validNamedInputs());
-      expect(nxJson.targetDefaults).toEqual({ build: { cache: true, outputs: ['{projectRoot}/dist'] } });
+      expect(nxJson.targetDefaults).toEqual(validTargetDefaults());
       expect(nxJson.plugins).toEqual([
         {
           plugin: '@nx/js/typescript',
@@ -152,12 +155,12 @@ describe('root smoo monorepo policy', () => {
         },
       });
 
-      expect(validateNxReleaseConfig(root)).toBe(4);
+      expect(validateNxReleaseConfig(root)).toBe(6);
 
       applyFixableMonorepoDefaults(root);
 
       const nxJson = await readJson(join(root, 'nx.json'));
-      expect(nxJson.targetDefaults).toEqual({ build: { cache: true, outputs: ['{projectRoot}/dist'] } });
+      expect(nxJson.targetDefaults).toEqual(validTargetDefaults());
       expect(validateNxReleaseConfig(root)).toBe(0);
     } finally {
       await rm(root, { recursive: true, force: true });
@@ -1096,7 +1099,7 @@ function validConfiguredNxJson(): Record<string, unknown> {
   return {
     ...validNxJson(),
     namedInputs: validNamedInputs(),
-    targetDefaults: { build: { cache: true, outputs: ['{projectRoot}/dist'] } },
+    targetDefaults: validTargetDefaults(),
     plugins: [
       {
         plugin: '@nx/js/typescript',
@@ -1115,6 +1118,13 @@ function validConfiguredNxJson(): Record<string, unknown> {
   };
 }
 
+function validTargetDefaults(): Record<string, unknown> {
+  return {
+    build: { cache: true, outputs: ['{projectRoot}/dist'] },
+    clean: { executor: '@smoothbricks/nx-plugin:clean-outputs', cache: false },
+  };
+}
+
 function validNamedInputs(): Record<string, unknown> {
   return {
     default: ['{projectRoot}/**/*', 'sharedGlobals'],

package/src/monorepo/package-policy.ts

@@ -48,10 +48,12 @@ export { SMOO_NX_RELEASE_TAG_PATTERN, SMOO_NX_VERSION_ACTIONS };
 
 const extraCommitScopes = ['release'];
 const rootScriptPolicy: Record<string, string> = {
+  clean: 'nx run-many -t clean; nx reset',
+  'clean:node_modules': 'rm -rf node_modules && find e* t* p* -type d -name node_modules -print0 | xargs -0 rm -rvf',
+  'format:changed': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --also-unstaged',
+  'format:staged': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml',
   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 {