@emeryld/manager 1.3.0 → 1.4.0

package/dist/create-package/variants/fullstack/utils.js

@@ -0,0 +1,241 @@
+import { access, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export function deriveNames(baseName) {
+    const normalized = baseName.trim();
+    return {
+        contract: `@${normalized}/contract`,
+        server: `@${normalized}/server`,
+        client: `@${normalized}/client`,
+        docker: `${normalized}-docker`,
+    };
+}
+export function deriveDirs(rootDir, baseName) {
+    const packagesRoot = path.join(rootDir, 'packages');
+    return {
+        root: rootDir,
+        packagesRoot,
+        contract: path.join(packagesRoot, `${baseName}-contract`),
+        server: path.join(packagesRoot, `${baseName}-server`),
+        client: path.join(packagesRoot, `${baseName}-client`),
+        docker: path.join(packagesRoot, `${baseName}-docker`),
+    };
+}
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+export async function pathExists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeWorkspaceGlob(value) {
+    const unquoted = value.replace(/^['"]|['"]$/g, '').trim();
+    const normalized = toPosixPath(unquoted || '');
+    return normalized.replace(/^\.\//, '');
+}
+function globCoversCandidate(pattern, candidate) {
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    const normalizedCandidate = normalizeWorkspaceGlob(candidate);
+    if (!normalizedPattern || !normalizedCandidate)
+        return false;
+    if (normalizedPattern === normalizedCandidate)
+        return true;
+    if (normalizedPattern === '*' || normalizedPattern === '**')
+        return true;
+    if (normalizedPattern.endsWith('/**')) {
+        return normalizedCandidate.startsWith(normalizedPattern.slice(0, -3));
+    }
+    return false;
+}
+function patternsContain(patterns, candidate) {
+    return patterns.some((pattern) => globCoversCandidate(pattern, candidate));
+}
+function parsePnpmWorkspacePackages(raw) {
+    const packages = [];
+    const lines = raw.split(/\r?\n/);
+    const packagesIndex = lines.findIndex((line) => line.trim().startsWith('packages:'));
+    if (packagesIndex === -1)
+        return packages;
+    const baseIndent = lines[packagesIndex]?.match(/^(\s*)/)?.[1] ?? '';
+    for (let i = packagesIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const indent = line.match(/^(\s*)/)?.[1] ?? '';
+        if (indent.length <= baseIndent.length && !trimmed.startsWith('-'))
+            break;
+        if (!trimmed.startsWith('-')) {
+            if (indent.length <= baseIndent.length)
+                break;
+            continue;
+        }
+        const value = trimmed.slice(1).trim().replace(/^['"]|['"]$/g, '');
+        if (value)
+            packages.push(value);
+    }
+    return packages;
+}
+function insertIntoPnpmWorkspace(raw, pattern) {
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    if (!normalizedPattern)
+        return { added: false, content: raw };
+    const existing = parsePnpmWorkspacePackages(raw);
+    if (patternsContain(existing, normalizedPattern)) {
+        return { added: false, content: raw };
+    }
+    const lines = raw.split(/\r?\n/);
+    const packagesIndex = lines.findIndex((line) => line.trim().startsWith('packages:'));
+    const entryLine = packagesIndex === -1
+        ? `  - '${normalizedPattern}'`
+        : `${lines[packagesIndex]?.match(/^(\s*)/)?.[1] ?? ''}  - '${normalizedPattern}'`;
+    if (packagesIndex === -1) {
+        const prefix = raw.trimEnd() ? `${raw.trimEnd()}\n` : '';
+        const content = `${prefix}packages:\n${entryLine}\n`;
+        return { added: true, content };
+    }
+    let insertAt = packagesIndex + 1;
+    const baseIndent = lines[packagesIndex]?.match(/^(\s*)/)?.[1] ?? '';
+    for (let i = packagesIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        const indent = line.match(/^(\s*)/)?.[1] ?? '';
+        if (!trimmed) {
+            insertAt = i + 1;
+            continue;
+        }
+        if (indent.length <= baseIndent.length && !trimmed.startsWith('-')) {
+            insertAt = i;
+            break;
+        }
+        if (trimmed.startsWith('-')) {
+            insertAt = i + 1;
+            continue;
+        }
+        if (indent.length <= baseIndent.length) {
+            insertAt = i;
+            break;
+        }
+    }
+    lines.splice(insertAt, 0, entryLine);
+    const content = lines.join('\n').replace(/\n+$/, '\n');
+    return { added: true, content };
+}
+async function readPackageJsonWorkspaces(configPath) {
+    const raw = await readFile(configPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    const workspaces = pkg.workspaces;
+    if (typeof workspaces === 'string')
+        return [workspaces];
+    if (Array.isArray(workspaces))
+        return workspaces.map(normalizeWorkspaceGlob).filter(Boolean);
+    if (workspaces && typeof workspaces === 'object' && 'packages' in workspaces) {
+        const packages = workspaces.packages;
+        if (typeof packages === 'string')
+            return [packages];
+        if (Array.isArray(packages))
+            return packages.map(normalizeWorkspaceGlob).filter(Boolean);
+    }
+    return undefined;
+}
+async function readPnpmWorkspace(configPath) {
+    const raw = await readFile(configPath, 'utf8');
+    return parsePnpmWorkspacePackages(raw).map(normalizeWorkspaceGlob).filter(Boolean);
+}
+export async function findWorkspaceRoot(startDir) {
+    let current = path.resolve(startDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const pnpmPath = path.join(current, 'pnpm-workspace.yaml');
+        if (await pathExists(pnpmPath)) {
+            const patterns = await readPnpmWorkspace(pnpmPath);
+            return { rootDir: current, configPath: pnpmPath, type: 'pnpm-workspace', patterns };
+        }
+        const pkgPath = path.join(current, 'package.json');
+        if (await pathExists(pkgPath)) {
+            const patterns = await readPackageJsonWorkspaces(pkgPath);
+            if (patterns) {
+                return { rootDir: current, configPath: pkgPath, type: 'package-json', patterns };
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+async function updatePnpmWorkspaceFile(configPath, pattern) {
+    const raw = await readFile(configPath, 'utf8');
+    const { added, content } = insertIntoPnpmWorkspace(raw, pattern);
+    if (!added)
+        return false;
+    await writeFile(configPath, content, 'utf8');
+    return true;
+}
+async function updatePackageJsonWorkspaces(configPath, pattern) {
+    const raw = await readFile(configPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (typeof pkg.workspaces === 'string') {
+        if (globCoversCandidate(pkg.workspaces, normalizedPattern))
+            return false;
+        pkg.workspaces = [pkg.workspaces, normalizedPattern];
+    }
+    else if (Array.isArray(pkg.workspaces)) {
+        if (patternsContain(pkg.workspaces, normalizedPattern))
+            return false;
+        pkg.workspaces.push(normalizedPattern);
+    }
+    else if (pkg.workspaces && typeof pkg.workspaces === 'object') {
+        const packages = pkg.workspaces.packages;
+        if (Array.isArray(packages)) {
+            if (patternsContain(packages, normalizedPattern))
+                return false;
+            packages.push(normalizedPattern);
+        }
+        else {
+            pkg.workspaces.packages = [normalizedPattern];
+        }
+    }
+    else {
+        pkg.workspaces = [normalizedPattern];
+    }
+    const next = `${JSON.stringify(pkg, null, 2)}\n`;
+    await writeFile(configPath, next, 'utf8');
+    return true;
+}
+export async function ensureWorkspacePattern(info, pattern) {
+    const normalizedPattern = normalizeWorkspaceGlob(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (patternsContain(info.patterns, normalizedPattern))
+        return false;
+    const updated = info.type === 'pnpm-workspace'
+        ? await updatePnpmWorkspaceFile(info.configPath, normalizedPattern)
+        : await updatePackageJsonWorkspaces(info.configPath, normalizedPattern);
+    if (updated) {
+        info.patterns.push(normalizedPattern);
+        const rel = path.relative(info.rootDir, info.configPath) || path.basename(info.configPath);
+        console.log(`  updated ${rel} (added workspace path ${normalizedPattern})`);
+    }
+    return updated;
+}
+export function workspacePatternForPackagesRoot(workspaceRootDir, packagesRoot) {
+    const relative = toPosixPath(path.relative(workspaceRootDir, path.join(packagesRoot, '*')));
+    const normalized = relative || './packages/*';
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}
+export function workspacePatternForStackRoot(workspaceRootDir, stackRoot) {
+    const relative = toPosixPath(path.relative(workspaceRootDir, stackRoot));
+    const normalized = relative || '';
+    if (!normalized || normalized === '.')
+        return undefined;
+    return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+}

package/dist/llm-pack.js

@@ -0,0 +1,2 @@
+EXPORTS: TYPES: SIGNATURES: EXEMPLARS: ;
+export {};

package/dist/robot/cli/prompts.js

@@ -1,11 +1,10 @@
 import { colors } from '../../utils/log.js';
 import { askLine } from '../../prompts.js';
-import { formatValue, parseInteractiveValue, parseKindsInput, SETTING_DESCRIPTORS, validateRobotSettings, } from './settings.js';
-import { promptInteractiveSettings, } from '../../cli/interactive-settings.js';
-import { stdin as input } from 'node:process';
+import { promptInteractiveSettings } from '../../cli/interactive-settings.js';
+import { SETTING_DESCRIPTORS, formatValue, parseInteractiveValue, validateRobotSettings, parseKindsInput, } from './settings.js';
 const READY_PROMPT = colors.dim('Settings retained. Use the keys above to adjust and confirm again.');
 export async function promptRobotSettings(defaults) {
-    const supportsInteractive = typeof input.setRawMode === 'function' && input.isTTY;
+    const supportsInteractive = typeof process.stdin.setRawMode === 'function' && process.stdin.isTTY;
     let currentSettings = defaults;
     while (true) {
         const chosen = supportsInteractive
@@ -19,7 +18,7 @@ export async function promptRobotSettings(defaults) {
     }
 }
 async function confirmExecution() {
-    const question = colors.cyan('Run the robot extractor with these settings? (Y/n): ');
+    const question = colors.cyan('Run the robot with these settings? (Y/n): ');
     while (true) {
         const answer = (await askLine(question)).trim().toLowerCase();
         if (!answer || answer === 'y' || answer === 'yes')
@@ -31,17 +30,60 @@ async function confirmExecution() {
 }
 async function promptRobotSettingsSequential(defaults) {
     console.log(colors.dim('Enter values to override defaults or press Enter to keep the current setting.'));
+    const includeGlobs = await promptList('Include globs', defaults.includeGlobs);
+    const excludeGlobs = await promptList('Exclude globs', defaults.excludeGlobs);
+    const entrypoints = await promptList('Entrypoints', defaults.entrypoints);
+    const exportMode = await promptChoice('Export mode', defaults.exportMode, ['entrypoints', 'all-files']);
+    const visibility = await promptChoice('Visibility', defaults.visibility, ['exported-only', 'exported+reexported', 'all']);
+    const closure = await promptChoice('Type closure', defaults.closure, ['surface-only', 'surface+deps']);
+    const includeKinds = await promptKinds(defaults.includeKinds);
+    const maxExemplars = await promptPositiveNumber('Maximum exemplars', defaults.maxExemplars);
+    const tokenBudget = await promptTokenBudget('Token budget (blank = unlimited)', defaults.tokenBudget);
+    const preferTypeSurface = await promptBoolean('Prefer type surface in dependencies', defaults.preferTypeSurface);
     return {
-        includeKinds: await promptKinds(defaults.includeKinds),
-        exportedOnly: await promptBoolean('Only consider exported symbols', defaults.exportedOnly),
-        maxColumns: await promptNumber('Maximum columns', defaults.maxColumns),
+        ...defaults,
+        includeGlobs,
+        excludeGlobs,
+        entrypoints,
+        exportMode,
+        visibility,
+        closure,
+        includeKinds,
+        maxExemplars,
+        tokenBudget,
+        preferTypeSurface,
     };
 }
+async function promptList(label, fallback) {
+    const question = colors.cyan(`${label} [default ${fallback.join(', ')}]: `);
+    while (true) {
+        const answer = await askLine(question);
+        if (!answer)
+            return fallback;
+        const parsed = answer
+            .split(',')
+            .map((chunk) => chunk.trim())
+            .filter(Boolean);
+        if (parsed.length)
+            return parsed;
+        console.log(colors.yellow('Provide at least one value or leave blank to keep the default.'));
+    }
+}
+async function promptChoice(label, fallback, options) {
+    const question = colors.cyan(`${label} [default ${fallback}]: `);
+    const lookup = new Set(options);
+    while (true) {
+        const answer = await askLine(question);
+        if (!answer)
+            return fallback;
+        const normalized = answer.trim();
+        if (lookup.has(normalized))
+            return normalized;
+        console.log(colors.yellow(`Choose one of: ${options.join(', ')}.`));
+    }
+}
 async function promptKinds(fallback) {
-    const descriptor = SETTING_DESCRIPTORS.find((entry) => entry.key === 'includeKinds');
-    if (!descriptor)
-        return fallback;
-    const question = colors.cyan(`Kinds to include [default ${formatValue(fallback, descriptor)}]: `);
+    const question = colors.cyan(`Kinds to include [default ${fallback.join(', ')}]: `);
     while (true) {
         const answer = await askLine(question);
         if (!answer)
@@ -55,30 +97,45 @@ async function promptKinds(fallback) {
             return parsed.value;
     }
 }
-async function promptBoolean(label, fallback) {
-    const question = colors.cyan(`${label} [default ${fallback ? 'yes' : 'no'}]: `);
+async function promptPositiveNumber(label, fallback) {
+    const question = colors.cyan(`${label} [default ${fallback}]: `);
     while (true) {
-        const answer = (await askLine(question)).trim().toLowerCase();
+        const answer = await askLine(question);
         if (!answer)
             return fallback;
-        if (['yes', 'y', 'true', '1'].includes(answer))
-            return true;
-        if (['no', 'n', 'false', '0'].includes(answer))
-            return false;
-        console.log(colors.yellow('Please answer "yes" or "no", or leave blank to keep the default.'));
+        const parsed = Number(answer);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return Math.floor(parsed);
+        console.log(colors.yellow('Provide a positive integer or leave blank to keep the default.'));
     }
 }
-async function promptNumber(label, fallback) {
-    const question = colors.cyan(`${label} [default ${fallback}]: `);
+async function promptTokenBudget(label, fallback) {
+    const text = fallback ? `${fallback}` : 'unlimited';
+    const question = colors.cyan(`${label} [default ${text}]: `);
     while (true) {
         const answer = await askLine(question);
         if (!answer)
             return fallback;
+        if (answer.trim() === '' || Number(answer) === 0) {
+            return undefined;
+        }
         const parsed = Number(answer);
-        if (!Number.isNaN(parsed) && parsed > 0) {
+        if (Number.isFinite(parsed) && parsed > 0)
             return Math.floor(parsed);
-        }
-        console.log(colors.yellow('Provide a positive integer or leave blank to keep the default.'));
+        console.log(colors.yellow('Provide a positive integer, 0 for unlimited, or leave blank for the default.'));
+    }
+}
+async function promptBoolean(label, fallback) {
+    const question = colors.cyan(`${label} [default ${fallback ? 'yes' : 'no'}]: `);
+    while (true) {
+        const answer = (await askLine(question)).trim().toLowerCase();
+        if (!answer)
+            return fallback;
+        if (['yes', 'y', 'true', '1'].includes(answer))
+            return true;
+        if (['no', 'n', 'false', '0'].includes(answer))
+            return false;
+        console.log(colors.yellow('Please answer "yes" or "no", or leave blank to keep the default.'));
     }
 }
 async function promptRobotSettingsInteractive(defaults) {
@@ -90,11 +147,11 @@ async function promptRobotSettingsInteractive(defaults) {
         parse: (buffer) => parseInteractiveValue(descriptor, buffer),
     }));
     return promptInteractiveSettings({
-        title: 'Robot settings (type to edit values)',
+        title: 'Robot pack settings (type to edit values)',
         descriptors,
         initial: defaults,
         instructions: [
-            'Use ↑/↓ to change rows, type comma separated values for kinds, Backspace to clear characters, and Enter to validate and confirm the selection.',
+            'Use ↑/↓ to change rows, type to replace the highlighted value, Backspace to clear characters, and Enter to validate and confirm the selection.',
             'Press Esc/Ctrl+C to abort, or hit Enter again after reviewing the summary to continue.',
         ],
         validate: validateRobotSettings,

package/dist/robot/cli/settings.js

@@ -1,22 +1,62 @@
-import { ROBOT_KINDS } from '../types.js';
-const KNOWN_KINDS = new Set(ROBOT_KINDS);
+import { ROBOT_PACK_SYMBOL_KINDS, } from '../pack/types.js';
 export const SETTING_DESCRIPTORS = [
+    {
+        key: 'includeGlobs',
+        label: 'Include globs',
+        type: 'list',
+        unit: 'comma-separated patterns',
+    },
+    {
+        key: 'excludeGlobs',
+        label: 'Exclude globs',
+        type: 'list',
+        unit: 'comma-separated patterns',
+    },
+    {
+        key: 'entrypoints',
+        label: 'Entrypoints',
+        type: 'list',
+        unit: 'comma-separated patterns',
+    },
+    {
+        key: 'exportMode',
+        label: 'Export mode',
+        type: 'choice',
+        options: ['entrypoints', 'all-files'],
+    },
+    {
+        key: 'visibility',
+        label: 'Visibility',
+        type: 'choice',
+        options: ['exported-only', 'exported+reexported', 'all'],
+    },
+    {
+        key: 'closure',
+        label: 'Type closure',
+        type: 'choice',
+        options: ['surface-only', 'surface+deps'],
+    },
     {
         key: 'includeKinds',
         label: 'Kinds to include',
-        unit: 'comma-separated (function, component, type, const, class)',
         type: 'list',
+        unit: 'comma-separated',
     },
     {
-        key: 'exportedOnly',
-        label: 'Only exported symbols',
-        type: 'boolean',
+        key: 'maxExemplars',
+        label: 'Maximum exemplars',
+        type: 'number',
     },
     {
-        key: 'maxColumns',
-        label: 'Maximum columns',
-        unit: 'columns',
+        key: 'tokenBudget',
+        label: 'Token budget (blank = unlimited)',
         type: 'number',
+        allowEmpty: true,
+    },
+    {
+        key: 'preferTypeSurface',
+        label: 'Prefer type surface in dependencies',
+        type: 'boolean',
     },
 ];
 export function formatValue(value, descriptor) {
@@ -24,81 +64,99 @@ export function formatValue(value, descriptor) {
         return value ? 'true' : 'false';
     }
     if (descriptor.type === 'list') {
-        const kinds = value;
-        if (kinds.length === ROBOT_KINDS.length)
-            return 'all';
-        return kinds.join(', ');
+        const items = value;
+        if (!items.length)
+            return 'none';
+        return items.join(', ');
+    }
+    if (descriptor.type === 'choice') {
+        return `${value}`;
+    }
+    if (descriptor.type === 'number') {
+        if (descriptor.key === 'tokenBudget' && value === undefined) {
+            return 'unlimited';
+        }
+        return `${value}`;
     }
     return `${value}`;
 }
 export function parseInteractiveValue(descriptor, buffer) {
     const trimmed = buffer.trim();
     if (!trimmed) {
+        if (descriptor.allowEmpty) {
+            return { value: undefined };
+        }
         return { value: undefined };
     }
-    if (descriptor.type === 'number') {
-        const parsed = parsePositiveInteger(trimmed, { allowZero: descriptor.allowZero });
-        if (parsed === undefined) {
-            return {
-                error: `${descriptor.label} requires a ${descriptor.allowZero ? 'non-negative' : 'positive'} integer.`,
-            };
+    switch (descriptor.type) {
+        case 'list':
+            if (descriptor.key === 'includeKinds') {
+                return parseKindsInput(trimmed);
+            }
+            return { value: parseStringList(trimmed) };
+        case 'choice':
+            if (!descriptor.options)
+                return { value: undefined };
+            if (!descriptor.options.includes(trimmed)) {
+                return { error: `Choose one of: ${descriptor.options.join(', ')}.` };
+            }
+            return { value: trimmed };
+        case 'number':
+            if (descriptor.allowEmpty && trimmed === '') {
+                return { value: undefined };
+            }
+            const parsed = parsePositiveInteger(trimmed);
+            if (parsed === undefined) {
+                return { error: `${descriptor.label} requires a positive integer.` };
+            }
+            return { value: parsed };
+        case 'boolean': {
+            const parsedBool = parseBooleanInput(trimmed);
+            if (parsedBool.error)
+                return { error: parsedBool.error };
+            return { value: parsedBool.value };
         }
-        return { value: parsed };
-    }
-    if (descriptor.type === 'boolean') {
-        const parsed = parseBooleanInput(trimmed);
-        if (parsed.error)
-            return { error: parsed.error };
-        return { value: parsed.value };
+        default:
+            return { value: undefined };
     }
-    if (descriptor.type === 'list') {
-        return parseKindsInput(trimmed);
-    }
-    return { value: undefined };
 }
 export function validateRobotSettings(settings) {
-    if (!settings.includeKinds.length) {
-        return 'Select at least one kind to include.';
+    if (!settings.includeGlobs.length)
+        return 'Specify at least one include glob.';
+    if (!settings.entrypoints.length)
+        return 'Specify at least one entrypoint pattern.';
+    if (!settings.includeKinds.length)
+        return 'Choose at least one kind to include.';
+    if (!Number.isFinite(settings.maxExemplars) || settings.maxExemplars <= 0) {
+        return 'Maximum exemplars must be a positive number.';
     }
-    if (!Number.isFinite(settings.maxColumns) || settings.maxColumns <= 0) {
-        return 'Maximum columns must be a positive number.';
+    if (settings.tokenBudget !== undefined && settings.tokenBudget <= 0) {
+        return 'Token budget must be greater than zero or blank for unlimited.';
     }
     return undefined;
 }
-function parsePositiveInteger(inputValue, options) {
-    const num = Number(inputValue);
-    if (!Number.isFinite(num))
-        return undefined;
-    const floored = Math.floor(num);
-    const min = options?.allowZero ? 0 : 1;
-    if (floored < min)
-        return undefined;
-    return floored;
-}
-function parseBooleanInput(raw) {
-    const normalized = raw.trim().toLowerCase();
-    if (['yes', 'y', 'true', '1'].includes(normalized))
-        return { value: true };
-    if (['no', 'n', 'false', '0'].includes(normalized))
-        return { value: false };
-    return { error: 'Provide "true" or "false".' };
+function parseStringList(input) {
+    return input
+        .split(',')
+        .map((chunk) => chunk.trim())
+        .filter(Boolean);
 }
 export function parseKindsInput(raw) {
     const normalized = raw
         .split(',')
         .map((chunk) => chunk.trim().toLowerCase())
         .filter(Boolean);
-    if (normalized.length === 0) {
+    if (!normalized.length) {
         return { error: 'Enter at least one kind or "all".' };
     }
     if (normalized.length === 1 && normalized[0] === 'all') {
-        return { value: [...ROBOT_KINDS] };
+        return { value: [...ROBOT_PACK_SYMBOL_KINDS] };
     }
     const invalid = [];
     const unique = [];
     const seen = new Set();
     for (const entry of normalized) {
-        if (!KNOWN_KINDS.has(entry)) {
+        if (!ROBOT_PACK_SYMBOL_KINDS.includes(entry)) {
             invalid.push(entry);
             continue;
         }
@@ -110,11 +168,28 @@ export function parseKindsInput(raw) {
     }
     if (invalid.length > 0) {
         return {
-            error: `Unknown kinds: ${invalid.join(', ')}. Valid kinds are ${ROBOT_KINDS.join(', ')}.`,
+            error: `Unknown kinds: ${invalid.join(', ')}. Valid kinds are ${ROBOT_PACK_SYMBOL_KINDS.join(', ')}.`,
         };
     }
-    if (unique.length === 0) {
+    if (!unique.length) {
         return { error: 'Provide at least one valid kind.' };
     }
     return { value: unique };
 }
+function parsePositiveInteger(input) {
+    const value = Number(input);
+    if (!Number.isFinite(value))
+        return undefined;
+    const floored = Math.floor(value);
+    if (floored <= 0)
+        return undefined;
+    return floored;
+}
+function parseBooleanInput(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (['yes', 'y', 'true', '1'].includes(normalized))
+        return { value: true };
+    if (['no', 'n', 'false', '0'].includes(normalized))
+        return { value: false };
+    return { error: 'Provide "true" or "false".' };
+}