@edcalderon/versioning 1.3.0 → 1.3.1

package/README.md

@@ -5,6 +5,7 @@ A comprehensive versioning and changelog management tool designed for monorepos
 ## Features
 
 - 🚀 Automated version bumping (patch, minor, major, prerelease)
+- 🌿 Optional branch-aware versioning (`main`, `develop`, `feature/*`, `hotfix/*`)
 - 📝 Conventional commit-based changelog generation
 - 🔄 Version synchronization across monorepo packages
 - 🎯 Works with both monorepos and single repositories
@@ -407,7 +408,41 @@ For single repositories:
   "changelogFile": "CHANGELOG.md",
   "conventionalCommits": true,
   "syncDependencies": false,
-  "ignorePackages": []
+  "ignorePackages": [],
+  "branchAwareness": {
+    "enabled": false,
+    "defaultBranch": "main",
+    "branches": {
+      "main": {
+        "versionFormat": "semantic",
+        "tagFormat": "v{version}",
+        "syncFiles": ["package.json", "version.production.json"],
+        "environment": "production",
+        "bumpStrategy": "semantic"
+      },
+      "develop": {
+        "versionFormat": "dev",
+        "tagFormat": "v{version}",
+        "syncFiles": ["version.development.json"],
+        "environment": "development",
+        "bumpStrategy": "dev-build"
+      },
+      "feature/*": {
+        "versionFormat": "feature",
+        "tagFormat": "v{version}",
+        "syncFiles": ["version.development.json"],
+        "environment": "development",
+        "bumpStrategy": "feature-branch"
+      },
+      "hotfix/*": {
+        "versionFormat": "hotfix",
+        "tagFormat": "v{version}",
+        "syncFiles": ["version.development.json"],
+        "environment": "development",
+        "bumpStrategy": "hotfix"
+      }
+    }
+  }
 }
 ```
 
@@ -431,6 +466,28 @@ For monorepos:
 - `conventionalCommits`: Whether to use conventional commits for changelog
 - `syncDependencies`: Whether to sync internal dependencies
 - `ignorePackages`: Array of package names to ignore during sync
+- `branchAwareness`: Optional branch-aware release rules and file sync targets
+- `branchAwareness.branches.<pattern>.versionFormat`: `semantic`, `dev`, `feature`, `hotfix`, or custom
+- `branchAwareness.branches.<pattern>.syncFiles`: Only these files are updated when branch-aware mode is enabled
+
+### Branch-Aware Releases
+
+Enable branch-aware mode per command:
+
+```bash
+versioning patch --branch-aware
+versioning patch --branch-aware --target-branch develop
+versioning patch --branch-aware --format dev --build 396
+versioning minor --branch-aware
+versioning major --branch-aware
+```
+
+Behavior summary:
+- Exact branch names are checked first (e.g. `main`, `develop`)
+- Wildcard patterns are checked next (e.g. `feature/*`, `hotfix/*`)
+- If no match is found, the `defaultBranch` rule is used
+- `--force-branch-aware` enables branch-aware behavior even when `branchAwareness.enabled` is `false`
+- Full config template: `packages/versioning/examples/versioning.config.branch-aware.json`
 
 ## Commands
 
@@ -471,13 +528,25 @@ versioning release 1.2.3 --message "Custom release"
 versioning release 2.0.0-beta.1 --skip-sync
 ```
 
-**Options for release commands:**
+**Options for `patch`, `minor`, and `major`:**
+- `-p, --packages <packages>`: Comma-separated list of packages to sync
+- `-m, --message <message>`: Release commit message
+- `-c, --config <file>`: Config file path (default: versioning.config.json)
+- `--branch-aware`: Enable branch-aware release behavior
+- `--force-branch-aware`: Force branch-aware mode even if disabled in config
+- `--target-branch <branch>`: Explicit branch to resolve branch rules
+- `--format <format>`: Override the configured branch version format
+- `--build <number>`: Override build number for non-semantic branch formats
+- `--no-tag`: Do not create git tag
+- `--no-commit`: Do not commit changes
+
+**Options for `release <version>`:**
 - `-p, --packages <packages>`: Comma-separated list of packages to sync
 - `-m, --message <message>`: Release commit message
 - `-c, --config <file>`: Config file path (default: versioning.config.json)
 - `--no-tag`: Do not create git tag
 - `--no-commit`: Do not commit changes
-- `--skip-sync`: Skip version synchronization (for `release` command)
+- `--skip-sync`: Skip version synchronization
 
 ### Other Commands
 
@@ -624,4 +693,4 @@ Tags should follow the format `v{major}.{minor}.{patch}` (e.g., `v1.0.0`, `v1.1.
 The `create-tag` script will:
 - Read the version from `package.json`
 - Create an annotated git tag
-- Push the tag to trigger the publish workflow
+- Push the tag to trigger the publish workflow

package/dist/cli.js

@@ -161,6 +161,11 @@ program
     .option('-p, --packages <packages>', 'Comma-separated list of packages to sync')
     .option('-m, --message <message>', 'Release commit message')
     .option('-c, --config <file>', 'Config file path', 'versioning.config.json')
+    .option('--branch-aware', 'Enable branch-aware versioning')
+    .option('--force-branch-aware', 'Force branch-aware mode even if disabled in config')
+    .option('--target-branch <branch>', 'Explicit branch to apply branch-aware rules')
+    .option('--format <format>', 'Override version format (semantic, dev, feature, hotfix)')
+    .option('--build <number>', 'Override build number for non-semantic formats', parseBuildOption)
     .option('--no-tag', 'Do not create git tag')
     .option('--no-commit', 'Do not commit changes')
     .action(async (options) => {
@@ -179,7 +184,12 @@ program
         const packages = options.packages ? options.packages.split(',').map((p) => p.trim()) : undefined;
         const newVersion = await releaseManager.patchRelease({
             packages,
-            message: options.message
+            message: options.message,
+            branchAware: options.branchAware,
+            forceBranchAware: options.forceBranchAware,
+            targetBranch: options.targetBranch,
+            format: options.format,
+            build: options.build
         });
         console.log(`✅ Patch release v${newVersion} completed`);
     }
@@ -194,6 +204,11 @@ program
     .option('-p, --packages <packages>', 'Comma-separated list of packages to sync')
     .option('-m, --message <message>', 'Release commit message')
     .option('-c, --config <file>', 'Config file path', 'versioning.config.json')
+    .option('--branch-aware', 'Enable branch-aware versioning')
+    .option('--force-branch-aware', 'Force branch-aware mode even if disabled in config')
+    .option('--target-branch <branch>', 'Explicit branch to apply branch-aware rules')
+    .option('--format <format>', 'Override version format (semantic, dev, feature, hotfix)')
+    .option('--build <number>', 'Override build number for non-semantic formats', parseBuildOption)
     .option('--no-tag', 'Do not create git tag')
     .option('--no-commit', 'Do not commit changes')
     .action(async (options) => {
@@ -212,7 +227,12 @@ program
         const packages = options.packages ? options.packages.split(',').map((p) => p.trim()) : undefined;
         const newVersion = await releaseManager.minorRelease({
             packages,
-            message: options.message
+            message: options.message,
+            branchAware: options.branchAware,
+            forceBranchAware: options.forceBranchAware,
+            targetBranch: options.targetBranch,
+            format: options.format,
+            build: options.build
         });
         console.log(`✅ Minor release v${newVersion} completed`);
     }
@@ -225,7 +245,13 @@ program
     .command('major')
     .description('Create a major release')
     .option('-p, --packages <packages>', 'Comma-separated list of packages to sync')
+    .option('-m, --message <message>', 'Release commit message')
     .option('-c, --config <file>', 'Config file path', 'versioning.config.json')
+    .option('--branch-aware', 'Enable branch-aware versioning')
+    .option('--force-branch-aware', 'Force branch-aware mode even if disabled in config')
+    .option('--target-branch <branch>', 'Explicit branch to apply branch-aware rules')
+    .option('--format <format>', 'Override version format (semantic, dev, feature, hotfix)')
+    .option('--build <number>', 'Override build number for non-semantic formats', parseBuildOption)
     .option('--no-tag', 'Do not create git tag')
     .option('--no-commit', 'Do not commit changes')
     .action(async (options) => {
@@ -244,7 +270,12 @@ program
         const packages = options.packages ? options.packages.split(',').map((p) => p.trim()) : undefined;
         const newVersion = await releaseManager.majorRelease({
             packages,
-            message: options.message
+            message: options.message,
+            branchAware: options.branchAware,
+            forceBranchAware: options.forceBranchAware,
+            targetBranch: options.targetBranch,
+            format: options.format,
+            build: options.build
         });
         console.log(`✅ Major release v${newVersion} completed`);
     }
@@ -306,7 +337,41 @@ program
             conventionalCommits: true,
             syncDependencies: false,
             ignorePackages: [],
-            extensions: [] // Add extensions array to config
+            extensions: [], // Add extensions array to config
+            branchAwareness: {
+                enabled: false,
+                defaultBranch: 'main',
+                branches: {
+                    main: {
+                        versionFormat: 'semantic',
+                        tagFormat: 'v{version}',
+                        syncFiles: ['package.json'],
+                        environment: 'production',
+                        bumpStrategy: 'semantic'
+                    },
+                    develop: {
+                        versionFormat: 'dev',
+                        tagFormat: 'v{version}',
+                        syncFiles: ['version.development.json'],
+                        environment: 'development',
+                        bumpStrategy: 'dev-build'
+                    },
+                    'feature/*': {
+                        versionFormat: 'feature',
+                        tagFormat: 'v{version}',
+                        syncFiles: ['version.development.json'],
+                        environment: 'development',
+                        bumpStrategy: 'feature-branch'
+                    },
+                    'hotfix/*': {
+                        versionFormat: 'hotfix',
+                        tagFormat: 'v{version}',
+                        syncFiles: ['version.development.json'],
+                        environment: 'development',
+                        bumpStrategy: 'hotfix'
+                    }
+                }
+            }
         };
         await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
         console.log('✅ Initialized versioning config at versioning.config.json');
@@ -322,6 +387,13 @@ async function loadConfig(configPath) {
     }
     return await fs.readJson(configPath);
 }
+function parseBuildOption(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`Invalid build number "${value}". Use a non-negative integer.`);
+    }
+    return parsed;
+}
 async function main() {
     try {
         // Load and register extensions

package/dist/release.d.ts

@@ -17,17 +17,21 @@ export declare class ReleaseManager {
         skipSync?: boolean;
     }): Promise<void>;
     private publishPackages;
-    patchRelease(options?: {
-        packages?: string[];
-        message?: string;
-    }): Promise<string>;
-    minorRelease(options?: {
-        packages?: string[];
-        message?: string;
-    }): Promise<string>;
-    majorRelease(options?: {
-        packages?: string[];
-        message?: string;
-    }): Promise<string>;
+    patchRelease(options?: ReleaseOptions): Promise<string>;
+    minorRelease(options?: ReleaseOptions): Promise<string>;
+    majorRelease(options?: ReleaseOptions): Promise<string>;
+    private shouldUseBranchAwareFlow;
+    private releaseBranchAware;
+}
+interface ReleaseOptions {
+    message?: string;
+    packages?: string[];
+    skipSync?: boolean;
+    branchAware?: boolean;
+    forceBranchAware?: boolean;
+    targetBranch?: string;
+    format?: string;
+    build?: number;
 }
+export {};
 //# sourceMappingURL=release.d.ts.map

package/dist/release.js

@@ -81,21 +81,55 @@ class ReleaseManager {
         console.log('Publishing packages:', packages || 'all');
     }
     async patchRelease(options = {}) {
-        const currentVersion = await this.config.versionManager.getCurrentVersion();
+        if (this.shouldUseBranchAwareFlow(options)) {
+            return await this.releaseBranchAware('patch', options);
+        }
         const newVersion = await this.config.versionManager.bumpVersion('patch');
         await this.release(newVersion, options);
         return newVersion;
     }
     async minorRelease(options = {}) {
+        if (this.shouldUseBranchAwareFlow(options)) {
+            return await this.releaseBranchAware('minor', options);
+        }
         const newVersion = await this.config.versionManager.bumpVersion('minor');
         await this.release(newVersion, options);
         return newVersion;
     }
     async majorRelease(options = {}) {
+        if (this.shouldUseBranchAwareFlow(options)) {
+            return await this.releaseBranchAware('major', options);
+        }
         const newVersion = await this.config.versionManager.bumpVersion('major');
         await this.release(newVersion, options);
         return newVersion;
     }
+    shouldUseBranchAwareFlow(options) {
+        return options.branchAware === true
+            || options.forceBranchAware === true
+            || typeof options.targetBranch === 'string'
+            || typeof options.format === 'string'
+            || typeof options.build === 'number';
+    }
+    async releaseBranchAware(releaseType, options) {
+        const result = await this.config.versionManager.bumpVersionBranchAware(releaseType, {
+            targetBranch: options.targetBranch,
+            forceBranchAware: options.forceBranchAware,
+            format: options.format,
+            build: options.build
+        });
+        await this.config.changelogManager.generate();
+        if (this.config.createCommit) {
+            await this.config.versionManager.commitChanges(result.version);
+        }
+        if (this.config.createTag) {
+            await this.config.versionManager.createGitTagWithFormat(result.version, result.tagFormat, options.message);
+        }
+        if (this.config.publish) {
+            await this.publishPackages(options.packages);
+        }
+        return result.version;
+    }
 }
 exports.ReleaseManager = ReleaseManager;
 //# sourceMappingURL=release.js.map

package/dist/versioning.d.ts

@@ -1,10 +1,37 @@
 import * as semver from 'semver';
+export interface BranchRuleConfig {
+    versionFormat?: 'semantic' | 'dev' | 'feature' | 'hotfix' | string;
+    tagFormat?: string;
+    syncFiles?: string[];
+    environment?: string;
+    bumpStrategy?: 'semantic' | 'dev-build' | 'feature-branch' | 'hotfix' | string;
+}
+export interface BranchAwarenessConfig {
+    enabled?: boolean;
+    defaultBranch?: string;
+    branches?: Record<string, BranchRuleConfig>;
+}
+export interface BranchAwareBumpOptions {
+    targetBranch?: string;
+    forceBranchAware?: boolean;
+    format?: string;
+    build?: number;
+}
+export interface BranchAwareBumpResult {
+    version: string;
+    branch: string;
+    matchPattern: string;
+    versionFormat: string;
+    tagFormat: string;
+    syncFiles: string[];
+}
 export interface VersionConfig {
     rootPackageJson: string;
     packages: string[];
     changelogFile?: string;
     conventionalCommits?: boolean;
     extensionConfig?: Record<string, any>;
+    branchAwareness?: BranchAwarenessConfig;
 }
 export declare class VersionManager {
     private config;
@@ -12,9 +39,30 @@ export declare class VersionManager {
     constructor(config: VersionConfig);
     getCurrentVersion(): Promise<string>;
     bumpVersion(releaseType: semver.ReleaseType, preRelease?: string): Promise<string>;
+    bumpVersionBranchAware(releaseType: semver.ReleaseType, options?: BranchAwareBumpOptions): Promise<BranchAwareBumpResult>;
     updateVersion(newVersion: string): Promise<void>;
     private updatePackageJson;
     createGitTag(version: string, message?: string): Promise<void>;
+    createGitTagWithFormat(version: string, tagFormat?: string, message?: string): Promise<string>;
     commitChanges(version: string): Promise<void>;
+    private getCurrentBranch;
+    private resolveBranchConfig;
+    private getBranchAwarenessConfig;
+    private getDefaultBranchRules;
+    private normalizeBranchRule;
+    private getDefaultBumpStrategy;
+    private buildBranchAwareVersion;
+    private shouldBumpSemantic;
+    private coerceBaseVersion;
+    private incrementSemanticVersion;
+    private resolveBuildNumber;
+    private getDefaultSyncFiles;
+    private applyVersionFormat;
+    private extractBuildNumber;
+    private readVersionFromFile;
+    private updateVersionFile;
+    private matchesPattern;
+    private escapeRegex;
+    private renderTag;
 }
 //# sourceMappingURL=versioning.d.ts.map

package/dist/versioning.js

@@ -65,6 +65,32 @@ class VersionManager {
         await this.updateVersion(newVersion);
         return newVersion;
     }
+    async bumpVersionBranchAware(releaseType, options = {}) {
+        if (options.build !== undefined && (!Number.isInteger(options.build) || options.build < 0)) {
+            throw new Error(`Invalid build number "${options.build}". Expected a non-negative integer.`);
+        }
+        const branch = options.targetBranch || await this.getCurrentBranch();
+        const { matchPattern, resolvedConfig } = this.resolveBranchConfig(branch, options.forceBranchAware === true);
+        const versionFormat = options.format || resolvedConfig.versionFormat;
+        const version = await this.buildBranchAwareVersion(releaseType, branch, versionFormat, resolvedConfig, options.build);
+        const syncFiles = resolvedConfig.syncFiles.length > 0
+            ? resolvedConfig.syncFiles
+            : this.getDefaultSyncFiles(versionFormat);
+        if (syncFiles.length === 0) {
+            throw new Error(`No sync files configured for branch "${branch}".`);
+        }
+        for (const filePath of syncFiles) {
+            await this.updateVersionFile(filePath, version);
+        }
+        return {
+            version,
+            branch,
+            matchPattern,
+            versionFormat,
+            tagFormat: resolvedConfig.tagFormat,
+            syncFiles
+        };
+    }
     async updateVersion(newVersion) {
         // Update root package.json
         await this.updatePackageJson(this.config.rootPackageJson, newVersion);
@@ -82,8 +108,13 @@ class VersionManager {
         await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
     }
     async createGitTag(version, message) {
-        const tagMessage = message || `Release v${version}`;
-        await this.git.addAnnotatedTag(`v${version}`, tagMessage);
+        await this.createGitTagWithFormat(version, 'v{version}', message);
+    }
+    async createGitTagWithFormat(version, tagFormat = 'v{version}', message) {
+        const tagName = this.renderTag(tagFormat, version);
+        const tagMessage = message || `Release ${tagName}`;
+        await this.git.addAnnotatedTag(tagName, tagMessage);
+        return tagName;
     }
     async commitChanges(version) {
         const commitMessage = this.config.conventionalCommits
@@ -92,6 +123,286 @@ class VersionManager {
         await this.git.add('.');
         await this.git.commit(commitMessage);
     }
+    async getCurrentBranch() {
+        const branch = (await this.git.revparse(['--abbrev-ref', 'HEAD'])).trim();
+        if (!branch) {
+            throw new Error('Unable to detect current Git branch.');
+        }
+        return branch;
+    }
+    resolveBranchConfig(branch, forceBranchAware) {
+        const branchAwareness = this.getBranchAwarenessConfig(forceBranchAware);
+        const { branches } = branchAwareness;
+        if (branches[branch]) {
+            return {
+                matchPattern: branch,
+                resolvedConfig: this.normalizeBranchRule(branches[branch])
+            };
+        }
+        const wildcardPatterns = Object.keys(branches)
+            .filter((pattern) => pattern.includes('*'))
+            .sort((a, b) => b.length - a.length);
+        for (const pattern of wildcardPatterns) {
+            if (this.matchesPattern(branch, pattern)) {
+                return {
+                    matchPattern: pattern,
+                    resolvedConfig: this.normalizeBranchRule(branches[pattern])
+                };
+            }
+        }
+        const fallbackPattern = branchAwareness.defaultBranch;
+        if (fallbackPattern && branches[fallbackPattern]) {
+            return {
+                matchPattern: fallbackPattern,
+                resolvedConfig: this.normalizeBranchRule(branches[fallbackPattern])
+            };
+        }
+        throw new Error(`No branch configuration matched "${branch}".`);
+    }
+    getBranchAwarenessConfig(forceBranchAware) {
+        const configured = this.config.branchAwareness;
+        const defaultBranch = configured?.defaultBranch || 'main';
+        const configuredBranches = configured?.branches && Object.keys(configured.branches).length > 0
+            ? configured.branches
+            : this.getDefaultBranchRules(defaultBranch);
+        if (!configured?.enabled && !forceBranchAware) {
+            throw new Error('Branch awareness is not enabled in versioning.config.json.');
+        }
+        return {
+            defaultBranch,
+            branches: configuredBranches
+        };
+    }
+    getDefaultBranchRules(defaultBranch) {
+        const rootPackageJson = this.config.rootPackageJson || 'package.json';
+        const defaults = {
+            main: {
+                versionFormat: 'semantic',
+                tagFormat: 'v{version}',
+                syncFiles: [rootPackageJson],
+                environment: 'production',
+                bumpStrategy: 'semantic'
+            },
+            develop: {
+                versionFormat: 'dev',
+                tagFormat: 'v{version}',
+                syncFiles: ['version.development.json'],
+                environment: 'development',
+                bumpStrategy: 'dev-build'
+            },
+            'feature/*': {
+                versionFormat: 'feature',
+                tagFormat: 'v{version}',
+                syncFiles: ['version.development.json'],
+                environment: 'development',
+                bumpStrategy: 'feature-branch'
+            },
+            'hotfix/*': {
+                versionFormat: 'hotfix',
+                tagFormat: 'v{version}',
+                syncFiles: ['version.development.json'],
+                environment: 'development',
+                bumpStrategy: 'hotfix'
+            }
+        };
+        if (!defaults[defaultBranch]) {
+            defaults[defaultBranch] = {
+                versionFormat: 'semantic',
+                tagFormat: 'v{version}',
+                syncFiles: [rootPackageJson],
+                environment: 'production',
+                bumpStrategy: 'semantic'
+            };
+        }
+        return defaults;
+    }
+    normalizeBranchRule(branchRule) {
+        const versionFormat = branchRule?.versionFormat || 'semantic';
+        return {
+            ...branchRule,
+            versionFormat,
+            tagFormat: branchRule?.tagFormat || 'v{version}',
+            syncFiles: branchRule?.syncFiles || [],
+            bumpStrategy: branchRule?.bumpStrategy || this.getDefaultBumpStrategy(versionFormat)
+        };
+    }
+    getDefaultBumpStrategy(versionFormat) {
+        switch (versionFormat) {
+            case 'semantic':
+                return 'semantic';
+            case 'feature':
+                return 'feature-branch';
+            case 'hotfix':
+                return 'hotfix';
+            case 'dev':
+            default:
+                return 'dev-build';
+        }
+    }
+    async buildBranchAwareVersion(releaseType, branch, versionFormat, branchConfig, explicitBuild) {
+        const currentVersion = await this.getCurrentVersion();
+        const baseVersion = this.coerceBaseVersion(currentVersion);
+        const shouldBumpSemantic = this.shouldBumpSemantic(releaseType, versionFormat, branchConfig.bumpStrategy);
+        const semanticVersion = shouldBumpSemantic ? this.incrementSemanticVersion(baseVersion, releaseType) : baseVersion;
+        if (versionFormat === 'semantic') {
+            return semanticVersion;
+        }
+        const buildNumber = explicitBuild ?? await this.resolveBuildNumber(branchConfig.syncFiles, versionFormat, branch);
+        return this.applyVersionFormat(versionFormat, semanticVersion, branch, buildNumber);
+    }
+    shouldBumpSemantic(releaseType, versionFormat, bumpStrategy) {
+        if (versionFormat === 'semantic') {
+            return true;
+        }
+        if (bumpStrategy === 'semantic') {
+            return true;
+        }
+        return releaseType !== 'patch';
+    }
+    coerceBaseVersion(version) {
+        const parsed = semver.parse(version) || semver.coerce(version);
+        if (!parsed) {
+            throw new Error(`Unable to parse semantic base version from "${version}".`);
+        }
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+    }
+    incrementSemanticVersion(version, releaseType) {
+        const incremented = semver.inc(version, releaseType);
+        if (!incremented) {
+            throw new Error(`Invalid semantic version bump: ${releaseType} from ${version}`);
+        }
+        return incremented;
+    }
+    async resolveBuildNumber(syncFiles, versionFormat, branch) {
+        const candidateFiles = syncFiles.length > 0 ? syncFiles : this.getDefaultSyncFiles(versionFormat);
+        let highestBuild = 0;
+        for (const filePath of candidateFiles) {
+            const existingVersion = await this.readVersionFromFile(filePath);
+            if (!existingVersion) {
+                continue;
+            }
+            const existingBuild = this.extractBuildNumber(existingVersion, versionFormat, branch);
+            if (existingBuild !== null) {
+                highestBuild = Math.max(highestBuild, existingBuild);
+            }
+        }
+        const rootVersion = await this.getCurrentVersion();
+        const rootBuild = this.extractBuildNumber(rootVersion, versionFormat, branch);
+        if (rootBuild !== null) {
+            highestBuild = Math.max(highestBuild, rootBuild);
+        }
+        return highestBuild + 1;
+    }
+    getDefaultSyncFiles(versionFormat) {
+        if (versionFormat === 'semantic') {
+            return [this.config.rootPackageJson];
+        }
+        return ['version.development.json'];
+    }
+    applyVersionFormat(versionFormat, semanticVersion, branch, build) {
+        if (versionFormat === 'dev') {
+            return `${semanticVersion}-dev.${build}`;
+        }
+        if (versionFormat === 'feature' || versionFormat === 'hotfix') {
+            return `${semanticVersion}-${branch}.${build}`;
+        }
+        const normalizedFormat = versionFormat.includes('{branch}')
+            ? versionFormat.replace(/\{branch\}/g, branch)
+            : versionFormat;
+        return `${semanticVersion}-${normalizedFormat}.${build}`;
+    }
+    extractBuildNumber(version, versionFormat, branch) {
+        let match = null;
+        if (versionFormat === 'dev') {
+            match = version.match(/-dev\.(\d+)$/);
+        }
+        else if (versionFormat === 'feature') {
+            match = version.match(/-feature\/.+\.(\d+)$/);
+        }
+        else if (versionFormat === 'hotfix') {
+            match = version.match(/-hotfix\/.+\.(\d+)$/);
+        }
+        else {
+            const normalizedFormat = versionFormat.includes('{branch}')
+                ? versionFormat.replace(/\{branch\}/g, branch)
+                : versionFormat;
+            const escapedFormat = this.escapeRegex(normalizedFormat);
+            match = version.match(new RegExp(`-${escapedFormat}\\.(\\d+)$`));
+        }
+        if (!match) {
+            return null;
+        }
+        return Number.parseInt(match[1], 10);
+    }
+    async readVersionFromFile(filePath) {
+        if (!(await fs.pathExists(filePath))) {
+            return null;
+        }
+        const extension = path.extname(filePath).toLowerCase();
+        if (extension === '.json') {
+            try {
+                const jsonContent = await fs.readJson(filePath);
+                if (typeof jsonContent === 'string') {
+                    return jsonContent;
+                }
+                if (jsonContent && typeof jsonContent === 'object') {
+                    const version = jsonContent.version;
+                    if (typeof version === 'string') {
+                        return version;
+                    }
+                }
+            }
+            catch {
+                return null;
+            }
+            return null;
+        }
+        const content = await fs.readFile(filePath, 'utf8');
+        const normalized = content.trim();
+        return normalized.length > 0 ? normalized : null;
+    }
+    async updateVersionFile(filePath, version) {
+        await fs.ensureDir(path.dirname(filePath));
+        const extension = path.extname(filePath).toLowerCase();
+        if (extension === '.json') {
+            let jsonContent = {};
+            if (await fs.pathExists(filePath)) {
+                try {
+                    jsonContent = await fs.readJson(filePath);
+                }
+                catch {
+                    jsonContent = {};
+                }
+            }
+            if (!jsonContent || typeof jsonContent !== 'object' || Array.isArray(jsonContent)) {
+                jsonContent = {};
+            }
+            const nextContent = jsonContent;
+            nextContent.version = version;
+            await fs.writeJson(filePath, nextContent, { spaces: 2 });
+            return;
+        }
+        await fs.writeFile(filePath, `${version}\n`, 'utf8');
+    }
+    matchesPattern(branch, pattern) {
+        if (!pattern.includes('*')) {
+            return branch === pattern;
+        }
+        const escapedPattern = pattern
+            .split('*')
+            .map((part) => this.escapeRegex(part))
+            .join('.*');
+        const regex = new RegExp(`^${escapedPattern}$`);
+        return regex.test(branch);
+    }
+    escapeRegex(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    renderTag(tagFormat, version) {
+        return tagFormat.includes('{version}')
+            ? tagFormat.replace(/\{version\}/g, version)
+            : tagFormat;
+    }
 }
 exports.VersionManager = VersionManager;
 //# sourceMappingURL=versioning.js.map

package/examples/versioning.config.branch-aware.json

@@ -0,0 +1,51 @@
+{
+  "rootPackageJson": "package.json",
+  "packages": [],
+  "changelogFile": "CHANGELOG.md",
+  "conventionalCommits": true,
+  "syncDependencies": false,
+  "ignorePackages": [],
+  "branchAwareness": {
+    "enabled": true,
+    "defaultBranch": "main",
+    "branches": {
+      "main": {
+        "versionFormat": "semantic",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "package.json",
+          "version.production.json"
+        ],
+        "environment": "production",
+        "bumpStrategy": "semantic"
+      },
+      "develop": {
+        "versionFormat": "dev",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "version.development.json"
+        ],
+        "environment": "development",
+        "bumpStrategy": "dev-build"
+      },
+      "feature/*": {
+        "versionFormat": "feature",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "version.development.json"
+        ],
+        "environment": "development",
+        "bumpStrategy": "feature-branch"
+      },
+      "hotfix/*": {
+        "versionFormat": "hotfix",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "version.development.json"
+        ],
+        "environment": "development",
+        "bumpStrategy": "hotfix"
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edcalderon/versioning",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "A comprehensive versioning and changelog management tool for monorepos",
   "main": "dist/index.js",
   "bin": {
@@ -78,4 +78,4 @@
     "url": "git+https://github.com/edcalderon/my-second-brain.git",
     "directory": "packages/versioning"
   }
-}
+}

package/versioning.config.json

@@ -5,6 +5,49 @@
   "conventionalCommits": true,
   "syncDependencies": false,
   "ignorePackages": [],
+  "branchAwareness": {
+    "enabled": false,
+    "defaultBranch": "main",
+    "branches": {
+      "main": {
+        "versionFormat": "semantic",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "package.json",
+          "version.production.json"
+        ],
+        "environment": "production",
+        "bumpStrategy": "semantic"
+      },
+      "develop": {
+        "versionFormat": "dev",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "version.development.json"
+        ],
+        "environment": "development",
+        "bumpStrategy": "dev-build"
+      },
+      "feature/*": {
+        "versionFormat": "feature",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "version.development.json"
+        ],
+        "environment": "development",
+        "bumpStrategy": "feature-branch"
+      },
+      "hotfix/*": {
+        "versionFormat": "hotfix",
+        "tagFormat": "v{version}",
+        "syncFiles": [
+          "version.development.json"
+        ],
+        "environment": "development",
+        "bumpStrategy": "hotfix"
+      }
+    }
+  },
   "changelog": {
     "preset": "angular",
     "releaseCount": 0
@@ -12,4 +55,4 @@
   "sync": {
     "includeRoot": true
   }
-}
+}