@emeryld/manager 0.8.0 → 0.8.2

package/dist/helper-cli/prompts.js

@@ -100,12 +100,12 @@ function formatInteractiveLines(state, selectedIndex, title, searchState) {
         lines.push(colors.yellow('No scripts match your search.'));
     }
     lines.push('');
-    lines.push(colors.dim(`Use ↑/↓ (or j/k) to move, 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} prev page (when shown), ${NEXT_KEY} next page (when shown), ${BACK_KEY} back, Enter to run, Space to filter, Esc/Ctrl+C to exit.`));
+    lines.push(colors.dim(`Use ↑/↓ (or j/k) to move, 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} prev page (when shown), ${NEXT_KEY} next page (when shown), ${BACK_KEY} back, Enter to run, Type to filter (numbers run scripts), Esc/Ctrl+C to exit.`));
     if (searchState?.active) {
         lines.push(colors.dim('Search mode: type to filter, Backspace edits the query, Esc returns to navigation, Enter runs the highlighted entry.'));
     }
     else {
-        lines.push(colors.dim('Press Space to start typing a filter.'));
+        lines.push(colors.dim('Type any non-number character to start filtering.'));
     }
     return lines;
 }
@@ -230,13 +230,13 @@ export async function promptForScript(entries, title) {
             selectedIndex = 0;
             render();
         };
-        const enterSearchMode = () => {
+        const enterSearchMode = (initialQuery = '') => {
             if (searchActive)
                 return;
             pageBeforeSearch = state.page;
             selectionBeforeSearch = selectedIndex;
             searchActive = true;
-            searchQuery = '';
+            searchQuery = initialQuery;
             applySearch();
         };
         const exitSearchMode = () => {
@@ -256,8 +256,10 @@ export async function promptForScript(entries, title) {
             const isEnter = buffer.length === 1 && (buffer[0] === 0x0d || buffer[0] === 0x0a);
             const isEscape = buffer.length === 1 && buffer[0] === 0x1b;
             const isBackspace = buffer.length === 1 && (buffer[0] === 0x7f || buffer[0] === 0x08);
-            const isPrintable = buffer.length === 1 && buffer[0] >= 0x20 && buffer[0] <= 0x7e;
-            const isSpace = buffer.length === 1 && buffer[0] === 0x20;
+            const ascii = buffer.length === 1 ? buffer[0] : undefined;
+            const isPrintable = ascii !== undefined && ascii >= 0x20 && ascii <= 0x7e;
+            const isDigit = ascii !== undefined && ascii >= 0x30 && ascii <= 0x39;
+            const typedChar = isPrintable && ascii !== undefined ? String.fromCharCode(ascii) : '';
             if (isCtrlC) {
                 cleanup();
                 process.exit(1);
@@ -270,10 +272,6 @@ export async function promptForScript(entries, title) {
                 cleanup();
                 process.exit(1);
             }
-            if (!searchActive && isSpace) {
-                enterSearchMode();
-                return;
-            }
             if (isArrowUp ||
                 (buffer.length === 1 && (buffer[0] === 0x6b || buffer[0] === 0x4b))) {
                 selectedIndex =
@@ -307,14 +305,14 @@ export async function promptForScript(entries, title) {
                     return;
                 }
                 if (isPrintable) {
-                    searchQuery += String.fromCharCode(buffer[0]);
+                    searchQuery += typedChar;
                     applySearch();
                     return;
                 }
                 return;
             }
-            if (buffer.length === 1 && buffer[0] >= 0x30 && buffer[0] <= 0x39) {
-                const numericValue = buffer[0] - 0x30;
+            if (isDigit && ascii !== undefined) {
+                const numericValue = ascii - 0x30;
                 const option = state.options.find((opt) => opt.hotkey === numericValue);
                 if (option)
                     activateOption(option);
@@ -322,20 +320,8 @@ export async function promptForScript(entries, title) {
                     process.stdout.write('\x07');
                 return;
             }
-            if (buffer.length === 1 &&
-                ((buffer[0] >= 0x41 && buffer[0] <= 0x5a) ||
-                    (buffer[0] >= 0x61 && buffer[0] <= 0x7a))) {
-                const char = String.fromCharCode(buffer[0]).toLowerCase();
-                const foundIndex = baseEntries.findIndex((entry) => entry.displayName.toLowerCase().startsWith(char));
-                if (foundIndex !== -1) {
-                    const page = Math.floor(foundIndex / PAGE_SIZE);
-                    state = buildVisibleOptions(filteredEntries, page);
-                    selectedIndex = foundIndex % PAGE_SIZE;
-                    render();
-                }
-                else {
-                    process.stdout.write('\x07');
-                }
+            if (isPrintable) {
+                enterSearchMode(typedChar);
                 return;
             }
             process.stdout.write('\x07');

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/utils/package-filter.js

@@ -0,0 +1,7 @@
+export function packageFilterArg(pkg) {
+    if (pkg.name)
+        return pkg.name;
+    if (!pkg.relativeDir || pkg.relativeDir === '.')
+        return '.';
+    return `./${pkg.relativeDir}`;
+}

package/dist/version-control.js

@@ -0,0 +1,249 @@
+import { askLine } from './prompts.js';
+import { run } from './utils/run.js';
+import { colors, logGlobal } from './utils/log.js';
+import { packageFilterArg } from './utils/package-filter.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 ensureVersionControlTargets(targets, allPackages, feature) {
+    if (allPackages.length === 0) {
+        logGlobal('No packages found to run version control actions.', colors.yellow);
+        return false;
+    }
+    if (targets.length === 0) {
+        logGlobal(`Select at least one package before running ${feature}.`, colors.yellow);
+        return false;
+    }
+    return true;
+}
+function buildPackageFilterArgs(targets, allPackages) {
+    if (!targets.length || targets.length === allPackages.length) {
+        return [];
+    }
+    const seen = new Set();
+    const args = [];
+    for (const pkg of targets) {
+        const filterArg = packageFilterArg(pkg);
+        if (seen.has(filterArg))
+            continue;
+        seen.add(filterArg);
+        args.push('--filter', filterArg);
+    }
+    return args;
+}
+function buildRecursiveUpdateArgs(targets, allPackages, spec) {
+    return ['update', '-r', ...buildPackageFilterArgs(targets, allPackages), spec];
+}
+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 (!ensureVersionControlTargets(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', buildRecursiveUpdateArgs(targets, allPackages, spec));
+    logGlobal('Pattern update complete.', colors.green);
+}
+async function runVersionHealthScan(targets, allPackages) {
+    if (!ensureVersionControlTargets(targets, allPackages, 'Version health scan'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    logGlobal(`Scanning version misalignments for ${scopeLabel}…`, colors.cyan);
+    const dependencyMap = collectDependencyMap(targets);
+    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 (!ensureVersionControlTargets(targets, allPackages, 'Dependency alignment'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    const dependencyMap = collectDependencyMap(targets);
+    if (!dependencyMap.size) {
+        logGlobal(`No dependencies found in ${scopeLabel}.`, 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 ${scopeLabel}.`, 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', buildRecursiveUpdateArgs(targets, allPackages, spec));
+    logGlobal('Dependency alignment complete.', colors.green);
+}
+async function showDriftReport(targets, allPackages) {
+    if (!ensureVersionControlTargets(targets, allPackages, 'Drift report'))
+        return;
+    const scopeLabel = describeVersionControlScope(targets, allPackages);
+    logGlobal(`Computing drift report for ${scopeLabel}…`, colors.cyan);
+    const dependencyMap = collectDependencyMap(targets);
+    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 (!ensureVersionControlTargets(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/dist/workspace.js

@@ -4,6 +4,7 @@ import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { run, rootDir } from './utils/run.js';
 import { logGlobal, logPkg, colors } from './utils/log.js';
+import { packageFilterArg } from './utils/package-filter.js';
 import { collectGitStatus, gitAdd, gitCommit } from './git.js';
 import { askLine, promptSingleKey } from './prompts.js';
 const dependencyFiles = new Set([
@@ -186,13 +187,6 @@ async function promptCommitMessage(proposed) {
     }
     return custom.trim();
 }
-function packageFilterArg(pkg) {
-    if (pkg.name)
-        return pkg.name;
-    if (!pkg.relativeDir || pkg.relativeDir === '.')
-        return '.';
-    return `./${pkg.relativeDir}`;
-}
 async function runLifecycleScenario(pkg, scenario) {
     if (pkg) {
         logPkg(pkg, scenario.singleMessage);

package/package.json

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