@edcalderon/versioning 1.4.6 → 1.4.7

package/CHANGELOG.md

@@ -5,6 +5,20 @@ 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.4.7](https://github.com/edcalderon/my-second-brain/tree/main/packages/versioning) (2026-03-16)
+
+### Added
+- ✨ New `workspace-scripts` extension (v1.0.0)
+  - `versioning scripts sync` — auto-generate `dev:all`, `build:all`, and per-app scripts in root package.json
+  - `versioning scripts list` — display current workspace script configuration
+  - `versioning scripts detect` — find new workspace apps not yet tracked in config
+  - `versioning scripts preview` — preview generated scripts without writing
+- 🔄 `postSync` hook auto-detects new apps added to pnpm-workspace.yaml
+- ⚙️ Config-driven via `extensionConfig.workspace-scripts` in versioning.config.json
+- 🏃 Runner support: `concurrently` (default) or `turbo`
+- 📦 Managed script tracking: safely adds/updates/removes only scripts it owns
+- 🧪 Comprehensive test suite for workspace-scripts extension
+
 ## [1.4.6](https://github.com/edcalderon/my-second-brain/tree/main/packages/versioning) (2026-03-01)
 
 ### Added

package/README.md

@@ -8,17 +8,19 @@ A comprehensive versioning and changelog management tool designed for monorepos
 
 ---
 
-## 📋 Latest Changes (v1.4.6)
+## 📋 Latest Changes (v1.4.7)
 
 ### Added
-- 🔧 `readme-maintainer` extension (`versioning update-readme`) — auto-updates README with the latest CHANGELOG entry
-- 🎯 Uses `package.json` version as authoritative source; falls back to highest semver in CHANGELOG
-- 📂 Logs resolved paths for transparency
-- 📝 `update-readme` script added to all packages and apps
-
-### Fixed
-- 🐛 Fixed README updater picking wrong version from malformed/misordered CHANGELOGs
-- 🐛 Fixed `@ed/auth` → `@edcalderon/auth` import in `apps/dashboard`
+- ✨ New `workspace-scripts` extension (v1.0.0)
+  - `versioning scripts sync` — auto-generate `dev:all`, `build:all`, and per-app scripts in root package.json
+  - `versioning scripts list` — display current workspace script configuration
+  - `versioning scripts detect` — find new workspace apps not yet tracked in config
+  - `versioning scripts preview` — preview generated scripts without writing
+- 🔄 `postSync` hook auto-detects new apps added to pnpm-workspace.yaml
+- ⚙️ Config-driven via `extensionConfig.workspace-scripts` in versioning.config.json
+- 🏃 Runner support: `concurrently` (default) or `turbo`
+- 📦 Managed script tracking: safely adds/updates/removes only scripts it owns
+- 🧪 Comprehensive test suite for workspace-scripts extension
 
 For full version history, see [CHANGELOG.md](./CHANGELOG.md) and [GitHub releases](https://github.com/edcalderon/my-second-brain/releases)
 

package/dist/extensions/workspace-scripts/index.d.ts

@@ -0,0 +1,47 @@
+import { VersioningExtension } from '../../extensions';
+export interface WorkspaceAppConfig {
+    /** The pnpm filter-compatible package name (auto-resolved from app's package.json if omitted) */
+    filter?: string;
+    /** The npm script to run for dev mode. Default: "dev" */
+    command?: string;
+    /** Extra args appended to the dev command (e.g. "-p 3000" or "--port 3001") */
+    args?: string;
+    /** The npm script to run for build. Default: "build" */
+    buildCommand?: string;
+    /** Extra args appended to the build command */
+    buildArgs?: string;
+    /** Optional port number (used for display/documentation only) */
+    port?: number;
+    /** Whether to include this app in dev:all / build:all. Default: true */
+    enabled?: boolean;
+}
+export interface WorkspaceScriptsConfig {
+    /** Master switch. Default: true */
+    enabled: boolean;
+    /** Apps included in concurrent dev/build scripts, keyed by workspace-relative path */
+    apps: Record<string, WorkspaceAppConfig>;
+    /** Generate individual dev:<app> scripts for each app. Default: true */
+    individualScripts?: boolean;
+    /** Generate build:all and individual build:<app> scripts. Default: true */
+    buildScripts?: boolean;
+    /** The concurrency runner: "concurrently" or "turbo". Default: "concurrently" */
+    runner?: 'concurrently' | 'turbo';
+    /** Auto-detect new apps in the workspace and prompt. Default: true */
+    autoDetect?: boolean;
+}
+export interface GeneratedScripts {
+    /** The full map of script-name → command to write into root package.json */
+    scripts: Record<string, string>;
+    /** Human-readable summary of what was generated */
+    summary: string[];
+}
+export declare function generateWorkspaceScripts(rootDir: string, wsCfg: WorkspaceScriptsConfig): Promise<GeneratedScripts>;
+export declare function syncScriptsToPackageJson(rootDir: string, generated: GeneratedScripts, dryRun?: boolean): Promise<{
+    added: string[];
+    updated: string[];
+    removed: string[];
+}>;
+export declare function detectNewApps(rootDir: string, wsCfg: WorkspaceScriptsConfig): Promise<string[]>;
+declare const extension: VersioningExtension;
+export default extension;
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/workspace-scripts/index.js

@@ -0,0 +1,507 @@
+"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.generateWorkspaceScripts = generateWorkspaceScripts;
+exports.syncScriptsToPackageJson = syncScriptsToPackageJson;
+exports.detectNewApps = detectNewApps;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+// ─────────────────────────────────────────────────────────────────
+//  EXTENSION METADATA
+// ─────────────────────────────────────────────────────────────────
+const EXTENSION_NAME = 'workspace-scripts';
+const EXTENSION_VERSION = '1.0.0';
+// ─────────────────────────────────────────────────────────────────
+//  MANAGED SCRIPT MARKER
+// ─────────────────────────────────────────────────────────────────
+/**
+ * All scripts generated by this extension are prefixed with one of these keys.
+ * During sync we only touch scripts whose key starts with a managed prefix.
+ */
+const MANAGED_PREFIXES = ['dev', 'build'];
+// A hidden marker script key so we know which scripts we own.
+const MARKER_KEY = '__workspace_scripts_managed';
+// ─────────────────────────────────────────────────────────────────
+//  HELPERS
+// ─────────────────────────────────────────────────────────────────
+function loadWorkspaceScriptsConfig(config) {
+    const wsCfg = config?.extensionConfig?.['workspace-scripts'];
+    if (!wsCfg || wsCfg.enabled === false)
+        return null;
+    return {
+        enabled: true,
+        apps: wsCfg.apps || {},
+        individualScripts: wsCfg.individualScripts !== false,
+        buildScripts: wsCfg.buildScripts !== false,
+        runner: wsCfg.runner || 'concurrently',
+        autoDetect: wsCfg.autoDetect !== false,
+    };
+}
+/** Derive a short name from a workspace path like "apps/dashboard" → "dashboard" */
+function shortName(wsPath) {
+    const parts = wsPath.split('/');
+    return parts[parts.length - 1];
+}
+/**
+ * Read the package name from a workspace app's package.json.
+ * Falls back to deriving from path if package.json doesn't exist.
+ */
+async function resolveFilter(rootDir, wsPath, appCfg) {
+    if (appCfg.filter)
+        return appCfg.filter;
+    const pkgPath = path.join(rootDir, wsPath, 'package.json');
+    if (await fs.pathExists(pkgPath)) {
+        try {
+            const pkg = await fs.readJson(pkgPath);
+            if (pkg.name)
+                return pkg.name;
+        }
+        catch {
+            // fall through
+        }
+    }
+    // Fallback: use the directory name
+    return shortName(wsPath);
+}
+/** Build a single pnpm --filter command string */
+function buildFilterCmd(filter, command, args) {
+    let cmd = `pnpm --filter ${filter} ${command}`;
+    if (args)
+        cmd += ` ${args}`;
+    return cmd;
+}
+async function generateWorkspaceScripts(rootDir, wsCfg) {
+    const scripts = {};
+    const summary = [];
+    const enabledApps = Object.entries(wsCfg.apps).filter(([, cfg]) => cfg.enabled !== false);
+    if (enabledApps.length === 0) {
+        summary.push('No enabled apps found in workspace-scripts config');
+        return { scripts, summary };
+    }
+    // ── Dev scripts ───────────────────────────────────────────────
+    const devCmds = [];
+    for (const [wsPath, appCfg] of enabledApps) {
+        const filter = await resolveFilter(rootDir, wsPath, appCfg);
+        const cmd = appCfg.command || 'dev';
+        const filterCmd = buildFilterCmd(filter, cmd, appCfg.args);
+        devCmds.push(filterCmd);
+        // Individual dev:<name> script
+        if (wsCfg.individualScripts) {
+            const name = shortName(wsPath);
+            scripts[`dev:${name}`] = filterCmd;
+            summary.push(`  dev:${name} → ${filterCmd}`);
+        }
+    }
+    // dev:all — concurrent execution
+    if (devCmds.length > 0) {
+        if (wsCfg.runner === 'turbo') {
+            scripts['dev:all'] = 'turbo run dev';
+            summary.push(`  dev:all → turbo run dev`);
+        }
+        else {
+            const quoted = devCmds.map((c) => `"${c}"`).join(' ');
+            scripts['dev:all'] = `concurrently ${quoted}`;
+            summary.push(`  dev:all → concurrently (${devCmds.length} apps)`);
+        }
+    }
+    // Primary dev → first app (convenience shortcut)
+    if (devCmds.length > 0) {
+        scripts['dev'] = devCmds[0];
+        summary.push(`  dev → ${devCmds[0]}`);
+    }
+    // ── Build scripts ─────────────────────────────────────────────
+    if (wsCfg.buildScripts) {
+        const buildCmds = [];
+        for (const [wsPath, appCfg] of enabledApps) {
+            const filter = await resolveFilter(rootDir, wsPath, appCfg);
+            const cmd = appCfg.buildCommand || 'build';
+            const filterCmd = buildFilterCmd(filter, cmd, appCfg.buildArgs);
+            buildCmds.push(filterCmd);
+            if (wsCfg.individualScripts) {
+                const name = shortName(wsPath);
+                scripts[`build:${name}`] = filterCmd;
+                summary.push(`  build:${name} → ${filterCmd}`);
+            }
+        }
+        // build:all
+        if (buildCmds.length > 0) {
+            if (wsCfg.runner === 'turbo') {
+                scripts['build:all'] = 'turbo run build';
+            }
+            else {
+                scripts['build:all'] = 'pnpm --recursive build';
+            }
+            summary.push(`  build:all → pnpm --recursive build`);
+        }
+        // Primary build → recursive
+        scripts['build'] = 'pnpm --recursive build';
+        summary.push(`  build → pnpm --recursive build`);
+    }
+    return { scripts, summary };
+}
+// ─────────────────────────────────────────────────────────────────
+//  CORE: SYNC SCRIPTS INTO PACKAGE.JSON
+// ─────────────────────────────────────────────────────────────────
+async function syncScriptsToPackageJson(rootDir, generated, dryRun = false) {
+    const pkgPath = path.join(rootDir, 'package.json');
+    if (!(await fs.pathExists(pkgPath))) {
+        throw new Error(`Root package.json not found at ${pkgPath}`);
+    }
+    const pkg = (await fs.readJson(pkgPath)) || {};
+    if (!pkg.scripts)
+        pkg.scripts = {};
+    const added = [];
+    const updated = [];
+    const removed = [];
+    // Identify currently managed scripts (from a previous sync)
+    const previouslyManaged = new Set();
+    if (pkg.scripts[MARKER_KEY]) {
+        try {
+            const managed = JSON.parse(pkg.scripts[MARKER_KEY]);
+            managed.forEach((k) => previouslyManaged.add(k));
+        }
+        catch {
+            // corrupted marker, ignore
+        }
+    }
+    // Remove scripts that we previously managed but are no longer generated
+    for (const key of previouslyManaged) {
+        if (!(key in generated.scripts)) {
+            if (pkg.scripts[key] !== undefined) {
+                if (!dryRun)
+                    delete pkg.scripts[key];
+                removed.push(key);
+            }
+        }
+    }
+    // Add/update generated scripts
+    for (const [key, value] of Object.entries(generated.scripts)) {
+        if (pkg.scripts[key] === undefined) {
+            added.push(key);
+        }
+        else if (pkg.scripts[key] !== value) {
+            updated.push(key);
+        }
+        if (!dryRun)
+            pkg.scripts[key] = value;
+    }
+    // Update the marker with currently managed keys
+    if (!dryRun) {
+        pkg.scripts[MARKER_KEY] = JSON.stringify(Object.keys(generated.scripts));
+    }
+    if (!dryRun) {
+        await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    }
+    return { added, updated, removed };
+}
+// ─────────────────────────────────────────────────────────────────
+//  CORE: DETECT NEW APPS IN WORKSPACE
+// ─────────────────────────────────────────────────────────────────
+async function detectNewApps(rootDir, wsCfg) {
+    const newApps = [];
+    // Read pnpm-workspace.yaml to find all workspace patterns
+    const workspaceYamlPath = path.join(rootDir, 'pnpm-workspace.yaml');
+    if (!(await fs.pathExists(workspaceYamlPath)))
+        return newApps;
+    const yamlContent = await fs.readFile(workspaceYamlPath, 'utf-8');
+    // Simple YAML parsing for pnpm-workspace.yaml (packages: - pattern)
+    const patterns = [];
+    const lines = yamlContent.split('\n');
+    let inPackages = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === 'packages:') {
+            inPackages = true;
+            continue;
+        }
+        if (inPackages) {
+            if (trimmed.startsWith('-')) {
+                const pattern = trimmed.replace(/^-\s*['"]?/, '').replace(/['"]?\s*$/, '');
+                patterns.push(pattern);
+            }
+            else if (trimmed && !trimmed.startsWith('#')) {
+                inPackages = false;
+            }
+        }
+    }
+    // Expand glob patterns (simple: only handles "foo/*" patterns)
+    const knownPaths = new Set(Object.keys(wsCfg.apps));
+    for (const pattern of patterns) {
+        if (pattern.endsWith('/*')) {
+            const dir = pattern.slice(0, -2);
+            const absDir = path.join(rootDir, dir);
+            if (await fs.pathExists(absDir)) {
+                const entries = await fs.readdir(absDir);
+                for (const entry of entries) {
+                    const entryPath = `${dir}/${entry}`;
+                    const fullPath = path.join(absDir, entry);
+                    const stat = await fs.stat(fullPath);
+                    if (!stat.isDirectory())
+                        continue;
+                    // Check it has a package.json (is a workspace package)
+                    const hasPkg = await fs.pathExists(path.join(fullPath, 'package.json'));
+                    if (!hasPkg)
+                        continue;
+                    if (!knownPaths.has(entryPath)) {
+                        newApps.push(entryPath);
+                    }
+                }
+            }
+        }
+    }
+    return newApps;
+}
+// ─────────────────────────────────────────────────────────────────
+//  EXTENSION REGISTRATION
+// ─────────────────────────────────────────────────────────────────
+const extension = {
+    name: EXTENSION_NAME,
+    description: 'Automates dev:all, build:all, and per-app scripts in root package.json',
+    version: EXTENSION_VERSION,
+    hooks: {
+        postSync: async (options) => {
+            try {
+                const configPath = options?.config ?? 'versioning.config.json';
+                if (!(await fs.pathExists(configPath)))
+                    return;
+                const config = await fs.readJson(configPath);
+                const wsCfg = loadWorkspaceScriptsConfig(config);
+                if (!wsCfg)
+                    return;
+                if (wsCfg.autoDetect) {
+                    const rootDir = process.cwd();
+                    const newApps = await detectNewApps(rootDir, wsCfg);
+                    if (newApps.length > 0) {
+                        console.log('');
+                        console.log('🔍 workspace-scripts: New apps detected in workspace:');
+                        for (const app of newApps) {
+                            console.log(`   📦 ${app}`);
+                        }
+                        console.log('');
+                        console.log('   Run `versioning scripts add` to configure them,');
+                        console.log('   or add them to versioning.config.json → extensionConfig → workspace-scripts → apps');
+                        console.log('');
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('⚠️  workspace-scripts postSync hook failed:', error instanceof Error ? error.message : String(error));
+            }
+        },
+    },
+    register: async (program, config) => {
+        const scriptsCmd = program
+            .command('scripts')
+            .description('Manage dev/build scripts in root package.json (workspace-scripts extension)');
+        // ── versioning scripts sync ───────────────────────────────
+        scriptsCmd
+            .command('sync')
+            .description('Regenerate dev:all, build:all, and per-app scripts from config')
+            .option('--dry-run', 'Preview changes without writing', false)
+            .action(async (options) => {
+            try {
+                const rootDir = process.cwd();
+                const wsCfg = loadWorkspaceScriptsConfig(config);
+                if (!wsCfg) {
+                    console.log('⚠️  workspace-scripts is not configured or disabled.');
+                    console.log('   Add "workspace-scripts" to extensionConfig in versioning.config.json');
+                    return;
+                }
+                console.log('🔄 Generating workspace scripts...\n');
+                const generated = await generateWorkspaceScripts(rootDir, wsCfg);
+                if (generated.summary.length === 0) {
+                    console.log('⚠️  No apps configured. Nothing to generate.');
+                    return;
+                }
+                console.log('📋 Scripts to generate:');
+                for (const line of generated.summary) {
+                    console.log(line);
+                }
+                console.log('');
+                const result = await syncScriptsToPackageJson(rootDir, generated, options.dryRun);
+                if (options.dryRun) {
+                    console.log('🔍 Dry run — no changes written.\n');
+                }
+                if (result.added.length > 0) {
+                    console.log(`✅ Added: ${result.added.join(', ')}`);
+                }
+                if (result.updated.length > 0) {
+                    console.log(`🔄 Updated: ${result.updated.join(', ')}`);
+                }
+                if (result.removed.length > 0) {
+                    console.log(`🗑️  Removed: ${result.removed.join(', ')}`);
+                }
+                if (result.added.length === 0 && result.updated.length === 0 && result.removed.length === 0) {
+                    console.log('✅ Scripts are already up to date.');
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.error('❌ Script sync failed:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+        // ── versioning scripts list ───────────────────────────────
+        scriptsCmd
+            .command('list')
+            .description('Show current workspace script configuration')
+            .action(async () => {
+            try {
+                const rootDir = process.cwd();
+                const wsCfg = loadWorkspaceScriptsConfig(config);
+                if (!wsCfg) {
+                    console.log('⚠️  workspace-scripts is not configured or disabled.');
+                    return;
+                }
+                console.log('📋 Workspace Scripts Configuration\n');
+                console.log(`   Runner:              ${wsCfg.runner}`);
+                console.log(`   Individual scripts:  ${wsCfg.individualScripts ? 'yes' : 'no'}`);
+                console.log(`   Build scripts:       ${wsCfg.buildScripts ? 'yes' : 'no'}`);
+                console.log(`   Auto-detect:         ${wsCfg.autoDetect ? 'yes' : 'no'}`);
+                console.log('');
+                const enabledApps = Object.entries(wsCfg.apps).filter(([, cfg]) => cfg.enabled !== false);
+                const disabledApps = Object.entries(wsCfg.apps).filter(([, cfg]) => cfg.enabled === false);
+                if (enabledApps.length > 0) {
+                    console.log('   Enabled apps:');
+                    for (const [wsPath, appCfg] of enabledApps) {
+                        const filter = await resolveFilter(rootDir, wsPath, appCfg);
+                        const cmd = appCfg.command || 'dev';
+                        const portInfo = appCfg.port ? ` (port ${appCfg.port})` : '';
+                        console.log(`     📦 ${wsPath} → ${filter} ${cmd}${appCfg.args ? ' ' + appCfg.args : ''}${portInfo}`);
+                    }
+                }
+                if (disabledApps.length > 0) {
+                    console.log('\n   Disabled apps:');
+                    for (const [wsPath] of disabledApps) {
+                        console.log(`     ⬚  ${wsPath}`);
+                    }
+                }
+                // Check for new untracked apps
+                if (wsCfg.autoDetect) {
+                    const newApps = await detectNewApps(rootDir, wsCfg);
+                    if (newApps.length > 0) {
+                        console.log('\n   🔍 New apps detected (not yet configured):');
+                        for (const app of newApps) {
+                            console.log(`     🆕 ${app}`);
+                        }
+                    }
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.error('❌ Failed to list scripts:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+        // ── versioning scripts detect ─────────────────────────────
+        scriptsCmd
+            .command('detect')
+            .description('Detect new workspace apps not yet in scripts config')
+            .action(async () => {
+            try {
+                const rootDir = process.cwd();
+                const wsCfg = loadWorkspaceScriptsConfig(config);
+                if (!wsCfg) {
+                    console.log('⚠️  workspace-scripts is not configured or disabled.');
+                    return;
+                }
+                const newApps = await detectNewApps(rootDir, wsCfg);
+                if (newApps.length === 0) {
+                    console.log('✅ All workspace apps are tracked in scripts config.');
+                    return;
+                }
+                console.log(`🔍 Found ${newApps.length} new app(s) not in workspace-scripts config:\n`);
+                for (const app of newApps) {
+                    const pkgPath = path.join(rootDir, app, 'package.json');
+                    let pkgName = shortName(app);
+                    if (await fs.pathExists(pkgPath)) {
+                        try {
+                            const pkg = await fs.readJson(pkgPath);
+                            if (pkg.name)
+                                pkgName = pkg.name;
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    console.log(`   📦 ${app} (${pkgName})`);
+                }
+                console.log('\n📝 To add them, update versioning.config.json:');
+                console.log('   extensionConfig → workspace-scripts → apps\n');
+                // Show example config for the first new app
+                if (newApps.length > 0) {
+                    const example = newApps[0];
+                    console.log('   Example:');
+                    console.log(`   "${example}": { "command": "dev", "args": "-p 3000" }\n`);
+                }
+            }
+            catch (error) {
+                console.error('❌ Detection failed:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+        // ── versioning scripts preview ────────────────────────────
+        scriptsCmd
+            .command('preview')
+            .description('Preview the scripts that would be generated without writing')
+            .action(async () => {
+            try {
+                const rootDir = process.cwd();
+                const wsCfg = loadWorkspaceScriptsConfig(config);
+                if (!wsCfg) {
+                    console.log('⚠️  workspace-scripts is not configured or disabled.');
+                    return;
+                }
+                const generated = await generateWorkspaceScripts(rootDir, wsCfg);
+                if (Object.keys(generated.scripts).length === 0) {
+                    console.log('⚠️  No scripts would be generated.');
+                    return;
+                }
+                console.log('📋 Preview — scripts that would be written to root package.json:\n');
+                const maxKeyLen = Math.max(...Object.keys(generated.scripts).map((k) => k.length));
+                for (const [key, value] of Object.entries(generated.scripts)) {
+                    console.log(`   "${key.padEnd(maxKeyLen)}" : "${value}"`);
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.error('❌ Preview failed:', error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
+    },
+};
+exports.default = extension;
+//# sourceMappingURL=index.js.map

package/package.json

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