@edcalderon/versioning 1.4.2 → 1.4.3

package/dist/cli.js

@@ -41,6 +41,7 @@ const changelog_1 = require("./changelog");
 const sync_1 = require("./sync");
 const release_1 = require("./release");
 const status_1 = require("./status");
+const extension_manager_1 = require("./extension-manager");
 const extensions_1 = require("./extensions");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const pkg = require('../package.json');
@@ -411,6 +412,58 @@ program
         process.exit(1);
     }
 });
+program
+    .command('extension')
+    .description('Manage extensions (list, bump, changelog)')
+    .argument('<action>', 'action to perform (list, bump, changelog)')
+    .argument('[extension]', 'extension name (required for bump and changelog)')
+    .option('-t, --type <type>', 'bump type for extension (patch, minor, major)', 'patch')
+    .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+    .action(async (action, extension, options) => {
+    try {
+        const extensionManager = new extension_manager_1.ExtensionManager();
+        if (action === 'bump') {
+            if (!extension) {
+                console.error('❌ Extension name required for bump action');
+                process.exit(1);
+            }
+            const newVersion = await extensionManager.bumpExtensionVersion(extension, options.type);
+            console.log(`✅ Bumped ${extension} to ${newVersion}`);
+        }
+        else if (action === 'list') {
+            const extensions = await extensionManager.listExtensions();
+            console.log('📦 Available Extensions:');
+            extensions.forEach(ext => {
+                console.log(`  • ${ext.name}@${ext.version} - ${ext.description}`);
+            });
+        }
+        else if (action === 'changelog') {
+            if (!extension) {
+                console.error('❌ Extension name required for changelog action');
+                process.exit(1);
+            }
+            const changelog = await extensionManager.getExtensionChangelog(extension);
+            if (changelog) {
+                console.log(`📝 Changelog for ${extension}:`);
+                console.log(changelog);
+            }
+            else {
+                console.log(`❌ No changelog found for extension: ${extension}`);
+            }
+        }
+        else {
+            console.log('Available actions: list, bump, changelog');
+            console.log('Usage:');
+            console.log('  versioning extension list');
+            console.log('  versioning extension bump <extension> --type patch');
+            console.log('  versioning extension changelog <extension>');
+        }
+    }
+    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 'versioning init' to create one.`);

package/dist/extension-manager.d.ts

@@ -0,0 +1,18 @@
+export interface ExtensionInfo {
+    name: string;
+    version: string;
+    description: string;
+    path: string;
+    changelogPath?: string;
+}
+export declare class ExtensionManager {
+    private extensionsDir;
+    constructor(extensionsDir?: string);
+    listExtensions(): Promise<ExtensionInfo[]>;
+    bumpExtensionVersion(extensionName: string, bumpType: 'patch' | 'minor' | 'major'): Promise<string>;
+    private updateExtensionChangelog;
+    private getChangeType;
+    getExtensionChangelog(extensionName: string): Promise<string | null>;
+    createExtensionChangelog(extensionName: string): Promise<void>;
+}
+//# sourceMappingURL=extension-manager.d.ts.map

package/dist/extension-manager.js

@@ -0,0 +1,176 @@
+"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.ExtensionManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
+class ExtensionManager {
+    constructor(extensionsDir) {
+        // In built version, __dirname is dist/, so go up one level to src/
+        const baseDir = path.dirname(__dirname);
+        this.extensionsDir = extensionsDir || path.join(baseDir, 'src', 'extensions');
+    }
+    async listExtensions() {
+        const extensions = [];
+        if (!(await fs.pathExists(this.extensionsDir))) {
+            return extensions;
+        }
+        const dirs = await fs.readdir(this.extensionsDir);
+        for (const dir of dirs) {
+            const extensionPath = path.join(this.extensionsDir, dir);
+            const stat = await fs.stat(extensionPath);
+            if (!stat.isDirectory())
+                continue;
+            const indexPath = path.join(extensionPath, 'index.ts');
+            if (!(await fs.pathExists(indexPath)))
+                continue;
+            const content = await fs.readFile(indexPath, 'utf-8');
+            const versionMatch = content.match(/version:\s*['"]([^'"]+)['"]/);
+            const descriptionMatch = content.match(/description:\s*['"]([^'"]+)['"]/);
+            if (versionMatch) {
+                const changelogPath = path.join(extensionPath, 'CHANGELOG.md');
+                const hasChangelog = await fs.pathExists(changelogPath);
+                extensions.push({
+                    name: dir,
+                    version: versionMatch[1],
+                    description: descriptionMatch ? descriptionMatch[1] : 'No description',
+                    path: extensionPath,
+                    changelogPath: hasChangelog ? changelogPath : undefined
+                });
+            }
+        }
+        return extensions;
+    }
+    async bumpExtensionVersion(extensionName, bumpType) {
+        const extensionPath = path.join(this.extensionsDir, extensionName, 'index.ts');
+        if (!(await fs.pathExists(extensionPath))) {
+            throw new Error(`Extension not found: ${extensionName}`);
+        }
+        const content = await fs.readFile(extensionPath, 'utf-8');
+        const versionMatch = content.match(/version:\s*['"]([^'"]+)['"]/);
+        if (!versionMatch) {
+            throw new Error(`Could not find version in ${extensionName}`);
+        }
+        const currentVersion = versionMatch[1];
+        const newVersion = semver.inc(currentVersion, bumpType);
+        if (!newVersion) {
+            throw new Error(`Invalid bump type: ${bumpType}`);
+        }
+        // Update version in index.ts
+        const updatedContent = content.replace(/version:\s*['"]([^'"]+)['"]/, `version: '${newVersion}'`);
+        await fs.writeFile(extensionPath, updatedContent);
+        // Update changelog if it exists
+        await this.updateExtensionChangelog(extensionName, currentVersion, newVersion, bumpType);
+        return newVersion;
+    }
+    async updateExtensionChangelog(extensionName, oldVersion, newVersion, bumpType) {
+        const changelogPath = path.join(this.extensionsDir, extensionName, 'CHANGELOG.md');
+        if (!(await fs.pathExists(changelogPath))) {
+            // Create changelog if it doesn't exist
+            const changelog = `# Changelog
+
+All notable changes to this extension 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).
+
+## [${newVersion}] - ${new Date().toISOString().split('T')[0]}
+
+### ${this.getChangeType(bumpType)}
+- Version bump from ${oldVersion}
+`;
+            await fs.writeFile(changelogPath, changelog);
+            return;
+        }
+        // Update existing changelog
+        const content = await fs.readFile(changelogPath, 'utf-8');
+        const today = new Date().toISOString().split('T')[0];
+        const newEntry = `\n## [${newVersion}] - ${today}\n\n### ${this.getChangeType(bumpType)}\n- Version bump from ${oldVersion}\n`;
+        // Find the first version entry and insert before it
+        const lines = content.split('\n');
+        const firstVersionIndex = lines.findIndex(line => line.match(/^## \[\d+\.\d+\.\d+\]/));
+        if (firstVersionIndex >= 0) {
+            lines.splice(firstVersionIndex, 0, newEntry.trim());
+        }
+        else {
+            lines.push(newEntry.trim());
+        }
+        await fs.writeFile(changelogPath, lines.join('\n'));
+    }
+    getChangeType(bumpType) {
+        switch (bumpType) {
+            case 'major': return 'Breaking';
+            case 'minor': return 'Features';
+            case 'patch': return 'Fixes';
+            default: return 'Changes';
+        }
+    }
+    async getExtensionChangelog(extensionName) {
+        const changelogPath = path.join(this.extensionsDir, extensionName, 'CHANGELOG.md');
+        if (!(await fs.pathExists(changelogPath))) {
+            return null;
+        }
+        return await fs.readFile(changelogPath, 'utf-8');
+    }
+    async createExtensionChangelog(extensionName) {
+        const changelogPath = path.join(this.extensionsDir, extensionName, 'CHANGELOG.md');
+        if (await fs.pathExists(changelogPath)) {
+            throw new Error(`Changelog already exists for ${extensionName}`);
+        }
+        const extensionPath = path.join(this.extensionsDir, extensionName, 'index.ts');
+        if (!(await fs.pathExists(extensionPath))) {
+            throw new Error(`Extension not found: ${extensionName}`);
+        }
+        const content = await fs.readFile(extensionPath, 'utf-8');
+        const versionMatch = content.match(/version:\s*['"]([^'"]+)['"]/);
+        const version = versionMatch ? versionMatch[1] : '1.0.0';
+        const changelog = `# Changelog
+
+All notable changes to this extension 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).
+
+## [${version}] - ${new Date().toISOString().split('T')[0]}
+
+### Added
+- Initial release
+`;
+        await fs.writeFile(changelogPath, changelog);
+    }
+}
+exports.ExtensionManager = ExtensionManager;
+//# sourceMappingURL=extension-manager.js.map

package/dist/extensions/cleanup-repo/index.js

@@ -238,7 +238,7 @@ async function scanRootForCleanup(rootDir, config) {
 const extension = {
     name: CLEANUP_EXTENSION_NAME,
     description: 'Config-driven repo root cleanup — keeps stray files out of root, configurable via versioning.config.json',
-    version: '1.4.2',
+    version: '1.1.0',
     register: async (program, rootConfig) => {
         const config = loadCleanupConfig(rootConfig);
         const cleanupCmd = program

package/dist/extensions/lifecycle-hooks/index.js

@@ -4,7 +4,7 @@ const commander_1 = require("commander");
 const extension = {
     name: 'lifecycle-hooks',
     description: 'Extension demonstrating lifecycle hooks for versioning process',
-    version: '1.4.2',
+    version: '1.0.0',
     hooks: {
         preVersion: async (type, options) => {
             console.log(`🔗 Pre-version hook: Preparing for ${type} release...`);

package/dist/extensions/npm-publish/index.js

@@ -39,7 +39,7 @@ const path = __importStar(require("path"));
 const extension = {
     name: 'npm-publish',
     description: 'Extension for NPM publishing with custom logic',
-    version: '1.4.2',
+    version: '1.0.0',
     register: async (program, config) => {
         // Add publish command
         program

package/dist/extensions/reentry-status/extension.js

@@ -52,7 +52,7 @@ const git_context_1 = require("./git-context");
 const extension = {
     name: constants_1.REENTRY_EXTENSION_NAME,
     description: 'Maintains canonical re-entry status and synchronizes to files, GitHub Issues, and Obsidian notes',
-    version: '1.4.2',
+    version: '1.2.0',
     hooks: {
         postVersion: async (type, version, options) => {
             try {

package/dist/extensions/sample-extension/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const extension = {
     name: 'sample-extension',
     description: 'Sample extension demonstrating custom business logic',
-    version: '1.4.2',
+    version: '1.0.1',
     register: async (program, config) => {
         // Add a custom command
         program

package/dist/extensions/secrets-check/index.js

@@ -103,7 +103,7 @@ function checkContentForSecrets(content, patterns, allowlist, filename) {
 const extension = {
     name: 'secrets-check',
     description: 'Checks for hardcoded secrets and private keys in staged files',
-    version: '1.4.2',
+    version: '1.1.0',
     register: async (program, config) => {
         // Try to get config from extensionConfig first, fallback to top-level secrets for backcompat
         const extensionConfig = config.extensionConfig?.['secrets-check'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edcalderon/versioning",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "A comprehensive versioning and changelog management tool for monorepos",
   "main": "dist/index.js",
   "bin": {