@edcalderon/versioning 1.0.3 → 1.0.7

package/CHANGELOG.md

@@ -1,3 +1,164 @@
+## 1.0.7 (2026-01-01)
+
+
+### Bug Fixes
+
+* add publishConfig to explicitly set package as public ([0138dc4](https://github.com/edcalderon/my-second-brain/commit/0138dc4de49bc1f5ee75622440b19ff643fd6224))
+* change package name from @ed/versioning to ed-versioning ([96e4495](https://github.com/edcalderon/my-second-brain/commit/96e4495fe575c6226f319fe62e0f1266fe6d6cfe))
+* change package name to @edcalderon/versioning ([246c7f4](https://github.com/edcalderon/my-second-brain/commit/246c7f445c17464ab63dcbd3bb30be8d8e30066d))
+* configure Next.js for GitHub Pages subdirectory ([af24444](https://github.com/edcalderon/my-second-brain/commit/af2444468d13dcbe2f867ea41208a385f24edb75))
+* correct tag existence check logic in create-tag.js ([f489f89](https://github.com/edcalderon/my-second-brain/commit/f489f89988b4877108b98e7910a79cc2a7e325a5))
+* make SUPERMEMORY_API_KEY private (not NEXT_PUBLIC) ([416d4c0](https://github.com/edcalderon/my-second-brain/commit/416d4c0bf007fbbc3381c9d9745c2cf21c9ae78b))
+* update GitHub release action to use modern softprops/action-gh-release ([dd11de0](https://github.com/edcalderon/my-second-brain/commit/dd11de0cc05dacb9cf7e614e57535a4d54617678))
+* update repository URL in versioning package.json ([3723c78](https://github.com/edcalderon/my-second-brain/commit/3723c781bc61ee9fdf2b9bb0446274be495403ac))
+
+
+### Features
+
+* add comprehensive versioning package with CLI, changelog, and NPM publishing ([dba69bd](https://github.com/edcalderon/my-second-brain/commit/dba69bd61cc0a6b11f881a913ee900142b5ddd14))
+
+
+
+
+
+## 1.0.7 (2026-01-01)
+
+
+### Bug Fixes
+
+* add publishConfig to explicitly set package as public ([0138dc4](https://github.com/edcalderon/my-second-brain/commit/0138dc4de49bc1f5ee75622440b19ff643fd6224))
+* change package name from @ed/versioning to ed-versioning ([96e4495](https://github.com/edcalderon/my-second-brain/commit/96e4495fe575c6226f319fe62e0f1266fe6d6cfe))
+* change package name to @edcalderon/versioning ([246c7f4](https://github.com/edcalderon/my-second-brain/commit/246c7f445c17464ab63dcbd3bb30be8d8e30066d))
+* configure Next.js for GitHub Pages subdirectory ([af24444](https://github.com/edcalderon/my-second-brain/commit/af2444468d13dcbe2f867ea41208a385f24edb75))
+* correct tag existence check logic in create-tag.js ([f489f89](https://github.com/edcalderon/my-second-brain/commit/f489f89988b4877108b98e7910a79cc2a7e325a5))
+* make SUPERMEMORY_API_KEY private (not NEXT_PUBLIC) ([416d4c0](https://github.com/edcalderon/my-second-brain/commit/416d4c0bf007fbbc3381c9d9745c2cf21c9ae78b))
+* update GitHub release action to use modern softprops/action-gh-release ([dd11de0](https://github.com/edcalderon/my-second-brain/commit/dd11de0cc05dacb9cf7e614e57535a4d54617678))
+* update repository URL in versioning package.json ([3723c78](https://github.com/edcalderon/my-second-brain/commit/3723c781bc61ee9fdf2b9bb0446274be495403ac))
+
+
+### Features
+
+* add comprehensive versioning package with CLI, changelog, and NPM publishing ([dba69bd](https://github.com/edcalderon/my-second-brain/commit/dba69bd61cc0a6b11f881a913ee900142b5ddd14))
+
+
+
+
+
+## 1.0.6 (2026-01-01)
+
+
+### Bug Fixes
+
+* add publishConfig to explicitly set package as public ([0138dc4](https://github.com/edcalderon/my-second-brain/commit/0138dc4de49bc1f5ee75622440b19ff643fd6224))
+* change package name from @ed/versioning to ed-versioning ([96e4495](https://github.com/edcalderon/my-second-brain/commit/96e4495fe575c6226f319fe62e0f1266fe6d6cfe))
+* change package name to @edcalderon/versioning ([246c7f4](https://github.com/edcalderon/my-second-brain/commit/246c7f445c17464ab63dcbd3bb30be8d8e30066d))
+* configure Next.js for GitHub Pages subdirectory ([af24444](https://github.com/edcalderon/my-second-brain/commit/af2444468d13dcbe2f867ea41208a385f24edb75))
+* correct tag existence check logic in create-tag.js ([f489f89](https://github.com/edcalderon/my-second-brain/commit/f489f89988b4877108b98e7910a79cc2a7e325a5))
+* make SUPERMEMORY_API_KEY private (not NEXT_PUBLIC) ([416d4c0](https://github.com/edcalderon/my-second-brain/commit/416d4c0bf007fbbc3381c9d9745c2cf21c9ae78b))
+* update GitHub release action to use modern softprops/action-gh-release ([dd11de0](https://github.com/edcalderon/my-second-brain/commit/dd11de0cc05dacb9cf7e614e57535a4d54617678))
+* update repository URL in versioning package.json ([3723c78](https://github.com/edcalderon/my-second-brain/commit/3723c781bc61ee9fdf2b9bb0446274be495403ac))
+
+
+### Features
+
+* add comprehensive versioning package with CLI, changelog, and NPM publishing ([dba69bd](https://github.com/edcalderon/my-second-brain/commit/dba69bd61cc0a6b11f881a913ee900142b5ddd14))
+
+
+
+
+
+## 1.0.6 (2026-01-01)
+
+
+### Bug Fixes
+
+* add publishConfig to explicitly set package as public ([0138dc4](https://github.com/edcalderon/my-second-brain/commit/0138dc4de49bc1f5ee75622440b19ff643fd6224))
+* change package name from @ed/versioning to ed-versioning ([96e4495](https://github.com/edcalderon/my-second-brain/commit/96e4495fe575c6226f319fe62e0f1266fe6d6cfe))
+* change package name to @edcalderon/versioning ([246c7f4](https://github.com/edcalderon/my-second-brain/commit/246c7f445c17464ab63dcbd3bb30be8d8e30066d))
+* configure Next.js for GitHub Pages subdirectory ([af24444](https://github.com/edcalderon/my-second-brain/commit/af2444468d13dcbe2f867ea41208a385f24edb75))
+* correct tag existence check logic in create-tag.js ([f489f89](https://github.com/edcalderon/my-second-brain/commit/f489f89988b4877108b98e7910a79cc2a7e325a5))
+* make SUPERMEMORY_API_KEY private (not NEXT_PUBLIC) ([416d4c0](https://github.com/edcalderon/my-second-brain/commit/416d4c0bf007fbbc3381c9d9745c2cf21c9ae78b))
+* update GitHub release action to use modern softprops/action-gh-release ([dd11de0](https://github.com/edcalderon/my-second-brain/commit/dd11de0cc05dacb9cf7e614e57535a4d54617678))
+* update repository URL in versioning package.json ([3723c78](https://github.com/edcalderon/my-second-brain/commit/3723c781bc61ee9fdf2b9bb0446274be495403ac))
+
+
+### Features
+
+* add comprehensive versioning package with CLI, changelog, and NPM publishing ([dba69bd](https://github.com/edcalderon/my-second-brain/commit/dba69bd61cc0a6b11f881a913ee900142b5ddd14))
+
+
+
+
+
+## 1.0.5 (2026-01-01)
+
+
+### Bug Fixes
+
+* add publishConfig to explicitly set package as public ([0138dc4](https://github.com/edcalderon/my-second-brain/commit/0138dc4de49bc1f5ee75622440b19ff643fd6224))
+* change package name from @ed/versioning to ed-versioning ([96e4495](https://github.com/edcalderon/my-second-brain/commit/96e4495fe575c6226f319fe62e0f1266fe6d6cfe))
+* change package name to @edcalderon/versioning ([246c7f4](https://github.com/edcalderon/my-second-brain/commit/246c7f445c17464ab63dcbd3bb30be8d8e30066d))
+* configure Next.js for GitHub Pages subdirectory ([af24444](https://github.com/edcalderon/my-second-brain/commit/af2444468d13dcbe2f867ea41208a385f24edb75))
+* correct tag existence check logic in create-tag.js ([f489f89](https://github.com/edcalderon/my-second-brain/commit/f489f89988b4877108b98e7910a79cc2a7e325a5))
+* make SUPERMEMORY_API_KEY private (not NEXT_PUBLIC) ([416d4c0](https://github.com/edcalderon/my-second-brain/commit/416d4c0bf007fbbc3381c9d9745c2cf21c9ae78b))
+* update GitHub release action to use modern softprops/action-gh-release ([dd11de0](https://github.com/edcalderon/my-second-brain/commit/dd11de0cc05dacb9cf7e614e57535a4d54617678))
+* update repository URL in versioning package.json ([3723c78](https://github.com/edcalderon/my-second-brain/commit/3723c781bc61ee9fdf2b9bb0446274be495403ac))
+
+
+### Features
+
+* add comprehensive versioning package with CLI, changelog, and NPM publishing ([dba69bd](https://github.com/edcalderon/my-second-brain/commit/dba69bd61cc0a6b11f881a913ee900142b5ddd14))
+
+
+
+
+
+## 1.0.5 (2026-01-01)
+
+
+### Bug Fixes
+
+* add publishConfig to explicitly set package as public ([0138dc4](https://github.com/edcalderon/my-second-brain/commit/0138dc4de49bc1f5ee75622440b19ff643fd6224))
+* change package name from @ed/versioning to ed-versioning ([96e4495](https://github.com/edcalderon/my-second-brain/commit/96e4495fe575c6226f319fe62e0f1266fe6d6cfe))
+* change package name to @edcalderon/versioning ([246c7f4](https://github.com/edcalderon/my-second-brain/commit/246c7f445c17464ab63dcbd3bb30be8d8e30066d))
+* configure Next.js for GitHub Pages subdirectory ([af24444](https://github.com/edcalderon/my-second-brain/commit/af2444468d13dcbe2f867ea41208a385f24edb75))
+* correct tag existence check logic in create-tag.js ([f489f89](https://github.com/edcalderon/my-second-brain/commit/f489f89988b4877108b98e7910a79cc2a7e325a5))
+* make SUPERMEMORY_API_KEY private (not NEXT_PUBLIC) ([416d4c0](https://github.com/edcalderon/my-second-brain/commit/416d4c0bf007fbbc3381c9d9745c2cf21c9ae78b))
+* update GitHub release action to use modern softprops/action-gh-release ([dd11de0](https://github.com/edcalderon/my-second-brain/commit/dd11de0cc05dacb9cf7e614e57535a4d54617678))
+* update repository URL in versioning package.json ([3723c78](https://github.com/edcalderon/my-second-brain/commit/3723c781bc61ee9fdf2b9bb0446274be495403ac))
+
+
+### Features
+
+* add comprehensive versioning package with CLI, changelog, and NPM publishing ([dba69bd](https://github.com/edcalderon/my-second-brain/commit/dba69bd61cc0a6b11f881a913ee900142b5ddd14))
+
+
+
+
+
+## 1.0.4 (2026-01-01)
+
+
+### Bug Fixes
+
+* add publishConfig to explicitly set package as public ([0138dc4](https://github.com/edcalderon/my-second-brain/commit/0138dc4de49bc1f5ee75622440b19ff643fd6224))
+* change package name from @ed/versioning to ed-versioning ([96e4495](https://github.com/edcalderon/my-second-brain/commit/96e4495fe575c6226f319fe62e0f1266fe6d6cfe))
+* change package name to @edcalderon/versioning ([246c7f4](https://github.com/edcalderon/my-second-brain/commit/246c7f445c17464ab63dcbd3bb30be8d8e30066d))
+* configure Next.js for GitHub Pages subdirectory ([af24444](https://github.com/edcalderon/my-second-brain/commit/af2444468d13dcbe2f867ea41208a385f24edb75))
+* correct tag existence check logic in create-tag.js ([f489f89](https://github.com/edcalderon/my-second-brain/commit/f489f89988b4877108b98e7910a79cc2a7e325a5))
+* make SUPERMEMORY_API_KEY private (not NEXT_PUBLIC) ([416d4c0](https://github.com/edcalderon/my-second-brain/commit/416d4c0bf007fbbc3381c9d9745c2cf21c9ae78b))
+* update GitHub release action to use modern softprops/action-gh-release ([dd11de0](https://github.com/edcalderon/my-second-brain/commit/dd11de0cc05dacb9cf7e614e57535a4d54617678))
+* update repository URL in versioning package.json ([3723c78](https://github.com/edcalderon/my-second-brain/commit/3723c781bc61ee9fdf2b9bb0446274be495403ac))
+
+
+### Features
+
+* add comprehensive versioning package with CLI, changelog, and NPM publishing ([dba69bd](https://github.com/edcalderon/my-second-brain/commit/dba69bd61cc0a6b11f881a913ee900142b5ddd14))
+
+
+
+
+
 # Changelog
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -11,6 +11,7 @@ A comprehensive versioning and changelog management tool designed for monorepos
 - 📦 NPM publishable
 - 🏷️ Git tagging and committing
 - ✅ Validation of version sync
+- 🔌 **Extensible plugin system** for custom business logic
 
 ## Installation
 
@@ -22,21 +23,184 @@ pnpm add -g @edcalderon/versioning
 yarn global add @edcalderon/versioning
 ```
 
+## Extensions
+
+The versioning tool supports a **composable extension system** that allows you to add custom business logic and commands. Extensions can:
+
+- Add new CLI commands
+- Hook into existing workflows (pre/post version bumps, releases, etc.)
+- Integrate with external services
+- Implement custom versioning strategies
+
+Extensions are loaded automatically from:
+- Built-in extensions in the `src/extensions/` directory
+- External packages listed in `versioning.config.json`
+
+### Creating Extensions
+
+Extensions are TypeScript modules that implement the `VersioningExtension` interface:
+
+```typescript
+import { Command } from 'commander';
+import { VersioningExtension } from '@edcalderon/versioning';
+
+const extension: VersioningExtension = {
+  name: 'my-extension',
+  description: 'My custom extension',
+  version: '1.0.0',
+
+  register: async (program: Command, config: any) => {
+    // Add custom commands here
+    program
+      .command('my-command')
+      .description('My custom command')
+      .action(async () => {
+        console.log('Custom command executed!');
+      });
+  },
+
+  hooks: {
+    preVersion: async (type: string, options: any) => {
+      console.log(`About to bump ${type} version...`);
+    },
+    postVersion: async (type: string, version: string, options: any) => {
+      console.log(`Version bumped to ${version}`);
+    }
+  }
+};
+
+export default extension;
+```
+
+### Extension Hooks
+
+Extensions can hook into the versioning lifecycle:
+
+- `preVersion`: Called before version bump
+- `postVersion`: Called after version bump
+- `preRelease`: Called before release creation
+- `postRelease`: Called after release creation
+- `preChangelog`: Called before changelog generation
+- `postChangelog`: Called after changelog generation
+- `preSync`: Called before version sync
+- `postSync`: Called after version sync
+
+### Built-in Extensions
+
+#### Lifecycle Hooks Extension
+
+Demonstrates all available hooks with example business logic:
+
+```bash
+versioning hooks list    # List available hooks
+versioning hooks run pre-deploy  # Manually run a hook
+```
+
+#### NPM Publish Extension
+
+Handles NPM publishing with custom logic:
+
+```bash
+versioning publish-package --tag latest
+versioning publish-local --registry http://localhost:4873
+```
+
+Features:
+- Automatic package building
+- Prepublish checks
+- Publication verification
+- 2FA/OTP support
+- Local registry support
+- Dry-run mode
+
+### External Extensions
+
+To use external extensions, add them to your `versioning.config.json`:
+
+```json
+{
+  "extensions": [
+    "my-versioning-extension",
+    {
+      "name": "another-extension",
+      "path": "./local-extensions/another-extension"
+    }
+  ]
+}
+```
+
+External extensions should be published as NPM packages with the naming convention `*-versioning-extension` or implement the `VersioningExtension` interface.
+
+### Extension Development
+
+1. Create a new TypeScript file in `src/extensions/`
+2. Implement the `VersioningExtension` interface
+3. Export the extension as default
+4. The extension will be loaded automatically
+
+For external extensions:
+1. Create a separate NPM package
+2. Export the extension as the main module
+3. Publish to NPM
+4. Install and configure in target projects
+
+### Extension API Reference
+
+#### VersioningExtension Interface
+
+```typescript
+interface VersioningExtension {
+  name: string;                    // Extension name
+  description: string;             // Extension description
+  version: string;                 // Extension version
+  register: (program: Command, config: any) => void | Promise<void>;
+  hooks?: ExtensionHooks;          // Optional lifecycle hooks
+}
+```
+
+#### ExtensionHooks Interface
+
+```typescript
+interface ExtensionHooks {
+  preVersion?: (type: string, options: any) => void | Promise<void>;
+  postVersion?: (type: string, version: string, options: any) => void | Promise<void>;
+  preRelease?: (version: string, options: any) => void | Promise<void>;
+  postRelease?: (version: string, options: any) => void | Promise<void>;
+  preChangelog?: (options: any) => void | Promise<void>;
+  postChangelog?: (options: any) => void | Promise<void>;
+  preSync?: (options: any) => void | Promise<void>;
+  postSync?: (options: any) => void | Promise<void>;
+}
+```
+
+### Extension Context
+
+Extensions can access the versioning context:
+
+```typescript
+import { getExtensionContext } from '@edcalderon/versioning';
+
+const context = getExtensionContext();
+if (context) {
+  // Access versionManager, changelogManager, etc.
+}
+```
+
 ## Quick Start
 
 1. Initialize configuration:
 ```bash
-ed-version init
+versioning init
 ```
 
 2. Bump version and generate changelog:
 ```bash
-ed-version bump patch
+versioning bump patch
 ```
 
 3. Sync versions across packages (for monorepos):
 ```bash
-ed-version sync
+versioning sync
 ```
 
 ### Edward's Monorepo Example
@@ -45,7 +209,7 @@ For this specific monorepo with dashboard app:
 
 ```bash
 # Initialize config
-ed-version init
+versioning init
 
 # Edit versioning.config.json to:
 {
@@ -54,12 +218,67 @@ ed-version init
 }
 
 # Sync dashboard with main version
-ed-version patch --packages "apps/dashboard"
+versioning patch --packages "apps/dashboard"
 
 # Versioning package maintains its own version
-cd packages/versioning && ed-version patch --skip-sync
+cd packages/versioning && versioning patch --skip-sync
+```
+
+### Internal Versioning
+
+This versioning package uses its own versioning system internally for development and releases:
+
+```bash
+# Bump version internally
+npm run version:patch    # Bump patch version
+npm run version:minor    # Bump minor version
+npm run version:major    # Bump major version
+
+# Generate changelog
+npm run changelog
+
+# Publish to NPM
+npm run publish:npm      # Publish to NPM
+npm run publish:npm -- --tag beta  # Publish with specific tag
+
+# Publish to local registry for testing
+npm run publish:local
+
+# Create and push version tag
+npm run create-tag
+
+# Complete release process
+npm run release          # Bump version, changelog, create tag
+npm run release:local    # Bump version, changelog, publish locally
+```
+
+The package maintains its own version using the same tooling it provides, ensuring consistency and testing the functionality in production. The NPM publishing extension handles all the complex publishing logic including building, verification, and 2FA support.
+
+#### NPM Publish Extension
+
+The package includes a built-in NPM publishing extension for streamlined publishing:
+
+```bash
+# Publish to NPM
+npm run publish:npm
+
+# Publish to NPM with specific tag
+npm run publish:npm -- --tag beta
+
+# Publish to local registry for testing
+npm run publish:local
+
+# Publish to custom local registry
+npm run publish:local -- --registry http://localhost:4873
 ```
 
+The extension automatically:
+- Builds the package if needed
+- Runs prepublish checks
+- Verifies publication
+- Handles 2FA/OTP if required
+- Supports dry-run mode
+
 ## Configuration
 
 Create a `versioning.config.json` file in your project root:
@@ -101,39 +320,39 @@ For monorepos:
 
 ### Release Commands
 
-#### `ed-version patch [options]`
+#### `versioning 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"
+versioning patch
+versioning patch --packages "packages/app1,packages/app2" --message "Fix critical bug"
 ```
 
-#### `ed-version minor [options]`
+#### `versioning 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"
+versioning minor
+versioning minor --packages "apps/dashboard" --message "Add new features"
 ```
 
-#### `ed-version major [options]`
+#### `versioning major [options]`
 
 Create a major release (bumps 1.0.0 → 2.0.0)
 
 ```bash
-ed-version major --message "Breaking changes"
+versioning major --message "Breaking changes"
 ```
 
-#### `ed-version release <version> [options]`
+#### `versioning 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
+versioning release 1.2.3 --message "Custom release"
+versioning release 2.0.0-beta.1 --skip-sync
 ```
 
 **Options for release commands:**
@@ -156,7 +375,7 @@ Options:
 - `--no-commit`: Don't commit changes
 - `--no-tag`: Don't create git tag
 
-### `ed-version changelog [options]`
+### `versioning changelog [options]`
 
 Generate changelog from commits.
 
@@ -165,7 +384,7 @@ Options:
 - `-t, --to <commit>`: To commit
 - `-c, --config <file>`: Config file path
 
-### `ed-version sync [options]`
+### `versioning sync [options]`
 
 Sync versions across all packages.
 
@@ -173,14 +392,14 @@ Options:
 - `-v, --version <version>`: Target version to sync to
 - `-c, --config <file>`: Config file path
 
-### `ed-version validate [options]`
+### `versioning validate [options]`
 
 Validate that all packages have the correct version.
 
 Options:
 - `-c, --config <file>`: Config file path
 
-### `ed-version init [options]`
+### `versioning init [options]`
 
 Initialize a new versioning config file.
 
@@ -205,7 +424,7 @@ Add to your release workflow:
 Use with husky for automated versioning:
 
 ```bash
-npx husky add .husky/pre-commit "ed-version validate"
+npx husky add .husky/pre-commit "versioning validate"
 ```
 
 ## Conventional Commits
@@ -230,21 +449,39 @@ This package uses GitHub Actions for automated publishing to NPM when version ta
 
 #### Release Process
 
-1. **Update Version**: Use the versioning commands to bump version and update changelog
+1. **Update Version**: Use the internal versioning scripts to bump version and update changelog
+   ```bash
+   npm run version:patch  # or version:minor, version:major
+   npm run changelog
+   ```
+
+2. **Publish Locally (Optional)**: Test publishing to a local registry
    ```bash
-   ed-version patch  # or minor, major
+   npm run publish:local
    ```
 
-2. **Create Git Tag**: The package includes a helper script to create and push version tags
+3. **Create Git Tag**: Use the create-tag 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
+4. **Automated Publishing**: GitHub Actions will automatically publish to NPM using the publish extension
+
+#### Quick Release Commands
+
+```bash
+# Full production release
+npm run release          # Bump version, changelog, create tag
+
+# Local testing release
+npm run release:local    # Bump version, changelog, publish locally
+
+# Manual publishing
+npm run publish:npm      # Publish current version to NPM
+npm run publish:npm -- --tag beta  # Publish with specific tag
+```
+
+This uses the same versioning and publishing logic that the package provides to users, ensuring the tool "eats its own dog food".
 
 #### Manual Publishing (First Release)
 

package/dist/changelogManager.d.ts

@@ -0,0 +1,4 @@
+export declare class ChangelogManager {
+    generate(from?: string, to?: string): Promise<string>;
+}
+//# sourceMappingURL=changelogManager.d.ts.map

package/dist/changelogManager.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangelogManager = void 0;
+class ChangelogManager {
+    async generate(from, to) {
+        // TODO: Implement changelog generation logic
+        console.log('Generating changelog...');
+        return '';
+    }
+}
+exports.ChangelogManager = ChangelogManager;
+//# sourceMappingURL=changelogManager.js.map

package/dist/cli.js

@@ -40,11 +40,12 @@ const versioning_1 = require("./versioning");
 const changelog_1 = require("./changelog");
 const sync_1 = require("./sync");
 const release_1 = require("./release");
+const extensions_1 = require("./extensions");
 const program = new commander_1.Command();
 program
-    .name('ed-version')
+    .name('versioning')
     .description('Comprehensive versioning and changelog management for monorepos')
-    .version('1.0.0');
+    .version('1.0.4');
 program
     .command('bump <type>')
     .description('Bump version (patch, minor, major, prerelease)')
@@ -57,6 +58,8 @@ program
         const config = await loadConfig(options.config);
         const versionManager = new versioning_1.VersionManager(config);
         const changelogManager = new changelog_1.ChangelogManager(config);
+        // Pre-version hook
+        await (0, extensions_1.runExtensionHooks)('preVersion', type, options);
         const newVersion = await versionManager.bumpVersion(type, options.preRelease);
         console.log(`Bumped version to ${newVersion}`);
         // Generate changelog
@@ -70,6 +73,8 @@ program
             await versionManager.createGitTag(newVersion);
             console.log('Created git tag');
         }
+        // Post-version hook
+        await (0, extensions_1.runExtensionHooks)('postVersion', type, newVersion, options);
         console.log(`✅ Successfully released v${newVersion}`);
     }
     catch (error) {
@@ -87,7 +92,11 @@ program
     try {
         const config = await loadConfig(options.config);
         const changelogManager = new changelog_1.ChangelogManager(config);
+        // Pre-changelog hook
+        await (0, extensions_1.runExtensionHooks)('preChangelog', options);
         await changelogManager.generate(options.from, options.to);
+        // Post-changelog hook
+        await (0, extensions_1.runExtensionHooks)('postChangelog', options);
         console.log('✅ Changelog generated');
     }
     catch (error) {
@@ -104,6 +113,8 @@ program
     try {
         const config = await loadConfig(options.config);
         const syncManager = new sync_1.SyncManager(config);
+        // Pre-sync hook
+        await (0, extensions_1.runExtensionHooks)('preSync', options);
         await syncManager.syncVersions(options.version);
         console.log('✅ Versions synced');
         const validation = await syncManager.validateSync();
@@ -111,6 +122,8 @@ program
             console.log('⚠️  Validation issues:');
             validation.issues.forEach(issue => console.log(`  - ${issue}`));
         }
+        // Post-sync hook
+        await (0, extensions_1.runExtensionHooks)('postSync', options);
     }
     catch (error) {
         console.error('❌ Error:', error instanceof Error ? error.message : String(error));
@@ -290,7 +303,8 @@ program
             changelogFile: 'CHANGELOG.md',
             conventionalCommits: true,
             syncDependencies: false,
-            ignorePackages: []
+            ignorePackages: [],
+            extensions: [] // Add extensions array to config
         };
         await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
         console.log('✅ Initialized versioning config at versioning.config.json');
@@ -302,9 +316,21 @@ program
 });
 async function loadConfig(configPath) {
     if (!(await fs.pathExists(configPath))) {
-        throw new Error(`Config file not found: ${configPath}. Run 'ed-version init' to create one.`);
+        throw new Error(`Config file not found: ${configPath}. Run 'versioning init' to create one.`);
     }
     return await fs.readJson(configPath);
 }
-program.parse();
+async function main() {
+    try {
+        // Load and register extensions
+        await (0, extensions_1.loadExtensions)(program);
+        // Parse command line arguments
+        program.parse();
+    }
+    catch (error) {
+        console.error('❌ Error loading extensions:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+main();
 //# sourceMappingURL=cli.js.map

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

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

package/dist/extensions/lifecycle-hooks.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const extension = {
+    name: 'lifecycle-hooks',
+    description: 'Extension demonstrating lifecycle hooks for versioning process',
+    version: '1.0.0',
+    hooks: {
+        preVersion: async (type, options) => {
+            console.log(`🔗 Pre-version hook: Preparing for ${type} release...`);
+            console.log('📋 Running pre-flight checks...');
+            console.log('🔍 Validating environment...');
+            console.log('📊 Gathering metrics...');
+        },
+        postVersion: async (type, version, options) => {
+            console.log(`🔗 Post-version hook: ${type} release ${version} completed!`);
+            console.log('📈 Updating dashboards...');
+            console.log('🔄 Triggering CI/CD pipelines...');
+            console.log('📝 Creating release notes...');
+        },
+        preChangelog: async (options) => {
+            console.log('🔗 Pre-changelog hook: Preparing changelog generation...');
+            console.log('📚 Analyzing commits...');
+        },
+        postChangelog: async (options) => {
+            console.log('🔗 Post-changelog hook: Changelog updated!');
+            console.log('📤 Changelog ready for review...');
+        },
+        preSync: async (options) => {
+            console.log('🔗 Pre-sync hook: Preparing version synchronization...');
+            console.log('🔗 Checking package dependencies...');
+        },
+        postSync: async (options) => {
+            console.log('🔗 Post-sync hook: Version sync completed!');
+            console.log('✅ All packages aligned...');
+        }
+    },
+    register: async (program, config) => {
+        // Add a command to demonstrate hook management
+        program
+            .command('hooks')
+            .description('Manage versioning lifecycle hooks (sample extension)')
+            .addCommand(new commander_1.Command('list')
+            .description('List available hooks')
+            .action(() => {
+            console.log('🔗 Available Lifecycle Hooks:');
+            console.log('  • preVersion: Runs before version bump');
+            console.log('  • postVersion: Runs after version bump');
+            console.log('  • preRelease: Runs before release creation');
+            console.log('  • postRelease: Runs after release creation');
+            console.log('  • preChangelog: Runs before changelog generation');
+            console.log('  • postChangelog: Runs after changelog generation');
+            console.log('  • preSync: Runs before version sync');
+            console.log('  • postSync: Runs after version sync');
+        }))
+            .addCommand(new commander_1.Command('run')
+            .description('Manually run a hook')
+            .argument('<hook>', 'Hook name to run')
+            .option('-d, --data <data>', 'Data to pass to hook')
+            .action(async (hookName, options) => {
+            console.log(`🔗 Running hook: ${hookName}`);
+            // This would be implemented to manually trigger hooks
+            console.log(`📄 Hook data: ${options.data || 'none'}`);
+        }));
+    }
+};
+exports.default = extension;
+//# sourceMappingURL=lifecycle-hooks.js.map

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

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

package/dist/extensions/npm-publish.js

@@ -0,0 +1,181 @@
+"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 child_process_1 = require("child_process");
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const extension = {
+    name: 'npm-publish',
+    description: 'Extension for NPM publishing with custom logic',
+    version: '1.0.0',
+    register: async (program, config) => {
+        // Add publish command
+        program
+            .command('publish-package')
+            .description('Publish package to NPM with custom logic')
+            .option('-t, --tag <tag>', 'NPM dist tag', 'latest')
+            .option('-d, --dry-run', 'Dry run mode', false)
+            .option('--otp <code>', 'NPM 2FA code')
+            .action(async (options) => {
+            try {
+                await publishToNPM(options);
+            }
+            catch (error) {
+                console.error('❌ Publish failed:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+        // Add local publish command for development
+        program
+            .command('publish-local')
+            .description('Publish to local NPM registry for testing')
+            .option('-r, --registry <url>', 'Local registry URL', 'http://localhost:4873')
+            .action(async (options) => {
+            try {
+                await publishToLocalRegistry(options);
+            }
+            catch (error) {
+                console.error('❌ Local publish failed:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+    },
+    hooks: {
+        postVersion: async (type, version, options) => {
+            console.log(`📦 Version bumped to ${version}, ready for publishing`);
+        },
+        postRelease: async (version, options) => {
+            console.log(`🚀 Release ${version} completed, triggering automated publish...`);
+            // Auto-publish if configured
+            if (process.env.CI && process.env.NPM_TOKEN) {
+                console.log('🤖 Running in CI with NPM_TOKEN, auto-publishing...');
+                try {
+                    await publishToNPM({
+                        tag: 'latest',
+                        otp: process.env.NPM_OTP
+                    });
+                }
+                catch (error) {
+                    console.error('❌ Auto-publish failed:', error instanceof Error ? error.message : String(error));
+                    // Don't exit in CI, let the workflow handle it
+                }
+            }
+        }
+    }
+};
+async function publishToNPM(options) {
+    const { tag = 'latest', dryRun = false, otp } = options;
+    console.log(`📦 Publishing to NPM with tag: ${tag}`);
+    if (dryRun) {
+        console.log('🔍 Dry run mode - would publish but not actually doing it');
+        return;
+    }
+    // Check if package.json exists
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!await fs.pathExists(packageJsonPath)) {
+        throw new Error('package.json not found');
+    }
+    // Read package info
+    const packageJson = await fs.readJson(packageJsonPath);
+    const packageName = packageJson.name;
+    const version = packageJson.version;
+    console.log(`📦 Publishing ${packageName}@${version}...`);
+    // Check if already published
+    try {
+        const result = (0, child_process_1.execSync)(`npm view ${packageName}@${version} version`, { stdio: 'pipe' });
+        if (result.toString().trim() === version) {
+            console.log(`⚠️  Version ${version} already published, skipping`);
+            return;
+        }
+    }
+    catch (error) {
+        // Version doesn't exist, continue with publish
+    }
+    // Build package if needed
+    if (packageJson.scripts && packageJson.scripts.build) {
+        console.log('🔨 Building package...');
+        (0, child_process_1.execSync)('npm run build', { stdio: 'inherit' });
+    }
+    // Run prepublish checks
+    if (packageJson.scripts && packageJson.scripts.prepublishOnly) {
+        console.log('🔍 Running prepublish checks...');
+        (0, child_process_1.execSync)('npm run prepublishOnly', { stdio: 'inherit' });
+    }
+    // Prepare publish command
+    let publishCmd = `npm publish --tag ${tag}`;
+    if (otp) {
+        publishCmd += ` --otp ${otp}`;
+    }
+    // Execute publish
+    console.log(`🚀 Executing: ${publishCmd}`);
+    (0, child_process_1.execSync)(publishCmd, { stdio: 'inherit' });
+    console.log(`✅ Successfully published ${packageName}@${version} with tag ${tag}`);
+    // Verify publication
+    console.log('🔍 Verifying publication...');
+    const verifyResult = (0, child_process_1.execSync)(`npm view ${packageName}@${version} version`, { stdio: 'pipe' });
+    if (verifyResult.toString().trim() === version) {
+        console.log(`✅ Publication verified: ${packageName}@${version}`);
+    }
+    else {
+        throw new Error('Publication verification failed');
+    }
+}
+async function publishToLocalRegistry(options) {
+    const { registry = 'http://localhost:4873' } = options;
+    console.log(`🏠 Publishing to local registry: ${registry}`);
+    // Check if local registry is running
+    try {
+        (0, child_process_1.execSync)(`curl -s ${registry} > /dev/null`, { stdio: 'pipe' });
+    }
+    catch (error) {
+        throw new Error(`Local registry at ${registry} is not accessible`);
+    }
+    // Set registry for this publish
+    const originalRegistry = process.env.npm_config_registry;
+    process.env.npm_config_registry = registry;
+    try {
+        await publishToNPM({
+            tag: 'local',
+            dryRun: false
+        });
+    }
+    finally {
+        // Restore original registry
+        process.env.npm_config_registry = originalRegistry;
+    }
+    console.log(`✅ Published to local registry: ${registry}`);
+}
+exports.default = extension;
+//# sourceMappingURL=npm-publish.js.map

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

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

package/dist/extensions/sample-extension.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extension = {
+    name: 'sample-extension',
+    description: 'Sample extension demonstrating custom business logic',
+    version: '1.0.0',
+    register: async (program, config) => {
+        // Add a custom command
+        program
+            .command('deploy')
+            .description('Deploy application after versioning (sample extension)')
+            .option('-e, --environment <env>', 'Deployment environment', 'staging')
+            .option('-c, --config <file>', 'Config file path', 'versioning.config.json')
+            .action(async (options) => {
+            try {
+                console.log(`🚀 Deploying to ${options.environment} environment...`);
+                // Custom deployment logic here
+                console.log('📦 Building application...');
+                console.log('🔄 Running tests...');
+                console.log('☁️  Deploying to cloud...');
+                console.log('✅ Deployment completed!');
+                console.log(`🎉 Successfully deployed to ${options.environment}`);
+            }
+            catch (error) {
+                console.error('❌ Deployment failed:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+        // Add another custom command
+        program
+            .command('notify')
+            .description('Send notifications after versioning (sample extension)')
+            .option('-m, --message <msg>', 'Notification message')
+            .option('-c, --channels <channels>', 'Comma-separated notification channels', 'slack,email')
+            .action(async (options) => {
+            try {
+                const channels = options.channels.split(',');
+                const message = options.message || 'Version update completed';
+                console.log(`📢 Sending notification: "${message}"`);
+                for (const channel of channels) {
+                    console.log(`📤 Notifying ${channel}...`);
+                    // Custom notification logic here
+                }
+                console.log('✅ Notifications sent!');
+            }
+            catch (error) {
+                console.error('❌ Notification failed:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+    }
+};
+exports.default = extension;
+//# sourceMappingURL=sample-extension.js.map

package/dist/extensions.d.ts

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+export interface VersioningExtension {
+    name: string;
+    description: string;
+    version: string;
+    register: (program: Command, config: any) => void | Promise<void>;
+    hooks?: ExtensionHooks;
+}
+export interface ExtensionHooks {
+    preVersion?: (type: string, options: any) => void | Promise<void>;
+    postVersion?: (type: string, version: string, options: any) => void | Promise<void>;
+    preRelease?: (version: string, options: any) => void | Promise<void>;
+    postRelease?: (version: string, options: any) => void | Promise<void>;
+    preChangelog?: (options: any) => void | Promise<void>;
+    postChangelog?: (options: any) => void | Promise<void>;
+    preSync?: (options: any) => void | Promise<void>;
+    postSync?: (options: any) => void | Promise<void>;
+}
+export interface ExtensionContext {
+    config: any;
+    versionManager?: any;
+    changelogManager?: any;
+    syncManager?: any;
+    releaseManager?: any;
+    hooks: ExtensionHooks[];
+}
+export declare function getExtensionContext(): ExtensionContext | null;
+export declare function initializeExtensionContext(config: any): Promise<ExtensionContext>;
+export declare function runExtensionHooks(hookName: keyof ExtensionHooks, ...args: any[]): Promise<void>;
+export declare function loadExtensions(program: Command): Promise<void>;
+export declare function createExtensionContext(config: any): ExtensionContext;
+//# sourceMappingURL=extensions.d.ts.map

package/dist/extensions.js

@@ -0,0 +1,147 @@
+"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.getExtensionContext = getExtensionContext;
+exports.initializeExtensionContext = initializeExtensionContext;
+exports.runExtensionHooks = runExtensionHooks;
+exports.loadExtensions = loadExtensions;
+exports.createExtensionContext = createExtensionContext;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+let globalExtensionContext = null;
+function getExtensionContext() {
+    return globalExtensionContext;
+}
+async function initializeExtensionContext(config) {
+    globalExtensionContext = {
+        config,
+        hooks: []
+    };
+    return globalExtensionContext;
+}
+async function runExtensionHooks(hookName, ...args) {
+    if (!globalExtensionContext)
+        return;
+    for (const extensionHooks of globalExtensionContext.hooks) {
+        const hook = extensionHooks[hookName];
+        if (hook) {
+            try {
+                await hook(...args);
+            }
+            catch (error) {
+                console.warn(`⚠️  Extension hook ${hookName} failed:`, error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+}
+async function loadExtensions(program) {
+    try {
+        // Try to load config to get extensions list
+        let config = {};
+        if (await fs.pathExists('versioning.config.json')) {
+            config = await fs.readJson('versioning.config.json');
+        }
+        // Initialize extension context
+        const context = await initializeExtensionContext(config);
+        const extensions = config.extensions || [];
+        // Load built-in extensions from local extensions directory
+        const extensionsDir = path.join(__dirname, 'extensions');
+        if (await fs.pathExists(extensionsDir)) {
+            const extensionFiles = await fs.readdir(extensionsDir);
+            for (const file of extensionFiles) {
+                if (file.endsWith('.js')) {
+                    try {
+                        const extensionPath = path.join(extensionsDir, file);
+                        const extensionModule = require(extensionPath);
+                        const extension = extensionModule.default || extensionModule;
+                        if (extension && typeof extension.register === 'function') {
+                            await extension.register(program, config);
+                            // Register hooks if available
+                            if (extension.hooks) {
+                                context.hooks.push(extension.hooks);
+                            }
+                            console.log(`✅ Loaded extension: ${extension.name}@${extension.version}`);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`⚠️  Failed to load extension ${file}:`, error instanceof Error ? error.message : String(error));
+                    }
+                }
+            }
+        }
+        // Note: External extensions from config.extensions are not yet implemented
+        // This would require a package manager to install and load external extensions
+        // Load external extensions from node_modules or specified paths
+        for (const extConfig of extensions) {
+            try {
+                let extension;
+                if (typeof extConfig === 'string') {
+                    // Load from node_modules
+                    extension = require(extConfig);
+                }
+                else if (extConfig.path) {
+                    // Load from custom path
+                    extension = require(path.resolve(extConfig.path));
+                }
+                else {
+                    continue;
+                }
+                if (extension && typeof extension.register === 'function') {
+                    await extension.register(program, config);
+                    // Register hooks if available
+                    if (extension.hooks) {
+                        context.hooks.push(extension.hooks);
+                    }
+                    console.log(`✅ Loaded external extension: ${extension.name}@${extension.version}`);
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Failed to load external extension:`, error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail if extensions can't be loaded, just warn
+        console.warn('⚠️  Could not load extensions:', error instanceof Error ? error.message : String(error));
+    }
+}
+function createExtensionContext(config) {
+    return {
+        config,
+        hooks: []
+        // Managers will be injected when available
+    };
+}
+//# sourceMappingURL=extensions.js.map

package/dist/release.d.ts

@@ -1,8 +1,9 @@
-import { VersionManager, ChangelogManager, SyncManager } from './index';
+import { VersionManager } from './index';
+import { ChangelogManager } from './changelog';
 export interface ReleaseConfig {
     versionManager: VersionManager;
     changelogManager: ChangelogManager;
-    syncManager: SyncManager;
+    syncManager: any;
     createTag?: boolean;
     createCommit?: boolean;
     publish?: boolean;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@edcalderon/versioning",
-  "version": "1.0.3",
+  "version": "1.0.7",
   "description": "A comprehensive versioning and changelog management tool for monorepos",
   "main": "dist/index.js",
   "bin": {
-    "ed-version": "dist/cli.js"
+    "versioning": "dist/cli.js"
   },
   "scripts": {
     "build": "tsc",
@@ -14,7 +14,15 @@
     "test:coverage": "jest --coverage",
     "lint": "eslint src/**/*.ts",
     "prepublishOnly": "npm run build && npm run test",
-    "create-tag": "node scripts/create-tag.js"
+    "version:patch": "node dist/cli.js patch --no-commit --no-tag",
+    "version:minor": "node dist/cli.js minor --no-commit --no-tag",
+    "version:major": "node dist/cli.js major --no-commit --no-tag",
+    "changelog": "node dist/cli.js changelog",
+    "publish:npm": "node dist/cli.js publish-package",
+    "publish:local": "node dist/cli.js publish-local",
+    "create-tag": "node scripts/create-tag.js",
+    "release": "npm run version:patch && npm run changelog && npm run create-tag",
+    "release:local": "npm run version:patch && npm run changelog && npm run publish:local"
   },
   "keywords": [
     "versioning",

package/scripts/create-tag.js

@@ -1,26 +1,41 @@
 #!/usr/bin/env node
 
 const { execSync } = require('child_process');
-const fs = require('fs');
 const path = require('path');
 
-function createVersionTag() {
+// Use the built versioning tool to get the current version
+async function getCurrentVersion() {
   try {
-    // Get current version from package.json (go up two directories from scripts/)
+    const { VersionManager } = require('../dist/versioning');
+    const versionManager = new VersionManager();
+    return await versionManager.getCurrentVersion();
+  } catch (error) {
+    // Fallback to reading package.json directly
+    const fs = require('fs');
     const packageJsonPath = path.join(__dirname, '..', 'package.json');
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    const version = packageJson.version;
+    return packageJson.version;
+  }
+}
+
+async function createVersionTag() {
+  try {
+    // Get current version using the versioning tool
+    const version = await getCurrentVersion();
 
     // Use versioning prefix to avoid conflicts with monorepo tags
     const tagPrefix = 'versioning-v';
     const fullTag = `${tagPrefix}${version}`;
 
+    console.log(`📦 Current version: ${version}`);
+    console.log(`🏷️  Creating tag: ${fullTag}`);
+
     // 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`);
+        console.log(`⚠️  Tag ${fullTag} already exists`);
         return;
       }
     } catch (error) {
@@ -31,17 +46,17 @@ function createVersionTag() {
     const tagMessage = `Release @edcalderon/versioning v${version}`;
     execSync(`git tag -a "${fullTag}" -m "${tagMessage}"`, { stdio: 'inherit' });
 
-    console.log(`Created tag ${fullTag}`);
+    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(`🚀 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);
+    console.error('❌ Error creating version tag:', error.message);
     process.exit(1);
   }
 }

package/versioning.config.json

@@ -0,0 +1,15 @@
+{
+  "rootPackageJson": "package.json",
+  "packages": [],
+  "changelogFile": "CHANGELOG.md",
+  "conventionalCommits": true,
+  "syncDependencies": false,
+  "ignorePackages": [],
+  "changelog": {
+    "preset": "angular",
+    "releaseCount": 0
+  },
+  "sync": {
+    "includeRoot": true
+  }
+}