@emeryld/manager 1.1.0 → 1.2.0

package/dist/format-checker/index.js

@@ -1,4 +1,5 @@
 import { colors } from '../utils/log.js';
+import { captureConsoleOutput, exportReportLines, promptExportMode, } from '../utils/export.js';
 import { rootDir } from '../helper-cli/env.js';
 import { loadFormatLimits, } from './config.js';
 import { collectSourceFiles, analyzeFiles } from './scan/index.js';
@@ -9,10 +10,11 @@ export async function runFormatChecker() {
     console.log(colors.cyan('Gathering defaults from .vscode/settings.json (manager.formatChecker)'));
     const defaults = await loadFormatLimits();
     const limits = await promptLimits(defaults);
-    await executeFormatCheck(limits);
+    const exportMode = await promptExportMode();
+    await executeFormatCheck(limits, exportMode);
 }
 export async function runFormatCheckerScanCli(argv) {
-    const { overrides, help } = parseScanCliArgs(argv);
+    const { overrides, help, exportMode } = parseScanCliArgs(argv);
     if (help) {
         printScanUsage();
         return;
@@ -20,9 +22,9 @@ export async function runFormatCheckerScanCli(argv) {
     const defaults = await loadFormatLimits();
     const limits = { ...defaults, ...overrides };
     console.log(colors.cyan('Running format checker scan (machine-friendly)'));
-    await executeFormatCheck(limits);
+    await executeFormatCheck(limits, exportMode);
 }
-async function executeFormatCheck(limits) {
+async function executeFormatCheck(limits, exportMode) {
     console.log(colors.magenta('Scanning workspace for source files...'));
     const files = await collectSourceFiles(rootDir);
     if (files.length === 0) {
@@ -31,8 +33,16 @@ async function executeFormatCheck(limits) {
     }
     console.log(colors.magenta(`Analyzing ${files.length} files`));
     const violations = await analyzeFiles(files, limits);
-    const hadViolations = reportViolations(violations, limits.reportingMode);
+    const hadViolations = await handleViolations(violations, limits.reportingMode, exportMode);
     if (!hadViolations) {
         console.log(colors.green('Workspace meets the configured format limits.'));
     }
 }
+async function handleViolations(violations, reportingMode, exportMode) {
+    if (exportMode === 'console') {
+        return reportViolations(violations, reportingMode);
+    }
+    const { result, lines } = captureConsoleOutput(() => reportViolations(violations, reportingMode));
+    await exportReportLines('format-checker', 'txt', lines);
+    return result;
+}

package/dist/format-checker/report.js

@@ -109,6 +109,9 @@ function logViolationEntry(entry, messagePrefix, locationDescriptor) {
             console.log(`    ${colors.yellow(line)}`);
         });
     }
+    if (entry.requiredVariables?.length) {
+        console.log(`    ${colors.dim('Required variables:')} ${entry.requiredVariables.join(', ')}`);
+    }
     if (locationDescriptor) {
         console.log(`    ${colors.dim(locationDescriptor)}`);
     }

package/dist/format-checker/scan/analysis.js

@@ -2,7 +2,9 @@ import { readFile } from 'node:fs/promises';
 import { collectDuplicateViolations, recordDuplicateLines, } from './duplicates.js';
 import { countIndentation, groupIndentationViolations, } from './indentation.js';
 import { collectFunctionRecords } from './functions.js';
-import { markImportLines, normalizeLine } from './utils.js';
+import { markImportLines, normalizeLine, resolveScriptKind } from './utils.js';
+import { collectRequiredVariables } from './variables.js';
+import * as ts from 'typescript';
 export async function analyzeFiles(files, limits) {
     const violations = [];
     const duplicateMap = new Map();
@@ -45,12 +47,19 @@ async function analyzeSingleFile(filePath, limits, duplicates) {
             indentationViolations.push({ line: index + 1, indent });
         }
     });
-    recordDuplicateLines(normalizedLines, filePath, limits, duplicates);
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(filePath));
+    recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines);
     const indentationGroups = groupIndentationViolations(indentationViolations, lines, limits.maxIndentationDepth);
     indentationGroups
         .sort((a, b) => b.severity - a.severity)
         .slice(0, 4)
         .forEach((group) => {
+        const requiredVariables = collectRequiredVariables(sourceFile, lines, {
+            startLine: group.startLine,
+            startColumn: group.startColumn,
+            endLine: group.endLine,
+            endColumn: group.endColumn,
+        });
         violations.push({
             type: 'indentation',
             file: filePath,
@@ -59,9 +68,10 @@ async function analyzeSingleFile(filePath, limits, duplicates) {
             message: `Indentation level ${group.maxIndent} exceeds max ${limits.maxIndentationDepth}`,
             snippet: group.snippet,
             detail: `${group.startLine}:${group.startColumn}/${group.endLine}:${group.endColumn}`,
+            requiredVariables,
         });
     });
-    const allFunctions = collectFunctionRecords(content, filePath);
+    const allFunctions = collectFunctionRecords(sourceFile);
     const functions = limits.exportOnly
         ? allFunctions.filter((record) => record.isExported)
         : allFunctions;

package/dist/format-checker/scan/duplicates.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { getLineColumnRange } from './utils.js';
-export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates) {
+import { collectRequiredVariables } from './variables.js';
+export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines) {
     const minLines = Math.max(1, limits.minDuplicateLines);
     if (limits.minDuplicateLines <= 0 || minLines === 1) {
         normalizedLines.forEach((entry, index) => {
@@ -12,7 +13,7 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
             if (entry.isImport)
                 return;
             const { startColumn, endColumn } = getLineColumnRange(entry.raw);
-            addDuplicateOccurrence(duplicates, entry.normalized, filePath, index + 1, startColumn, index + 1, endColumn, snippet);
+            addDuplicateOccurrence(duplicates, entry.normalized, filePath, index + 1, startColumn, index + 1, endColumn, snippet, sourceFile, lines);
         });
         return;
     }
@@ -47,10 +48,10 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
         const endLine = i + 1 + lastNonEmptyIndex;
         const { startColumn } = getLineColumnRange(slice[firstNonEmptyIndex].raw);
         const { endColumn } = getLineColumnRange(slice[lastNonEmptyIndex].raw);
-        addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet);
+        addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet, sourceFile, lines);
     }
 }
-function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet) {
+function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet, sourceFile, lines) {
     const tracker = duplicates.get(key);
     if (tracker) {
         tracker.count += 1;
@@ -69,6 +70,12 @@ function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColum
     duplicates.set(key, {
         count: 1,
         snippet,
+        requiredVariables: collectRequiredVariables(sourceFile, lines, {
+            startLine,
+            startColumn,
+            endLine,
+            endColumn,
+        }),
         occurrences: [
             {
                 file: filePath,
@@ -102,6 +109,7 @@ export function collectDuplicateViolations(duplicates, limits) {
                 .join('\n'),
             snippet: tracker.snippet,
             repeatCount: tracker.count,
+            requiredVariables: tracker.requiredVariables,
         });
     }
     return violations;

package/dist/format-checker/scan/functions.js

@@ -1,7 +1,5 @@
 import * as ts from 'typescript';
-import { resolveScriptKind } from './utils.js';
-export function collectFunctionRecords(content, filePath) {
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(filePath));
+export function collectFunctionRecords(sourceFile) {
     const records = [];
     function visit(node) {
         if ((ts.isFunctionDeclaration(node) ||

package/dist/format-checker/scan/variables.js

@@ -0,0 +1,246 @@
+import * as ts from 'typescript';
+const RANGE_CLAMP_MIN = 0;
+export const DEFAULT_REQUIRED_VARIABLE_EXCLUSIONS = new Set(['Object', 'console', 'Boolean', 'Number', 'String', 'Array', 'Math', 'Date', 'Set', 'Map', 'WeakSet', 'WeakMap', 'Symbol', 'Promise', 'Error', 'RegExp', 'JSON', 'Intl', 'Reflect', 'Proxy', 'globalThis']);
+export function collectRequiredVariables(sourceFile, lines, range, exclusions) {
+    if (!lines.length)
+        return [];
+    const lastLineIndex = Math.max(0, lines.length - 1);
+    let startLineIndex = clamp(range.startLine - 1, RANGE_CLAMP_MIN, lastLineIndex);
+    let endLineIndex = clamp(range.endLine - 1, RANGE_CLAMP_MIN, lastLineIndex);
+    if (startLineIndex > endLineIndex) {
+        const temp = startLineIndex;
+        startLineIndex = endLineIndex;
+        endLineIndex = temp;
+    }
+    const startLineText = lines[startLineIndex] ?? '';
+    const endLineText = lines[endLineIndex] ?? '';
+    const startColumnIndex = clamp(range.startColumn - 1, RANGE_CLAMP_MIN, startLineText.length);
+    let endColumnIndex = clamp(range.endColumn - 1, RANGE_CLAMP_MIN, endLineText.length);
+    if (startLineIndex === endLineIndex &&
+        endColumnIndex < startColumnIndex) {
+        endColumnIndex = startLineText.length;
+    }
+    const rangeStart = sourceFile.getPositionOfLineAndCharacter(startLineIndex, startColumnIndex);
+    const rangeEnd = sourceFile.getPositionOfLineAndCharacter(endLineIndex, endColumnIndex);
+    const declared = new Set();
+    const referenced = new Set();
+    const exclusionSet = new Set(DEFAULT_REQUIRED_VARIABLE_EXCLUSIONS);
+    if (exclusions) {
+        for (const value of exclusions) {
+            exclusionSet.add(value);
+        }
+    }
+    function declareSymbol(name) {
+        if (!name)
+            return;
+        declared.add(name);
+        referenced.delete(name);
+    }
+    function isIdentifierLike(node) {
+        return ts.isIdentifier(node);
+    }
+    function addDeclaration(node) {
+        if ((ts.isVariableDeclaration(node) || ts.isParameter(node)) && node.name) {
+            collectBindingNames(node.name, declareSymbol);
+            return;
+        }
+        if (ts.isBindingElement(node) && node.name) {
+            collectBindingNames(node.name, declareSymbol);
+            return;
+        }
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node)) &&
+            node.name) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) && node.name) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if (ts.isEnumDeclaration(node) && node.name) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if (ts.isInterfaceDeclaration(node) && node.name) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if (ts.isTypeAliasDeclaration(node) && node.name) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if (ts.isImportClause(node) && node.name) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if (ts.isNamespaceImport(node) && node.name) {
+            declareSymbol(node.name.text);
+            return;
+        }
+        if (ts.isImportSpecifier(node) && node.name) {
+            declareSymbol(node.name.text);
+        }
+    }
+    function collectBindingNames(name, collector) {
+        if (ts.isIdentifier(name)) {
+            if (name.text) {
+                collector(name.text);
+            }
+            return;
+        }
+        if (ts.isObjectBindingPattern(name)) {
+            for (const element of name.elements) {
+                if (element.name) {
+                    collectBindingNames(element.name, collector);
+                }
+            }
+            return;
+        }
+        if (ts.isArrayBindingPattern(name)) {
+            for (const element of name.elements) {
+                if (ts.isBindingElement(element) && element.name) {
+                    collectBindingNames(element.name, collector);
+                }
+            }
+        }
+    }
+    function getIdentifierText(node) {
+        const escaped = node.escapedText;
+        if (typeof escaped === 'string')
+            return escaped;
+        if (escaped !== undefined)
+            return String(escaped);
+        return node.getText(sourceFile);
+    }
+    function shouldSkipIdentifier(node) {
+        const parent = node.parent;
+        if (!parent)
+            return true;
+        if ((ts.isPropertyAccessExpression(parent) ||
+            ts.isPropertyAccessChain(parent)) &&
+            parent.name === node) {
+            return true;
+        }
+        if ((ts.isPropertyAssignment(parent) ||
+            ts.isPropertySignature(parent) ||
+            ts.isPropertyDeclaration(parent) ||
+            ts.isMethodDeclaration(parent) ||
+            ts.isMethodSignature(parent) ||
+            ts.isGetAccessorDeclaration(parent) ||
+            ts.isSetAccessorDeclaration(parent)) &&
+            parent.name === node) {
+            return true;
+        }
+        if (ts.isIndexSignatureDeclaration(parent))
+            return true;
+        if (ts.isEnumMember(parent) && parent.name === node)
+            return true;
+        if (ts.isBindingElement(parent) && parent.propertyName === node)
+            return true;
+        if (ts.isTypeReferenceNode(parent))
+            return true;
+        if (ts.isTypePredicateNode(parent))
+            return true;
+        if (ts.isTypeQueryNode(parent))
+            return true;
+        if (ts.isImportClause(parent) && parent.name === node)
+            return true;
+        if (ts.isNamespaceImport(parent) && parent.name === node)
+            return true;
+        if (ts.isImportSpecifier(parent)) {
+            if (parent.propertyName === node)
+                return true;
+            if (parent.name === node)
+                return true;
+        }
+        if (ts.isJsxAttribute(parent) && parent.name === node)
+            return true;
+        if (ts.isJsxNamespacedName(parent) && parent.name === node)
+            return true;
+        if (ts.isLabeledStatement(parent) && parent.label === node)
+            return true;
+        if ((ts.isBreakStatement(parent) || ts.isContinueStatement(parent)) &&
+            parent.label === node) {
+            return true;
+        }
+        if (ts.isMetaProperty(parent))
+            return true;
+        if (ts.isTypeAliasDeclaration(parent) && parent.name === node)
+            return true;
+        if (ts.isInterfaceDeclaration(parent) && parent.name === node)
+            return true;
+        if (ts.isClassDeclaration(parent) && parent.name === node)
+            return true;
+        return false;
+    }
+    function addReference(node) {
+        const name = getIdentifierText(node);
+        if (!name)
+            return;
+        if (shouldSkipIdentifier(node))
+            return;
+        if (isDeclarationIdentifier(node))
+            return;
+        if (declared.has(name))
+            return;
+        if (exclusionSet.has(name))
+            return;
+        referenced.add(name);
+    }
+    function isDeclarationIdentifier(node) {
+        const parent = node.parent;
+        if (!parent)
+            return false;
+        if ((ts.isVariableDeclaration(parent) ||
+            ts.isParameter(parent) ||
+            ts.isBindingElement(parent)) &&
+            parent.name === node) {
+            return true;
+        }
+        if ((ts.isFunctionDeclaration(parent) ||
+            ts.isFunctionExpression(parent) ||
+            ts.isArrowFunction(parent) ||
+            ts.isClassDeclaration(parent) ||
+            ts.isClassExpression(parent) ||
+            ts.isEnumDeclaration(parent) ||
+            ts.isInterfaceDeclaration(parent) ||
+            ts.isTypeAliasDeclaration(parent)) &&
+            parent.name === node) {
+            return true;
+        }
+        if ((ts.isImportClause(parent) ||
+            ts.isNamespaceImport(parent) ||
+            ts.isImportSpecifier(parent)) &&
+            parent.name === node) {
+            return true;
+        }
+        return false;
+    }
+    function overlapsRange(node) {
+        const nodeStart = node.getStart(sourceFile);
+        const nodeEnd = node.end;
+        return nodeEnd >= rangeStart && nodeStart <= rangeEnd;
+    }
+    function visit(node) {
+        if (!overlapsRange(node))
+            return;
+        addDeclaration(node);
+        if (isIdentifierLike(node)) {
+            addReference(node);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return [...referenced].sort();
+}
+function clamp(value, min, max) {
+    if (min > max)
+        return min;
+    return Math.min(Math.max(value, min), max);
+}

package/dist/menu.js

@@ -10,6 +10,7 @@ import { openDockerHelper } from './docker.js';
 import { run } from './utils/run.js';
 import { makeBaseScriptEntries, getPackageMarker, getPackageModule } from './menu/script-helpers.js';
 import { runFormatChecker } from './format-checker/index.js';
+import { runRobot } from './robot/index.js';
 import { describeVersionControlScope, makeVersionControlEntries, } from './version-control.js';
 function formatKindLabel(kind) {
     if (kind === 'cli')
@@ -77,6 +78,14 @@ function makeManagerStepEntries(targets, packages, state) {
                 await runFormatChecker();
             },
         },
+        {
+            name: 'robot metadata',
+            emoji: '🤖',
+            description: 'Collect functions, components, types, consts, and classes across the workspace',
+            handler: async () => {
+                await runRobot();
+            },
+        },
         {
             name: 'build',
             emoji: '🏗️',

package/dist/robot/cli/prompts.js

@@ -0,0 +1,102 @@
+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';
+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;
+    let currentSettings = defaults;
+    while (true) {
+        const chosen = supportsInteractive
+            ? await promptRobotSettingsInteractive(currentSettings)
+            : await promptRobotSettingsSequential(currentSettings);
+        const confirmed = await confirmExecution();
+        if (confirmed)
+            return chosen;
+        currentSettings = chosen;
+        console.log(READY_PROMPT);
+    }
+}
+async function confirmExecution() {
+    const question = colors.cyan('Run the robot extractor with these settings? (Y/n): ');
+    while (true) {
+        const answer = (await askLine(question)).trim().toLowerCase();
+        if (!answer || answer === 'y' || answer === 'yes')
+            return true;
+        if (answer === 'n' || answer === 'no')
+            return false;
+        console.log(colors.yellow('Answer "yes" or "no", or press Enter to proceed.'));
+    }
+}
+async function promptRobotSettingsSequential(defaults) {
+    console.log(colors.dim('Enter values to override defaults or press Enter to keep the current setting.'));
+    return {
+        includeKinds: await promptKinds(defaults.includeKinds),
+        exportedOnly: await promptBoolean('Only consider exported symbols', defaults.exportedOnly),
+        maxColumns: await promptNumber('Maximum columns', defaults.maxColumns),
+    };
+}
+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)}]: `);
+    while (true) {
+        const answer = await askLine(question);
+        if (!answer)
+            return fallback;
+        const parsed = parseKindsInput(answer);
+        if (parsed.error) {
+            console.log(colors.yellow(parsed.error));
+            continue;
+        }
+        if (parsed.value)
+            return parsed.value;
+    }
+}
+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 promptNumber(label, fallback) {
+    const question = colors.cyan(`${label} [default ${fallback}]: `);
+    while (true) {
+        const answer = await askLine(question);
+        if (!answer)
+            return fallback;
+        const parsed = Number(answer);
+        if (!Number.isNaN(parsed) && parsed > 0) {
+            return Math.floor(parsed);
+        }
+        console.log(colors.yellow('Provide a positive integer or leave blank to keep the default.'));
+    }
+}
+async function promptRobotSettingsInteractive(defaults) {
+    const descriptors = SETTING_DESCRIPTORS.map((descriptor) => ({
+        key: descriptor.key,
+        label: descriptor.label,
+        unit: descriptor.unit,
+        format: (value) => formatValue(value, descriptor),
+        parse: (buffer) => parseInteractiveValue(descriptor, buffer),
+    }));
+    return promptInteractiveSettings({
+        title: 'Robot 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.',
+            'Press Esc/Ctrl+C to abort, or hit Enter again after reviewing the summary to continue.',
+        ],
+        validate: validateRobotSettings,
+    });
+}

package/dist/robot/cli/settings.js

@@ -0,0 +1,120 @@
+import { ROBOT_KINDS } from '../types.js';
+const KNOWN_KINDS = new Set(ROBOT_KINDS);
+export const SETTING_DESCRIPTORS = [
+    {
+        key: 'includeKinds',
+        label: 'Kinds to include',
+        unit: 'comma-separated (function, component, type, const, class)',
+        type: 'list',
+    },
+    {
+        key: 'exportedOnly',
+        label: 'Only exported symbols',
+        type: 'boolean',
+    },
+    {
+        key: 'maxColumns',
+        label: 'Maximum columns',
+        unit: 'columns',
+        type: 'number',
+    },
+];
+export function formatValue(value, descriptor) {
+    if (descriptor.type === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (descriptor.type === 'list') {
+        const kinds = value;
+        if (kinds.length === ROBOT_KINDS.length)
+            return 'all';
+        return kinds.join(', ');
+    }
+    return `${value}`;
+}
+export function parseInteractiveValue(descriptor, buffer) {
+    const trimmed = buffer.trim();
+    if (!trimmed) {
+        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.`,
+            };
+        }
+        return { value: parsed };
+    }
+    if (descriptor.type === 'boolean') {
+        const parsed = parseBooleanInput(trimmed);
+        if (parsed.error)
+            return { error: parsed.error };
+        return { value: parsed.value };
+    }
+    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 (!Number.isFinite(settings.maxColumns) || settings.maxColumns <= 0) {
+        return 'Maximum columns must be a positive number.';
+    }
+    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".' };
+}
+export function parseKindsInput(raw) {
+    const normalized = raw
+        .split(',')
+        .map((chunk) => chunk.trim().toLowerCase())
+        .filter(Boolean);
+    if (normalized.length === 0) {
+        return { error: 'Enter at least one kind or "all".' };
+    }
+    if (normalized.length === 1 && normalized[0] === 'all') {
+        return { value: [...ROBOT_KINDS] };
+    }
+    const invalid = [];
+    const unique = [];
+    const seen = new Set();
+    for (const entry of normalized) {
+        if (!KNOWN_KINDS.has(entry)) {
+            invalid.push(entry);
+            continue;
+        }
+        const kind = entry;
+        if (!seen.has(kind)) {
+            seen.add(kind);
+            unique.push(kind);
+        }
+    }
+    if (invalid.length > 0) {
+        return {
+            error: `Unknown kinds: ${invalid.join(', ')}. Valid kinds are ${ROBOT_KINDS.join(', ')}.`,
+        };
+    }
+    if (unique.length === 0) {
+        return { error: 'Provide at least one valid kind.' };
+    }
+    return { value: unique };
+}