@edcalderon/versioning 1.0.3

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-01-01
+
+### Added
+- Initial release of @edcalderon/versioning
+- Comprehensive versioning and changelog management
+- Support for both single repositories and monorepos
+- CLI tool with multiple commands (patch, minor, major, release, bump, changelog, sync, validate, init)
+- Conventional commits integration
+- Git tagging and committing
+- Version synchronization across packages
+- Package selection for selective releases
+- TypeScript support with full type safety
+- Jest testing framework
+- NPM publishable package structure

package/README.md

@@ -0,0 +1,274 @@
+# @edcalderon/versioning
+
+A comprehensive versioning and changelog management tool designed for monorepos and single repositories. It provides automated version bumping, changelog generation using conventional commits, and version synchronization across multiple packages.
+
+## Features
+
+- 🚀 Automated version bumping (patch, minor, major, prerelease)
+- 📝 Conventional commit-based changelog generation
+- 🔄 Version synchronization across monorepo packages
+- 🎯 Works with both monorepos and single repositories
+- 📦 NPM publishable
+- 🏷️ Git tagging and committing
+- ✅ Validation of version sync
+
+## Installation
+
+```bash
+npm install -g @edcalderon/versioning
+# or
+pnpm add -g @edcalderon/versioning
+# or
+yarn global add @edcalderon/versioning
+```
+
+## Quick Start
+
+1. Initialize configuration:
+```bash
+ed-version init
+```
+
+2. Bump version and generate changelog:
+```bash
+ed-version bump patch
+```
+
+3. Sync versions across packages (for monorepos):
+```bash
+ed-version sync
+```
+
+### Edward's Monorepo Example
+
+For this specific monorepo with dashboard app:
+
+```bash
+# Initialize config
+ed-version init
+
+# Edit versioning.config.json to:
+{
+  "packages": ["apps/dashboard"],
+  "ignorePackages": ["packages/versioning"]
+}
+
+# Sync dashboard with main version
+ed-version patch --packages "apps/dashboard"
+
+# Versioning package maintains its own version
+cd packages/versioning && ed-version patch --skip-sync
+```
+
+## Configuration
+
+Create a `versioning.config.json` file in your project root:
+
+For single repositories:
+```json
+{
+  "rootPackageJson": "package.json",
+  "packages": [],
+  "changelogFile": "CHANGELOG.md",
+  "conventionalCommits": true,
+  "syncDependencies": false,
+  "ignorePackages": []
+}
+```
+
+For monorepos:
+```json
+{
+  "rootPackageJson": "package.json",
+  "packages": ["packages/*", "apps/*"],
+  "changelogFile": "CHANGELOG.md",
+  "conventionalCommits": true,
+  "syncDependencies": true,
+  "ignorePackages": []
+}
+```
+
+### Configuration Options
+
+- `rootPackageJson`: Path to the root package.json file
+- `packages`: Array of glob patterns for packages to sync
+- `changelogFile`: Path to the changelog file
+- `conventionalCommits`: Whether to use conventional commits for changelog
+- `syncDependencies`: Whether to sync internal dependencies
+- `ignorePackages`: Array of package names to ignore during sync
+
+## Commands
+
+### Release Commands
+
+#### `ed-version patch [options]`
+
+Create a patch release (bumps 1.0.0 → 1.0.1)
+
+```bash
+ed-version patch
+ed-version patch --packages "packages/app1,packages/app2" --message "Fix critical bug"
+```
+
+#### `ed-version minor [options]`
+
+Create a minor release (bumps 1.0.0 → 1.1.0)
+
+```bash
+ed-version minor
+ed-version minor --packages "apps/dashboard" --message "Add new features"
+```
+
+#### `ed-version major [options]`
+
+Create a major release (bumps 1.0.0 → 2.0.0)
+
+```bash
+ed-version major --message "Breaking changes"
+```
+
+#### `ed-version release <version> [options]`
+
+Create a custom release with specific version
+
+```bash
+ed-version release 1.2.3 --message "Custom release"
+ed-version release 2.0.0-beta.1 --skip-sync
+```
+
+**Options for release commands:**
+- `-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)
+
+### Other Commands
+
+Bump the version and generate changelog.
+
+Types: `patch`, `minor`, `major`, `prerelease`
+
+Options:
+- `-p, --pre-release <identifier>`: Prerelease identifier
+- `-c, --config <file>`: Config file path (default: versioning.config.json)
+- `--no-commit`: Don't commit changes
+- `--no-tag`: Don't create git tag
+
+### `ed-version changelog [options]`
+
+Generate changelog from commits.
+
+Options:
+- `-f, --from <commit>`: From commit
+- `-t, --to <commit>`: To commit
+- `-c, --config <file>`: Config file path
+
+### `ed-version sync [options]`
+
+Sync versions across all packages.
+
+Options:
+- `-v, --version <version>`: Target version to sync to
+- `-c, --config <file>`: Config file path
+
+### `ed-version validate [options]`
+
+Validate that all packages have the correct version.
+
+Options:
+- `-c, --config <file>`: Config file path
+
+### `ed-version init [options]`
+
+Initialize a new versioning config file.
+
+Options:
+- `-f, --force`: Overwrite existing config
+
+## Workflow Integration
+
+### GitHub Actions
+
+Add to your release workflow:
+
+```yaml
+- name: Bump version
+  run: npx @edcalderon/versioning bump patch
+  env:
+    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+```
+
+### Pre-commit Hooks
+
+Use with husky for automated versioning:
+
+```bash
+npx husky add .husky/pre-commit "ed-version validate"
+```
+
+## Conventional Commits
+
+This tool works best with conventional commits. Examples:
+
+- `feat: add new feature` (minor bump)
+- `fix: resolve bug` (patch bump)
+- `BREAKING CHANGE: change API` (major bump)
+
+## Documentation
+
+- **[Usage Guide](USAGE.md)** - Comprehensive examples and advanced usage patterns
+- **[Configuration Examples](examples.md)** - Real-world configuration examples
+- **[CHANGELOG](CHANGELOG.md)** - Version history and changes
+
+## Publishing & Releases
+
+### Automated NPM Publishing
+
+This package uses GitHub Actions for automated publishing to NPM when version tags are created.
+
+#### Release Process
+
+1. **Update Version**: Use the versioning commands to bump version and update changelog
+   ```bash
+   ed-version patch  # or minor, major
+   ```
+
+2. **Create Git Tag**: The package includes a helper script to create and push version tags
+   ```bash
+   npm run create-tag
+   ```
+
+3. **Automated Publishing**: GitHub Actions will automatically:
+   - Build the package
+   - Run tests
+   - Publish to NPM
+   - Create a GitHub Release
+
+#### Manual Publishing (First Release)
+
+For the initial release, publish manually:
+
+```bash
+cd packages/versioning
+npm login
+npm publish
+```
+
+#### NPM Token Setup
+
+To enable automated publishing:
+
+1. Go to [NPM](https://www.npmjs.com/) → Access Tokens → Generate New Token
+2. Create a token with **Automation** scope
+3. Add to GitHub repository secrets as `NPM_TOKEN`
+
+### Version Tags
+
+Tags should follow the format `v{major}.{minor}.{patch}` (e.g., `v1.0.0`, `v1.1.0`, `v2.0.0`).
+
+The `create-tag` script will:
+- Read the version from `package.json`
+- Create an annotated git tag
+- Push the tag to trigger the publish workflow

package/dist/changelog.d.ts

@@ -0,0 +1,15 @@
+export interface ChangelogConfig {
+    preset?: string;
+    infile?: string;
+    outfile?: string;
+    releaseCount?: number;
+    sameFile?: boolean;
+}
+export declare class ChangelogManager {
+    private config;
+    constructor(config?: ChangelogConfig);
+    generate(from?: string, to?: string): Promise<string>;
+    private updateExistingChangelog;
+    getLatestRelease(): Promise<string | null>;
+}
+//# sourceMappingURL=changelog.d.ts.map

package/dist/changelog.js

@@ -0,0 +1,99 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangelogManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const conventional_changelog_1 = __importDefault(require("conventional-changelog"));
+class ChangelogManager {
+    constructor(config = {}) {
+        this.config = {
+            preset: 'angular',
+            infile: 'CHANGELOG.md',
+            outfile: 'CHANGELOG.md',
+            sameFile: true,
+            ...config
+        };
+    }
+    async generate(from, to) {
+        return new Promise((resolve, reject) => {
+            let changelog = '';
+            const stream = (0, conventional_changelog_1.default)({
+                preset: this.config.preset,
+                releaseCount: this.config.releaseCount,
+                ...(from && { from }),
+                ...(to && { to })
+            });
+            stream.on('data', (chunk) => {
+                changelog += chunk.toString();
+            });
+            stream.on('end', async () => {
+                if (this.config.sameFile && this.config.infile) {
+                    await this.updateExistingChangelog(changelog);
+                }
+                else {
+                    await fs.writeFile(this.config.outfile, changelog);
+                }
+                resolve(changelog);
+            });
+            stream.on('error', reject);
+        });
+    }
+    async updateExistingChangelog(newContent) {
+        const existingContent = await fs.readFile(this.config.infile, 'utf-8');
+        const updatedContent = newContent + '\n\n' + existingContent;
+        await fs.writeFile(this.config.infile, updatedContent);
+    }
+    async getLatestRelease() {
+        try {
+            const content = await fs.readFile(this.config.infile, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const match = line.match(/^## \[?(\d+\.\d+\.\d+)/);
+                if (match) {
+                    return match[1];
+                }
+            }
+        }
+        catch (error) {
+            // File doesn't exist or can't be read
+        }
+        return null;
+    }
+}
+exports.ChangelogManager = ChangelogManager;
+//# sourceMappingURL=changelog.js.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs-extra"));
+const versioning_1 = require("./versioning");
+const changelog_1 = require("./changelog");
+const sync_1 = require("./sync");
+const release_1 = require("./release");
+const program = new commander_1.Command();
+program
+    .name('ed-version')
+    .description('Comprehensive versioning and changelog management for monorepos')
+    .version('1.0.0');
+program
+    .command('bump <type>')
+    .description('Bump version (patch, minor, major, prerelease)')
+    .option('-p, --pre-release <identifier>', 'prerelease identifier')
+    .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+    .option('--no-commit', 'do not commit changes')
+    .option('--no-tag', 'do not create git tag')
+    .action(async (type, options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const versionManager = new versioning_1.VersionManager(config);
+        const changelogManager = new changelog_1.ChangelogManager(config);
+        const newVersion = await versionManager.bumpVersion(type, options.preRelease);
+        console.log(`Bumped version to ${newVersion}`);
+        // Generate changelog
+        await changelogManager.generate();
+        console.log('Generated changelog');
+        if (options.commit !== false) {
+            await versionManager.commitChanges(newVersion);
+            console.log('Committed changes');
+        }
+        if (options.tag !== false) {
+            await versionManager.createGitTag(newVersion);
+            console.log('Created git tag');
+        }
+        console.log(`✅ Successfully released v${newVersion}`);
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('changelog')
+    .description('Generate changelog')
+    .option('-f, --from <commit>', 'from commit')
+    .option('-t, --to <commit>', 'to commit')
+    .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const changelogManager = new changelog_1.ChangelogManager(config);
+        await changelogManager.generate(options.from, options.to);
+        console.log('✅ Changelog generated');
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('sync')
+    .description('Sync versions across monorepo')
+    .option('-v, --version <version>', 'target version to sync to')
+    .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const syncManager = new sync_1.SyncManager(config);
+        await syncManager.syncVersions(options.version);
+        console.log('✅ Versions synced');
+        const validation = await syncManager.validateSync();
+        if (!validation.valid) {
+            console.log('⚠️  Validation issues:');
+            validation.issues.forEach(issue => console.log(`  - ${issue}`));
+        }
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('validate')
+    .description('Validate version sync across monorepo')
+    .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const syncManager = new sync_1.SyncManager(config);
+        const validation = await syncManager.validateSync();
+        if (validation.valid) {
+            console.log('✅ All versions are in sync');
+        }
+        else {
+            console.log('❌ Version sync issues:');
+            validation.issues.forEach(issue => console.log(`  - ${issue}`));
+            process.exit(1);
+        }
+    }
+    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('--no-tag', 'Do not create git tag')
+    .option('--no-commit', 'Do not commit changes')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const versionManager = new versioning_1.VersionManager(config);
+        const changelogManager = new changelog_1.ChangelogManager(config);
+        const syncManager = new sync_1.SyncManager(config);
+        const releaseManager = new release_1.ReleaseManager({
+            versionManager,
+            changelogManager,
+            syncManager,
+            createTag: options.tag !== false,
+            createCommit: options.commit !== false
+        });
+        const packages = options.packages ? options.packages.split(',').map((p) => p.trim()) : undefined;
+        const newVersion = await releaseManager.patchRelease({
+            packages,
+            message: options.message
+        });
+        console.log(`✅ Patch release v${newVersion} completed`);
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('minor')
+    .description('Create a minor 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('--no-tag', 'Do not create git tag')
+    .option('--no-commit', 'Do not commit changes')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const versionManager = new versioning_1.VersionManager(config);
+        const changelogManager = new changelog_1.ChangelogManager(config);
+        const syncManager = new sync_1.SyncManager(config);
+        const releaseManager = new release_1.ReleaseManager({
+            versionManager,
+            changelogManager,
+            syncManager,
+            createTag: options.tag !== false,
+            createCommit: options.commit !== false
+        });
+        const packages = options.packages ? options.packages.split(',').map((p) => p.trim()) : undefined;
+        const newVersion = await releaseManager.minorRelease({
+            packages,
+            message: options.message
+        });
+        console.log(`✅ Minor release v${newVersion} completed`);
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('major')
+    .description('Create a major release')
+    .option('-p, --packages <packages>', 'Comma-separated list of packages to sync')
+    .option('-c, --config <file>', 'Config file path', 'versioning.config.json')
+    .option('--no-tag', 'Do not create git tag')
+    .option('--no-commit', 'Do not commit changes')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const versionManager = new versioning_1.VersionManager(config);
+        const changelogManager = new changelog_1.ChangelogManager(config);
+        const syncManager = new sync_1.SyncManager(config);
+        const releaseManager = new release_1.ReleaseManager({
+            versionManager,
+            changelogManager,
+            syncManager,
+            createTag: options.tag !== false,
+            createCommit: options.commit !== false
+        });
+        const packages = options.packages ? options.packages.split(',').map((p) => p.trim()) : undefined;
+        const newVersion = await releaseManager.majorRelease({
+            packages,
+            message: options.message
+        });
+        console.log(`✅ Major release v${newVersion} completed`);
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('release <version>')
+    .description('Create a custom 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('--no-tag', 'Do not create git tag')
+    .option('--no-commit', 'Do not commit changes')
+    .option('--skip-sync', 'Skip version synchronization')
+    .action(async (version, options) => {
+    try {
+        const config = await loadConfig(options.config);
+        const versionManager = new versioning_1.VersionManager(config);
+        const changelogManager = new changelog_1.ChangelogManager(config);
+        const syncManager = new sync_1.SyncManager(config);
+        const releaseManager = new release_1.ReleaseManager({
+            versionManager,
+            changelogManager,
+            syncManager,
+            createTag: options.tag !== false,
+            createCommit: options.commit !== false
+        });
+        const packages = options.packages ? options.packages.split(',').map((p) => p.trim()) : undefined;
+        await releaseManager.release(version, {
+            packages,
+            message: options.message,
+            skipSync: options.skipSync
+        });
+        console.log(`✅ Release v${version} completed`);
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program
+    .command('init')
+    .description('Initialize versioning config')
+    .option('-f, --force', 'overwrite existing config')
+    .action(async (options) => {
+    try {
+        const configPath = 'versioning.config.json';
+        if (!options.force && await fs.pathExists(configPath)) {
+            console.error('❌ Config file already exists. Use --force to overwrite.');
+            process.exit(1);
+        }
+        const defaultConfig = {
+            rootPackageJson: 'package.json',
+            packages: [],
+            changelogFile: 'CHANGELOG.md',
+            conventionalCommits: true,
+            syncDependencies: false,
+            ignorePackages: []
+        };
+        await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
+        console.log('✅ Initialized versioning config at versioning.config.json');
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+async function loadConfig(configPath) {
+    if (!(await fs.pathExists(configPath))) {
+        throw new Error(`Config file not found: ${configPath}. Run 'ed-version init' to create one.`);
+    }
+    return await fs.readJson(configPath);
+}
+program.parse();
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./versioning"), exports);
+__exportStar(require("./changelog"), exports);
+__exportStar(require("./sync"), exports);
+__exportStar(require("./release"), exports);
+//# sourceMappingURL=index.js.map

package/dist/release.d.ts

@@ -0,0 +1,32 @@
+import { VersionManager, ChangelogManager, SyncManager } from './index';
+export interface ReleaseConfig {
+    versionManager: VersionManager;
+    changelogManager: ChangelogManager;
+    syncManager: SyncManager;
+    createTag?: boolean;
+    createCommit?: boolean;
+    publish?: boolean;
+}
+export declare class ReleaseManager {
+    private config;
+    constructor(config: ReleaseConfig);
+    release(version: string, options?: {
+        message?: string;
+        packages?: string[];
+        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>;
+}
+//# sourceMappingURL=release.d.ts.map

package/dist/release.js

@@ -0,0 +1,101 @@
+"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.ReleaseManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+class ReleaseManager {
+    constructor(config) {
+        this.config = {
+            createTag: true,
+            createCommit: true,
+            publish: false,
+            ...config
+        };
+    }
+    async release(version, options = {}) {
+        const { message, packages, skipSync } = options;
+        // Update versions
+        await this.config.versionManager.updateVersion(version);
+        // Sync specific packages if specified
+        if (!skipSync && packages && packages.length > 0) {
+            for (const pkg of packages) {
+                const packageJsonPath = path.join(pkg, 'package.json');
+                if (await fs.pathExists(packageJsonPath)) {
+                    await this.config.versionManager.updateVersion(version); // This needs to be package-specific
+                }
+            }
+        }
+        else if (!skipSync) {
+            await this.config.syncManager.syncVersions(version);
+        }
+        // Generate changelog
+        await this.config.changelogManager.generate();
+        // Commit changes
+        if (this.config.createCommit) {
+            await this.config.versionManager.commitChanges(version);
+        }
+        // Create git tag
+        if (this.config.createTag) {
+            await this.config.versionManager.createGitTag(version, message);
+        }
+        // Publish if requested (future implementation)
+        if (this.config.publish) {
+            await this.publishPackages(packages);
+        }
+    }
+    async publishPackages(packages) {
+        // TODO: Implement npm publish logic
+        console.log('Publishing packages:', packages || 'all');
+    }
+    async patchRelease(options = {}) {
+        const currentVersion = await this.config.versionManager.getCurrentVersion();
+        const newVersion = await this.config.versionManager.bumpVersion('patch');
+        await this.release(newVersion, options);
+        return newVersion;
+    }
+    async minorRelease(options = {}) {
+        const newVersion = await this.config.versionManager.bumpVersion('minor');
+        await this.release(newVersion, options);
+        return newVersion;
+    }
+    async majorRelease(options = {}) {
+        const newVersion = await this.config.versionManager.bumpVersion('major');
+        await this.release(newVersion, options);
+        return newVersion;
+    }
+}
+exports.ReleaseManager = ReleaseManager;
+//# sourceMappingURL=release.js.map

package/dist/sync.d.ts

@@ -0,0 +1,19 @@
+import { VersionConfig } from './versioning';
+export interface SyncConfig extends VersionConfig {
+    syncDependencies?: boolean;
+    ignorePackages?: string[];
+}
+export declare class SyncManager {
+    private config;
+    private versionManager;
+    constructor(config: SyncConfig);
+    syncVersions(targetVersion?: string): Promise<void>;
+    private updatePackageVersion;
+    private syncInternalDependencies;
+    private getInternalDependencies;
+    validateSync(): Promise<{
+        valid: boolean;
+        issues: string[];
+    }>;
+}
+//# sourceMappingURL=sync.d.ts.map

package/dist/sync.js

@@ -0,0 +1,113 @@
+"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.SyncManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const versioning_1 = require("./versioning");
+class SyncManager {
+    constructor(config) {
+        this.config = {
+            syncDependencies: true,
+            ignorePackages: [],
+            ...config
+        };
+        this.versionManager = new versioning_1.VersionManager(config);
+    }
+    async syncVersions(targetVersion) {
+        const version = targetVersion || await this.versionManager.getCurrentVersion();
+        // Update all packages to match root version
+        for (const pkgPath of this.config.packages) {
+            if (this.config.ignorePackages?.includes(path.basename(pkgPath))) {
+                continue;
+            }
+            const packageJsonPath = path.join(pkgPath, 'package.json');
+            if (await fs.pathExists(packageJsonPath)) {
+                await this.updatePackageVersion(packageJsonPath, version);
+                if (this.config.syncDependencies) {
+                    await this.syncInternalDependencies(packageJsonPath, version);
+                }
+            }
+        }
+    }
+    async updatePackageVersion(packageJsonPath, version) {
+        const packageJson = await fs.readJson(packageJsonPath);
+        packageJson.version = version;
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    async syncInternalDependencies(packageJsonPath, version) {
+        const packageJson = await fs.readJson(packageJsonPath);
+        const internalDeps = this.getInternalDependencies(packageJson);
+        for (const dep of internalDeps) {
+            if (packageJson.dependencies && packageJson.dependencies[dep]) {
+                packageJson.dependencies[dep] = `^${version}`;
+            }
+            if (packageJson.devDependencies && packageJson.devDependencies[dep]) {
+                packageJson.devDependencies[dep] = `^${version}`;
+            }
+            if (packageJson.peerDependencies && packageJson.peerDependencies[dep]) {
+                packageJson.peerDependencies[dep] = `^${version}`;
+            }
+        }
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    getInternalDependencies(packageJson) {
+        const allDeps = [
+            ...Object.keys(packageJson.dependencies || {}),
+            ...Object.keys(packageJson.devDependencies || {}),
+            ...Object.keys(packageJson.peerDependencies || {})
+        ];
+        return allDeps.filter(dep => dep.startsWith('@ed/') || dep.startsWith('workspace:'));
+    }
+    async validateSync() {
+        const rootVersion = await this.versionManager.getCurrentVersion();
+        const issues = [];
+        for (const pkgPath of this.config.packages) {
+            const packageJsonPath = path.join(pkgPath, 'package.json');
+            if (await fs.pathExists(packageJsonPath)) {
+                const packageJson = await fs.readJson(packageJsonPath);
+                if (packageJson.version !== rootVersion) {
+                    issues.push(`${pkgPath}: version ${packageJson.version} does not match root ${rootVersion}`);
+                }
+            }
+        }
+        return {
+            valid: issues.length === 0,
+            issues
+        };
+    }
+}
+exports.SyncManager = SyncManager;
+//# sourceMappingURL=sync.js.map

package/dist/versioning.d.ts

@@ -0,0 +1,19 @@
+import * as semver from 'semver';
+export interface VersionConfig {
+    rootPackageJson: string;
+    packages: string[];
+    changelogFile?: string;
+    conventionalCommits?: boolean;
+}
+export declare class VersionManager {
+    private config;
+    private git;
+    constructor(config: VersionConfig);
+    getCurrentVersion(): Promise<string>;
+    bumpVersion(releaseType: semver.ReleaseType, preRelease?: string): Promise<string>;
+    updateVersion(newVersion: string): Promise<void>;
+    private updatePackageJson;
+    createGitTag(version: string, message?: string): Promise<void>;
+    commitChanges(version: string): Promise<void>;
+}
+//# sourceMappingURL=versioning.d.ts.map

package/dist/versioning.js

@@ -0,0 +1,97 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
+const simple_git_1 = __importDefault(require("simple-git"));
+class VersionManager {
+    constructor(config) {
+        this.git = (0, simple_git_1.default)();
+        this.config = {
+            changelogFile: 'CHANGELOG.md',
+            conventionalCommits: true,
+            ...config
+        };
+    }
+    async getCurrentVersion() {
+        const packageJson = await fs.readJson(this.config.rootPackageJson);
+        return packageJson.version;
+    }
+    async bumpVersion(releaseType, preRelease) {
+        const currentVersion = await this.getCurrentVersion();
+        const newVersion = preRelease
+            ? semver.inc(currentVersion, releaseType, preRelease)
+            : semver.inc(currentVersion, releaseType);
+        if (!newVersion) {
+            throw new Error(`Invalid version bump: ${releaseType} from ${currentVersion}`);
+        }
+        await this.updateVersion(newVersion);
+        return newVersion;
+    }
+    async updateVersion(newVersion) {
+        // Update root package.json
+        await this.updatePackageJson(this.config.rootPackageJson, newVersion);
+        // Update all specified packages
+        for (const pkgPath of this.config.packages) {
+            const packageJsonPath = path.join(pkgPath, 'package.json');
+            if (await fs.pathExists(packageJsonPath)) {
+                await this.updatePackageJson(packageJsonPath, newVersion);
+            }
+        }
+    }
+    async updatePackageJson(packageJsonPath, version) {
+        const packageJson = await fs.readJson(packageJsonPath);
+        packageJson.version = version;
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    async createGitTag(version, message) {
+        const tagMessage = message || `Release v${version}`;
+        await this.git.addAnnotatedTag(`v${version}`, tagMessage);
+    }
+    async commitChanges(version) {
+        const commitMessage = this.config.conventionalCommits
+            ? `chore: release v${version}`
+            : `Release v${version}`;
+        await this.git.add('.');
+        await this.git.commit(commitMessage);
+    }
+}
+exports.VersionManager = VersionManager;
+//# sourceMappingURL=versioning.js.map

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@edcalderon/versioning",
+  "version": "1.0.3",
+  "description": "A comprehensive versioning and changelog management tool for monorepos",
+  "main": "dist/index.js",
+  "bin": {
+    "ed-version": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "prepublishOnly": "npm run build && npm run test",
+    "create-tag": "node scripts/create-tag.js"
+  },
+  "keywords": [
+    "versioning",
+    "changelog",
+    "monorepo",
+    "npm",
+    "conventional-commits"
+  ],
+  "author": "Edward",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.17",
+    "@types/semver": "^7.5.8",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/__tests__/**/*.test.ts"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!src/**/*.d.ts",
+      "!src/**/__tests__/**"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/src/__tests__/setup.ts"
+    ],
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    }
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "conventional-changelog": "^5.1.0",
+    "fs-extra": "^11.2.0",
+    "semver": "^7.6.0",
+    "simple-git": "^3.22.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/edcalderon/my-second-brain.git",
+    "directory": "packages/versioning"
+  }
+}

package/scripts/create-tag.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function createVersionTag() {
+  try {
+    // Get current version from package.json (go up two directories from scripts/)
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const version = packageJson.version;
+
+    // Use versioning prefix to avoid conflicts with monorepo tags
+    const tagPrefix = 'versioning-v';
+    const fullTag = `${tagPrefix}${version}`;
+
+    // Check if tag already exists
+    try {
+      const result = execSync(`git tag -l "${fullTag}"`, { stdio: 'pipe' });
+      const output = result.toString().trim();
+      if (output === fullTag) {
+        console.log(`Tag ${fullTag} already exists`);
+        return;
+      }
+    } catch (error) {
+      // Tag doesn't exist, continue
+    }
+
+    // Create annotated tag
+    const tagMessage = `Release @edcalderon/versioning v${version}`;
+    execSync(`git tag -a "${fullTag}" -m "${tagMessage}"`, { stdio: 'inherit' });
+
+    console.log(`Created tag ${fullTag}`);
+
+    // Push tag
+    execSync('git push origin --tags', { stdio: 'inherit' });
+
+    console.log(`Pushed tag ${fullTag} to remote`);
+    console.log(`\n🚀 Tag ${fullTag} created and pushed!`);
+    console.log(`The NPM publish workflow will now run automatically.`);
+
+  } catch (error) {
+    console.error('Error creating version tag:', error.message);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  createVersionTag();
+}