projen-pipelines 0.2.12 → 0.2.13

package/lib/versioning/strategy.js

@@ -0,0 +1,51 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningStrategy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Composite versioning strategy that combines multiple strategies
+ */
+class VersioningStrategy {
+    /**
+     * Create a composite strategy with custom format and components
+     */
+    static create(format, components) {
+        return new VersioningStrategy(format, components);
+    }
+    /**
+     * Create a build number based strategy
+     */
+    static buildNumber(config) {
+        const prefix = config?.prefix ?? 'build';
+        return new VersioningStrategy(`${prefix}-{commit-count}-{commit-hash:8}`, {
+            commitCount: config?.commitCount ?? { countFrom: 'all', padding: 5 },
+        });
+    }
+    static gitTag(config) {
+        return new VersioningStrategy('{git-tag}', {
+            gitTag: config ?? { stripPrefix: 'v' },
+            commitCount: { countFrom: 'all' },
+        });
+    }
+    static packageJson(config) {
+        return new VersioningStrategy('{package-version}', { packageJson: config ?? {} });
+    }
+    static commitCount(config) {
+        return new VersioningStrategy('{commit-count}', {
+            commitCount: config ?? { countFrom: 'all' },
+        });
+    }
+    static commitHash() {
+        return new VersioningStrategy('{commit-hash}', {});
+    }
+    constructor(format, components) {
+        this.format = format;
+        this.components = components;
+        //
+    }
+}
+exports.VersioningStrategy = VersioningStrategy;
+_a = JSII_RTTI_SYMBOL_1;
+VersioningStrategy[_a] = { fqn: "projen-pipelines.VersioningStrategy", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/versioning/types.d.ts

@@ -0,0 +1,183 @@
+export type StageOverrides = {
+    [stage: string]: VersioningConfig;
+};
+export interface VersioningConfig {
+    /**
+     * Enable versioning feature
+     * @default true
+     */
+    readonly enabled: boolean;
+    /**
+     * Primary versioning strategy
+     */
+    readonly strategy: IVersioningStrategy;
+    /**
+     * Output configuration
+     */
+    readonly outputs: VersioningOutputConfig;
+    /**
+     * Stage-specific overrides
+     */
+    readonly stageOverrides?: StageOverrides;
+}
+export interface VersioningStrategyComponents {
+    readonly gitTag?: GitTagConfig;
+    readonly packageJson?: PackageJsonConfig;
+    readonly commitCount?: CommitCountConfig;
+}
+export interface IVersioningStrategy {
+    /**
+     * Version format template
+     * Variables: {git-tag}, {package-version}, {commit-count}, {commit-hash},
+     *            {commit-hash:8}, {branch}, {build-number}
+     */
+    readonly format: string;
+    /**
+     * Components to include
+     */
+    readonly components: VersioningStrategyComponents;
+}
+export interface GitTagConfig {
+    /**
+     * Only use annotated tags
+     */
+    readonly annotatedOnly?: boolean;
+    /**
+     * Tag pattern to match
+     */
+    readonly pattern?: string;
+    /**
+     * Strip prefix from tag
+     */
+    readonly stripPrefix?: string;
+    /**
+     * Include commits since tag
+     */
+    readonly includeSinceTag?: boolean;
+}
+export interface PackageJsonConfig {
+    /**
+     * Path to package.json
+     */
+    readonly path?: string;
+    /**
+     * Include pre-release version
+     */
+    readonly includePrerelease?: boolean;
+    /**
+     * Append commit info
+     */
+    readonly appendCommitInfo?: boolean;
+}
+export interface CommitCountConfig {
+    /**
+     * Count from: 'all' | 'branch' | 'since-tag'
+     */
+    readonly countFrom?: 'all' | 'branch' | 'since-tag';
+    /**
+     * Include branch name
+     */
+    readonly includeBranch?: boolean;
+    /**
+     * Reset on major version
+     */
+    readonly resetOnMajor?: boolean;
+    /**
+     * Padding for count
+     */
+    readonly padding?: number;
+}
+export interface VersioningOutputConfig {
+    /**
+     * Output to CloudFormation stack outputs
+     * @default true
+     */
+    readonly cloudFormation: CloudFormationOutputConfig;
+    /**
+     * Output to SSM Parameter Store
+     * @default false
+     */
+    readonly parameterStore: ParameterStoreConfig;
+}
+export interface CloudFormationOutputConfig {
+    readonly enabled: boolean;
+    readonly exportName?: string;
+}
+export interface ParameterStoreConfig {
+    readonly enabled: boolean;
+    readonly parameterName?: string;
+    readonly description?: string;
+    readonly allowOverwrite?: boolean;
+    readonly splitParameters?: boolean;
+    readonly hierarchical?: boolean;
+}
+export interface BuildNumberConfig {
+    readonly prefix?: string;
+    readonly commitCount?: CommitCountConfig;
+}
+export interface GitInfoInput {
+    readonly commitHash: string;
+    readonly branch: string;
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    readonly commitCount: number;
+}
+export interface DeploymentInfoInput {
+    readonly environment: string;
+    readonly deployedBy?: string;
+    readonly buildNumber?: string;
+}
+export interface StandardConfigOptions {
+    readonly parameterStore?: boolean | string;
+    readonly format?: 'plain' | 'structured';
+}
+export interface CloudFormationOnlyOptions {
+    readonly format?: 'plain' | 'structured';
+    readonly stackOutputName?: string;
+    readonly exportName?: string;
+}
+export interface HierarchicalParametersOptions {
+    readonly includeCloudFormation?: boolean;
+    readonly format?: 'plain' | 'structured';
+}
+export interface StandardOutputOptions {
+    readonly parameterName?: string;
+    readonly format?: 'plain' | 'structured';
+}
+export interface IVersionInfo {
+    /**
+     * Primary version string
+     */
+    readonly version: string;
+    /**
+     * Git information (ALWAYS included)
+     */
+    readonly commitHash: string;
+    readonly commitHashShort: string;
+    readonly branch: string;
+    /**
+     * Optional git tag information
+     */
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    /**
+     * Commit count information
+     */
+    readonly commitCount: number;
+    /**
+     * Package.json information (if applicable)
+     */
+    readonly packageVersion?: string;
+    /**
+     * Deployment metadata
+     */
+    readonly deployedAt: string;
+    readonly deployedBy: string;
+    readonly buildNumber?: string;
+    readonly environment: string;
+    /**
+     * Additional metadata
+     */
+    readonly repository?: string;
+    readonly pipelineVersion?: string;
+}

package/lib/versioning/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/versioning/version-info.d.ts

@@ -0,0 +1,106 @@
+import { IVersionInfo, GitInfoInput, DeploymentInfoInput } from './types';
+/**
+ * Represents complete version information for a deployment
+ */
+export declare class VersionInfo implements IVersionInfo {
+    /**
+     * Create a VersionInfo instance from raw data
+     */
+    static create(props: IVersionInfo): VersionInfo;
+    /**
+     * Create a VersionInfo instance from environment variables
+     */
+    static fromEnvironment(env: {
+        [key: string]: string;
+    }): VersionInfo;
+    /**
+     * Create a VersionInfo instance from a JSON string
+     */
+    static fromJson(json: string): VersionInfo;
+    readonly version: string;
+    readonly commitHash: string;
+    readonly commitHashShort: string;
+    readonly branch: string;
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    readonly commitCount: number;
+    readonly packageVersion?: string;
+    readonly deployedAt: string;
+    readonly deployedBy: string;
+    readonly buildNumber?: string;
+    readonly environment: string;
+    readonly repository?: string;
+    readonly pipelineVersion?: string;
+    private constructor();
+    /**
+     * Convert to plain version string
+     */
+    toString(): string;
+    /**
+     * Convert to JSON string
+     */
+    toJson(pretty?: boolean): string;
+    /**
+     * Convert to object
+     */
+    toObject(): IVersionInfo;
+    /**
+     * Get formatted version for display
+     */
+    displayVersion(): string;
+    /**
+     * Check if this version is from a tagged release
+     */
+    taggedRelease(): boolean;
+    /**
+     * Check if this version is from the main branch
+     */
+    mainBranch(): boolean;
+    /**
+     * Compare with another version
+     * Returns: -1 if this < other, 0 if equal, 1 if this > other
+     */
+    compare(other: VersionInfo): number;
+    /**
+     * Create a parameter name for SSM Parameter Store
+     */
+    parameterName(template: string): string;
+    /**
+     * Create CloudFormation export name
+     */
+    exportName(template: string): string;
+}
+/**
+ * Builder class for creating VersionInfo instances
+ */
+export declare class VersionInfoBuilder {
+    private props;
+    /**
+     * Set the version string
+     */
+    version(version: string): this;
+    /**
+     * Set git information
+     */
+    gitInfo(info: GitInfoInput): this;
+    /**
+     * Set package version
+     */
+    packageVersion(version: string): this;
+    /**
+     * Set deployment metadata
+     */
+    deploymentInfo(info: DeploymentInfoInput): this;
+    /**
+     * Set repository information
+     */
+    repository(repo: string): this;
+    /**
+     * Set pipeline version
+     */
+    pipelineVersion(version: string): this;
+    /**
+     * Build the VersionInfo instance
+     */
+    create(): VersionInfo;
+}

package/lib/versioning/version-info.js

@@ -0,0 +1,269 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionInfoBuilder = exports.VersionInfo = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Represents complete version information for a deployment
+ */
+class VersionInfo {
+    /**
+     * Create a VersionInfo instance from raw data
+     */
+    static create(props) {
+        return new VersionInfo(props);
+    }
+    /**
+     * Create a VersionInfo instance from environment variables
+     */
+    static fromEnvironment(env) {
+        const commitHash = env.GITHUB_SHA || env.GIT_COMMIT_HASH || '';
+        const commitHashShort = commitHash.substring(0, 8);
+        const props = {
+            version: env.VERSION || '0.0.0',
+            commitHash,
+            commitHashShort,
+            branch: env.GIT_BRANCH || env.GITHUB_REF_NAME || 'unknown',
+            commitCount: parseInt(env.GIT_COMMIT_COUNT || '0', 10),
+            deployedAt: new Date().toISOString(),
+            deployedBy: env.GITHUB_ACTOR || env.GITLAB_USER_LOGIN || env.USER || 'unknown',
+            environment: env.STAGE || env.ENVIRONMENT || 'unknown',
+        };
+        // Add optional fields only if they exist
+        if (env.GIT_TAG)
+            props.tag = env.GIT_TAG;
+        if (env.COMMITS_SINCE_TAG)
+            props.commitsSinceTag = parseInt(env.COMMITS_SINCE_TAG, 10);
+        if (env.PACKAGE_VERSION)
+            props.packageVersion = env.PACKAGE_VERSION;
+        if (env.GITHUB_RUN_NUMBER)
+            props.buildNumber = env.GITHUB_RUN_NUMBER;
+        else if (env.CI_PIPELINE_ID)
+            props.buildNumber = env.CI_PIPELINE_ID;
+        if (env.GITHUB_REPOSITORY)
+            props.repository = env.GITHUB_REPOSITORY;
+        else if (env.CI_PROJECT_PATH)
+            props.repository = env.CI_PROJECT_PATH;
+        if (env.PIPELINE_VERSION)
+            props.pipelineVersion = env.PIPELINE_VERSION;
+        return new VersionInfo(props);
+    }
+    /**
+     * Create a VersionInfo instance from a JSON string
+     */
+    static fromJson(json) {
+        const data = JSON.parse(json);
+        return new VersionInfo(data);
+    }
+    constructor(props) {
+        this.version = props.version;
+        this.commitHash = props.commitHash;
+        this.commitHashShort = props.commitHashShort;
+        this.branch = props.branch;
+        this.tag = props.tag;
+        this.commitsSinceTag = props.commitsSinceTag;
+        this.commitCount = props.commitCount;
+        this.packageVersion = props.packageVersion;
+        this.deployedAt = props.deployedAt;
+        this.deployedBy = props.deployedBy;
+        this.buildNumber = props.buildNumber;
+        this.environment = props.environment;
+        this.repository = props.repository;
+        this.pipelineVersion = props.pipelineVersion;
+    }
+    /**
+     * Convert to plain version string
+     */
+    toString() {
+        return this.version;
+    }
+    /**
+     * Convert to JSON string
+     */
+    toJson(pretty = false) {
+        const data = {
+            version: this.version,
+            commitHash: this.commitHash,
+            commitHashShort: this.commitHashShort,
+            branch: this.branch,
+            commitCount: this.commitCount,
+            deployedAt: this.deployedAt,
+            deployedBy: this.deployedBy,
+            environment: this.environment,
+        };
+        if (this.tag !== undefined)
+            data.tag = this.tag;
+        if (this.commitsSinceTag !== undefined)
+            data.commitsSinceTag = this.commitsSinceTag;
+        if (this.packageVersion !== undefined)
+            data.packageVersion = this.packageVersion;
+        if (this.buildNumber !== undefined)
+            data.buildNumber = this.buildNumber;
+        if (this.repository !== undefined)
+            data.repository = this.repository;
+        if (this.pipelineVersion !== undefined)
+            data.pipelineVersion = this.pipelineVersion;
+        return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    }
+    /**
+     * Convert to object
+     */
+    toObject() {
+        return JSON.parse(this.toJson());
+    }
+    /**
+     * Get formatted version for display
+     */
+    displayVersion() {
+        if (this.tag && this.commitsSinceTag === 0) {
+            return this.tag;
+        }
+        return this.version;
+    }
+    /**
+     * Check if this version is from a tagged release
+     */
+    taggedRelease() {
+        return this.tag !== undefined && this.commitsSinceTag === 0;
+    }
+    /**
+     * Check if this version is from the main branch
+     */
+    mainBranch() {
+        return this.branch === 'main' || this.branch === 'master';
+    }
+    /**
+     * Compare with another version
+     * Returns: -1 if this < other, 0 if equal, 1 if this > other
+     */
+    compare(other) {
+        // First compare by commit count
+        if (this.commitCount < other.commitCount)
+            return -1;
+        if (this.commitCount > other.commitCount)
+            return 1;
+        // Then by version string
+        return this.version.localeCompare(other.version);
+    }
+    /**
+     * Create a parameter name for SSM Parameter Store
+     */
+    parameterName(template) {
+        return template
+            .replace('{stage}', this.environment)
+            .replace('{environment}', this.environment)
+            .replace('{branch}', this.branch)
+            .replace('{version}', this.version);
+    }
+    /**
+     * Create CloudFormation export name
+     */
+    exportName(template) {
+        return template
+            .replace('{stage}', this.environment)
+            .replace('{environment}', this.environment)
+            .replace('{branch}', this.branch)
+            .replace('{version}', this.version);
+    }
+}
+exports.VersionInfo = VersionInfo;
+_a = JSII_RTTI_SYMBOL_1;
+VersionInfo[_a] = { fqn: "projen-pipelines.VersionInfo", version: "0.2.13" };
+/**
+ * Builder class for creating VersionInfo instances
+ */
+class VersionInfoBuilder {
+    constructor() {
+        this.props = {};
+    }
+    /**
+     * Set the version string
+     */
+    version(version) {
+        this.props.version = version;
+        return this;
+    }
+    /**
+     * Set git information
+     */
+    gitInfo(info) {
+        this.props.commitHash = info.commitHash;
+        this.props.commitHashShort = info.commitHash.substring(0, 8);
+        this.props.branch = info.branch;
+        this.props.tag = info.tag;
+        this.props.commitsSinceTag = info.commitsSinceTag;
+        this.props.commitCount = info.commitCount;
+        return this;
+    }
+    /**
+     * Set package version
+     */
+    packageVersion(version) {
+        this.props.packageVersion = version;
+        return this;
+    }
+    /**
+     * Set deployment metadata
+     */
+    deploymentInfo(info) {
+        this.props.environment = info.environment;
+        this.props.deployedBy = info.deployedBy ?? 'unknown';
+        this.props.buildNumber = info.buildNumber;
+        this.props.deployedAt = new Date().toISOString();
+        return this;
+    }
+    /**
+     * Set repository information
+     */
+    repository(repo) {
+        this.props.repository = repo;
+        return this;
+    }
+    /**
+     * Set pipeline version
+     */
+    pipelineVersion(version) {
+        this.props.pipelineVersion = version;
+        return this;
+    }
+    /**
+     * Build the VersionInfo instance
+     */
+    create() {
+        if (!this.props.version) {
+            throw new Error('Version is required');
+        }
+        if (!this.props.commitHash) {
+            throw new Error('Commit hash is required');
+        }
+        if (!this.props.branch) {
+            throw new Error('Branch is required');
+        }
+        if (this.props.commitCount === undefined) {
+            throw new Error('Commit count is required');
+        }
+        if (!this.props.environment) {
+            throw new Error('Environment is required');
+        }
+        return VersionInfo.create({
+            version: this.props.version,
+            commitHash: this.props.commitHash,
+            commitHashShort: this.props.commitHashShort,
+            branch: this.props.branch,
+            tag: this.props.tag,
+            commitsSinceTag: this.props.commitsSinceTag,
+            commitCount: this.props.commitCount,
+            packageVersion: this.props.packageVersion,
+            deployedAt: this.props.deployedAt ?? new Date().toISOString(),
+            deployedBy: this.props.deployedBy ?? 'unknown',
+            buildNumber: this.props.buildNumber,
+            environment: this.props.environment,
+            repository: this.props.repository,
+            pipelineVersion: this.props.pipelineVersion,
+        });
+    }
+}
+exports.VersionInfoBuilder = VersionInfoBuilder;
+_b = JSII_RTTI_SYMBOL_1;
+VersionInfoBuilder[_b] = { fqn: "projen-pipelines.VersionInfoBuilder", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version-info.js","sourceRoot":"","sources":["../../src/versioning/version-info.ts"],"names":[],"mappings":"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","sourcesContent":["import { IVersionInfo, GitInfoInput, DeploymentInfoInput } from './types';\n\n\ninterface MutableVersionInfo {\n  version?: string;\n  commitHash?: string;\n  commitHashShort?: string;\n  branch?: string;\n  tag?: string;\n  commitsSinceTag?: number;\n  commitCount?: number;\n  packageVersion?: string;\n  deployedAt?: string;\n  deployedBy?: string;\n  buildNumber?: string;\n  environment?: string;\n  repository?: string;\n  pipelineVersion?: string;\n}\n/**\n * Represents complete version information for a deployment\n */\nexport class VersionInfo implements IVersionInfo {\n\n  /**\n   * Create a VersionInfo instance from raw data\n   */\n  public static create(props: IVersionInfo): VersionInfo {\n    return new VersionInfo(props);\n  }\n\n  /**\n   * Create a VersionInfo instance from environment variables\n   */\n  public static fromEnvironment(env: { [key: string]: string }): VersionInfo {\n    const commitHash = env.GITHUB_SHA || env.GIT_COMMIT_HASH || '';\n    const commitHashShort = commitHash.substring(0, 8);\n\n    const props: MutableVersionInfo = {\n      version: env.VERSION || '0.0.0',\n      commitHash,\n      commitHashShort,\n      branch: env.GIT_BRANCH || env.GITHUB_REF_NAME || 'unknown',\n      commitCount: parseInt(env.GIT_COMMIT_COUNT || '0', 10),\n      deployedAt: new Date().toISOString(),\n      deployedBy: env.GITHUB_ACTOR || env.GITLAB_USER_LOGIN || env.USER || 'unknown',\n      environment: env.STAGE || env.ENVIRONMENT || 'unknown',\n    };\n\n    // Add optional fields only if they exist\n    if (env.GIT_TAG) props.tag = env.GIT_TAG;\n    if (env.COMMITS_SINCE_TAG) props.commitsSinceTag = parseInt(env.COMMITS_SINCE_TAG, 10);\n    if (env.PACKAGE_VERSION) props.packageVersion = env.PACKAGE_VERSION;\n    if (env.GITHUB_RUN_NUMBER) props.buildNumber = env.GITHUB_RUN_NUMBER;\n    else if (env.CI_PIPELINE_ID) props.buildNumber = env.CI_PIPELINE_ID;\n    if (env.GITHUB_REPOSITORY) props.repository = env.GITHUB_REPOSITORY;\n    else if (env.CI_PROJECT_PATH) props.repository = env.CI_PROJECT_PATH;\n    if (env.PIPELINE_VERSION) props.pipelineVersion = env.PIPELINE_VERSION;\n\n    return new VersionInfo(props as IVersionInfo);\n  }\n\n  /**\n   * Create a VersionInfo instance from a JSON string\n   */\n  public static fromJson(json: string): VersionInfo {\n    const data = JSON.parse(json);\n    return new VersionInfo(data);\n  }\n\n  public readonly version: string;\n  public readonly commitHash: string;\n  public readonly commitHashShort: string;\n  public readonly branch: string;\n  public readonly tag?: string;\n  public readonly commitsSinceTag?: number;\n  public readonly commitCount: number;\n  public readonly packageVersion?: string;\n  public readonly deployedAt: string;\n  public readonly deployedBy: string;\n  public readonly buildNumber?: string;\n  public readonly environment: string;\n  public readonly repository?: string;\n  public readonly pipelineVersion?: string;\n\n  private constructor(props: IVersionInfo) {\n    this.version = props.version;\n    this.commitHash = props.commitHash;\n    this.commitHashShort = props.commitHashShort;\n    this.branch = props.branch;\n    this.tag = props.tag;\n    this.commitsSinceTag = props.commitsSinceTag;\n    this.commitCount = props.commitCount;\n    this.packageVersion = props.packageVersion;\n    this.deployedAt = props.deployedAt;\n    this.deployedBy = props.deployedBy;\n    this.buildNumber = props.buildNumber;\n    this.environment = props.environment;\n    this.repository = props.repository;\n    this.pipelineVersion = props.pipelineVersion;\n  }\n\n  /**\n   * Convert to plain version string\n   */\n  public toString(): string {\n    return this.version;\n  }\n\n  /**\n   * Convert to JSON string\n   */\n  public toJson(pretty = false): string {\n    const data: MutableVersionInfo = {\n      version: this.version,\n      commitHash: this.commitHash,\n      commitHashShort: this.commitHashShort,\n      branch: this.branch,\n      commitCount: this.commitCount,\n      deployedAt: this.deployedAt,\n      deployedBy: this.deployedBy,\n      environment: this.environment,\n    };\n\n    if (this.tag !== undefined) data.tag = this.tag;\n    if (this.commitsSinceTag !== undefined) data.commitsSinceTag = this.commitsSinceTag;\n    if (this.packageVersion !== undefined) data.packageVersion = this.packageVersion;\n    if (this.buildNumber !== undefined) data.buildNumber = this.buildNumber;\n    if (this.repository !== undefined) data.repository = this.repository;\n    if (this.pipelineVersion !== undefined) data.pipelineVersion = this.pipelineVersion;\n\n    return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);\n  }\n\n  /**\n   * Convert to object\n   */\n  public toObject(): IVersionInfo {\n    return JSON.parse(this.toJson());\n  }\n\n  /**\n   * Get formatted version for display\n   */\n  public displayVersion(): string {\n    if (this.tag && this.commitsSinceTag === 0) {\n      return this.tag;\n    }\n    return this.version;\n  }\n\n  /**\n   * Check if this version is from a tagged release\n   */\n  public taggedRelease(): boolean {\n    return this.tag !== undefined && this.commitsSinceTag === 0;\n  }\n\n  /**\n   * Check if this version is from the main branch\n   */\n  public mainBranch(): boolean {\n    return this.branch === 'main' || this.branch === 'master';\n  }\n\n  /**\n   * Compare with another version\n   * Returns: -1 if this < other, 0 if equal, 1 if this > other\n   */\n  public compare(other: VersionInfo): number {\n    // First compare by commit count\n    if (this.commitCount < other.commitCount) return -1;\n    if (this.commitCount > other.commitCount) return 1;\n\n    // Then by version string\n    return this.version.localeCompare(other.version);\n  }\n\n  /**\n   * Create a parameter name for SSM Parameter Store\n   */\n  public parameterName(template: string): string {\n    return template\n      .replace('{stage}', this.environment)\n      .replace('{environment}', this.environment)\n      .replace('{branch}', this.branch)\n      .replace('{version}', this.version);\n  }\n\n  /**\n   * Create CloudFormation export name\n   */\n  public exportName(template: string): string {\n    return template\n      .replace('{stage}', this.environment)\n      .replace('{environment}', this.environment)\n      .replace('{branch}', this.branch)\n      .replace('{version}', this.version);\n  }\n}\n\n/**\n * Builder class for creating VersionInfo instances\n */\nexport class VersionInfoBuilder {\n  private props: MutableVersionInfo = {};\n\n  /**\n   * Set the version string\n   */\n  public version(version: string): this {\n    this.props.version = version;\n    return this;\n  }\n\n  /**\n   * Set git information\n   */\n  public gitInfo(info: GitInfoInput): this {\n    this.props.commitHash = info.commitHash;\n    this.props.commitHashShort = info.commitHash.substring(0, 8);\n    this.props.branch = info.branch;\n    this.props.tag = info.tag;\n    this.props.commitsSinceTag = info.commitsSinceTag;\n    this.props.commitCount = info.commitCount;\n    return this;\n  }\n\n  /**\n   * Set package version\n   */\n  public packageVersion(version: string): this {\n    this.props.packageVersion = version;\n    return this;\n  }\n\n  /**\n   * Set deployment metadata\n   */\n  public deploymentInfo(info: DeploymentInfoInput): this {\n    this.props.environment = info.environment;\n    this.props.deployedBy = info.deployedBy ?? 'unknown';\n    this.props.buildNumber = info.buildNumber;\n    this.props.deployedAt = new Date().toISOString();\n    return this;\n  }\n\n  /**\n   * Set repository information\n   */\n  public repository(repo: string): this {\n    this.props.repository = repo;\n    return this;\n  }\n\n  /**\n   * Set pipeline version\n   */\n  public pipelineVersion(version: string): this {\n    this.props.pipelineVersion = version;\n    return this;\n  }\n\n  /**\n   * Build the VersionInfo instance\n   */\n  public create(): VersionInfo {\n    if (!this.props.version) {\n      throw new Error('Version is required');\n    }\n    if (!this.props.commitHash) {\n      throw new Error('Commit hash is required');\n    }\n    if (!this.props.branch) {\n      throw new Error('Branch is required');\n    }\n    if (this.props.commitCount === undefined) {\n      throw new Error('Commit count is required');\n    }\n    if (!this.props.environment) {\n      throw new Error('Environment is required');\n    }\n\n    return VersionInfo.create({\n      version: this.props.version,\n      commitHash: this.props.commitHash,\n      commitHashShort: this.props.commitHashShort!,\n      branch: this.props.branch,\n      tag: this.props.tag,\n      commitsSinceTag: this.props.commitsSinceTag,\n      commitCount: this.props.commitCount,\n      packageVersion: this.props.packageVersion,\n      deployedAt: this.props.deployedAt ?? new Date().toISOString(),\n      deployedBy: this.props.deployedBy ?? 'unknown',\n      buildNumber: this.props.buildNumber,\n      environment: this.props.environment,\n      repository: this.props.repository,\n      pipelineVersion: this.props.pipelineVersion,\n    });\n  }\n}"]}

package/package.json

@@ -83,7 +83,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.12",
+  "version": "0.2.13",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [