@raindancers/agentl 0.0.0

package/lib/gha-pipeline.js

@@ -0,0 +1,148 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GHAPipeline = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs = require("fs");
+const path = require("path");
+const gha_stage_1 = require("./gha-stage");
+const gha_workflow_1 = require("./gha-workflow");
+/**
+ * A GitHub Actions CDK pipeline.
+ *
+ * Model:
+ * - Stages (environments) deploy sequentially: dev → staging → prod
+ * - Waves within a stage deploy sequentially
+ * - Stacks within a wave deploy in parallel
+ */
+class GHAPipeline {
+    constructor(_props) {
+        this.stages = [];
+    }
+    /**
+     * Add a stage (environment) to the pipeline. Stages deploy sequentially.
+     * @param id Stage identifier (e.g. 'dev', 'staging', 'prod')
+     */
+    addStage(id, options) {
+        const stage = new gha_stage_1.GHAStage(id, options);
+        this.stages.push(stage);
+        return stage;
+    }
+    /**
+     * Synthesize the pipeline — wires CDK stack dependencies and optionally generates workflows.
+     * @param print Whether to print the deployment order to console
+     * @param saveMermaidDiagram If provided, saves a Mermaid diagram
+     * @param workflowConfig If provided, generates GitHub Actions workflow files
+     */
+    synth(print = true, saveMermaidDiagram, workflowConfig) {
+        this.wireDependencies();
+        if (print) {
+            this.printDeploymentOrder();
+        }
+        if (saveMermaidDiagram) {
+            const diagram = this.generateMermaidDiagram();
+            const outputPath = saveMermaidDiagram.path || process.cwd();
+            const fileName = saveMermaidDiagram.fileName || 'pipeline-deployment-order.md';
+            const fullPath = path.join(outputPath, fileName);
+            fs.writeFileSync(fullPath, diagram);
+        }
+        if (workflowConfig) {
+            (0, gha_workflow_1.generateWorkflows)(this.stages, workflowConfig);
+        }
+    }
+    /**
+     * Wire CDK stack dependencies based on stage/wave structure.
+     */
+    wireDependencies() {
+        for (const stage of this.stages) {
+            for (let w = 0; w < stage.waves.length; w++) {
+                const wave = stage.waves[w];
+                // Intra-wave: explicit dependsOn
+                for (const entry of wave.stacks) {
+                    for (const dep of entry.dependsOn) {
+                        entry.stack.addDependency(dep, stage.id + '/' + wave.id + ' intra-wave dependency');
+                    }
+                }
+                // Inter-wave: all stacks in wave N depend on all stacks in wave N-1
+                if (w > 0) {
+                    const prevWave = stage.waves[w - 1];
+                    for (const entry of wave.stacks) {
+                        for (const prevEntry of prevWave.stacks) {
+                            entry.stack.addDependency(prevEntry.stack, stage.id + ' wave ordering');
+                        }
+                    }
+                }
+            }
+        }
+        // Inter-stage: all stacks in stage N depend on all stacks in stage N-1
+        for (let s = 1; s < this.stages.length; s++) {
+            const prevStageStacks = this.stages[s - 1].allStacks();
+            const currFirstWave = this.stages[s].waves[0];
+            if (currFirstWave) {
+                for (const entry of currFirstWave.stacks) {
+                    for (const prevStack of prevStageStacks) {
+                        entry.stack.addDependency(prevStack, 'stage ordering');
+                    }
+                }
+            }
+        }
+    }
+    /** Get all stack names across all stages in deployment order. */
+    stackNames() {
+        return this.stages.flatMap(s => s.allStacks().map(st => st.stackName));
+    }
+    /** Print the deployment order to console. */
+    printDeploymentOrder() {
+        console.log('');
+        console.log('ORDER OF DEPLOYMENT');
+        console.log('🚀 Stages       - Deployed sequentially (environments)');
+        console.log('🌊 Waves        - Deployed sequentially within a stage');
+        console.log('📦 Stacks       - Deployed in parallel within a wave');
+        console.log('');
+        for (const stage of this.stages) {
+            console.log('| 🚀 ' + stage.id);
+            for (const wave of stage.waves) {
+                console.log('|   🌊 ' + wave.id);
+                for (const entry of wave.stacks) {
+                    const deps = entry.dependsOn.map(d => d.stackName);
+                    const depStr = deps.length > 0 ? ' ↳ ' + deps.join(', ') : '';
+                    console.log('|     📦 ' + entry.stack.stackName + depStr);
+                }
+            }
+        }
+        console.log('');
+    }
+    /** Generate a Mermaid diagram of the pipeline. */
+    generateMermaidDiagram() {
+        let diagram = '```mermaid\ngraph TD\n';
+        for (let s = 0; s < this.stages.length; s++) {
+            const stage = this.stages[s];
+            const stageId = 'Stage' + s;
+            diagram += '    subgraph ' + stageId + '["🚀 ' + stage.id + '"]\n';
+            for (let w = 0; w < stage.waves.length; w++) {
+                const wave = stage.waves[w];
+                const waveId = stageId + 'Wave' + w;
+                diagram += '        subgraph ' + waveId + '["🌊 ' + wave.id + '"]\n';
+                for (const entry of wave.stacks) {
+                    const stackNodeId = 'Stack' + entry.stack.stackName.replace(/[^a-zA-Z0-9]/g, '_');
+                    diagram += '            ' + stackNodeId + '["📦 ' + entry.stack.stackName + '"]\n';
+                }
+                diagram += '        end\n';
+                if (w > 0) {
+                    const prevWaveId = stageId + 'Wave' + (w - 1);
+                    diagram += '        ' + prevWaveId + ' --> ' + waveId + '\n';
+                }
+            }
+            diagram += '    end\n';
+        }
+        for (let s = 1; s < this.stages.length; s++) {
+            diagram += '    Stage' + (s - 1) + ' --> Stage' + s + '\n';
+        }
+        diagram += '```\n';
+        return diagram;
+    }
+}
+exports.GHAPipeline = GHAPipeline;
+_a = JSII_RTTI_SYMBOL_1;
+GHAPipeline[_a] = { fqn: "@raindancers/agentl.GHAPipeline", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gha-pipeline.js","sourceRoot":"","sources":["../src/gha-pipeline.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { GHAStage, GHAStageOptions } from './gha-stage';\nimport { generateWorkflows, GHAWorkflowConfig } from './gha-workflow';\nimport { MermaidDiagramOutput } from './shared';\n\nexport interface GHAPipelineProps {\n  /** Separator used in identifiers @default _ */\n  readonly separator?: string;\n}\n\n/**\n * A GitHub Actions CDK pipeline.\n *\n * Model:\n * - Stages (environments) deploy sequentially: dev → staging → prod\n * - Waves within a stage deploy sequentially\n * - Stacks within a wave deploy in parallel\n */\nexport class GHAPipeline {\n  public readonly stages: GHAStage[] = [];\n\n  constructor(_props?: GHAPipelineProps) {}\n\n  /**\n   * Add a stage (environment) to the pipeline. Stages deploy sequentially.\n   * @param id Stage identifier (e.g. 'dev', 'staging', 'prod')\n   */\n  public addStage(id: string, options?: GHAStageOptions): GHAStage {\n    const stage = new GHAStage(id, options);\n    this.stages.push(stage);\n    return stage;\n  }\n\n  /**\n   * Synthesize the pipeline — wires CDK stack dependencies and optionally generates workflows.\n   * @param print Whether to print the deployment order to console\n   * @param saveMermaidDiagram If provided, saves a Mermaid diagram\n   * @param workflowConfig If provided, generates GitHub Actions workflow files\n   */\n  public synth(print: boolean = true, saveMermaidDiagram?: MermaidDiagramOutput, workflowConfig?: GHAWorkflowConfig) {\n    this.wireDependencies();\n\n    if (print) {\n      this.printDeploymentOrder();\n    }\n\n    if (saveMermaidDiagram) {\n      const diagram = this.generateMermaidDiagram();\n      const outputPath = saveMermaidDiagram.path || process.cwd();\n      const fileName = saveMermaidDiagram.fileName || 'pipeline-deployment-order.md';\n      const fullPath = path.join(outputPath, fileName);\n      fs.writeFileSync(fullPath, diagram);\n    }\n\n    if (workflowConfig) {\n      generateWorkflows(this.stages, workflowConfig);\n    }\n  }\n\n  /**\n   * Wire CDK stack dependencies based on stage/wave structure.\n   */\n  private wireDependencies() {\n    for (const stage of this.stages) {\n      for (let w = 0; w < stage.waves.length; w++) {\n        const wave = stage.waves[w];\n\n        // Intra-wave: explicit dependsOn\n        for (const entry of wave.stacks) {\n          for (const dep of entry.dependsOn) {\n            entry.stack.addDependency(dep, stage.id + '/' + wave.id + ' intra-wave dependency');\n          }\n        }\n\n        // Inter-wave: all stacks in wave N depend on all stacks in wave N-1\n        if (w > 0) {\n          const prevWave = stage.waves[w - 1];\n          for (const entry of wave.stacks) {\n            for (const prevEntry of prevWave.stacks) {\n              entry.stack.addDependency(prevEntry.stack, stage.id + ' wave ordering');\n            }\n          }\n        }\n      }\n    }\n\n    // Inter-stage: all stacks in stage N depend on all stacks in stage N-1\n    for (let s = 1; s < this.stages.length; s++) {\n      const prevStageStacks = this.stages[s - 1].allStacks();\n      const currFirstWave = this.stages[s].waves[0];\n      if (currFirstWave) {\n        for (const entry of currFirstWave.stacks) {\n          for (const prevStack of prevStageStacks) {\n            entry.stack.addDependency(prevStack, 'stage ordering');\n          }\n        }\n      }\n    }\n  }\n\n  /** Get all stack names across all stages in deployment order. */\n  public stackNames(): string[] {\n    return this.stages.flatMap(s => s.allStacks().map(st => st.stackName));\n  }\n\n  /** Print the deployment order to console. */\n  public printDeploymentOrder() {\n    console.log('');\n    console.log('ORDER OF DEPLOYMENT');\n    console.log('🚀 Stages       - Deployed sequentially (environments)');\n    console.log('🌊 Waves        - Deployed sequentially within a stage');\n    console.log('📦 Stacks       - Deployed in parallel within a wave');\n    console.log('');\n\n    for (const stage of this.stages) {\n      console.log('| 🚀 ' + stage.id);\n      for (const wave of stage.waves) {\n        console.log('|   🌊 ' + wave.id);\n        for (const entry of wave.stacks) {\n          const deps = entry.dependsOn.map(d => d.stackName);\n          const depStr = deps.length > 0 ? ' ↳ ' + deps.join(', ') : '';\n          console.log('|     📦 ' + entry.stack.stackName + depStr);\n        }\n      }\n    }\n    console.log('');\n  }\n\n  /** Generate a Mermaid diagram of the pipeline. */\n  public generateMermaidDiagram(): string {\n    let diagram = '```mermaid\\ngraph TD\\n';\n\n    for (let s = 0; s < this.stages.length; s++) {\n      const stage = this.stages[s];\n      const stageId = 'Stage' + s;\n      diagram += '    subgraph ' + stageId + '[\"🚀 ' + stage.id + '\"]\\n';\n\n      for (let w = 0; w < stage.waves.length; w++) {\n        const wave = stage.waves[w];\n        const waveId = stageId + 'Wave' + w;\n        diagram += '        subgraph ' + waveId + '[\"🌊 ' + wave.id + '\"]\\n';\n\n        for (const entry of wave.stacks) {\n          const stackNodeId = 'Stack' + entry.stack.stackName.replace(/[^a-zA-Z0-9]/g, '_');\n          diagram += '            ' + stackNodeId + '[\"📦 ' + entry.stack.stackName + '\"]\\n';\n        }\n        diagram += '        end\\n';\n\n        if (w > 0) {\n          const prevWaveId = stageId + 'Wave' + (w - 1);\n          diagram += '        ' + prevWaveId + ' --> ' + waveId + '\\n';\n        }\n      }\n      diagram += '    end\\n';\n    }\n\n    for (let s = 1; s < this.stages.length; s++) {\n      diagram += '    Stage' + (s - 1) + ' --> Stage' + s + '\\n';\n    }\n\n    diagram += '```\\n';\n    return diagram;\n  }\n}\n"]}

package/lib/gha-stage.d.ts

@@ -0,0 +1,38 @@
+import { Stack } from 'aws-cdk-lib';
+import { AddStackOptions, GHAWave } from './gha-wave';
+export interface GHAStageOptions {
+    /**
+     * GitHub Actions environment name. Enables protection rules (manual approval,
+     * wait timers, branch restrictions). Set to undefined to disable.
+     * @default same as stage id
+     */
+    readonly environment?: string;
+}
+/**
+ * A stage represents a deployment environment (e.g. dev, staging, prod).
+ * Stages deploy sequentially in the order they are added to the pipeline.
+ * Each stage contains waves, which deploy sequentially within the stage.
+ */
+export declare class GHAStage {
+    readonly id: string;
+    readonly waves: GHAWave[];
+    /** GitHub Actions environment name (enables protection rules, approvals, etc.) */
+    readonly environment?: string;
+    constructor(id: string, options?: GHAStageOptions);
+    /**
+     * Add a wave to this stage. Waves deploy sequentially.
+     * Stacks within a wave deploy in parallel.
+     * @param id Wave identifier (e.g. 'Foundation', 'Platform', 'Services')
+     */
+    addWave(id: string): GHAWave;
+    /**
+     * Add a stack directly to the stage (goes into a default wave).
+     * Equivalent to adding to a single wave — all stacks deploy in parallel
+     * respecting CDK dependency ordering.
+     * @param stack A standard CDK Stack
+     * @param options Optional dependencies
+     */
+    addStack(stack: Stack, options?: AddStackOptions): Stack;
+    /** Get all stacks in this stage, in wave order. */
+    allStacks(): Stack[];
+}

package/lib/gha-stage.js

@@ -0,0 +1,51 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GHAStage = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const gha_wave_1 = require("./gha-wave");
+/**
+ * A stage represents a deployment environment (e.g. dev, staging, prod).
+ * Stages deploy sequentially in the order they are added to the pipeline.
+ * Each stage contains waves, which deploy sequentially within the stage.
+ */
+class GHAStage {
+    constructor(id, options) {
+        this.waves = [];
+        this.id = id;
+        this.environment = options?.environment ?? id;
+    }
+    /**
+     * Add a wave to this stage. Waves deploy sequentially.
+     * Stacks within a wave deploy in parallel.
+     * @param id Wave identifier (e.g. 'Foundation', 'Platform', 'Services')
+     */
+    addWave(id) {
+        const wave = new gha_wave_1.GHAWave(id);
+        this.waves.push(wave);
+        return wave;
+    }
+    /**
+     * Add a stack directly to the stage (goes into a default wave).
+     * Equivalent to adding to a single wave — all stacks deploy in parallel
+     * respecting CDK dependency ordering.
+     * @param stack A standard CDK Stack
+     * @param options Optional dependencies
+     */
+    addStack(stack, options) {
+        let defaultWave = this.waves.find(w => w.id === 'default');
+        if (!defaultWave) {
+            defaultWave = new gha_wave_1.GHAWave('default');
+            this.waves.push(defaultWave);
+        }
+        return defaultWave.addStack(stack, options);
+    }
+    /** Get all stacks in this stage, in wave order. */
+    allStacks() {
+        return this.waves.flatMap(w => w.stacks.map(e => e.stack));
+    }
+}
+exports.GHAStage = GHAStage;
+_a = JSII_RTTI_SYMBOL_1;
+GHAStage[_a] = { fqn: "@raindancers/agentl.GHAStage", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/gha-wave.d.ts

@@ -0,0 +1,24 @@
+import { Stack } from 'aws-cdk-lib';
+export interface AddStackOptions {
+    /** Stacks within this wave that this stack depends on */
+    readonly dependsOn?: Stack[];
+}
+export interface StackEntry {
+    readonly stack: Stack;
+    readonly dependsOn: Stack[];
+}
+/**
+ * A wave is a group of stacks that deploy in parallel.
+ * Waves within a stage deploy sequentially (wave 1 completes before wave 2 starts).
+ */
+export declare class GHAWave {
+    readonly id: string;
+    readonly stacks: StackEntry[];
+    constructor(id: string);
+    /**
+     * Add a stack to this wave. Stacks within a wave deploy in parallel.
+     * @param stack A standard CDK Stack
+     * @param options Optional dependencies on other stacks within this wave
+     */
+    addStack(stack: Stack, options?: AddStackOptions): Stack;
+}

package/lib/gha-wave.js

@@ -0,0 +1,31 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GHAWave = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * A wave is a group of stacks that deploy in parallel.
+ * Waves within a stage deploy sequentially (wave 1 completes before wave 2 starts).
+ */
+class GHAWave {
+    constructor(id) {
+        this.stacks = [];
+        this.id = id;
+    }
+    /**
+     * Add a stack to this wave. Stacks within a wave deploy in parallel.
+     * @param stack A standard CDK Stack
+     * @param options Optional dependencies on other stacks within this wave
+     */
+    addStack(stack, options) {
+        this.stacks.push({
+            stack: stack,
+            dependsOn: options?.dependsOn || [],
+        });
+        return stack;
+    }
+}
+exports.GHAWave = GHAWave;
+_a = JSII_RTTI_SYMBOL_1;
+GHAWave[_a] = { fqn: "@raindancers/agentl.GHAWave", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2hhLXdhdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZ2hhLXdhdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFZQTs7O0dBR0c7QUFDSCxNQUFhLE9BQU87SUFJbEIsWUFBWSxFQUFVO1FBRk4sV0FBTSxHQUFpQixFQUFFLENBQUM7UUFHeEMsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUM7SUFDZixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLFFBQVEsQ0FBQyxLQUFZLEVBQUUsT0FBeUI7UUFDckQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUM7WUFDZixLQUFLLEVBQUUsS0FBSztZQUNaLFNBQVMsRUFBRSxPQUFPLEVBQUUsU0FBUyxJQUFJLEVBQUU7U0FDcEMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDOztBQW5CSCwwQkFvQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTdGFjayB9IGZyb20gJ2F3cy1jZGstbGliJztcblxuZXhwb3J0IGludGVyZmFjZSBBZGRTdGFja09wdGlvbnMge1xuICAvKiogU3RhY2tzIHdpdGhpbiB0aGlzIHdhdmUgdGhhdCB0aGlzIHN0YWNrIGRlcGVuZHMgb24gKi9cbiAgcmVhZG9ubHkgZGVwZW5kc09uPzogU3RhY2tbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTdGFja0VudHJ5IHtcbiAgcmVhZG9ubHkgc3RhY2s6IFN0YWNrO1xuICByZWFkb25seSBkZXBlbmRzT246IFN0YWNrW107XG59XG5cbi8qKlxuICogQSB3YXZlIGlzIGEgZ3JvdXAgb2Ygc3RhY2tzIHRoYXQgZGVwbG95IGluIHBhcmFsbGVsLlxuICogV2F2ZXMgd2l0aGluIGEgc3RhZ2UgZGVwbG95IHNlcXVlbnRpYWxseSAod2F2ZSAxIGNvbXBsZXRlcyBiZWZvcmUgd2F2ZSAyIHN0YXJ0cykuXG4gKi9cbmV4cG9ydCBjbGFzcyBHSEFXYXZlIHtcbiAgcHVibGljIHJlYWRvbmx5IGlkOiBzdHJpbmc7XG4gIHB1YmxpYyByZWFkb25seSBzdGFja3M6IFN0YWNrRW50cnlbXSA9IFtdO1xuXG4gIGNvbnN0cnVjdG9yKGlkOiBzdHJpbmcpIHtcbiAgICB0aGlzLmlkID0gaWQ7XG4gIH1cblxuICAvKipcbiAgICogQWRkIGEgc3RhY2sgdG8gdGhpcyB3YXZlLiBTdGFja3Mgd2l0aGluIGEgd2F2ZSBkZXBsb3kgaW4gcGFyYWxsZWwuXG4gICAqIEBwYXJhbSBzdGFjayBBIHN0YW5kYXJkIENESyBTdGFja1xuICAgKiBAcGFyYW0gb3B0aW9ucyBPcHRpb25hbCBkZXBlbmRlbmNpZXMgb24gb3RoZXIgc3RhY2tzIHdpdGhpbiB0aGlzIHdhdmVcbiAgICovXG4gIHB1YmxpYyBhZGRTdGFjayhzdGFjazogU3RhY2ssIG9wdGlvbnM/OiBBZGRTdGFja09wdGlvbnMpOiBTdGFjayB7XG4gICAgdGhpcy5zdGFja3MucHVzaCh7XG4gICAgICBzdGFjazogc3RhY2ssXG4gICAgICBkZXBlbmRzT246IG9wdGlvbnM/LmRlcGVuZHNPbiB8fCBbXSxcbiAgICB9KTtcbiAgICByZXR1cm4gc3RhY2s7XG4gIH1cbn1cbiJdfQ==

package/lib/gha-workflow.d.ts

@@ -0,0 +1,31 @@
+import { GHAStage } from './gha-stage';
+export interface GHAWorkflowConfig {
+    /** Directory to write workflow files @default .github/workflows */
+    readonly outputDir?: string;
+    /** AWS region for CDK operations */
+    readonly awsRegion: string;
+    /** IAM role ARN to assume for deployments (OIDC) */
+    readonly deployRoleArn: string;
+    /** IAM role ARN for Bedrock analysis @default same as deployRoleArn */
+    readonly bedrockRoleArn?: string;
+    /** Bedrock region @default us-east-1 */
+    readonly bedrockRegion?: string;
+    /** Node.js version @default 22 */
+    readonly nodeVersion?: string;
+    /** Install command @default yarn install --frozen-lockfile */
+    readonly installCommand?: string;
+    /** Synth command @default npx cdk synth */
+    readonly synthCommand?: string;
+    /** Branch that triggers deploy @default main */
+    readonly deployBranch?: string;
+    /** Enable Bedrock analysis on PRs @default true */
+    readonly enableBedrockAnalysis?: boolean;
+    /** Concurrency for cdk deploy @default 5 */
+    readonly deployConcurrency?: number;
+    /** Which stage to diff on PRs @default first stage (index 0) */
+    readonly diffStageIndex?: number;
+}
+/**
+ * Generate GitHub Actions workflows for the pipeline.
+ */
+export declare function generateWorkflows(stages: GHAStage[], config: GHAWorkflowConfig): void;

package/lib/gha-workflow.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWorkflows = generateWorkflows;
+const fs = require("fs");
+const path = require("path");
+const ACTIONS_VERSION = 'v6';
+/**
+ * Generate GitHub Actions workflows for the pipeline.
+ */
+function generateWorkflows(stages, config) {
+    const outputDir = config.outputDir || '.github/workflows';
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(path.join(outputDir, 'pr-review.yml'), buildPRWorkflow(stages, config));
+    fs.writeFileSync(path.join(outputDir, 'deploy.yml'), buildDeployWorkflow(stages, config));
+}
+function buildPRWorkflow(stages, config) {
+    const nodeVersion = config.nodeVersion || '22';
+    const installCmd = config.installCommand || 'yarn install --frozen-lockfile';
+    const synthCmd = config.synthCommand || 'npx cdk synth';
+    const bedrockRegion = config.bedrockRegion || 'us-east-1';
+    const bedrockRoleArn = config.bedrockRoleArn || config.deployRoleArn;
+    const enableBedrock = config.enableBedrockAnalysis !== false;
+    const branch = config.deployBranch || 'main';
+    // Only diff the first workload stage (skip credentials-only stages if diffStageIndex not set)
+    const diffStageIdx = config.diffStageIndex ?? 1;
+    const diffStage = stages[diffStageIdx] || stages[0];
+    const diffStackNames = diffStage.allStacks().map(st => st.stackName);
+    const diffSteps = diffStackNames.map(name => [
+        '          DIFF_OUTPUT=$(npx cdk diff ' + name + ' --exclusively 2>&1 || true)',
+        '          if echo "$DIFF_OUTPUT" | grep -q "There were differences"; then',
+        '            HAS_CHANGES=true',
+        '            echo "$DIFF_OUTPUT" > "cdk.out/diffs/' + name + '.diff"',
+        '          fi',
+    ].join('\n')).join('\n');
+    const lines = [
+        'name: PR Review - Diff & Analysis',
+        '',
+        'on:',
+        '  pull_request:',
+        '    branches: [' + branch + ']',
+        '',
+        'permissions:',
+        '  id-token: write',
+        '  contents: read',
+        '  pull-requests: write',
+        '',
+        'jobs:',
+        '  review:',
+        '    runs-on: ubuntu-latest',
+        '    steps:',
+        '      - uses: actions/checkout@' + ACTIONS_VERSION,
+        '',
+        '      - uses: actions/setup-node@' + ACTIONS_VERSION,
+        '        with:',
+        '          node-version: \'' + nodeVersion + '\'',
+        '          cache: yarn',
+        '',
+        '      - run: ' + installCmd,
+        '',
+        '      - uses: aws-actions/configure-aws-credentials@v4',
+        '        with:',
+        '          role-to-assume: ' + config.deployRoleArn,
+        '          aws-region: ' + config.awsRegion,
+        '',
+        '      - name: CDK Synth',
+        '        run: ' + synthCmd,
+        '',
+        '      - name: CDK Diff (' + diffStage.id + ')',
+        '        id: diff',
+        '        run: |',
+        '          mkdir -p cdk.out/diffs',
+        '          HAS_CHANGES=false',
+        diffSteps,
+        '          echo "has_changes=$HAS_CHANGES" >> $GITHUB_OUTPUT',
+        '',
+        '      - name: Generate Diff Summary',
+        '        if: steps.diff.outputs.has_changes == \'true\'',
+        '        run: |',
+        '          echo "## 📋 CDK Diff Summary (' + diffStage.id + ')" > cdk.out/diffs/comment.md',
+        '          echo "" >> cdk.out/diffs/comment.md',
+        '          for f in cdk.out/diffs/*.diff; do',
+        '            [ -f "$f" ] || continue',
+        '            STACK=$(basename "$f" .diff)',
+        '            echo "<details>" >> cdk.out/diffs/comment.md',
+        '            echo "<summary>📦 $STACK</summary>" >> cdk.out/diffs/comment.md',
+        '            echo "" >> cdk.out/diffs/comment.md',
+        '            echo \'```diff\' >> cdk.out/diffs/comment.md',
+        '            cat "$f" >> cdk.out/diffs/comment.md',
+        '            echo \'```\' >> cdk.out/diffs/comment.md',
+        '            echo "</details>" >> cdk.out/diffs/comment.md',
+        '            echo "" >> cdk.out/diffs/comment.md',
+        '          done',
+    ];
+    if (enableBedrock) {
+        lines.push('', '      - uses: aws-actions/configure-aws-credentials@v4', '        if: steps.diff.outputs.has_changes == \'true\'', '        with:', '          role-to-assume: ' + bedrockRoleArn, '          aws-region: ' + bedrockRegion, '', '      - name: Well-Architected Analysis', '        if: steps.diff.outputs.has_changes == \'true\'', '        run: |', '          npx agentl analyze --output cdk.out/diffs/analysis.md', '          cat cdk.out/diffs/analysis.md >> cdk.out/diffs/comment.md');
+    }
+    lines.push('', '      - name: Post PR Comment', '        if: steps.diff.outputs.has_changes == \'true\'', '        uses: marocchino/sticky-pull-request-comment@v2', '        with:', '          path: cdk.out/diffs/comment.md');
+    return lines.join('\n') + '\n';
+}
+function buildDeployWorkflow(stages, config) {
+    const nodeVersion = config.nodeVersion || '22';
+    const installCmd = config.installCommand || 'yarn install --frozen-lockfile';
+    const synthCmd = config.synthCommand || 'npx cdk synth';
+    const concurrency = config.deployConcurrency || 5;
+    const branch = config.deployBranch || 'main';
+    const lines = [
+        'name: Deploy',
+        '',
+        'on:',
+        '  push:',
+        '    branches: [' + branch + ']',
+        '',
+        'permissions:',
+        '  id-token: write',
+        '  contents: read',
+        '',
+        'concurrency:',
+        '  group: deploy',
+        '  cancel-in-progress: false',
+        '',
+        'jobs:',
+        '  synth:',
+        '    runs-on: ubuntu-latest',
+        '    steps:',
+        '      - uses: actions/checkout@' + ACTIONS_VERSION,
+        '',
+        '      - uses: actions/setup-node@' + ACTIONS_VERSION,
+        '        with:',
+        '          node-version: \'' + nodeVersion + '\'',
+        '          cache: yarn',
+        '',
+        '      - run: ' + installCmd,
+        '',
+        '      - uses: aws-actions/configure-aws-credentials@v4',
+        '        with:',
+        '          role-to-assume: ' + config.deployRoleArn,
+        '          aws-region: ' + config.awsRegion,
+        '',
+        '      - name: CDK Synth',
+        '        run: ' + synthCmd,
+        '',
+        '      - uses: actions/upload-artifact@v4',
+        '        with:',
+        '          name: cdk-out',
+        '          path: cdk.out/',
+    ];
+    let previousJobId = 'synth';
+    for (let s = 0; s < stages.length; s++) {
+        const stage = stages[s];
+        const stageJobId = 'deploy_' + stage.id;
+        const deploySteps = [];
+        for (const wave of stage.waves) {
+            const stacks = wave.stacks.map(e => e.stack.stackName).join(' ');
+            deploySteps.push('', '      - name: "🌊 ' + wave.id + '"', '        run: npx cdk deploy ' + stacks + ' --require-approval never --concurrency ' + concurrency + ' --app cdk.out/');
+        }
+        lines.push('', '  ' + stageJobId + ':', '    name: "🚀 ' + stage.id + '"', '    runs-on: ubuntu-latest', '    needs: ' + previousJobId);
+        if (stage.environment) {
+            lines.push('    environment: ' + stage.environment);
+        }
+        lines.push('    steps:', '      - uses: actions/checkout@' + ACTIONS_VERSION, '', '      - uses: actions/setup-node@' + ACTIONS_VERSION, '        with:', '          node-version: \'' + nodeVersion + '\'', '          cache: yarn', '', '      - run: ' + installCmd, '', '      - uses: actions/download-artifact@v4', '        with:', '          name: cdk-out', '          path: cdk.out/', '', '      - uses: aws-actions/configure-aws-credentials@v4', '        with:', '          role-to-assume: ' + config.deployRoleArn, '          aws-region: ' + config.awsRegion, ...deploySteps);
+        previousJobId = stageJobId;
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gha-workflow.js","sourceRoot":"","sources":["../src/gha-workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { GHAStage } from './gha-stage';\n\nexport interface GHAWorkflowConfig {\n  /** Directory to write workflow files @default .github/workflows */\n  readonly outputDir?: string;\n  /** AWS region for CDK operations */\n  readonly awsRegion: string;\n  /** IAM role ARN to assume for deployments (OIDC) */\n  readonly deployRoleArn: string;\n  /** IAM role ARN for Bedrock analysis @default same as deployRoleArn */\n  readonly bedrockRoleArn?: string;\n  /** Bedrock region @default us-east-1 */\n  readonly bedrockRegion?: string;\n  /** Node.js version @default 22 */\n  readonly nodeVersion?: string;\n  /** Install command @default yarn install --frozen-lockfile */\n  readonly installCommand?: string;\n  /** Synth command @default npx cdk synth */\n  readonly synthCommand?: string;\n  /** Branch that triggers deploy @default main */\n  readonly deployBranch?: string;\n  /** Enable Bedrock analysis on PRs @default true */\n  readonly enableBedrockAnalysis?: boolean;\n  /** Concurrency for cdk deploy @default 5 */\n  readonly deployConcurrency?: number;\n  /** Which stage to diff on PRs @default first stage (index 0) */\n  readonly diffStageIndex?: number;\n}\n\nconst ACTIONS_VERSION = 'v6';\n\n/**\n * Generate GitHub Actions workflows for the pipeline.\n */\nexport function generateWorkflows(stages: GHAStage[], config: GHAWorkflowConfig): void {\n  const outputDir = config.outputDir || '.github/workflows';\n  fs.mkdirSync(outputDir, { recursive: true });\n\n  fs.writeFileSync(path.join(outputDir, 'pr-review.yml'), buildPRWorkflow(stages, config));\n  fs.writeFileSync(path.join(outputDir, 'deploy.yml'), buildDeployWorkflow(stages, config));\n}\n\nfunction buildPRWorkflow(stages: GHAStage[], config: GHAWorkflowConfig): string {\n  const nodeVersion = config.nodeVersion || '22';\n  const installCmd = config.installCommand || 'yarn install --frozen-lockfile';\n  const synthCmd = config.synthCommand || 'npx cdk synth';\n  const bedrockRegion = config.bedrockRegion || 'us-east-1';\n  const bedrockRoleArn = config.bedrockRoleArn || config.deployRoleArn;\n  const enableBedrock = config.enableBedrockAnalysis !== false;\n  const branch = config.deployBranch || 'main';\n\n  // Only diff the first workload stage (skip credentials-only stages if diffStageIndex not set)\n  const diffStageIdx = config.diffStageIndex ?? 1;\n  const diffStage = stages[diffStageIdx] || stages[0];\n  const diffStackNames = diffStage.allStacks().map(st => st.stackName);\n\n  const diffSteps = diffStackNames.map(name =>\n    [\n      '          DIFF_OUTPUT=$(npx cdk diff ' + name + ' --exclusively 2>&1 || true)',\n      '          if echo \"$DIFF_OUTPUT\" | grep -q \"There were differences\"; then',\n      '            HAS_CHANGES=true',\n      '            echo \"$DIFF_OUTPUT\" > \"cdk.out/diffs/' + name + '.diff\"',\n      '          fi',\n    ].join('\\n'),\n  ).join('\\n');\n\n  const lines: string[] = [\n    'name: PR Review - Diff & Analysis',\n    '',\n    'on:',\n    '  pull_request:',\n    '    branches: [' + branch + ']',\n    '',\n    'permissions:',\n    '  id-token: write',\n    '  contents: read',\n    '  pull-requests: write',\n    '',\n    'jobs:',\n    '  review:',\n    '    runs-on: ubuntu-latest',\n    '    steps:',\n    '      - uses: actions/checkout@' + ACTIONS_VERSION,\n    '',\n    '      - uses: actions/setup-node@' + ACTIONS_VERSION,\n    '        with:',\n    '          node-version: \\'' + nodeVersion + '\\'',\n    '          cache: yarn',\n    '',\n    '      - run: ' + installCmd,\n    '',\n    '      - uses: aws-actions/configure-aws-credentials@v4',\n    '        with:',\n    '          role-to-assume: ' + config.deployRoleArn,\n    '          aws-region: ' + config.awsRegion,\n    '',\n    '      - name: CDK Synth',\n    '        run: ' + synthCmd,\n    '',\n    '      - name: CDK Diff (' + diffStage.id + ')',\n    '        id: diff',\n    '        run: |',\n    '          mkdir -p cdk.out/diffs',\n    '          HAS_CHANGES=false',\n    diffSteps,\n    '          echo \"has_changes=$HAS_CHANGES\" >> $GITHUB_OUTPUT',\n    '',\n    '      - name: Generate Diff Summary',\n    '        if: steps.diff.outputs.has_changes == \\'true\\'',\n    '        run: |',\n    '          echo \"## 📋 CDK Diff Summary (' + diffStage.id + ')\" > cdk.out/diffs/comment.md',\n    '          echo \"\" >> cdk.out/diffs/comment.md',\n    '          for f in cdk.out/diffs/*.diff; do',\n    '            [ -f \"$f\" ] || continue',\n    '            STACK=$(basename \"$f\" .diff)',\n    '            echo \"<details>\" >> cdk.out/diffs/comment.md',\n    '            echo \"<summary>📦 $STACK</summary>\" >> cdk.out/diffs/comment.md',\n    '            echo \"\" >> cdk.out/diffs/comment.md',\n    '            echo \\'```diff\\' >> cdk.out/diffs/comment.md',\n    '            cat \"$f\" >> cdk.out/diffs/comment.md',\n    '            echo \\'```\\' >> cdk.out/diffs/comment.md',\n    '            echo \"</details>\" >> cdk.out/diffs/comment.md',\n    '            echo \"\" >> cdk.out/diffs/comment.md',\n    '          done',\n  ];\n\n  if (enableBedrock) {\n    lines.push(\n      '',\n      '      - uses: aws-actions/configure-aws-credentials@v4',\n      '        if: steps.diff.outputs.has_changes == \\'true\\'',\n      '        with:',\n      '          role-to-assume: ' + bedrockRoleArn,\n      '          aws-region: ' + bedrockRegion,\n      '',\n      '      - name: Well-Architected Analysis',\n      '        if: steps.diff.outputs.has_changes == \\'true\\'',\n      '        run: |',\n      '          npx agentl analyze --output cdk.out/diffs/analysis.md',\n      '          cat cdk.out/diffs/analysis.md >> cdk.out/diffs/comment.md',\n    );\n  }\n\n  lines.push(\n    '',\n    '      - name: Post PR Comment',\n    '        if: steps.diff.outputs.has_changes == \\'true\\'',\n    '        uses: marocchino/sticky-pull-request-comment@v2',\n    '        with:',\n    '          path: cdk.out/diffs/comment.md',\n  );\n\n  return lines.join('\\n') + '\\n';\n}\n\nfunction buildDeployWorkflow(stages: GHAStage[], config: GHAWorkflowConfig): string {\n  const nodeVersion = config.nodeVersion || '22';\n  const installCmd = config.installCommand || 'yarn install --frozen-lockfile';\n  const synthCmd = config.synthCommand || 'npx cdk synth';\n  const concurrency = config.deployConcurrency || 5;\n  const branch = config.deployBranch || 'main';\n\n  const lines: string[] = [\n    'name: Deploy',\n    '',\n    'on:',\n    '  push:',\n    '    branches: [' + branch + ']',\n    '',\n    'permissions:',\n    '  id-token: write',\n    '  contents: read',\n    '',\n    'concurrency:',\n    '  group: deploy',\n    '  cancel-in-progress: false',\n    '',\n    'jobs:',\n    '  synth:',\n    '    runs-on: ubuntu-latest',\n    '    steps:',\n    '      - uses: actions/checkout@' + ACTIONS_VERSION,\n    '',\n    '      - uses: actions/setup-node@' + ACTIONS_VERSION,\n    '        with:',\n    '          node-version: \\'' + nodeVersion + '\\'',\n    '          cache: yarn',\n    '',\n    '      - run: ' + installCmd,\n    '',\n    '      - uses: aws-actions/configure-aws-credentials@v4',\n    '        with:',\n    '          role-to-assume: ' + config.deployRoleArn,\n    '          aws-region: ' + config.awsRegion,\n    '',\n    '      - name: CDK Synth',\n    '        run: ' + synthCmd,\n    '',\n    '      - uses: actions/upload-artifact@v4',\n    '        with:',\n    '          name: cdk-out',\n    '          path: cdk.out/',\n  ];\n\n  let previousJobId = 'synth';\n\n  for (let s = 0; s < stages.length; s++) {\n    const stage = stages[s];\n    const stageJobId = 'deploy_' + stage.id;\n\n    const deploySteps: string[] = [];\n    for (const wave of stage.waves) {\n      const stacks = wave.stacks.map(e => e.stack.stackName).join(' ');\n      deploySteps.push(\n        '',\n        '      - name: \"🌊 ' + wave.id + '\"',\n        '        run: npx cdk deploy ' + stacks + ' --require-approval never --concurrency ' + concurrency + ' --app cdk.out/',\n      );\n    }\n\n    lines.push(\n      '',\n      '  ' + stageJobId + ':',\n      '    name: \"🚀 ' + stage.id + '\"',\n      '    runs-on: ubuntu-latest',\n      '    needs: ' + previousJobId,\n    );\n\n    if (stage.environment) {\n      lines.push('    environment: ' + stage.environment);\n    }\n\n    lines.push(\n      '    steps:',\n      '      - uses: actions/checkout@' + ACTIONS_VERSION,\n      '',\n      '      - uses: actions/setup-node@' + ACTIONS_VERSION,\n      '        with:',\n      '          node-version: \\'' + nodeVersion + '\\'',\n      '          cache: yarn',\n      '',\n      '      - run: ' + installCmd,\n      '',\n      '      - uses: actions/download-artifact@v4',\n      '        with:',\n      '          name: cdk-out',\n      '          path: cdk.out/',\n      '',\n      '      - uses: aws-actions/configure-aws-credentials@v4',\n      '        with:',\n      '          role-to-assume: ' + config.deployRoleArn,\n      '          aws-region: ' + config.awsRegion,\n      ...deploySteps,\n    );\n\n    previousJobId = stageJobId;\n  }\n\n  return lines.join('\\n') + '\\n';\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './gha-pipeline';
+export * from './gha-stage';
+export * from './gha-wave';
+export * from './gha-workflow';
+export * from './gha-oidc-role';
+export * from './shared';
+export * from './utils/json-patch';
+export * from './diff';
+export * from './bedrock-analysis';

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Core pipeline
+__exportStar(require("./gha-pipeline"), exports);
+__exportStar(require("./gha-stage"), exports);
+__exportStar(require("./gha-wave"), exports);
+__exportStar(require("./gha-workflow"), exports);
+__exportStar(require("./gha-oidc-role"), exports);
+__exportStar(require("./shared"), exports);
+__exportStar(require("./utils/json-patch"), exports);
+// Analysis
+__exportStar(require("./diff"), exports);
+__exportStar(require("./bedrock-analysis"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGdCQUFnQjtBQUNoQixpREFBK0I7QUFDL0IsOENBQTRCO0FBQzVCLDZDQUEyQjtBQUMzQixpREFBK0I7QUFDL0Isa0RBQWdDO0FBQ2hDLDJDQUF5QjtBQUN6QixxREFBbUM7QUFFbkMsV0FBVztBQUNYLHlDQUF1QjtBQUN2QixxREFBbUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3JlIHBpcGVsaW5lXG5leHBvcnQgKiBmcm9tICcuL2doYS1waXBlbGluZSc7XG5leHBvcnQgKiBmcm9tICcuL2doYS1zdGFnZSc7XG5leHBvcnQgKiBmcm9tICcuL2doYS13YXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZ2hhLXdvcmtmbG93JztcbmV4cG9ydCAqIGZyb20gJy4vZ2hhLW9pZGMtcm9sZSc7XG5leHBvcnQgKiBmcm9tICcuL3NoYXJlZCc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL2pzb24tcGF0Y2gnO1xuXG4vLyBBbmFseXNpc1xuZXhwb3J0ICogZnJvbSAnLi9kaWZmJztcbmV4cG9ydCAqIGZyb20gJy4vYmVkcm9jay1hbmFseXNpcyc7XG4iXX0=

package/lib/shared.d.ts

@@ -0,0 +1,10 @@
+export interface MermaidDiagramOutput {
+    /**
+     * The path where the Mermaid diagram will be saved. If not provided defaults to root
+     * */
+    readonly path?: string;
+    /**
+     * Must end in `.md`. If not provided, defaults to cdk-express-pipeline-deployment-order.md
+     * */
+    readonly fileName?: string;
+}

package/lib/shared.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3NoYXJlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBNZXJtYWlkRGlhZ3JhbU91dHB1dCB7XG4gIC8qKlxuICAgKiBUaGUgcGF0aCB3aGVyZSB0aGUgTWVybWFpZCBkaWFncmFtIHdpbGwgYmUgc2F2ZWQuIElmIG5vdCBwcm92aWRlZCBkZWZhdWx0cyB0byByb290XG4gICAqICovXG4gIHJlYWRvbmx5IHBhdGg/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIE11c3QgZW5kIGluIGAubWRgLiBJZiBub3QgcHJvdmlkZWQsIGRlZmF1bHRzIHRvIGNkay1leHByZXNzLXBpcGVsaW5lLWRlcGxveW1lbnQtb3JkZXIubWRcbiAgICogKi9cbiAgcmVhZG9ubHkgZmlsZU5hbWU/OiBzdHJpbmc7XG59Il19