@emeryld/manager 0.6.3 → 0.6.5

package/dist/colors-shared.js

@@ -0,0 +1,11 @@
+const ansi = (code) => (text) => `\x1b[${code}m${text}\x1b[0m`;
+export const colors = {
+    cyan: ansi(36),
+    green: ansi(32),
+    yellow: ansi(33),
+    magenta: ansi(35),
+    red: ansi(31),
+    bold: ansi(1),
+    dim: ansi(2),
+    gray: ansi(90),
+};

package/dist/create-package/index.js

@@ -1,9 +1,8 @@
 import { mkdir, readdir, readFile, rm, stat } from 'node:fs/promises';
-import { spawn } from 'node:child_process';
 import path from 'node:path';
-import { stdin as input } from 'node:process';
-import { askLine, promptSingleKey } from '../prompts.js';
+import { askLine } from '../prompts.js';
 import { colors, logGlobal } from '../utils/log.js';
+import { run } from '../utils/run.js';
 import { runHelperCli } from '../helper-cli.js';
 import { loadPackages } from '../packages.js';
 import { SCRIPT_DESCRIPTIONS, workspaceRoot, ensureWorkspaceToolingFiles, } from './shared.js';
@@ -257,133 +256,26 @@ async function ensureTargetDir(targetDir, options) {
         throw error;
     }
 }
-async function runCommand(cmd, args, cwd = workspaceRoot) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(cmd, args, {
-            cwd,
-            stdio: 'inherit',
-            shell: process.platform === 'win32',
-        });
-        child.on('exit', (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`${cmd} ${args.join(' ')} exited with ${code}`));
-        });
-        child.on('error', (err) => reject(err));
-    });
-}
-function formatVariantLines(variants, selected) {
-    const heading = colors.magenta('Available templates');
-    const lines = [heading];
-    variants.forEach((variant, index) => {
-        const isSelected = index === selected;
-        const pointer = isSelected ? `${colors.green('➤')} ` : '  ';
-        const numberLabel = colors.cyan(String(index + 1).padStart(2, ' '));
-        const label = isSelected ? colors.green(variant.label) : variant.label;
-        const meta = colors.dim(variant.defaultDir);
-        lines.push(`${pointer}${numberLabel}. ${label} ${meta}`);
-    });
-    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 promptForVariant() {
-    const supportsRawMode = typeof input.setRawMode === 'function' && input.isTTY;
-    if (!supportsRawMode) {
-        const fallbackMessage = [
-            'Pick a package template:',
-            VARIANTS.map((opt, idx) => `  [${idx + 1}] ${opt.label}`).join('\n'),
-            `Enter 1-${VARIANTS.length}: `,
-        ].join('\n');
-        return promptSingleKey(fallbackMessage, (key) => {
-            const idx = Number.parseInt(key, 10);
-            if (Number.isInteger(idx) && idx >= 1 && idx <= VARIANTS.length) {
-                return VARIANTS[idx - 1];
-            }
-            return undefined;
+    let selection;
+    const scripts = VARIANTS.map((variant) => ({
+        name: variant.label,
+        emoji: '✨',
+        description: variant.summary
+            ? `${variant.summary} · ${variant.defaultDir}`
+            : variant.defaultDir,
+        handler: () => {
+            selection = variant;
+        },
+    }));
+    while (!selection) {
+        await runHelperCli({
+            title: 'Pick a package template',
+            scripts,
+            argv: [],
         });
     }
-    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 = (variant) => {
-            cleanup();
-            console.log();
-            resolve(variant);
-        };
-        const render = () => {
-            const lines = formatVariantLines(VARIANTS, selectedIndex);
-            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 + VARIANTS.length) % VARIANTS.length;
-                render();
-                return;
-            }
-            if (isArrowDown ||
-                (buffer.length === 1 && (buffer[0] === 0x6a || buffer[0] === 0x4a))) {
-                selectedIndex = (selectedIndex + 1) % VARIANTS.length;
-                render();
-                return;
-            }
-            if (buffer.length === 1 && (buffer[0] === 0x0d || buffer[0] === 0x0a)) {
-                commitSelection(VARIANTS[selectedIndex]);
-                return;
-            }
-            if (buffer.length === 1 && buffer[0] >= 0x30 && buffer[0] <= 0x39) {
-                const numericValue = buffer[0] === 0x30 ? 10 : buffer[0] - 0x30;
-                const idx = numericValue - 1;
-                if (idx >= 0 && idx < VARIANTS.length) {
-                    commitSelection(VARIANTS[idx]);
-                }
-                else {
-                    process.stdout.write('\x07');
-                }
-                return;
-            }
-        };
-        input.on('data', onData);
-        render();
-    });
+    return selection;
 }
 async function promptForTargetDir(fallback) {
     const answer = await askLine(`Path for the new package? (${fallback}): `);
@@ -401,7 +293,7 @@ async function postCreateTasks(targetDir, options) {
     }
     try {
         logGlobal('Running pnpm install…', colors.cyan);
-        await runCommand('pnpm', ['install'], workspaceRoot);
+        await run('pnpm', ['install'], { cwd: workspaceRoot });
     }
     catch (error) {
         logGlobal(`pnpm install failed: ${error instanceof Error ? error.message : String(error)}`, colors.yellow);
@@ -415,7 +307,9 @@ async function postCreateTasks(targetDir, options) {
     try {
         if (options?.pkgName) {
             logGlobal(`Building workspace deps for ${options.pkgName}…`, colors.cyan);
-            await runCommand('pnpm', ['-r', '--filter', `${options.pkgName}...`, 'build'], workspaceRoot);
+            await run('pnpm', ['-r', '--filter', `${options.pkgName}...`, 'build'], {
+                cwd: workspaceRoot,
+            });
             return;
         }
     }
@@ -425,7 +319,7 @@ async function postCreateTasks(targetDir, options) {
     // Fallback: build everything
     try {
         logGlobal('Building full workspace…', colors.cyan);
-        await runCommand('pnpm', ['-r', 'build'], workspaceRoot);
+        await run('pnpm', ['-r', 'build'], { cwd: workspaceRoot });
         return;
     }
     catch (error) {
@@ -438,7 +332,9 @@ async function postCreateTasks(targetDir, options) {
         const pkg = JSON.parse(pkgRaw);
         if (pkg.scripts?.build) {
             logGlobal('Running pnpm run build for the new package…', colors.cyan);
-            await runCommand('pnpm', ['-C', targetDir, 'run', 'build'], workspaceRoot);
+            await run('pnpm', ['-C', targetDir, 'run', 'build'], {
+                cwd: workspaceRoot,
+            });
         }
     }
     catch (error) {

package/dist/helper-cli/colors.js

@@ -0,0 +1,7 @@
+import { colors as sharedColors } from '../colors-shared.js';
+export const colors = sharedColors;
+export function getEntryColor(entry) {
+    if (entry.color && colors[entry.color])
+        return colors[entry.color];
+    return colors.cyan;
+}

package/dist/helper-cli/display.js

@@ -0,0 +1,49 @@
+import { colors, getEntryColor } from './colors.js';
+import { BACK_KEY, NEXT_KEY, PAGE_SIZE, PREVIOUS_KEY } from './pagination.js';
+export function pageHeading(title, page, pageCount) {
+    const heading = title
+        ? colors.magenta(title)
+        : colors.magenta('Available scripts');
+    if (page === undefined || pageCount === undefined || pageCount <= 1) {
+        return heading;
+    }
+    return `${heading} ${colors.dim(`(page ${page + 1}/${pageCount})`)}`;
+}
+export function printScriptList(entries, title) {
+    const heading = pageHeading(title);
+    console.log(heading);
+    entries.forEach((entry, index) => {
+        const colorizer = entry.color ? getEntryColor(entry) : colors.cyan;
+        const label = entry.color ? colorizer(entry.displayName) : entry.displayName;
+        console.log(`  ${colorizer(String(index + 1).padStart(2, ' '))} ${entry.emoji} ${label} ${colors.dim(entry.metaLabel)}`);
+    });
+}
+export function printPaginatedScriptList(state, title) {
+    console.log(pageHeading(title, state.page, state.pageCount));
+    state.options.forEach((option) => {
+        const colorizer = option.type === 'entry' && option.entry.color
+            ? getEntryColor(option.entry)
+            : colors.cyan;
+        const numberLabel = colorizer(String(option.hotkey).padStart(2, ' '));
+        if (option.type === 'entry') {
+            const label = option.entry.color
+                ? colorizer(option.entry.displayName)
+                : option.entry.displayName;
+            console.log(`  ${numberLabel} ${option.entry.emoji} ${label} ${colors.dim(option.entry.metaLabel)}`);
+            return;
+        }
+        const icon = option.action === 'back'
+            ? '↩️'
+            : option.action === 'previous'
+                ? '⬅️'
+                : '➡️';
+        const label = option.action === 'previous'
+            ? 'Previous page'
+            : option.action === 'next'
+                ? 'Next page'
+                : 'Back';
+        const display = option.enabled ? label : colors.dim(label);
+        console.log(`  ${numberLabel} ${icon} ${display}`);
+    });
+    console.log(colors.dim(`Enter 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} for previous page, ${NEXT_KEY} for next page, ${BACK_KEY} to go back, or type a name.`));
+}

package/dist/helper-cli/env.js

@@ -0,0 +1,14 @@
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+export const managerRoot = path.resolve(path.dirname(__filename), '..', '..');
+export const rootDir = process.cwd();
+export const managerRequire = createRequire(import.meta.url);
+let tsNodeLoaderPath;
+export function getTsNodeLoaderPath() {
+    if (!tsNodeLoaderPath) {
+        tsNodeLoaderPath = managerRequire.resolve('ts-node/esm.mjs');
+    }
+    return tsNodeLoaderPath;
+}

package/dist/helper-cli/pagination.js

@@ -0,0 +1,41 @@
+export const PAGE_SIZE = 7;
+export const PREVIOUS_KEY = 8;
+export const NEXT_KEY = 9;
+export const BACK_KEY = 0;
+export function buildVisibleOptions(entries, page) {
+    const pageCount = Math.max(1, Math.ceil(entries.length / PAGE_SIZE));
+    const safePage = Math.min(Math.max(page, 0), pageCount - 1);
+    const start = safePage * PAGE_SIZE;
+    const pageEntries = entries.slice(start, start + PAGE_SIZE);
+    const options = pageEntries.map((entry, index) => ({
+        type: 'entry',
+        entry,
+        hotkey: index + 1,
+        absoluteIndex: start + index,
+    }));
+    const hasPrevious = safePage > 0;
+    const hasNext = safePage < pageCount - 1;
+    options.push({
+        type: 'nav',
+        action: 'previous',
+        hotkey: PREVIOUS_KEY,
+        enabled: hasPrevious,
+    });
+    options.push({
+        type: 'nav',
+        action: 'next',
+        hotkey: NEXT_KEY,
+        enabled: hasNext,
+    });
+    options.push({
+        type: 'nav',
+        action: 'back',
+        hotkey: BACK_KEY,
+        enabled: true,
+    });
+    return {
+        options,
+        page: safePage,
+        pageCount,
+    };
+}

package/dist/helper-cli/prompts.js

@@ -0,0 +1,229 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { colors, getEntryColor } from './colors.js';
+import { pageHeading, printPaginatedScriptList } from './display.js';
+import { BACK_KEY, buildVisibleOptions, NEXT_KEY, PAGE_SIZE, PREVIOUS_KEY, } from './pagination.js';
+import { findScriptEntry } from './scripts.js';
+async function promptWithReadline(entries, title) {
+    let page = 0;
+    const rl = readline.createInterface({ input, output });
+    try {
+        while (true) {
+            const state = buildVisibleOptions(entries, page);
+            page = state.page;
+            printPaginatedScriptList(state, title);
+            const answer = (await rl.question(colors.cyan('\nSelect an option by number or name: '))).trim();
+            if (!answer)
+                continue;
+            const numeric = Number.parseInt(answer, 10);
+            if (!Number.isNaN(numeric)) {
+                const option = state.options.find((opt) => opt.hotkey === numeric);
+                if (!option) {
+                    console.log(colors.yellow(`Unknown option "${answer}". Try again.`));
+                    continue;
+                }
+                if (option.type === 'entry') {
+                    return option.entry;
+                }
+                if (option.action === 'back') {
+                    return undefined;
+                }
+                if (option.action === 'previous') {
+                    if (option.enabled)
+                        page = Math.max(0, state.page - 1);
+                    else
+                        console.log(colors.yellow('No previous page.'));
+                    continue;
+                }
+                if (option.action === 'next') {
+                    if (option.enabled)
+                        page = Math.min(state.pageCount - 1, state.page + 1);
+                    else
+                        console.log(colors.yellow('No next page.'));
+                    continue;
+                }
+            }
+            const byName = findScriptEntry(entries, answer);
+            if (byName)
+                return byName;
+            console.log(colors.yellow(`Could not find "${answer}". Try again.`));
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+function formatInteractiveLines(state, selectedIndex, title) {
+    const heading = pageHeading(title, state.page, state.pageCount);
+    const lines = [heading];
+    state.options.forEach((option, index) => {
+        const isSelected = index === selectedIndex;
+        const pointer = isSelected ? `${colors.green('➤')} ` : '';
+        const colorizer = option.type === 'entry' && option.entry.color
+            ? getEntryColor(option.entry)
+            : colors.cyan;
+        const numberLabel = colorizer(`${option.hotkey}`.padStart(2, ' '));
+        if (option.type === 'entry') {
+            const label = option.entry.color
+                ? colorizer(option.entry.displayName)
+                : isSelected
+                    ? colors.green(option.entry.displayName)
+                    : option.entry.displayName;
+            lines.push(`${pointer}${numberLabel}. ${option.entry.emoji} ${label} ${colors.dim(option.entry.metaLabel)}`);
+            return;
+        }
+        const icon = option.action === 'back'
+            ? '↩️'
+            : option.action === 'previous'
+                ? '⬅️'
+                : '➡️';
+        const baseLabel = option.action === 'previous'
+            ? 'Previous page'
+            : option.action === 'next'
+                ? 'Next page'
+                : 'Back';
+        const navLabel = option.enabled ? baseLabel : colors.dim(baseLabel);
+        lines.push(`${pointer}${numberLabel}. ${icon} ${navLabel}`);
+    });
+    lines.push('');
+    lines.push(colors.dim(`Use ↑/↓ (or j/k) to move, 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} prev page, ${NEXT_KEY} next page, ${BACK_KEY} back, 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;
+}
+export 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;
+        let state = buildVisibleOptions(entries, 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 commitBack = () => {
+            cleanup();
+            console.log();
+            resolve(undefined);
+        };
+        const setPage = (page) => {
+            state = buildVisibleOptions(entries, page);
+            selectedIndex = Math.min(selectedIndex, state.options.length - 1);
+            selectedIndex = Math.max(0, selectedIndex);
+            render();
+        };
+        const handleNav = (option) => {
+            if (option.action === 'back') {
+                commitBack();
+                return;
+            }
+            if (option.action === 'previous') {
+                if (option.enabled)
+                    setPage(state.page - 1);
+                else
+                    process.stdout.write('\x07');
+                return;
+            }
+            if (option.action === 'next') {
+                if (option.enabled)
+                    setPage(state.page + 1);
+                else
+                    process.stdout.write('\x07');
+            }
+        };
+        const activateOption = (option) => {
+            if (option.type === 'entry') {
+                commitSelection(option.entry);
+                return;
+            }
+            handleNav(option);
+        };
+        const render = () => {
+            const lines = formatInteractiveLines(state, 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 + state.options.length) % state.options.length;
+                render();
+                return;
+            }
+            if (isArrowDown ||
+                (buffer.length === 1 && (buffer[0] === 0x6a || buffer[0] === 0x4a))) {
+                selectedIndex = (selectedIndex + 1) % state.options.length;
+                render();
+                return;
+            }
+            if (isEnter) {
+                activateOption(state.options[selectedIndex]);
+                return;
+            }
+            if (buffer.length === 1 && buffer[0] >= 0x30 && buffer[0] <= 0x39) {
+                const numericValue = buffer[0] - 0x30;
+                const option = state.options.find((opt) => opt.hotkey === numericValue);
+                if (option)
+                    activateOption(option);
+                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) {
+                    const page = Math.floor(foundIndex / PAGE_SIZE);
+                    state = buildVisibleOptions(entries, page);
+                    selectedIndex = foundIndex % PAGE_SIZE;
+                    render();
+                }
+                else {
+                    process.stdout.write('\x07');
+                }
+            }
+        };
+        input.on('data', onData);
+        render();
+    });
+}

package/dist/helper-cli/runner.js

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { colors } from './colors.js';
+import { managerRoot, rootDir } from './env.js';
+import { buildTsNodeRegisterImport } from './ts-node.js';
+export 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}`));
+        });
+    });
+}

package/dist/helper-cli/scripts.js

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { rootDir } from './env.js';
+export 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]'),
+        };
+    });
+}
+export 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;
+    });
+}

package/dist/helper-cli/ts-node.js

@@ -0,0 +1,10 @@
+import { getTsNodeLoaderPath } from './env.js';
+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)}`;
+}

package/dist/helper-cli/types.js

@@ -0,0 +1 @@
+export {};