@smoothbricks/cli 0.1.0 → 0.2.0

package/dist/monorepo/publish-workflow.js

@@ -0,0 +1,336 @@
+import { isSmoothBricksCodebasePackageName } from '../lib/cli-package.js';
+export var PublishWorkflowStepKind;
+(function (PublishWorkflowStepKind) {
+    PublishWorkflowStepKind["Checkout"] = "checkout";
+    PublishWorkflowStepKind["SetupDevenv"] = "setup-devenv";
+    PublishWorkflowStepKind["ConfigureReleaseAuthor"] = "configure-release-author";
+    PublishWorkflowStepKind["BuildSelfHostedCli"] = "build-self-hosted-cli";
+    PublishWorkflowStepKind["RepairPendingReleases"] = "repair-pending-releases";
+    PublishWorkflowStepKind["VersionRelease"] = "version-release";
+    PublishWorkflowStepKind["CheckManagedMonorepoFiles"] = "check-managed-monorepo-files";
+    PublishWorkflowStepKind["Build"] = "build";
+    PublishWorkflowStepKind["Lint"] = "lint";
+    PublishWorkflowStepKind["UnitTests"] = "unit-tests";
+    PublishWorkflowStepKind["UploadTraceDbs"] = "upload-trace-dbs";
+    PublishWorkflowStepKind["ValidateMonorepoConfig"] = "validate-monorepo-config";
+    PublishWorkflowStepKind["PublishRelease"] = "publish-release";
+    PublishWorkflowStepKind["SaveNixDevenv"] = "save-nix-devenv";
+})(PublishWorkflowStepKind || (PublishWorkflowStepKind = {}));
+export function definePublishWorkflow(options = {}) {
+    const versionMode = githubExpression('steps.version.outputs.mode');
+    const setupSteps = [
+        { kind: PublishWorkflowStepKind.Checkout, name: '📥 Checkout' },
+        { kind: PublishWorkflowStepKind.SetupDevenv, name: '🧱 Setup Nix/devenv', id: 'setup' },
+        { kind: PublishWorkflowStepKind.ConfigureReleaseAuthor, name: '🤖 Configure release author' },
+    ];
+    if (isSmoothBricksCodebasePackageName(options.repoName)) {
+        setupSteps.push({ kind: PublishWorkflowStepKind.BuildSelfHostedCli, name: '🏗️ Build self-hosted smoo' });
+    }
+    return {
+        steps: numberWorkflowSteps([
+            ...setupSteps,
+            {
+                kind: PublishWorkflowStepKind.RepairPendingReleases,
+                name: '🧯 Repair pending releases',
+            },
+            { kind: PublishWorkflowStepKind.VersionRelease, name: '🏷️ Version release', id: 'version' },
+            {
+                kind: PublishWorkflowStepKind.CheckManagedMonorepoFiles,
+                name: `✅ Check managed monorepo files (${versionMode})`,
+                condition: 'version-mode-not-none',
+            },
+            {
+                kind: PublishWorkflowStepKind.Build,
+                name: `🔨 Build (${versionMode})`,
+                condition: 'version-mode-not-none',
+                nxTarget: 'build',
+            },
+            {
+                kind: PublishWorkflowStepKind.Lint,
+                name: `🔍 Lint (${versionMode})`,
+                condition: 'version-mode-not-none',
+                nxTarget: 'lint',
+            },
+            {
+                kind: PublishWorkflowStepKind.UnitTests,
+                name: `🧪 Unit Tests (${versionMode})`,
+                condition: 'version-mode-not-none',
+                nxTarget: 'test',
+            },
+            { kind: PublishWorkflowStepKind.UploadTraceDbs, name: '📎 Upload trace DBs', condition: 'failure' },
+            {
+                kind: PublishWorkflowStepKind.ValidateMonorepoConfig,
+                name: `✅ Validate monorepo config (${versionMode})`,
+                condition: 'version-mode-not-none',
+            },
+            {
+                kind: PublishWorkflowStepKind.PublishRelease,
+                name: `📦 Publish release (${versionMode})`,
+            },
+            {
+                kind: PublishWorkflowStepKind.SaveNixDevenv,
+                name: '🧹 Cleanup and cache Nix/devenv',
+                condition: 'always',
+            },
+        ]),
+    };
+}
+function numberWorkflowSteps(steps) {
+    return steps.map((step, index) => ({ ...step, number: index + 2 }));
+}
+export async function runPublishWorkflow(workflow, context) {
+    let setupOutputs = { nixCacheHit: '', devenvCacheHit: '' };
+    let version = { mode: 'none', projects: [] };
+    let failed = false;
+    let failure;
+    for (const step of workflow.steps) {
+        if (!shouldRunStep(step, version, failed)) {
+            continue;
+        }
+        try {
+            switch (step.kind) {
+                case PublishWorkflowStepKind.Checkout:
+                    await context.callbacks.checkout();
+                    break;
+                case PublishWorkflowStepKind.SetupDevenv:
+                    setupOutputs = await context.callbacks.setupDevenv();
+                    break;
+                case PublishWorkflowStepKind.ConfigureReleaseAuthor:
+                    await context.callbacks.configureReleaseAuthor();
+                    break;
+                case PublishWorkflowStepKind.BuildSelfHostedCli:
+                    await context.callbacks.buildSelfHostedCli();
+                    break;
+                case PublishWorkflowStepKind.RepairPendingReleases:
+                    await context.callbacks.repairPendingReleases({
+                        dryRun: context.inputs.dryRun,
+                    });
+                    break;
+                case PublishWorkflowStepKind.VersionRelease:
+                    version = await context.callbacks.versionRelease(context.inputs);
+                    break;
+                case PublishWorkflowStepKind.CheckManagedMonorepoFiles:
+                    await context.callbacks.checkManagedMonorepoFiles();
+                    break;
+                case PublishWorkflowStepKind.Build:
+                case PublishWorkflowStepKind.Lint:
+                case PublishWorkflowStepKind.UnitTests:
+                    if (!step.nxTarget) {
+                        throw new Error(`Workflow step ${step.kind} is missing an Nx target.`);
+                    }
+                    await context.callbacks.nxRunMany({ target: step.nxTarget, projects: version.projects });
+                    break;
+                case PublishWorkflowStepKind.UploadTraceDbs:
+                    await context.callbacks.uploadTraceDbs();
+                    break;
+                case PublishWorkflowStepKind.ValidateMonorepoConfig:
+                    await context.callbacks.validateMonorepoConfig();
+                    break;
+                case PublishWorkflowStepKind.PublishRelease:
+                    await context.callbacks.publishRelease({
+                        bump: context.inputs.bump,
+                        dryRun: context.inputs.dryRun,
+                    });
+                    break;
+                case PublishWorkflowStepKind.SaveNixDevenv:
+                    await context.callbacks.saveNixDevenv(setupOutputs);
+                    break;
+            }
+        }
+        catch (error) {
+            failed = true;
+            failure = error;
+        }
+    }
+    if (failure) {
+        throw failure;
+    }
+    return { version, failed };
+}
+function shouldRunStep(step, version, failed) {
+    if (step.condition === 'version-mode-not-none') {
+        return version.mode !== 'none';
+    }
+    if (step.condition === 'failure') {
+        return failed;
+    }
+    return true;
+}
+export function renderPublishWorkflowYaml(options = {}) {
+    const steps = definePublishWorkflow(options).steps;
+    return `${renderPublishWorkflowHeader()}${renderPublishWorkflowSteps(steps)}`;
+}
+function renderPublishWorkflowHeader() {
+    return `name: Publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      bump:
+        type: choice
+        description:
+          Use auto for conventional commits, or force a semver bump. Prerelease publishes to next; all others publish to
+          latest.
+        options: [auto, patch, minor, major, prerelease]
+        default: auto
+      dry_run:
+        type: boolean
+        description: Run release commands without writing versions, tags, publishes, or GitHub Releases.
+        default: false
+
+permissions:
+  contents: write
+  id-token: write
+
+concurrency:
+  group: release-${githubExpression('github.ref')}
+  cancel-in-progress: false
+
+defaults:
+  run:
+    working-directory: tooling/direnv
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    env:
+      NIX_STORE_NAR: ${githubExpression('github.workspace')}/nix-store.nar
+      GH_TOKEN: ${githubExpression('github.token')}
+    steps:
+`;
+}
+function renderPublishWorkflowSteps(steps) {
+    const lines = [];
+    for (const step of steps) {
+        lines.push(...sectionLinesBefore(step));
+        lines.push(...commentLinesForStep(step));
+        lines.push(...yamlLinesForStep(step));
+        lines.push('');
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+function sectionLinesBefore(step) {
+    if (step.kind === PublishWorkflowStepKind.Checkout) {
+        return ['      # --- Setup --------------------------------------------------------------', ''];
+    }
+    if (step.kind === PublishWorkflowStepKind.CheckManagedMonorepoFiles) {
+        return [
+            '      # --- Validation ---------------------------------------------------------',
+            '',
+            '      # Release validation intentionally does not restore persisted Nx task',
+            '      # cache. Nx may reuse tasks produced earlier in this same job, but publish',
+            '      # never relies on task outputs restored from CI cache. version runs before',
+            '      # validation so the commit completed below is the commit that was checked.',
+            '',
+        ];
+    }
+    if (step.kind === PublishWorkflowStepKind.PublishRelease) {
+        return ['      # --- Release ------------------------------------------------------------', ''];
+    }
+    if (step.kind === PublishWorkflowStepKind.SaveNixDevenv) {
+        return ['      # --- Cleanup ------------------------------------------------------------', ''];
+    }
+    return [];
+}
+function commentLinesForStep(step) {
+    if (step.kind === PublishWorkflowStepKind.Checkout) {
+        return ['      # Step 1: GitHub adds "Set up job" automatically', '      # Step 2'];
+    }
+    if (step.kind === PublishWorkflowStepKind.SetupDevenv) {
+        return [
+            '      # Step 3. Composite action internals do not affect top-level job step',
+            '      # anchors; update these comments if top-level steps move.',
+        ];
+    }
+    return [`      # Step ${step.number}`];
+}
+function yamlLinesForStep(step) {
+    switch (step.kind) {
+        case PublishWorkflowStepKind.Checkout:
+            return [
+                `      - name: ${step.name}`,
+                '        uses: actions/checkout@v6.0.2',
+                '        with:',
+                '          filter: blob:none',
+                '          fetch-depth: 0',
+            ];
+        case PublishWorkflowStepKind.SetupDevenv:
+            return [`      - name: ${step.name}`, '        id: setup', '        uses: ./.github/actions/setup-devenv'];
+        case PublishWorkflowStepKind.ConfigureReleaseAuthor:
+            return [
+                `      - name: ${step.name}`,
+                '        run:',
+                '          git config user.name "github-actions[bot]" && git config user.email',
+                '          "41898282+github-actions[bot]@users.noreply.github.com"',
+            ];
+        case PublishWorkflowStepKind.BuildSelfHostedCli:
+            return [
+                `      - name: ${step.name}`,
+                '        # SmoothBricks self-hosts smoo from source, but Nx release loads',
+                '        # @smoothbricks/cli/nx-version-actions through the built package export.',
+                '        run: nx build cli',
+            ];
+        case PublishWorkflowStepKind.RepairPendingReleases:
+            return [
+                `      - name: ${step.name}`,
+                `        run: smoo release repair-pending --dry-run "${githubExpression('inputs.dry_run')}"`,
+            ];
+        case PublishWorkflowStepKind.VersionRelease:
+            return [
+                `      - name: ${step.name}`,
+                '        id: version',
+                '        run:',
+                `          smoo release version --bump "${githubExpression('inputs.bump')}" --dry-run "${githubExpression('inputs.dry_run')}" --github-output`,
+                '          "$GITHUB_OUTPUT"',
+            ];
+        case PublishWorkflowStepKind.CheckManagedMonorepoFiles:
+            return conditionalRunStep(step, 'smoo monorepo check');
+        case PublishWorkflowStepKind.Build:
+            return conditionalRunStep(step, `smoo github-ci nx-run-many --targets build --projects "${githubExpression('steps.version.outputs.projects')}"`);
+        case PublishWorkflowStepKind.Lint:
+            return conditionalRunStep(step, `smoo github-ci nx-run-many --targets lint --projects "${githubExpression('steps.version.outputs.projects')}"`);
+        case PublishWorkflowStepKind.UnitTests:
+            return conditionalRunStep(step, `smoo github-ci nx-run-many --targets test --projects "${githubExpression('steps.version.outputs.projects')}"`);
+        case PublishWorkflowStepKind.UploadTraceDbs:
+            return [
+                `      - name: ${step.name}`,
+                `        if: ${githubExpression('failure()')}`,
+                '        uses: actions/upload-artifact@v4',
+                '        with:',
+                `          name: trace-results-${githubExpression('github.run_id')}`,
+                '          path: packages/*/.trace-results.db',
+                '          if-no-files-found: ignore',
+                '          retention-days: 14',
+                '          include-hidden-files: true',
+            ];
+        case PublishWorkflowStepKind.ValidateMonorepoConfig:
+            return conditionalRunStep(step, 'smoo monorepo validate');
+        case PublishWorkflowStepKind.PublishRelease:
+            return [
+                `      - name: ${step.name}`,
+                '        # smoo packs with Bun, then publishes tarballs with npm. Existing',
+                '        # packages must already exist on npm and use trusted publishing/OIDC.',
+                '        # Missing package names are bootstrapped locally before trust setup.',
+                `        run: smoo release publish --bump "${githubExpression('inputs.bump')}" --dry-run "${githubExpression('inputs.dry_run')}"`,
+            ];
+        case PublishWorkflowStepKind.SaveNixDevenv:
+            return [
+                `      - name: ${step.name}`,
+                `        if: ${githubExpression('always()')}`,
+                '        uses: ./.github/actions/save-nix-devenv',
+                '        with:',
+                `          nix-cache-hit: ${githubExpression('steps.setup.outputs.nix-cache-hit')}`,
+                `          devenv-cache-hit: ${githubExpression('steps.setup.outputs.devenv-cache-hit')}`,
+            ];
+    }
+}
+function conditionalRunStep(step, run) {
+    return [
+        `      - name: ${step.name}`,
+        `        if: ${githubExpression("steps.version.outputs.mode != 'none'")}`,
+        `        run: ${run}`,
+    ];
+}
+function githubExpression(expression) {
+    return ['$', '{{ ', expression, ' }}'].join('');
+}

package/dist/monorepo/tool-validation.d.ts

@@ -0,0 +1,22 @@
+import { type PackageJson } from '../lib/workspace.js';
+export interface ToolPolicy {
+    isSmoothBricksCodebase: boolean;
+    toolingPackageName: string;
+    cliDependencyRange: string;
+}
+export interface ToolContext {
+    rootPackage: PackageJson | null;
+    policy: ToolPolicy;
+}
+export declare function applyToolConfigDefaults(root: string): Promise<void>;
+export declare function validateToolConfig(root: string): number;
+export declare function applyRootDevDependencyDefaults(root: string, context: ToolContext): Promise<void>;
+export declare function applyToolingPackageDefaults(root: string, policy: ToolPolicy): void;
+export declare function applyToolingWorkspaceDefault(root: string): void;
+export declare function applyDevenvPackageDefaults(root: string): void;
+export declare function validateRootDevDependencies(policy: ToolPolicy, rootPackage: PackageJson | null): number;
+export declare function validateToolingPackage(root: string, policy: ToolPolicy): number;
+export declare function validateToolingWorkspace(rootPackage: PackageJson | null): number;
+export declare function validateDevenvPackages(root: string): number;
+export declare function readToolContext(root: string): ToolContext;
+//# sourceMappingURL=tool-validation.d.ts.map

package/dist/monorepo/tool-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-validation.d.ts","sourceRoot":"","sources":["../../src/monorepo/tool-validation.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,WAAW,EAAyB,MAAM,qBAAqB,CAAC;AAU9E,MAAM,WAAW,UAAU;IACzB,sBAAsB,EAAE,OAAO,CAAC;IAChC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,MAAM,EAAE,UAAU,CAAC;CACpB;AA8BD,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKzE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQvD;AAED,wBAAsB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBtG;AAoCD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAkBlF;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAY/D;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CA0B7D;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,CAyBvG;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,CAoB/E;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,CAWhF;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmB3D;AA0DD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAGzD"}