@emeryld/manager 0.6.3 → 0.6.5

package/dist/helper-cli.js

@@ -1,285 +1,9 @@
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-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 managerRoot = path.resolve(path.dirname(__filename), '..');
-// Workspace root is wherever the CLI is executed.
-const rootDir = process.cwd();
-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 tsConfigFallback = path.join(rootDir, 'tsconfig.json');
-    const bundledTsconfig = path.join(managerRoot, 'tsconfig.base.json');
-    const projectPath = existsSync(tsConfigPath)
-        ? tsConfigPath
-        : existsSync(tsConfigFallback)
-            ? tsConfigFallback
-            : existsSync(bundledTsconfig)
-                ? bundledTsconfig
-                : undefined;
-    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,
-                    ...(projectPath ? { TS_NODE_PROJECT: projectPath } : {}),
-                }
-                : 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}`));
-        });
-    });
-}
+import { colors } from './helper-cli/colors.js';
+import { printScriptList } from './helper-cli/display.js';
+import { promptForScript } from './helper-cli/prompts.js';
+import { findScriptEntry, normalizeScripts } from './helper-cli/scripts.js';
+import { runEntry } from './helper-cli/runner.js';
+export { buildTsNodeRegisterImport } from './helper-cli/ts-node.js';
 export async function runHelperCli({ scripts, title = 'Helper CLI', argv = process.argv.slice(2), }) {
     const normalized = normalizeScripts(scripts);
     let args = Array.isArray(argv) ? [...argv] : [];
@@ -310,5 +34,7 @@ export async function runHelperCli({ scripts, title = 'Helper CLI', argv = proce
         console.log(colors.yellow(`Unknown script "${firstArg}". Falling back to interactive selection…`));
     }
     const selection = await promptForScript(normalized, title);
-    await runEntry(selection, []);
+    if (selection) {
+        await runEntry(selection, []);
+    }
 }

package/dist/menu/script-helpers.js

@@ -0,0 +1,178 @@
+import { colors } from "../utils/log.js";
+import { run } from "../utils/run.js";
+export function collectDependencies(pkg) {
+    return new Set([
+        ...Object.keys(pkg.json?.dependencies ?? {}),
+        ...Object.keys(pkg.json?.devDependencies ?? {}),
+    ]);
+}
+const BASE_SCRIPT_KEYS = ['format', 'typecheck', 'dev', 'lint'];
+function commandDescription(args) {
+    return `pnpm ${args.join(' ')}`;
+}
+function resolveRunScript(scripts, candidates) {
+    for (const name of candidates) {
+        if (!scripts[name])
+            continue;
+        const cmd = commandDescription(['run', name]);
+        const scriptDetail = scripts[name]?.trim();
+        const description = scriptDetail ? `${cmd} (${scriptDetail})` : cmd;
+        return {
+            label: name,
+            description,
+            args: ['run', name],
+            available: true,
+        };
+    }
+    return undefined;
+}
+function resolveFormatScript(pkg, scripts, dependencies) {
+    const direct = resolveRunScript(scripts, ['format', 'fmt']);
+    if (direct)
+        return direct;
+    if (dependencies.has('prettier')) {
+        const args = ['exec', 'prettier', '--check', '.'];
+        return {
+            label: 'prettier --check',
+            description: commandDescription(args),
+            args,
+            available: true,
+        };
+    }
+    return {
+        label: 'format',
+        description: `No format/fmt script found for ${pkg.name}`,
+        available: false,
+    };
+}
+function resolveTypecheckScript(pkg, scripts, dependencies) {
+    const direct = resolveRunScript(scripts, ['typecheck', 'check']);
+    if (direct)
+        return direct;
+    if (dependencies.has('typescript')) {
+        const args = ['exec', 'tsc', '--noEmit', '--pretty', 'false'];
+        return {
+            label: 'tsc --noEmit',
+            description: commandDescription(args),
+            args,
+            available: true,
+        };
+    }
+    return {
+        label: 'typecheck',
+        description: `No typecheck/check script found for ${pkg.name}`,
+        available: false,
+    };
+}
+function resolveLintScript(pkg, scripts, dependencies) {
+    const direct = resolveRunScript(scripts, ['lint']);
+    if (direct)
+        return direct;
+    if (dependencies.has('eslint')) {
+        const args = ['exec', 'eslint', '.', '--ext', '.ts,.tsx,.js,.jsx'];
+        return {
+            label: 'eslint .',
+            description: commandDescription(args),
+            args,
+            available: true,
+        };
+    }
+    return {
+        label: 'lint',
+        description: `No lint script found for ${pkg.name}`,
+        available: false,
+    };
+}
+function resolveDevScript(pkg, scripts, dependencies, kind) {
+    const devCandidates = kind === 'frontend'
+        ? ['dev', 'start', 'serve']
+        : kind === 'backend'
+            ? ['dev', 'start', 'watch', 'serve', 'start:dev']
+            : ['dev', 'start'];
+    const direct = resolveRunScript(scripts, devCandidates);
+    if (direct)
+        return direct;
+    if (dependencies.has('next')) {
+        const args = ['exec', 'next', 'dev'];
+        return {
+            label: 'next dev',
+            description: commandDescription(args),
+            args,
+            available: true,
+        };
+    }
+    if (dependencies.has('vite')) {
+        const args = ['exec', 'vite', 'dev'];
+        return {
+            label: 'vite dev',
+            description: commandDescription(args),
+            args,
+            available: true,
+        };
+    }
+    if (dependencies.has('expo')) {
+        const args = ['exec', 'expo', 'start'];
+        return {
+            label: 'expo start',
+            description: commandDescription(args),
+            args,
+            available: true,
+        };
+    }
+    return {
+        label: 'dev',
+        description: `No dev/start script found for ${pkg.name}`,
+        available: false,
+    };
+}
+function resolveBaseScript(pkg, key, scripts, dependencies, kind) {
+    switch (key) {
+        case 'format':
+            return resolveFormatScript(pkg, scripts, dependencies);
+        case 'typecheck':
+            return resolveTypecheckScript(pkg, scripts, dependencies);
+        case 'lint':
+            return resolveLintScript(pkg, scripts, dependencies);
+        case 'dev':
+        default:
+            return resolveDevScript(pkg, scripts, dependencies, kind);
+    }
+}
+export function makeBaseScriptEntries(pkg) {
+    const scripts = pkg.json?.scripts ?? {};
+    const dependencies = collectDependencies(pkg);
+    const marker = getPackageMarker(pkg, dependencies);
+    return BASE_SCRIPT_KEYS.map((key) => {
+        const resolution = resolveBaseScript(pkg, key, scripts, dependencies, marker.kind);
+        const description = resolution.available
+            ? resolution.description
+            : `No ${key} command detected`;
+        return {
+            name: key,
+            emoji: '⚡️',
+            description,
+            handler: async () => {
+                if (!resolution.available || !resolution.args) {
+                    console.log(colors.yellow(`No ${key} command found for ${pkg.name}.`));
+                    return;
+                }
+                await run('pnpm', resolution.args, { cwd: pkg.path });
+            },
+        };
+    });
+}
+export function getPackageMarker(pkg, dependencies = collectDependencies(pkg)) {
+    const hasFrontend = ['react', 'next', 'expo', 'react-native', 'vite'].some((dep) => dependencies.has(dep));
+    const hasBackend = ['express', 'fastify', 'hono', 'koa', '@nestjs/core'].some((dep) => dependencies.has(dep));
+    const pkgType = pkg.json?.type?.toLowerCase();
+    if (hasFrontend) {
+        return { label: 'frontend', colorize: colors.magenta, kind: 'frontend' };
+    }
+    if (hasBackend) {
+        return { label: 'backend', colorize: colors.green, kind: 'backend' };
+    }
+    if (pkgType === 'module') {
+        return { label: 'esm', colorize: colors.yellow, kind: 'library' };
+    }
+    return { label: 'node', colorize: colors.cyan, kind: 'library' };
+}

package/dist/menu.js

@@ -1,13 +1,14 @@
 // src/menu.js
 import path from 'node:path';
 import { colors, globalEmoji } from './utils/log.js';
-import { updateDependencies, testAll, testSingle, buildAll, buildSingle, } from './workspace.js';
+import { updateDependencies, testAll, testSingle, buildAll, buildSingle, cleanPackages, rebuildPackages, } 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';
 import { openDockerHelper } from './docker.js';
 import { run } from './utils/run.js';
+import { makeBaseScriptEntries, getPackageMarker } from './menu/script-helpers.js';
 function makeManagerStepEntries(targets, packages, state, options) {
     const includeBack = options?.includeBack ?? true;
     return [
@@ -20,6 +21,24 @@ function makeManagerStepEntries(targets, packages, state, options) {
                 state.lastStep = 'update';
             },
         },
+        {
+            name: 'clean',
+            emoji: '🧹',
+            description: 'Remove node_modules, dist, and caches',
+            handler: async () => {
+                await cleanPackages(targets);
+                state.lastStep = 'clean';
+            },
+        },
+        {
+            name: 'rebuild',
+            emoji: '🔁',
+            description: 'Clean then build',
+            handler: async () => {
+                await rebuildPackages(targets);
+                state.lastStep = 'rebuild';
+            },
+        },
         {
             name: 'test',
             emoji: '🧪',
@@ -93,25 +112,32 @@ function makeManagerStepEntries(targets, packages, state, options) {
             : []),
     ];
 }
-function makePackageScriptEntries(pkg) {
-    const scripts = pkg.json?.scripts ?? {};
-    const entries = [];
+function makeDockerEntry(pkg) {
     if (pkg.dockerfilePath) {
         const dockerLabel = path
             .relative(process.cwd(), pkg.dockerfilePath)
             .replace(/\\/g, '/');
-        entries.push({
+        return {
             name: `Dockerfile (${dockerLabel})`,
             emoji: '🐳',
             description: 'manager -> opens the docker cli',
             handler: async () => {
                 await openDockerHelper(pkg);
             },
-        });
+        };
     }
+    return undefined;
+}
+function makePackageScriptEntries(pkg) {
+    const scripts = pkg.json?.scripts ?? {};
+    const baseEntries = makeBaseScriptEntries(pkg);
+    const baseNames = new Set(baseEntries.map((entry) => entry.name));
+    const entries = [];
     Object.entries(scripts)
         .sort(([a], [b]) => a.localeCompare(b))
         .forEach(([name, command]) => {
+        if (baseNames.has(name))
+            return;
         entries.push({
             name,
             emoji: '▶️',
@@ -121,23 +147,31 @@ function makePackageScriptEntries(pkg) {
             },
         });
     });
-    return entries;
+    return [...baseEntries, ...entries];
 }
 export function buildPackageSelectionMenu(packages, onStepComplete) {
     const ordered = getOrderedPackages(packages);
-    const entries = ordered.map((pkg) => ({
-        name: pkg.name ?? pkg.substitute ?? pkg.dirName,
-        emoji: colors[pkg.color]('●'),
-        description: pkg.relativeDir ?? pkg.dirName,
-        handler: async () => {
-            const step = await runStepLoop([pkg], packages);
-            onStepComplete?.(step);
-        },
-    }));
+    const entries = ordered.map((pkg) => {
+        const marker = getPackageMarker(pkg);
+        const pkgColor = pkg.color ?? 'cyan';
+        const descriptionMeta = pkg.relativeDir ?? pkg.dirName;
+        const markerHint = marker.label ? ` · ${marker.label}` : '';
+        return {
+            name: pkg.name ?? pkg.substitute ?? pkg.dirName,
+            emoji: marker.colorize('●'),
+            description: `${descriptionMeta}${colors.dim(markerHint)}`,
+            color: pkgColor,
+            handler: async () => {
+                const step = await runStepLoop([pkg], packages);
+                onStepComplete?.(step);
+            },
+        };
+    });
     if (ordered.length === 0)
         return entries;
     entries.push({
         name: 'All packages',
+        color: 'gray',
         emoji: globalEmoji,
         description: 'Select all packages',
         handler: async () => {
@@ -154,10 +188,12 @@ export async function runStepLoop(targets, packages) {
     // Single package: show combined menu (manager actions + package.json scripts)
     if (targets.length === 1) {
         const pkg = targets[0];
+        const dockerEntry = makeDockerEntry(pkg);
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const scriptEntries = makePackageScriptEntries(pkg);
             const entries = [
+                ...(dockerEntry ? [dockerEntry] : []),
                 {
                     name: 'manager actions',
                     emoji: globalEmoji,
@@ -170,9 +206,8 @@ export async function runStepLoop(targets, packages) {
                             {
                                 name: 'back',
                                 emoji: '↩️',
-                                description: 'Return to package scripts',
+                                description: 'Return to package menu',
                                 handler: () => {
-                                    // no state change; just exit to the package scripts menu
                                     state.lastStep = undefined;
                                 },
                             },
@@ -184,7 +219,31 @@ export async function runStepLoop(targets, packages) {
                         });
                     },
                 },
-                ...scriptEntries,
+                {
+                    name: 'package scripts',
+                    emoji: '📜',
+                    description: 'Run package.json scripts',
+                    handler: async () => {
+                        if (scriptEntries.length === 0) {
+                            console.log(colors.yellow(`No package.json scripts found for ${pkg.name}.`));
+                            return;
+                        }
+                        const scriptsMenu = [
+                            ...scriptEntries,
+                            {
+                                name: 'back',
+                                emoji: '↩️',
+                                description: 'Return to package menu',
+                                handler: () => { },
+                            },
+                        ];
+                        await runHelperCli({
+                            title: `${pkg.name} scripts`,
+                            scripts: scriptsMenu,
+                            argv: [],
+                        });
+                    },
+                },
                 {
                     name: 'back',
                     emoji: '↩️',