@edcalderon/versioning 1.3.0 → 1.4.0

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

@@ -40,6 +40,7 @@ const versioning_1 = require("./versioning");
 const changelog_1 = require("./changelog");
 const sync_1 = require("./sync");
 const release_1 = require("./release");
+const status_1 = require("./status");
 const extensions_1 = require("./extensions");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const pkg = require('../package.json');
@@ -155,12 +156,46 @@ program
         process.exit(1);
     }
 });
+program
+    .command('status')
+    .alias('info')
+    .description('Display version and sync status report')
+    .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+    .option('--json', 'output as JSON')
+    .option('--dot', 'output as Graphviz DOT format')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const statusManager = new status_1.StatusManager(config);
+        if (options.json) {
+            const json = await statusManager.getJSON();
+            console.log(json);
+        }
+        else if (options.dot) {
+            const dot = await statusManager.getDOT();
+            console.log(dot);
+        }
+        else {
+            const report = await statusManager.formatConsole();
+            console.log(report);
+        }
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
 program
     .command('patch')
     .description('Create a patch 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) => {
@@ -179,7 +214,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 +234,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 +257,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 +275,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 +300,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 +367,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 +417,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/index.d.ts

@@ -2,4 +2,5 @@ export * from './versioning';
 export * from './changelog';
 export * from './sync';
 export * from './release';
+export * from './status';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -18,4 +18,5 @@ __exportStar(require("./versioning"), exports);
 __exportStar(require("./changelog"), exports);
 __exportStar(require("./sync"), exports);
 __exportStar(require("./release"), exports);
+__exportStar(require("./status"), exports);
 //# sourceMappingURL=index.js.map

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/status.d.ts

@@ -0,0 +1,62 @@
+export interface AppStatus {
+    name: string;
+    version: string;
+    status: 'sync' | 'stale' | 'newer';
+    target: string;
+}
+export interface PackageStatus {
+    name: string;
+    version: string;
+    status: 'sync' | 'stale' | 'newer';
+}
+export interface StatusReport {
+    timestamp: string;
+    cli: {
+        installed: string;
+        latest: string;
+        updateAvailable: boolean;
+    };
+    sync: {
+        currentTarget: string;
+        isSynced: boolean;
+        syncedPackages: number;
+        totalPackages: number;
+        lastUpdated: string;
+    };
+    apps: AppStatus[];
+    packages: PackageStatus[];
+    dependencies: {
+        circularCount: number;
+        staleCount: number;
+        healthStatus: 'healthy' | 'warning' | 'critical';
+    };
+    environment: {
+        nodeVersion: string;
+        pnpmVersion: string;
+        gitAvailable: boolean;
+        configValid: boolean;
+    };
+    lastRelease: {
+        version: string;
+        date: string;
+        commitsSince: number;
+    };
+    overallStatus: 'healthy' | 'warning' | 'critical';
+}
+export declare class StatusManager {
+    private config;
+    private rootDir;
+    constructor(config: any, rootDir?: string);
+    getStatus(): Promise<StatusReport>;
+    private getAppStatuses;
+    private getPackageStatuses;
+    private getEnvironmentInfo;
+    private getPnpmVersion;
+    private isGitAvailable;
+    private getLastReleaseInfo;
+    formatTable(header: string[], rows: string[][]): string;
+    formatConsole(): Promise<string>;
+    getJSON(): Promise<string>;
+    getDOT(): Promise<string>;
+}
+//# sourceMappingURL=status.d.ts.map

package/dist/status.js

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const versioning_1 = require("./versioning");
+const sync_1 = require("./sync");
+class StatusManager {
+    constructor(config, rootDir = process.cwd()) {
+        this.config = config;
+        this.rootDir = rootDir;
+    }
+    async getStatus() {
+        const timestamp = new Date().toISOString();
+        const versionManager = new versioning_1.VersionManager(this.config);
+        const syncManager = new sync_1.SyncManager(this.config);
+        // Get CLI version
+        const pkgPath = path.join(this.rootDir, 'packages/versioning/package.json');
+        const pkgJson = await fs.readJson(pkgPath).catch(() => ({ version: '0.0.0' }));
+        const cliVersion = pkgJson.version || '0.0.0';
+        // Get root package version
+        const rootPkgPath = path.join(this.rootDir, 'package.json');
+        const rootPkg = await fs.readJson(rootPkgPath).catch(() => ({ version: '0.0.0' }));
+        const targetVersion = rootPkg.version || this.config.targetVersion || '0.0.0';
+        // Get sync status
+        const syncValidation = await syncManager.validateSync();
+        const isSynced = syncValidation.valid;
+        // Get app statuses
+        const apps = await this.getAppStatuses(targetVersion);
+        // Get package statuses
+        const packages = await this.getPackageStatuses(targetVersion);
+        // Get environment info
+        const environment = this.getEnvironmentInfo();
+        // Get last release info
+        const lastRelease = this.getLastReleaseInfo();
+        // Calculate overall health
+        const staleCount = packages.filter(p => p.status === 'stale').length + apps.filter(a => a.status === 'stale').length;
+        const healthStatus = staleCount === 0 ? 'healthy' : staleCount > 2 ? 'critical' : 'warning';
+        const overallStatus = isSynced && staleCount === 0 ? 'healthy' : 'warning';
+        return {
+            timestamp,
+            cli: {
+                installed: cliVersion,
+                latest: cliVersion, // Would fetch from npm in real scenario
+                updateAvailable: false,
+            },
+            sync: {
+                currentTarget: targetVersion,
+                isSynced,
+                syncedPackages: isSynced ? packages.length : packages.filter(p => p.status === 'sync').length,
+                totalPackages: packages.length,
+                lastUpdated: timestamp,
+            },
+            apps,
+            packages,
+            dependencies: {
+                circularCount: 0,
+                staleCount,
+                healthStatus,
+            },
+            environment,
+            lastRelease,
+            overallStatus,
+        };
+    }
+    async getAppStatuses(targetVersion) {
+        const appsDir = path.join(this.rootDir, 'apps');
+        if (!await fs.pathExists(appsDir))
+            return [];
+        const appDirs = await fs.readdir(appsDir);
+        const statuses = [];
+        for (const appName of appDirs) {
+            const pkgPath = path.join(appsDir, appName, 'package.json');
+            if (await fs.pathExists(pkgPath)) {
+                const pkg = await fs.readJson(pkgPath);
+                const version = pkg.version || '0.0.0';
+                const status = version === targetVersion ? 'sync' : version > targetVersion ? 'newer' : 'stale';
+                statuses.push({ name: appName, version, status, target: targetVersion });
+            }
+        }
+        return statuses;
+    }
+    async getPackageStatuses(targetVersion) {
+        const packagesDir = path.join(this.rootDir, 'packages');
+        if (!await fs.pathExists(packagesDir))
+            return [];
+        const pkgDirs = await fs.readdir(packagesDir);
+        const statuses = [];
+        for (const pkgName of pkgDirs) {
+            const pkgPath = path.join(packagesDir, pkgName, 'package.json');
+            if (await fs.pathExists(pkgPath)) {
+                const pkg = await fs.readJson(pkgPath);
+                const version = pkg.version || '0.0.0';
+                const status = version === targetVersion ? 'sync' : version > targetVersion ? 'newer' : 'stale';
+                statuses.push({ name: pkgName, version, status });
+            }
+        }
+        return statuses;
+    }
+    getEnvironmentInfo() {
+        try {
+            const nodeVersion = process.version.replace('v', '');
+            const pnpmVersion = this.getPnpmVersion();
+            const gitAvailable = this.isGitAvailable();
+            const configValid = true;
+            return {
+                nodeVersion,
+                pnpmVersion,
+                gitAvailable,
+                configValid,
+            };
+        }
+        catch {
+            return {
+                nodeVersion: 'unknown',
+                pnpmVersion: 'unknown',
+                gitAvailable: false,
+                configValid: false,
+            };
+        }
+    }
+    getPnpmVersion() {
+        try {
+            const output = (0, child_process_1.execSync)('pnpm --version', { encoding: 'utf8' }).trim();
+            return output;
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    isGitAvailable() {
+        try {
+            (0, child_process_1.execSync)('git --version', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getLastReleaseInfo() {
+        try {
+            const output = (0, child_process_1.execSync)('git log --oneline --all --decorate | grep -E "tag:|release|v[0-9]" | head -1', {
+                encoding: 'utf8',
+                shell: '/bin/bash',
+            }).trim();
+            const tagMatch = output.match(/v\d+\.\d+\.\d+/);
+            const version = tagMatch ? tagMatch[0].replace('v', '') : '1.0.0';
+            // Get commit count since last tag
+            let commitsSince = 0;
+            try {
+                const countOutput = (0, child_process_1.execSync)(`git rev-list --count ${version}..HEAD`, { encoding: 'utf8' }).trim();
+                commitsSince = parseInt(countOutput, 10) || 0;
+            }
+            catch {
+                commitsSince = 0;
+            }
+            const dateStr = new Date().toISOString().split('T')[0];
+            return {
+                version,
+                date: dateStr,
+                commitsSince,
+            };
+        }
+        catch {
+            return {
+                version: '1.0.0',
+                date: new Date().toISOString().split('T')[0],
+                commitsSince: 0,
+            };
+        }
+    }
+    formatTable(header, rows) {
+        const colWidths = header.map((h, i) => Math.max(h.length, ...rows.map(r => (r[i] || '').length)));
+        const separator = '┌' + colWidths.map(w => '─'.repeat(w + 2)).join('┬') + '┐';
+        const headerRow = '│ ' + header.map((h, i) => h.padEnd(colWidths[i])).join(' │ ') + ' │';
+        const divider = '├' + colWidths.map(w => '─'.repeat(w + 2)).join('┼') + '┤';
+        const dataRows = rows.map(row => '│ ' + row.map((cell, i) => (cell || '').padEnd(colWidths[i])).join(' │ ') + ' │');
+        const footer = '└' + colWidths.map(w => '─'.repeat(w + 2)).join('┴') + '┘';
+        return [separator, headerRow, divider, ...dataRows, footer].join('\n');
+    }
+    async formatConsole() {
+        const status = await this.getStatus();
+        const lines = [];
+        lines.push('┌─────────────────────────────────────────────────────────┐');
+        lines.push('│          📊 Monorepo Versioning Status Report            │');
+        lines.push('└─────────────────────────────────────────────────────────┘\n');
+        // CLI Version
+        lines.push('🔧 CLI Version Information');
+        lines.push(`  Installed: v${status.cli.installed}`);
+        lines.push(`  Latest:    v${status.cli.latest}`);
+        lines.push(`  Status:    ${status.cli.updateAvailable ? '⚠️  Update available' : '✅ Up to date'}\n`);
+        // Core Sync
+        lines.push('📦 Core Version Sync');
+        lines.push(`  Current Target: ${status.sync.currentTarget}`);
+        lines.push(`  Synced: ${status.sync.isSynced ? '✅' : '❌'} (${status.sync.syncedPackages}/${status.sync.totalPackages} packages)`);
+        lines.push(`  Last Updated: ${new Date(status.sync.lastUpdated).toLocaleString()} UTC\n`);
+        // Apps
+        if (status.apps.length > 0) {
+            lines.push('📂 Applications Version Status');
+            const appRows = status.apps.map(app => [
+                app.name,
+                app.version,
+                app.status === 'sync' ? '✅ Sync' : app.status === 'stale' ? '⚠️ Stale' : '✨ Newer',
+                app.target,
+            ]);
+            lines.push(this.formatTable(['App', 'Version', 'Status', 'Target'], appRows));
+            lines.push('');
+        }
+        // Packages
+        if (status.packages.length > 0) {
+            lines.push('📚 Packages Version Status');
+            const pkgRows = status.packages.map(pkg => [
+                pkg.name,
+                pkg.version,
+                pkg.status === 'sync' ? '✅ Sync' : pkg.status === 'stale' ? '⚠️ Stale' : '✨ Newer',
+            ]);
+            lines.push(this.formatTable(['Package', 'Version', 'Status'], pkgRows));
+            lines.push('');
+        }
+        // Dependencies
+        lines.push('🔗 Dependency Graph Health');
+        lines.push(`  Critical Dependencies:`);
+        lines.push(`    ✅ All versions locked correctly`);
+        lines.push(`    ✅ No circular dependencies detected`);
+        lines.push(`    ${status.dependencies.staleCount === 0 ? '✅' : '⚠️'} ${status.dependencies.staleCount || '0'} stale/out-of-date packages\n`);
+        // Environment
+        lines.push('⚡ Installation Health');
+        lines.push(`  ✅ Node.js: ${status.environment.nodeVersion}`);
+        lines.push(`  ✅ pnpm: ${status.environment.pnpmVersion}`);
+        lines.push(`  ${status.environment.gitAvailable ? '✅' : '❌'} Git: ${status.environment.gitAvailable ? 'Available' : 'Not available'}`);
+        lines.push(`  ${status.environment.configValid ? '✅' : '❌'} Config: versioning.config.json ${status.environment.configValid ? 'found' : 'not found'}\n`);
+        // Last Release
+        lines.push('🎯 Last Release');
+        lines.push(`  Version: ${status.lastRelease.version}`);
+        lines.push(`  Date: ${status.lastRelease.date}`);
+        lines.push(`  Commits: ${status.lastRelease.commitsSince} since last release`);
+        const nextBump = status.lastRelease.commitsSince > 10 ? 'Minor' : 'Patch';
+        lines.push(`  Next Suggested: ${nextBump} release\n`);
+        // Overall status
+        const statusEmoji = status.overallStatus === 'healthy' ? '✅' : status.overallStatus === 'warning' ? '⚠️' : '❌';
+        const statusText = status.overallStatus.toUpperCase();
+        lines.push(`${statusEmoji} Overall Status: ${statusText} - ${status.overallStatus === 'healthy'
+            ? 'All systems synced and ready'
+            : 'Some packages out of sync'}`);
+        return lines.join('\n');
+    }
+    async getJSON() {
+        const status = await this.getStatus();
+        return JSON.stringify(status, null, 2);
+    }
+    async getDOT() {
+        const status = await this.getStatus();
+        const lines = ['digraph VersionDependencies {'];
+        // Add app dependencies
+        for (const app of status.apps) {
+            lines.push(`  ${app.name} [label="${app.name}\\n${app.version}", shape=box];`);
+        }
+        // Add package dependencies
+        for (const pkg of status.packages) {
+            const color = pkg.status === 'stale' ? ', color=red' : pkg.status === 'newer' ? ', color=orange' : '';
+            lines.push(`  ${pkg.name} [label="${pkg.name}\\n${pkg.version}"${color}];`);
+        }
+        // Add edges (simplified - could be enhanced)
+        for (const app of status.apps) {
+            for (const pkg of status.packages) {
+                if (!pkg.name.includes('versioning')) {
+                    lines.push(`  ${app.name} -> ${pkg.name};`);
+                }
+            }
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+}
+exports.StatusManager = StatusManager;
+//# sourceMappingURL=status.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.4.0",
   "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
   }
-}
+}