@emeryld/manager 0.7.10 → 0.8.1

package/dist/menu.js

@@ -9,6 +9,7 @@ import { ensureWorkingTreeCommitted } from './preflight.js';
 import { openDockerHelper } from './docker.js';
 import { run } from './utils/run.js';
 import { makeBaseScriptEntries, getPackageMarker, getPackageModule } from './menu/script-helpers.js';
+import { describeVersionControlScope, makeVersionControlEntries, } from './version-control.js';
 function formatKindLabel(kind) {
     if (kind === 'cli')
         return 'CLI';
@@ -43,6 +44,18 @@ function makeManagerStepEntries(targets, packages, state) {
                 state.lastStep = 'rebuild';
             },
         },
+        {
+            name: 'version control',
+            emoji: '🧭',
+            description: 'Workspace version health, updates, and lockfile checks',
+            handler: async () => {
+                await runHelperCli({
+                    title: `Version control for ${describeVersionControlScope(targets, packages)}`,
+                    scripts: makeVersionControlEntries(targets, packages),
+                    argv: [],
+                });
+            },
+        },
         {
             name: 'test',
             emoji: '🧪',

package/dist/prompts.js

@@ -1,6 +1,7 @@
 // src/prompts.js
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
+import { colors } from './utils/log.js';
 export const publishCliState = {
     autoDecision: undefined,
 };
@@ -70,22 +71,78 @@ export async function promptYesNoAll(question) {
         console.log(`${question} (auto-${publishCliState.autoDecision} via "all")`);
         return publishCliState.autoDecision;
     }
-    // Allow yes/no + "apply to all" variants: y, ya, n, na
-    // Use readline-style input to capture multi-character tokens consistently.
+    // Allow yes/no + "apply to all" variants: yy, ya, nn, na
+    const promptMessage = `${question} (yy/ya/nn/na): `;
+    const supportsRawMode = typeof input.setRawMode === 'function' && input.isTTY;
+    const readDecisionInput = async () => {
+        if (!supportsRawMode) {
+            const fallback = await askLine(promptMessage);
+            return fallback.trim().toLowerCase();
+        }
+        return new Promise((resolve) => {
+            const wasRaw = input.isRaw;
+            if (!wasRaw) {
+                input.setRawMode(true);
+                input.resume();
+            }
+            process.stdout.write(promptMessage);
+            const cleanup = () => {
+                input.off('data', onData);
+                if (!wasRaw) {
+                    input.setRawMode(false);
+                    input.pause();
+                }
+            };
+            let collected = '';
+            const onData = (buffer) => {
+                const str = buffer.toString('utf8');
+                for (const char of str) {
+                    if (char === '\u0003') {
+                        cleanup();
+                        process.stdout.write('\n');
+                        process.exit(1);
+                    }
+                    if (char === '\u0008' || char === '\u007f') {
+                        if (collected.length > 0) {
+                            collected = collected.slice(0, -1);
+                            process.stdout.write('\b \b');
+                        }
+                        continue;
+                    }
+                    if (char === '\r' || char === '\n') {
+                        continue;
+                    }
+                    if (!/^[a-zA-Z]$/.test(char)) {
+                        continue;
+                    }
+                    process.stdout.write(char);
+                    collected += char;
+                    if (collected.length === 2) {
+                        cleanup();
+                        process.stdout.write('\n');
+                        resolve(collected.toLowerCase());
+                        return;
+                    }
+                }
+            };
+            input.on('data', onData);
+        });
+    };
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const answer = (await askLine(`${question} (y/ya/n/na): `)).toLowerCase();
-        if (answer === 'y')
+        const answer = await readDecisionInput();
+        if (answer === 'yy')
             return 'yes';
         if (answer === 'ya') {
             publishCliState.autoDecision = 'yes';
             return 'yes';
         }
-        if (answer === 'n')
+        if (answer === 'nn')
             return 'no';
         if (answer === 'na') {
             publishCliState.autoDecision = 'no';
             return 'no';
         }
+        console.log(colors.red('Please enter yy, ya, nn, or na.'));
     }
 }

package/dist/version-control.js

@@ -0,0 +1,230 @@
+import { askLine } from './prompts.js';
+import { run } from './utils/run.js';
+import { colors, logGlobal } from './utils/log.js';
+const DEP_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies'];
+const FIELD_LABELS = {
+    dependencies: 'deps',
+    devDependencies: 'dev',
+    peerDependencies: 'peer',
+};
+function packageLabel(pkg) {
+    return pkg.name ?? pkg.dirName;
+}
+function describeVersionControlScope(targets, allPackages) {
+    if (targets.length === 0)
+        return 'no packages';
+    if (targets.length === 1)
+        return packageLabel(targets[0]);
+    if (targets.length === allPackages.length)
+        return 'workspace';
+    return `${targets.length} packages`;
+}
+function collectDependencyMap(pkgs) {
+    const map = new Map();
+    for (const pkg of pkgs) {
+        for (const field of DEP_FIELDS) {
+            const deps = (pkg.json?.[field] ?? {});
+            for (const [name, value] of Object.entries(deps)) {
+                if (typeof value !== 'string')
+                    continue;
+                const fieldMap = map.get(name) ?? new Map();
+                const entry = { pkg, range: value, field };
+                const list = fieldMap.get(value) ?? [];
+                list.push(entry);
+                fieldMap.set(value, list);
+                map.set(name, fieldMap);
+            }
+        }
+    }
+    return map;
+}
+function getMostCommonVersion(versions) {
+    let best;
+    let bestCount = 0;
+    for (const [ver, entries] of versions) {
+        if (entries.length > bestCount) {
+            best = ver;
+            bestCount = entries.length;
+        }
+    }
+    return best;
+}
+function hasWorkspaceScope(targets, allPackages, feature) {
+    if (allPackages.length === 0) {
+        logGlobal('No packages found to run version control actions.', colors.yellow);
+        return false;
+    }
+    if (targets.length !== allPackages.length) {
+        logGlobal(`${feature} works across the whole workspace; select "All packages" first.`, colors.yellow);
+        return false;
+    }
+    return true;
+}
+function formatConflictDetails(versions) {
+    return [...versions.entries()]
+        .map(([range, entries]) => {
+        const fields = new Set(entries.map((entry) => FIELD_LABELS[entry.field]));
+        const label = [...fields].join('/') || 'deps';
+        const packages = entries
+            .map((entry) => packageLabel(entry.pkg))
+            .join(', ');
+        return `${range} (${label}: ${packages})`;
+    })
+        .join(' | ');
+}
+async function updateByPattern(targets, allPackages) {
+    if (!hasWorkspaceScope(targets, allPackages, 'Regex dependency update'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    const defaultPattern = '@emeryld/*';
+    const promptPattern = `Dependency pattern (use wildcards or scopes, default ${defaultPattern}): `;
+    const patternInput = await askLine(promptPattern);
+    const rawPattern = (patternInput ?? '').trim() || defaultPattern;
+    const promptVersion = 'Version or tag to pin (default "latest"): ';
+    const versionInput = await askLine(promptVersion);
+    const normalizedVersion = (versionInput ?? '').trim() || 'latest';
+    const lastAt = rawPattern.lastIndexOf('@');
+    const slashIndex = rawPattern.lastIndexOf('/');
+    const hasExplicitVersion = lastAt > 0 && lastAt > slashIndex;
+    const spec = hasExplicitVersion
+        ? rawPattern
+        : `${rawPattern}@${normalizedVersion}`;
+    logGlobal(`Updating dependencies using ${colors.cyan(spec)} for ${scopeLabel}…`, colors.cyan);
+    await run('pnpm', ['update', '-r', spec]);
+    logGlobal('Pattern update complete.', colors.green);
+}
+async function runVersionHealthScan(targets, allPackages) {
+    if (!hasWorkspaceScope(targets, allPackages, 'Version health scan'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    logGlobal(`Scanning version misalignments for ${scopeLabel}…`, colors.cyan);
+    const dependencyMap = collectDependencyMap(allPackages);
+    const conflicts = [...dependencyMap.entries()].filter(([, versions]) => versions.size > 1);
+    if (conflicts.length === 0) {
+        logGlobal('No version conflicts detected.', colors.green);
+        return;
+    }
+    console.log(colors.yellow('Misaligned dependency versions:'));
+    conflicts.forEach(([dep, versions]) => {
+        console.log(`  ${colors.bold(dep)} → ${formatConflictDetails(versions)}`);
+    });
+}
+async function alignDependencyVersions(targets, allPackages) {
+    if (!hasWorkspaceScope(targets, allPackages, 'Dependency alignment'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    const dependencyMap = collectDependencyMap(allPackages);
+    if (!dependencyMap.size) {
+        logGlobal('No dependencies found in the workspace.', colors.yellow);
+        return;
+    }
+    const misaligned = [...dependencyMap.entries()]
+        .filter(([, versions]) => versions.size > 1)
+        .map(([dep]) => dep);
+    const defaultDependency = misaligned[0] ?? dependencyMap.keys().next().value ?? '';
+    if (!defaultDependency) {
+        logGlobal('Unable to infer a dependency to align.', colors.yellow);
+        return;
+    }
+    const dependencyPrompt = `Dependency to align (default ${defaultDependency}): `;
+    const dependencyInput = (await askLine(dependencyPrompt))?.trim();
+    const dependency = dependencyInput || defaultDependency;
+    const versions = dependencyMap.get(dependency);
+    if (!versions) {
+        logGlobal(`Dependency "${dependency}" not tracked across the workspace.`, colors.yellow);
+        return;
+    }
+    const defaultVersion = getMostCommonVersion(versions) ?? [...versions.keys()][0];
+    const versionPrompt = defaultVersion && defaultVersion.length
+        ? `Version to align to (default ${defaultVersion}): `
+        : 'Version to align to: ';
+    const versionInputFinal = (await askLine(versionPrompt))?.trim();
+    const targetVersion = versionInputFinal || defaultVersion;
+    if (!targetVersion) {
+        logGlobal('No version selected; cancelling alignment.', colors.yellow);
+        return;
+    }
+    const spec = `${dependency}@${targetVersion}`;
+    logGlobal(`Aligning ${colors.cyan(dependency)} to ${colors.cyan(targetVersion)} across ${scopeLabel}…`, colors.cyan);
+    await run('pnpm', ['update', '-r', spec]);
+    logGlobal('Dependency alignment complete.', colors.green);
+}
+async function showDriftReport(targets, allPackages) {
+    if (!hasWorkspaceScope(targets, allPackages, 'Drift report'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    logGlobal(`Computing drift report for ${scopeLabel}…`, colors.cyan);
+    const dependencyMap = collectDependencyMap(allPackages);
+    const driftLines = [];
+    for (const [dep, versions] of dependencyMap.entries()) {
+        if (versions.size <= 1)
+            continue;
+        const standard = getMostCommonVersion(versions);
+        const deviators = [...versions.entries()].filter(([range]) => range !== standard);
+        if (!deviators.length)
+            continue;
+        const detail = deviators
+            .map(([range, entries]) => `${range}: ${entries.map((entry) => packageLabel(entry.pkg)).join(', ')}`)
+            .join(' | ');
+        driftLines.push(`${colors.bold(dep)} (standard ${standard}) → ${detail}`);
+    }
+    if (!driftLines.length) {
+        logGlobal('No drift detected; shared dependencies are aligned.', colors.green);
+        return;
+    }
+    console.log(colors.yellow('Drifting dependencies:'));
+    driftLines.forEach((line) => console.log(`  ${line}`));
+}
+async function checkLockfile(targets, allPackages) {
+    if (!hasWorkspaceScope(targets, allPackages, 'Lockfile check'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    logGlobal(`Verifying lockfile matches the ${scopeLabel} manifests…`, colors.cyan);
+    await run('pnpm', ['install', '--frozen-lockfile', '--ignore-scripts']);
+    logGlobal('Lockfile verification succeeded.', colors.green);
+}
+export function makeVersionControlEntries(targets, allPackages) {
+    return [
+        {
+            name: 'regex dependency update',
+            emoji: '🧷',
+            description: 'Update all workspace packages matching a pattern to a version/tag',
+            handler: async () => {
+                await updateByPattern(targets, allPackages);
+            },
+        },
+        {
+            name: 'version health scan',
+            emoji: '🩺',
+            description: 'Flag conflicting dependency versions across the workspace',
+            handler: async () => {
+                await runVersionHealthScan(targets, allPackages);
+            },
+        },
+        {
+            name: 'dependency alignment',
+            emoji: '🎯',
+            description: 'Pick a dependency and pin every workspace package to the same version',
+            handler: async () => {
+                await alignDependencyVersions(targets, allPackages);
+            },
+        },
+        {
+            name: 'drift & outdated report',
+            emoji: '📉',
+            description: 'Summarize distances from the standard version for shared deps',
+            handler: async () => {
+                await showDriftReport(targets, allPackages);
+            },
+        },
+        {
+            name: 'lockfile consistency check',
+            emoji: '🧰',
+            description: 'Ensure pnpm-lock.yaml stays compatible with the manifest',
+            handler: async () => {
+                await checkLockfile(targets, allPackages);
+            },
+        },
+    ];
+}
+export { describeVersionControlScope };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "0.7.10",
+  "version": "0.8.1",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",