@invarn/cibuild 1.3.16 → 1.3.18

package/dist/src/yaml/steps/registry.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Step registry - manages available YAML steps
+ */
+import type { StepExecutor, StepMetadata } from './base.js';
+export declare class UnrecognizedStepError extends Error {
+    readonly stepName: string;
+    readonly availableSteps: string[];
+    constructor(stepName: string, availableSteps: string[]);
+}
+/**
+ * Global step registry
+ */
+declare class StepRegistry {
+    private steps;
+    /**
+     * Registers a step executor
+     * @param name Step name (e.g., 'git-clone')
+     * @param executor Step executor instance
+     * @param metadata Optional step metadata
+     */
+    register(name: string, executor: StepExecutor, metadata?: StepMetadata): void;
+    /**
+     * Gets a step executor by name
+     * @param name Step name
+     * @returns Step executor
+     * @throws UnrecognizedStepError if step not found
+     */
+    getExecutor(name: string): StepExecutor;
+    /**
+     * Checks if a step is registered
+     * @param name Step name
+     * @returns True if step exists
+     */
+    has(name: string): boolean;
+    /**
+     * Gets all registered step names
+     * @returns Array of step names
+     */
+    getStepNames(): string[];
+    /**
+     * Gets metadata for a step
+     * @param name Step name
+     * @returns Step metadata or undefined
+     */
+    getMetadata(name: string): StepMetadata | undefined;
+    /**
+     * Clears all registered steps (useful for testing)
+     */
+    clear(): void;
+}
+declare const registry: StepRegistry;
+/**
+ * Registers a step in the global registry
+ * @param name Step name
+ * @param executor Step executor
+ * @param metadata Optional metadata
+ */
+export declare function registerStep(name: string, executor: StepExecutor, metadata?: StepMetadata): void;
+/**
+ * Gets a step executor from the global registry
+ * @param name Step name
+ * @returns Step executor
+ * @throws UnrecognizedStepError if step not found
+ */
+export declare function getStepExecutor(name: string): StepExecutor;
+/**
+ * Checks if a step is registered
+ * @param name Step name
+ * @returns True if step exists
+ */
+export declare function hasStep(name: string): boolean;
+/**
+ * Gets all registered step names
+ * @returns Array of step names
+ */
+export declare function getAvailableSteps(): string[];
+/**
+ * Gets metadata for a step
+ * @param name Step name
+ * @returns Step metadata or undefined
+ */
+export declare function getStepMetadata(name: string): StepMetadata | undefined;
+/**
+ * Clears the registry (for testing)
+ */
+export declare function clearRegistry(): void;
+export { registry };
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/yaml/steps/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE5D,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,QAAQ,EAAE,MAAM;aAChB,cAAc,EAAE,MAAM,EAAE;gBADxB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EAAE;CAQ3C;AAUD;;GAEG;AACH,cAAM,YAAY;IAChB,OAAO,CAAC,KAAK,CAA6C;IAE1D;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI;IAI7E;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;IASvC;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;;OAGG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAKnD;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd;AAGD,QAAA,MAAM,QAAQ,cAAqB,CAAC;AAEpC;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,YAAY,EACtB,QAAQ,CAAC,EAAE,YAAY,GACtB,IAAI,CAEN;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAE5C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEtE;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAGD,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/src/yaml/steps/registry.js

@@ -0,0 +1,125 @@
+/**
+ * Step registry - manages available YAML steps
+ */
+export class UnrecognizedStepError extends Error {
+    stepName;
+    availableSteps;
+    constructor(stepName, availableSteps) {
+        super(`Unrecognized step: '${stepName}'\n` +
+            `Supported steps: ${availableSteps.join(', ')}`);
+        this.stepName = stepName;
+        this.availableSteps = availableSteps;
+        this.name = 'UnrecognizedStepError';
+    }
+}
+/**
+ * Global step registry
+ */
+class StepRegistry {
+    steps = new Map();
+    /**
+     * Registers a step executor
+     * @param name Step name (e.g., 'git-clone')
+     * @param executor Step executor instance
+     * @param metadata Optional step metadata
+     */
+    register(name, executor, metadata) {
+        this.steps.set(name, { executor, metadata });
+    }
+    /**
+     * Gets a step executor by name
+     * @param name Step name
+     * @returns Step executor
+     * @throws UnrecognizedStepError if step not found
+     */
+    getExecutor(name) {
+        const entry = this.steps.get(name);
+        if (!entry) {
+            const availableSteps = Array.from(this.steps.keys()).sort();
+            throw new UnrecognizedStepError(name, availableSteps);
+        }
+        return entry.executor;
+    }
+    /**
+     * Checks if a step is registered
+     * @param name Step name
+     * @returns True if step exists
+     */
+    has(name) {
+        return this.steps.has(name);
+    }
+    /**
+     * Gets all registered step names
+     * @returns Array of step names
+     */
+    getStepNames() {
+        return Array.from(this.steps.keys()).sort();
+    }
+    /**
+     * Gets metadata for a step
+     * @param name Step name
+     * @returns Step metadata or undefined
+     */
+    getMetadata(name) {
+        const entry = this.steps.get(name);
+        return entry?.metadata;
+    }
+    /**
+     * Clears all registered steps (useful for testing)
+     */
+    clear() {
+        this.steps.clear();
+    }
+}
+// Global registry instance
+const registry = new StepRegistry();
+/**
+ * Registers a step in the global registry
+ * @param name Step name
+ * @param executor Step executor
+ * @param metadata Optional metadata
+ */
+export function registerStep(name, executor, metadata) {
+    registry.register(name, executor, metadata);
+}
+/**
+ * Gets a step executor from the global registry
+ * @param name Step name
+ * @returns Step executor
+ * @throws UnrecognizedStepError if step not found
+ */
+export function getStepExecutor(name) {
+    return registry.getExecutor(name);
+}
+/**
+ * Checks if a step is registered
+ * @param name Step name
+ * @returns True if step exists
+ */
+export function hasStep(name) {
+    return registry.has(name);
+}
+/**
+ * Gets all registered step names
+ * @returns Array of step names
+ */
+export function getAvailableSteps() {
+    return registry.getStepNames();
+}
+/**
+ * Gets metadata for a step
+ * @param name Step name
+ * @returns Step metadata or undefined
+ */
+export function getStepMetadata(name) {
+    return registry.getMetadata(name);
+}
+/**
+ * Clears the registry (for testing)
+ */
+export function clearRegistry() {
+    registry.clear();
+}
+// Export the registry instance for advanced usage
+export { registry };
+//# sourceMappingURL=registry.js.map

package/dist/src/yaml/steps/registry.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for step registry
+ */
+export {};
+//# sourceMappingURL=registry.test.d.ts.map

package/dist/src/yaml/steps/registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/registry.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/src/yaml/steps/registry.test.js

@@ -0,0 +1,235 @@
+/**
+ * Unit tests for step registry
+ */
+import { describe, test, expect, beforeEach } from '@jest/globals';
+import { testConfig } from './test-config.js';
+import { registerStep, getStepExecutor, hasStep, getAvailableSteps, getStepMetadata, clearRegistry, UnrecognizedStepError, } from './registry.js';
+import { BaseStepExecutor } from './base.js';
+// Mock step executor for testing
+class MockStepExecutor extends BaseStepExecutor {
+    async execute(inputs, env) {
+        return this.createScriptStep('echo "mock step"', 'mock-step');
+    }
+}
+describe('Step Registry', () => {
+    beforeEach(() => {
+        // Clear registry before each test to ensure clean state
+        clearRegistry();
+    });
+    describe('registerStep', () => {
+        test('should register a step successfully', () => {
+            const executor = new MockStepExecutor();
+            registerStep('test-step', executor);
+            expect(hasStep('test-step')).toBe(true);
+        });
+        test('should register a step with metadata', () => {
+            const executor = new MockStepExecutor();
+            const metadata = {
+                name: 'test-step',
+                description: 'A test step',
+                inputs: {
+                    test_input: {
+                        description: 'Test input',
+                        required: true,
+                    },
+                },
+            };
+            registerStep('test-step', executor, metadata);
+            expect(hasStep('test-step')).toBe(true);
+            expect(getStepMetadata('test-step')).toEqual(metadata);
+        });
+        test('should allow overwriting an existing step', () => {
+            const executor1 = new MockStepExecutor();
+            const executor2 = new MockStepExecutor();
+            registerStep('test-step', executor1);
+            registerStep('test-step', executor2);
+            expect(hasStep('test-step')).toBe(true);
+            expect(getStepExecutor('test-step')).toBe(executor2);
+        });
+    });
+    describe('getStepExecutor', () => {
+        test('should retrieve a registered step executor', () => {
+            const executor = new MockStepExecutor();
+            registerStep('test-step', executor);
+            const retrieved = getStepExecutor('test-step');
+            expect(retrieved).toBe(executor);
+        });
+        test('should throw UnrecognizedStepError for unknown step', () => {
+            expect(() => {
+                getStepExecutor('unknown-step');
+            }).toThrow(UnrecognizedStepError);
+        });
+        test('UnrecognizedStepError should include step name', () => {
+            try {
+                getStepExecutor('unknown-step');
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(UnrecognizedStepError);
+                expect(error.stepName).toBe('unknown-step');
+            }
+        });
+        test('UnrecognizedStepError should include available steps', () => {
+            registerStep('step-a', new MockStepExecutor());
+            registerStep('step-b', new MockStepExecutor());
+            try {
+                getStepExecutor('unknown-step');
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(UnrecognizedStepError);
+                const err = error;
+                expect(err.availableSteps).toContain('step-a');
+                expect(err.availableSteps).toContain('step-b');
+            }
+        });
+        test('UnrecognizedStepError message should be helpful', () => {
+            registerStep('git-clone', new MockStepExecutor());
+            registerStep('script', new MockStepExecutor());
+            try {
+                getStepExecutor('git-push');
+                expect(true).toBe(false); // Should not reach here
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(UnrecognizedStepError);
+                const message = error.message;
+                expect(message).toContain('git-push');
+                expect(message).toContain('Supported steps');
+                expect(message).toContain('git-clone');
+                expect(message).toContain('script');
+            }
+        });
+    });
+    describe('hasStep', () => {
+        test('should return true for registered step', () => {
+            registerStep('test-step', new MockStepExecutor());
+            expect(hasStep('test-step')).toBe(true);
+        });
+        test('should return false for unregistered step', () => {
+            expect(hasStep('unknown-step')).toBe(false);
+        });
+        test('should return false after clearing registry', () => {
+            registerStep('test-step', new MockStepExecutor());
+            clearRegistry();
+            expect(hasStep('test-step')).toBe(false);
+        });
+    });
+    describe('getAvailableSteps', () => {
+        test('should return empty array when no steps registered', () => {
+            expect(getAvailableSteps()).toEqual([]);
+        });
+        test('should return all registered step names', () => {
+            registerStep('step-a', new MockStepExecutor());
+            registerStep('step-b', new MockStepExecutor());
+            registerStep('step-c', new MockStepExecutor());
+            const steps = getAvailableSteps();
+            expect(steps).toHaveLength(3);
+            expect(steps).toContain('step-a');
+            expect(steps).toContain('step-b');
+            expect(steps).toContain('step-c');
+        });
+        test('should return steps in sorted order', () => {
+            registerStep('zebra', new MockStepExecutor());
+            registerStep('apple', new MockStepExecutor());
+            registerStep('mango', new MockStepExecutor());
+            const steps = getAvailableSteps();
+            expect(steps).toEqual(['apple', 'mango', 'zebra']);
+        });
+    });
+    describe('getStepMetadata', () => {
+        test('should return metadata for registered step', () => {
+            const metadata = {
+                name: 'test-step',
+                description: 'A test step',
+            };
+            registerStep('test-step', new MockStepExecutor(), metadata);
+            expect(getStepMetadata('test-step')).toEqual(metadata);
+        });
+        test('should return undefined for step without metadata', () => {
+            registerStep('test-step', new MockStepExecutor());
+            expect(getStepMetadata('test-step')).toBeUndefined();
+        });
+        test('should return undefined for unregistered step', () => {
+            expect(getStepMetadata('unknown-step')).toBeUndefined();
+        });
+    });
+    describe('clearRegistry', () => {
+        test('should remove all registered steps', () => {
+            registerStep('step-a', new MockStepExecutor());
+            registerStep('step-b', new MockStepExecutor());
+            expect(getAvailableSteps()).toHaveLength(2);
+            clearRegistry();
+            expect(getAvailableSteps()).toHaveLength(0);
+            expect(hasStep('step-a')).toBe(false);
+            expect(hasStep('step-b')).toBe(false);
+        });
+        test('should allow re-registration after clear', () => {
+            registerStep('test-step', new MockStepExecutor());
+            clearRegistry();
+            registerStep('test-step', new MockStepExecutor());
+            expect(hasStep('test-step')).toBe(true);
+        });
+    });
+    describe('Step execution', () => {
+        test('should execute registered step', async () => {
+            const executor = new MockStepExecutor();
+            registerStep('test-step', executor);
+            const retrieved = getStepExecutor('test-step');
+            const result = await retrieved.execute({}, {}, testConfig);
+            expect(result).toHaveProperty('kind', 'script');
+            expect(result).toHaveProperty('name', 'mock-step');
+            expect(result).toHaveProperty('script');
+        });
+        test('should pass inputs and env to executor', async () => {
+            class InputCapturingExecutor extends BaseStepExecutor {
+                capturedInputs;
+                capturedEnv;
+                async execute(inputs, env) {
+                    this.capturedInputs = inputs;
+                    this.capturedEnv = env;
+                    return this.createScriptStep('echo "test"', 'test');
+                }
+            }
+            const executor = new InputCapturingExecutor();
+            registerStep('test-step', executor);
+            const inputs = { test: 'value' };
+            const env = { VAR: 'test' };
+            const retrieved = getStepExecutor('test-step');
+            await retrieved.execute(inputs, env, testConfig);
+            expect(executor.capturedInputs).toEqual(inputs);
+            expect(executor.capturedEnv).toEqual(env);
+        });
+    });
+    describe('Integration scenarios', () => {
+        test('should handle multiple steps with same prefix', () => {
+            registerStep('git-clone', new MockStepExecutor());
+            registerStep('git-push', new MockStepExecutor());
+            registerStep('git-pull', new MockStepExecutor());
+            expect(hasStep('git-clone')).toBe(true);
+            expect(hasStep('git-push')).toBe(true);
+            expect(hasStep('git-pull')).toBe(true);
+            const steps = getAvailableSteps();
+            expect(steps).toEqual(['git-clone', 'git-pull', 'git-push']);
+        });
+        test('should handle case-sensitive step names', () => {
+            registerStep('Step-A', new MockStepExecutor());
+            registerStep('step-a', new MockStepExecutor());
+            expect(hasStep('Step-A')).toBe(true);
+            expect(hasStep('step-a')).toBe(true);
+            expect(getAvailableSteps()).toHaveLength(2);
+        });
+        test('should provide helpful error when typo in step name', () => {
+            registerStep('git-clone', new MockStepExecutor());
+            try {
+                getStepExecutor('git-clonee'); // Common typo
+                expect(true).toBe(false);
+            }
+            catch (error) {
+                const message = error.message;
+                expect(message).toContain('git-clonee');
+                expect(message).toContain('git-clone');
+            }
+        });
+    });
+});
+//# sourceMappingURL=registry.test.js.map

package/dist/src/yaml/steps/release.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Release steps: generate-changelog, github-release
+ */
+import { BaseStepExecutor } from './base.js';
+import type { StepDef, CIConfig } from '../../types.js';
+import type { ValidationRequirement, StepOutput } from '../validation-types.js';
+export interface GenerateChangelogInputs {
+    /** Path to write the changelog file */
+    changelog_path?: string;
+    /** Working directory containing the git repo */
+    working_dir?: string;
+}
+/**
+ * Generates changelog from git commit history since the last tag.
+ */
+export declare class GenerateChangelogStepExecutor extends BaseStepExecutor {
+    getValidationRequirements(_inputs: GenerateChangelogInputs, _env: Record<string, string>, _config: CIConfig): ValidationRequirement[];
+    getOutputs(): StepOutput[];
+    execute(inputs: GenerateChangelogInputs, _env: Record<string, string>, _config: CIConfig): Promise<StepDef>;
+}
+export interface GithubReleaseInputs {
+    /** GitHub repository (owner/repo) */
+    repository_url?: string;
+    /** Release tag name */
+    tag?: string;
+    /** Release title */
+    name?: string;
+    /** Release body / notes */
+    body?: string;
+    /** Path to changelog file to use as body (alternative to body) */
+    changelog_path?: string;
+    /** Whether this is a draft release (true/false) */
+    draft?: string;
+    /** Whether this is a pre-release (true/false) */
+    pre_release?: string;
+    /** File paths to attach as release assets (newline-separated) */
+    files_to_upload?: string;
+    /** GitHub API token */
+    api_token?: string;
+}
+/**
+ * Creates a GitHub release with optional artifact attachments using the gh CLI.
+ */
+export declare class GithubReleaseStepExecutor extends BaseStepExecutor {
+    getValidationRequirements(_inputs: GithubReleaseInputs, _env: Record<string, string>, _config: CIConfig): ValidationRequirement[];
+    getOutputs(): StepOutput[];
+    isSkippedInLocalMode(): boolean;
+    execute(inputs: GithubReleaseInputs, _env: Record<string, string>, _config: CIConfig): Promise<StepDef>;
+}
+//# sourceMappingURL=release.d.ts.map

package/dist/src/yaml/steps/release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/release.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAMhF,MAAM,WAAW,uBAAuB;IACtC,uCAAuC;IACvC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,gBAAgB;IACjE,yBAAyB,CACvB,OAAO,EAAE,uBAAuB,EAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAM1B,UAAU,IAAI,UAAU,EAAE;IAMpB,OAAO,CAAC,MAAM,EAAE,uBAAuB,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;CAqDlH;AAMD,MAAM,WAAW,mBAAmB;IAClC,qCAAqC;IACrC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uBAAuB;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2BAA2B;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uBAAuB;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,gBAAgB;IAC7D,yBAAyB,CACvB,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAM1B,UAAU,IAAI,UAAU,EAAE;IAM1B,oBAAoB,IAAI,OAAO;IAIzB,OAAO,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;CAmF9G"}

package/dist/src/yaml/steps/release.js

@@ -0,0 +1,154 @@
+/**
+ * Release steps: generate-changelog, github-release
+ */
+import { BaseStepExecutor } from './base.js';
+/**
+ * Generates changelog from git commit history since the last tag.
+ */
+export class GenerateChangelogStepExecutor extends BaseStepExecutor {
+    getValidationRequirements(_inputs, _env, _config) {
+        return [
+            this.requireCommand('git', 'git is required for changelog generation'),
+        ];
+    }
+    getOutputs() {
+        return [
+            { name: 'CIBUILD_CHANGELOG', type: 'environment', description: 'The generated changelog content' },
+        ];
+    }
+    async execute(inputs, _env, _config) {
+        const stepName = 'generate-changelog';
+        const changelogPath = this.getInput(inputs, 'changelog_path', './CHANGELOG.md');
+        const workingDir = this.getInput(inputs, 'working_dir', '.');
+        const commands = [];
+        commands.push('# generate-changelog — from git history');
+        commands.push('echo "📝 Generating changelog..."');
+        commands.push('');
+        commands.push(`cd '${this.escapeBash(workingDir)}'`);
+        commands.push('');
+        // Find the latest tag
+        commands.push('# Find the latest tag');
+        commands.push('LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")');
+        commands.push('');
+        // Generate changelog
+        commands.push('if [ -n "$LATEST_TAG" ]; then');
+        commands.push('  echo "Generating changelog since tag: $LATEST_TAG"');
+        commands.push('  CHANGELOG=$(git log "$LATEST_TAG"..HEAD --pretty=format:"- %s (%h)" --no-merges)');
+        commands.push('else');
+        commands.push('  echo "No tags found — generating changelog from all commits"');
+        commands.push('  CHANGELOG=$(git log --pretty=format:"- %s (%h)" --no-merges)');
+        commands.push('fi');
+        commands.push('');
+        // Handle empty changelog
+        commands.push('if [ -z "$CHANGELOG" ]; then');
+        commands.push('  CHANGELOG="No changes since last release."');
+        commands.push('fi');
+        commands.push('');
+        // Write to file
+        commands.push(`CHANGELOG_PATH='${this.escapeBash(changelogPath)}'`);
+        commands.push('mkdir -p "$(dirname "$CHANGELOG_PATH")"');
+        commands.push('echo "$CHANGELOG" > "$CHANGELOG_PATH"');
+        commands.push('echo "Changelog written to: $CHANGELOG_PATH"');
+        commands.push('echo "---"');
+        commands.push('echo "$CHANGELOG"');
+        commands.push('echo "---"');
+        commands.push('');
+        // Export
+        commands.push('envman add --key CIBUILD_CHANGELOG --value "$CHANGELOG"');
+        commands.push('echo "✅ Changelog generated"');
+        const script = this.createBashScriptFromCommands(commands, stepName);
+        return this.createScriptStep(script, stepName);
+    }
+}
+/**
+ * Creates a GitHub release with optional artifact attachments using the gh CLI.
+ */
+export class GithubReleaseStepExecutor extends BaseStepExecutor {
+    getValidationRequirements(_inputs, _env, _config) {
+        return [
+            this.requireCommand('gh', 'GitHub CLI (gh) is required for creating releases'),
+        ];
+    }
+    getOutputs() {
+        return [
+            { name: 'CIBUILD_RELEASE_URL', type: 'environment', description: 'URL of the created GitHub release' },
+        ];
+    }
+    isSkippedInLocalMode() {
+        return true;
+    }
+    async execute(inputs, _env, _config) {
+        const stepName = 'github-release';
+        const tag = this.getRequiredInput(inputs, 'tag', stepName);
+        const repositoryUrl = this.getInput(inputs, 'repository_url', '');
+        const name = this.getInput(inputs, 'name', '');
+        const body = this.getInput(inputs, 'body', '');
+        const changelogPath = this.getInput(inputs, 'changelog_path', '');
+        const draft = this.getInput(inputs, 'draft', 'false') === 'true';
+        const preRelease = this.getInput(inputs, 'pre_release', 'false') === 'true';
+        const filesToUpload = this.getInput(inputs, 'files_to_upload', '');
+        const apiToken = this.getInput(inputs, 'api_token', '$GITHUB_TOKEN');
+        const commands = [];
+        commands.push('# github-release — create a GitHub release');
+        commands.push('echo "🚀 Creating GitHub release..."');
+        commands.push('');
+        // Auth
+        commands.push(`export GH_TOKEN='${this.escapeBash(apiToken)}'`);
+        commands.push('');
+        // Build gh release create command
+        const flags = [];
+        flags.push(`--title '${this.escapeBash(name || tag)}'`);
+        if (body) {
+            flags.push(`--notes '${this.escapeBash(body)}'`);
+        }
+        else if (changelogPath) {
+            flags.push(`--notes-file '${this.escapeBash(changelogPath)}'`);
+        }
+        else {
+            flags.push('--generate-notes');
+        }
+        if (draft) {
+            flags.push('--draft');
+        }
+        if (preRelease) {
+            flags.push('--prerelease');
+        }
+        // Repository flag
+        let repoFlag = '';
+        if (repositoryUrl) {
+            repoFlag = ` --repo '${this.escapeBash(repositoryUrl)}'`;
+        }
+        // File attachments
+        if (filesToUpload) {
+            commands.push('# Collect files to upload');
+            commands.push(`FILES_INPUT='${this.escapeBash(filesToUpload)}'`);
+            commands.push('FILE_ARGS=""');
+            commands.push('while IFS= read -r file; do');
+            commands.push('  file=$(echo "$file" | xargs)');
+            commands.push('  [ -z "$file" ] && continue');
+            commands.push('  if [ -f "$file" ]; then');
+            commands.push('    FILE_ARGS="$FILE_ARGS \\"$file\\""');
+            commands.push('  else');
+            commands.push('    echo "⚠️  File not found: $file"');
+            commands.push('  fi');
+            commands.push('done <<< "$FILES_INPUT"');
+            commands.push('');
+        }
+        const flagStr = flags.join(' ');
+        commands.push(`TAG='${this.escapeBash(tag)}'`);
+        commands.push('');
+        if (filesToUpload) {
+            commands.push(`RELEASE_URL=$(eval gh release create "$TAG" ${flagStr}${repoFlag} $FILE_ARGS 2>&1)`);
+        }
+        else {
+            commands.push(`RELEASE_URL=$(gh release create "$TAG" ${flagStr}${repoFlag} 2>&1)`);
+        }
+        commands.push('');
+        commands.push('echo "Release URL: $RELEASE_URL"');
+        commands.push('envman add --key CIBUILD_RELEASE_URL --value "$RELEASE_URL"');
+        commands.push('echo "✅ GitHub release created"');
+        const script = this.createBashScriptFromCommands(commands, stepName);
+        return this.createScriptStep(script, stepName);
+    }
+}
+//# sourceMappingURL=release.js.map