@edcalderon/versioning 1.2.0 → 1.3.1

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.2.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
   }
-}
+}

package/dist/extensions/lifecycle-hooks.d.ts

@@ -1,4 +0,0 @@
-import { VersioningExtension } from '../extensions';
-declare const extension: VersioningExtension;
-export default extension;
-//# sourceMappingURL=lifecycle-hooks.d.ts.map

package/dist/extensions/npm-publish.d.ts

@@ -1,4 +0,0 @@
-import { VersioningExtension } from '../extensions';
-declare const extension: VersioningExtension;
-export default extension;
-//# sourceMappingURL=npm-publish.d.ts.map

package/dist/extensions/reentry-status-extension.d.ts

@@ -1,4 +0,0 @@
-import { VersioningExtension } from '../extensions';
-declare const extension: VersioningExtension;
-export default extension;
-//# sourceMappingURL=reentry-status-extension.d.ts.map

package/dist/extensions/sample-extension.d.ts

@@ -1,4 +0,0 @@
-import { VersioningExtension } from '../extensions';
-declare const extension: VersioningExtension;
-export default extension;
-//# sourceMappingURL=sample-extension.d.ts.map