@emeryld/manager 0.2.0 → 0.2.2

package/bin/manager-cli.js

@@ -15,9 +15,7 @@ const tsNodeLoader = require.resolve('ts-node/esm.mjs')
 const registerCode = [
   'import { register } from "node:module";',
   'import { pathToFileURL } from "node:url";',
-  `register(${JSON.stringify(
-    tsNodeLoader,
-  )}, pathToFileURL(${JSON.stringify(entryPoint)}));`,
+   `register(${JSON.stringify(tsNodeLoader)}, pathToFileURL(${JSON.stringify(packageRoot + path.sep)}));`,
 ].join(' ')
 const registerImport = `data:text/javascript,${encodeURIComponent(registerCode)}`
 

package/dist/git.js

@@ -0,0 +1,68 @@
+// src/git.js
+import { spawn } from 'node:child_process';
+import { run } from './utils/run.js';
+import { logGlobal, colors } from './utils/log.js';
+import { rootDir } from './utils/run.js';
+export async function collectGitStatus() {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', ['status', '--porcelain'], {
+            cwd: rootDir,
+            stdio: ['ignore', 'pipe', 'inherit'],
+        });
+        const lines = [];
+        child.stdout.on('data', (chunk) => {
+            lines.push(...chunk
+                .toString()
+                .split('\n')
+                // Preserve leading status markers; strip only trailing whitespace/newlines
+                .map((line) => line.replace(/\s+$/, ''))
+                .filter(Boolean));
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code !== 0)
+                return reject(new Error('Failed to read git status.'));
+            resolve(lines);
+        });
+    });
+}
+export async function gitAdd(paths) {
+    await run('git', ['add', ...paths]);
+}
+export async function gitCommit(message) {
+    await run('git', ['commit', '-m', message]);
+}
+export async function hasStagedChanges() {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', ['diff', '--cached', '--quiet'], {
+            cwd: rootDir,
+            stdio: 'ignore',
+        });
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve(false);
+            else if (code === 1)
+                resolve(true);
+            else
+                reject(new Error('git diff --cached --quiet failed'));
+        });
+    });
+}
+export async function stageCommitPush(changedPaths, commitMessage) {
+    if (!changedPaths.length) {
+        logGlobal('No files changed; skipping commit.', colors.dim);
+        return;
+    }
+    const unique = [...new Set(changedPaths)];
+    logGlobal('Staging files…', colors.cyan);
+    await gitAdd(unique);
+    const staged = await hasStagedChanges();
+    if (!staged) {
+        logGlobal('Nothing to commit; skipping commit/push.', colors.dim);
+        return;
+    }
+    logGlobal('Creating commit…', colors.cyan);
+    await gitCommit(commitMessage);
+    logGlobal('Pushing to origin…', colors.cyan);
+    await run('git', ['push']);
+}

package/dist/helper-cli.js

@@ -0,0 +1,299 @@
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+const rootDir = path.resolve(path.dirname(__filename), '..');
+const managerRequire = createRequire(import.meta.url);
+let tsNodeLoaderPath;
+function getTsNodeLoaderPath() {
+    if (!tsNodeLoaderPath) {
+        tsNodeLoaderPath = managerRequire.resolve('ts-node/esm.mjs');
+    }
+    return tsNodeLoaderPath;
+}
+export function buildTsNodeRegisterImport(scriptPath) {
+    const loader = getTsNodeLoaderPath();
+    const code = [
+        'import { register } from "node:module";',
+        'import { pathToFileURL } from "node:url";',
+        `register(${JSON.stringify(loader)}, pathToFileURL(${JSON.stringify(scriptPath)}));`,
+    ].join(' ');
+    return `data:text/javascript,${encodeURIComponent(code)}`;
+}
+const ansi = (code) => (text) => `\x1b[${code}m${text}\x1b[0m`;
+const colors = {
+    cyan: ansi(36),
+    green: ansi(32),
+    yellow: ansi(33),
+    magenta: ansi(35),
+    dim: ansi(2),
+};
+function normalizeScripts(entries) {
+    if (!Array.isArray(entries) || entries.length === 0) {
+        throw new Error('runHelperCli requires at least one script definition.');
+    }
+    return entries.map((entry, index) => {
+        if (!entry || typeof entry !== 'object') {
+            throw new Error(`Script entry at index ${index} is not an object.`);
+        }
+        if (!entry.name || typeof entry.name !== 'string') {
+            throw new Error(`Script entry at index ${index} is missing a "name".`);
+        }
+        const hasHandler = typeof entry.handler === 'function';
+        const hasScript = typeof entry.script === 'string' && entry.script.length > 0;
+        if (!hasHandler && !hasScript) {
+            throw new Error(`Script "${entry.name}" requires either a "script" path or a "handler" function.`);
+        }
+        const absoluteScript = hasScript && path.isAbsolute(entry.script)
+            ? entry.script
+            : hasScript
+                ? path.join(rootDir, entry.script)
+                : undefined;
+        return {
+            ...entry,
+            emoji: entry.emoji ?? '🔧',
+            displayName: entry.name.trim(),
+            absoluteScript,
+            script: hasScript ? entry.script : undefined,
+            handler: hasHandler ? entry.handler : undefined,
+            metaLabel: entry.description ?? (hasScript ? entry.script : '[callback]'),
+        };
+    });
+}
+function findScriptEntry(entries, key) {
+    if (!key)
+        return undefined;
+    const normalized = key.toLowerCase();
+    return entries.find((entry) => {
+        const nameMatch = entry.displayName.toLowerCase() === normalized;
+        const aliasMatch = entry.displayName.toLowerCase().includes(normalized);
+        const scriptMatch = entry.script
+            ? entry.script.toLowerCase().includes(normalized)
+            : false;
+        return nameMatch || aliasMatch || scriptMatch;
+    });
+}
+function printScriptList(entries, title) {
+    const heading = title
+        ? colors.magenta(title)
+        : colors.magenta('Available scripts');
+    console.log(heading);
+    entries.forEach((entry, index) => {
+        console.log(`  ${colors.cyan(String(index + 1).padStart(2, ' '))} ${entry.emoji} ${entry.displayName} ${colors.dim(entry.metaLabel)}`);
+    });
+}
+async function promptWithReadline(entries, title) {
+    printScriptList(entries, title);
+    const rl = readline.createInterface({ input, output });
+    try {
+        while (true) {
+            const answer = (await rl.question(colors.cyan('\nSelect a script by number or name: '))).trim();
+            if (!answer)
+                continue;
+            const numeric = Number.parseInt(answer, 10);
+            if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= entries.length) {
+                return entries[numeric - 1];
+            }
+            const byName = findScriptEntry(entries, answer);
+            if (byName)
+                return byName;
+            console.log(colors.yellow(`Could not find "${answer}". Try again.`));
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+function formatInteractiveLines(entries, selectedIndex, title) {
+    const heading = title
+        ? colors.magenta(title)
+        : colors.magenta('Available scripts');
+    const lines = [heading];
+    entries.forEach((entry, index) => {
+        const isSelected = index === selectedIndex;
+        const pointer = isSelected ? `${colors.green('➤')} ` : '';
+        const numberLabel = colors.cyan(`${index + 1}`.padStart(2, ' '));
+        const label = isSelected
+            ? colors.green(entry.displayName)
+            : entry.displayName;
+        lines.push(`${pointer}${numberLabel}. ${entry.emoji} ${label} ${colors.dim(entry.metaLabel)}`);
+    });
+    lines.push('');
+    lines.push(colors.dim('Use ↑/↓ (or j/k) to move, digits (1-9,0 for 10) to run instantly, Enter to confirm, Esc/Ctrl+C to exit.'));
+    return lines;
+}
+function renderInteractiveList(lines, previousLineCount) {
+    if (previousLineCount > 0) {
+        process.stdout.write(`\x1b[${previousLineCount}A`);
+        process.stdout.write('\x1b[0J');
+    }
+    lines.forEach((line) => console.log(line));
+    return lines.length;
+}
+async function promptForScript(entries, title) {
+    const supportsRawMode = typeof input.setRawMode === 'function' && input.isTTY;
+    if (!supportsRawMode) {
+        return promptWithReadline(entries, title);
+    }
+    const wasRaw = input.isRaw;
+    if (!wasRaw) {
+        input.setRawMode(true);
+        input.resume();
+    }
+    process.stdout.write('\x1b[?25l');
+    return new Promise((resolve) => {
+        let selectedIndex = 0;
+        let renderedLines = 0;
+        const cleanup = () => {
+            if (renderedLines > 0) {
+                process.stdout.write(`\x1b[${renderedLines}A`);
+                process.stdout.write('\x1b[0J');
+                renderedLines = 0;
+            }
+            process.stdout.write('\x1b[?25h');
+            if (!wasRaw) {
+                input.setRawMode(false);
+                input.pause();
+            }
+            input.removeListener('data', onData);
+        };
+        const commitSelection = (entry) => {
+            cleanup();
+            console.log();
+            resolve(entry);
+        };
+        const render = () => {
+            const lines = formatInteractiveLines(entries, selectedIndex, title);
+            renderedLines = renderInteractiveList(lines, renderedLines);
+        };
+        const onData = (buffer) => {
+            const isArrowUp = buffer.equals(Buffer.from([0x1b, 0x5b, 0x41]));
+            const isArrowDown = buffer.equals(Buffer.from([0x1b, 0x5b, 0x42]));
+            const isCtrlC = buffer.length === 1 && buffer[0] === 0x03;
+            const isEnter = buffer.length === 1 && (buffer[0] === 0x0d || buffer[0] === 0x0a);
+            const isEscape = buffer.length === 1 && buffer[0] === 0x1b;
+            if (isCtrlC || isEscape) {
+                cleanup();
+                process.exit(1);
+            }
+            if (isArrowUp ||
+                (buffer.length === 1 && (buffer[0] === 0x6b || buffer[0] === 0x4b))) {
+                selectedIndex = (selectedIndex - 1 + entries.length) % entries.length;
+                render();
+                return;
+            }
+            if (isArrowDown ||
+                (buffer.length === 1 && (buffer[0] === 0x6a || buffer[0] === 0x4a))) {
+                selectedIndex = (selectedIndex + 1) % entries.length;
+                render();
+                return;
+            }
+            if (isEnter) {
+                commitSelection(entries[selectedIndex]);
+                return;
+            }
+            if (buffer.length === 1 && buffer[0] >= 0x30 && buffer[0] <= 0x39) {
+                const numericValue = buffer[0] === 0x30 ? 10 : buffer[0] - 0x30;
+                const selected = numericValue - 1;
+                if (selected >= 0 && selected < entries.length) {
+                    commitSelection(entries[selected]);
+                }
+                else {
+                    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 = entries.findIndex((entry) => entry.displayName.toLowerCase().startsWith(char));
+                if (foundIndex !== -1) {
+                    selectedIndex = foundIndex;
+                    render();
+                }
+                else {
+                    process.stdout.write('\x07');
+                }
+            }
+        };
+        input.on('data', onData);
+        render();
+    });
+}
+function runEntry(entry, forwardedArgs) {
+    const detail = entry.script
+        ? path.relative(rootDir, entry.absoluteScript ?? entry.script)
+        : (entry.metaLabel ?? '[callback]');
+    console.log(`${entry.emoji} ${colors.green(`Running "${entry.displayName}"`)} ${colors.dim(detail)}`);
+    if (entry.handler) {
+        return Promise.resolve(entry.handler({ args: forwardedArgs, entry, rootDir }));
+    }
+    if (!entry.absoluteScript) {
+        throw new Error(`Script "${entry.displayName}" is missing a resolved path.`);
+    }
+    const scriptPath = entry.absoluteScript;
+    const tsConfigPath = path.join(rootDir, 'tsconfig.base.json');
+    const extension = path.extname(scriptPath).toLowerCase();
+    const isTypeScript = extension === '.js' || extension === '.mts' || extension === '.cts';
+    const command = process.execPath;
+    const execArgs = isTypeScript
+        ? [
+            '--import',
+            buildTsNodeRegisterImport(scriptPath),
+            scriptPath,
+            ...forwardedArgs,
+        ]
+        : [scriptPath, ...forwardedArgs];
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, execArgs, {
+            cwd: rootDir,
+            stdio: 'inherit',
+            env: isTypeScript
+                ? { ...process.env, TS_NODE_PROJECT: tsConfigPath }
+                : process.env,
+            shell: process.platform === 'win32' && isTypeScript,
+        });
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Script "${entry.displayName}" exited with code ${code}`));
+        });
+    });
+}
+export async function runHelperCli({ scripts, title = 'Helper CLI', argv = process.argv.slice(2), }) {
+    const normalized = normalizeScripts(scripts);
+    let args = Array.isArray(argv) ? [...argv] : [];
+    const separatorIndex = args.indexOf('--');
+    if (separatorIndex !== -1) {
+        args = [...args.slice(0, separatorIndex), ...args.slice(separatorIndex + 1)];
+    }
+    const [firstArg, ...restArgs] = args;
+    if (firstArg === '--list' || firstArg === '-l') {
+        printScriptList(normalized, title);
+        return;
+    }
+    if (firstArg === '--help' || firstArg === '-h') {
+        console.log(colors.magenta('Usage:'));
+        console.log('  pnpm run <cli> [script] [...args]');
+        console.log('\nFlags:');
+        console.log('  --list  Show available scripts');
+        console.log('  --help  Show this information');
+        return;
+    }
+    const argLooksLikeScript = firstArg && !firstArg.startsWith('-');
+    if (argLooksLikeScript) {
+        const requested = findScriptEntry(normalized, firstArg);
+        if (requested) {
+            await runEntry(requested, restArgs);
+            return;
+        }
+        console.log(colors.yellow(`Unknown script "${firstArg}". Falling back to interactive selection…`));
+    }
+    const selection = await promptForScript(normalized, title);
+    await runEntry(selection, []);
+}

package/dist/menu.js

@@ -0,0 +1,130 @@
+import { colors, globalEmoji } from './utils/log.js';
+import { updateDependencies, testAll, testSingle, buildAll, buildSingle, } from './workspace.js';
+import { releaseMultiple, releaseSingle } from './release.js';
+import { getOrderedPackages } from './packages.js';
+import { runHelperCli } from './helper-cli.js';
+import { ensureWorkingTreeCommitted } from './preflight.js';
+export function makeStepEntries(targets, packages, state) {
+    return [
+        {
+            name: 'update dependencies',
+            emoji: '♻️',
+            description: 'Update dependencies for the selection',
+            handler: async () => {
+                await updateDependencies(targets);
+                state.lastStep = 'update';
+            },
+        },
+        {
+            name: 'test',
+            emoji: '🧪',
+            description: 'Run tests',
+            handler: async () => {
+                if (targets.length === 1)
+                    await testSingle(targets[0]);
+                else
+                    await testAll();
+                state.lastStep = 'test';
+            },
+        },
+        {
+            name: 'build',
+            emoji: '🏗️',
+            description: 'Build packages',
+            handler: async () => {
+                if (targets.length === 1)
+                    await buildSingle(targets[0]);
+                else
+                    await buildAll();
+                state.lastStep = 'build';
+            },
+        },
+        {
+            name: 'publish',
+            emoji: '🚀',
+            description: 'Version, commit, and publish',
+            handler: async () => {
+                await ensureWorkingTreeCommitted();
+                if (targets.length > 1)
+                    await releaseMultiple(targets, packages);
+                else
+                    await releaseSingle(targets[0], packages);
+                state.lastStep = 'publish';
+            },
+        },
+        {
+            name: 'full',
+            emoji: '✅',
+            description: 'update → test → build → publish',
+            handler: async () => {
+                await updateDependencies(targets);
+                if (targets.length === 1)
+                    await testSingle(targets[0]);
+                else
+                    await testAll();
+                if (targets.length === 1)
+                    await buildSingle(targets[0]);
+                else
+                    await buildAll();
+                await ensureWorkingTreeCommitted();
+                if (targets.length > 1)
+                    await releaseMultiple(targets, packages);
+                else
+                    await releaseSingle(targets[0], packages);
+                state.lastStep = 'full';
+            },
+        },
+        {
+            name: 'back',
+            emoji: '↩️',
+            description: 'Pick packages again',
+            handler: async () => {
+                state.lastStep = 'back';
+            },
+        },
+    ];
+}
+export function buildPackageSelectionMenu(packages, onStepComplete) {
+    const ordered = getOrderedPackages(packages);
+    const entries = ordered.map((pkg) => ({
+        name: pkg.substitute,
+        emoji: colors[pkg.color]('●'),
+        description: pkg.name ?? pkg.dirName,
+        handler: async () => {
+            const step = await runStepLoop([pkg], packages);
+            onStepComplete?.(step);
+        },
+    }));
+    entries.push({
+        name: 'All packages',
+        emoji: globalEmoji,
+        description: 'Select all packages',
+        handler: async () => {
+            const step = await runStepLoop(ordered, packages);
+            onStepComplete?.(step);
+        },
+    });
+    return entries;
+}
+// IMPORTANT FIX: do not auto-pass argv derived from lastStep.
+// This removes the infinite loop and returns to the step menu after each run.
+export async function runStepLoop(targets, packages) {
+    const state = {};
+    // Loop shows the step menu and executes a chosen action once.
+    // After the handler completes, show the menu again.
+    // Selecting "back" breaks and returns control to the package picker.
+    // No argv auto-execution here.
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        state.lastStep = undefined;
+        const entries = makeStepEntries(targets, packages, state);
+        await runHelperCli({
+            title: `Actions for ${targets.length === 1 ? targets[0].name : 'selected packages'}`,
+            scripts: entries,
+            argv: [], // <- key change
+        });
+        if (state.lastStep === 'back')
+            return state.lastStep;
+        // keep looping to show menu again
+    }
+}