@agentrhq/webcmd 0.3.0 → 0.3.2

package/dist/src/command-presentation.js

@@ -0,0 +1,486 @@
+import { CLI_COMMAND } from './brand.js';
+const COMMON_OPTIONS = [
+    {
+        flags: '-f, --format <fmt>',
+        name: 'format',
+        help: 'Output format: table, plain, json, yaml, md, csv',
+        default: 'table',
+        choices: ['table', 'plain', 'json', 'yaml', 'md', 'csv'],
+    },
+    {
+        flags: '--trace <mode>',
+        name: 'trace',
+        help: 'Trace capture: off, on, retain-on-failure',
+        default: 'off',
+        choices: ['off', 'on', 'retain-on-failure'],
+    },
+    {
+        flags: '-v, --verbose',
+        name: 'verbose',
+        help: 'Debug output',
+        default: false,
+    },
+    {
+        flags: '-h, --help',
+        name: 'help',
+        help: 'display help for command',
+    },
+];
+const BROWSER_COMMON_OPTIONS = [
+    {
+        flags: '--window <mode>',
+        name: 'window',
+        help: 'Browser window mode: foreground or background',
+        choices: ['foreground', 'background'],
+    },
+    {
+        flags: '--site-session <mode>',
+        name: 'site-session',
+        help: 'Adapter site session lifecycle: ephemeral or persistent',
+        choices: ['ephemeral', 'persistent'],
+    },
+    {
+        flags: '--keep-tab <bool>',
+        name: 'keep-tab',
+        help: 'Keep the browser tab lease after the command finishes',
+        choices: ['true', 'false'],
+    },
+];
+export function toPresentableCommand(command) {
+    return {
+        site: command.site,
+        name: command.name,
+        aliases: [...(command.aliases ?? [])],
+        description: command.description,
+        access: command.access === 'write' ? 'write' : 'read',
+        strategy: (command.strategy ?? 'public').toLowerCase(),
+        browser: command.browser === true,
+        args: command.args.map((arg) => ({ ...arg, ...(arg.choices ? { choices: [...arg.choices] } : {}) })),
+        columns: [...(command.columns ?? [])],
+        ...(command.defaultFormat ? { defaultFormat: command.defaultFormat } : {}),
+        ...(command.domain ? { domain: command.domain } : {}),
+        ...(command.example ? { example: command.example } : {}),
+        ...(command.siteSession ? { siteSession: command.siteSession } : {}),
+    };
+}
+export function formatRootHelp(presentation) {
+    if (presentation.baseText !== undefined) {
+        const baseText = presentation.baseText.replace(/\n+$/, '');
+        const groups = (presentation.groups ?? []).filter((group) => group.items.length > 0);
+        if (groups.length === 0)
+            return `${baseText}\n`;
+        const tail = [];
+        for (const group of groups) {
+            tail.push(`${group.label}:`, wrapCommaList(group.items), '');
+        }
+        if (presentation.footer?.length)
+            tail.push(...presentation.footer);
+        return `${baseText}\n\n${tail.join('\n')}\n`;
+    }
+    const usage = presentation.usage ?? [
+        `${CLI_COMMAND} <site> <command> [args] [options]`,
+        `${CLI_COMMAND} list [options]`,
+    ];
+    const lines = [
+        'Usage:',
+        ...usage.map((entry) => `  ${entry}`),
+        '',
+        presentation.description,
+        '',
+        'Options:',
+        ...formatRows(presentation.options.map((option) => [option.flags, option.description])),
+        '',
+        'Commands:',
+        ...formatRows(presentation.commands.map((command) => [command.name, command.description])),
+    ];
+    if (presentation.localOnlyCommands?.length) {
+        lines.push('', 'Local-only commands:', ...formatRows(presentation.localOnlyCommands.map((command) => [command.name, command.description])));
+        if (presentation.localOnlyExplanation)
+            lines.push('', presentation.localOnlyExplanation);
+    }
+    for (const group of presentation.groups ?? []) {
+        if (group.items.length === 0)
+            continue;
+        lines.push('', `${group.label}:`, wrapCommaList(group.items));
+    }
+    if (presentation.footer?.length)
+        lines.push('', ...presentation.footer);
+    lines.push('');
+    return lines.join('\n');
+}
+export function commandListRows(commands, structured) {
+    return uniqueCommands(commands).map((command) => {
+        if (structured) {
+            return {
+                command: commandFullName(command),
+                site: command.site,
+                name: command.name,
+                aliases: [...command.aliases],
+                description: command.description,
+                access: command.access,
+                strategy: command.strategy,
+                browser: command.browser,
+                args: command.args.map(serializePresentableArg),
+                columns: [...command.columns],
+                domain: command.domain ?? null,
+                example: formatPresentableCommandExample(command),
+                defaultFormat: command.defaultFormat ?? null,
+                siteSession: command.siteSession ?? null,
+            };
+        }
+        return {
+            command: commandFullName(command),
+            site: command.site,
+            name: command.name,
+            aliases: command.aliases.join(', '),
+            description: command.description,
+            access: command.access,
+            strategy: command.strategy,
+            browser: command.browser,
+            args: formatArgumentSummary(command.args),
+        };
+    });
+}
+export function commandListPresentation(commands, format, options = {}) {
+    const structured = format === 'json' || format === 'yaml';
+    const unique = uniqueCommands(commands);
+    return {
+        rows: commandListRows(unique, structured),
+        columns: [
+            'command',
+            'site',
+            'name',
+            'aliases',
+            'description',
+            'access',
+            'strategy',
+            'browser',
+            'args',
+            ...(structured ? ['columns', 'domain'] : []),
+        ],
+        structured,
+        ...(format === 'table'
+            ? { displayLines: formatGroupedCommandList(unique, options.externalClis ?? []) }
+            : {}),
+    };
+}
+function isLocalIpDomain(domain) {
+    if (domain === '::1' || domain === '[::1]')
+        return true;
+    const parts = domain.split('.');
+    if (parts.length !== 4)
+        return false;
+    return parts.every((part) => /^\d+$/.test(part) && Number(part) >= 0 && Number(part) <= 255)
+        && Number(parts[0]) === 127;
+}
+export function classifyAdapterDomain(domain) {
+    if (!domain)
+        return 'site';
+    if (isLocalIpDomain(domain))
+        return 'app';
+    return domain.includes('.') ? 'site' : 'app';
+}
+function formatGroupedCommandList(commands, externalClis) {
+    const appsBySite = new Map();
+    const sitesBySite = new Map();
+    for (const command of commands) {
+        const target = classifyAdapterDomain(command.domain) === 'app' ? appsBySite : sitesBySite;
+        const group = target.get(command.site) ?? [];
+        group.push(command);
+        target.set(command.site, group);
+    }
+    const lines = ['', `  ${CLI_COMMAND} — available commands`, ''];
+    const appendAdapterSection = (label, groups) => {
+        if (groups.size === 0)
+            return;
+        lines.push(`  ${label}`, '');
+        for (const [site, siteCommands] of groups) {
+            lines.push(`  ${site}`);
+            for (const command of siteCommands) {
+                const aliases = command.aliases.length > 0 ? ` (aliases: ${command.aliases.join(', ')})` : '';
+                lines.push(`    ${command.name} [${command.strategy}]${aliases}`
+                    + `${command.description ? ` — ${command.description}` : ''}`);
+            }
+            lines.push('');
+        }
+    };
+    appendAdapterSection('App adapters', appsBySite);
+    appendAdapterSection('Site adapters', sitesBySite);
+    if (externalClis.length > 0) {
+        lines.push('  external CLIs');
+        for (const external of externalClis) {
+            const tag = external.installed ? '[installed]' : '[auto-install]';
+            lines.push(`    ${external.label} ${tag}${external.description ? ` — ${external.description}` : ''}`);
+        }
+        lines.push('');
+    }
+    lines.push(`  ${commands.length} built-in commands across ${appsBySite.size} apps + ${sitesBySite.size} sites, `
+        + `${externalClis.length} external CLIs`, '');
+    return lines;
+}
+export function getCommandCompletionCandidates(commands, words, cursor, builtins) {
+    if (cursor <= 1) {
+        const sites = new Set(commands.map((command) => command.site));
+        return [...builtins, ...sites].sort();
+    }
+    const site = words[0];
+    if (!site || builtins.includes(site))
+        return [];
+    if (cursor !== 2)
+        return [];
+    return [...new Set(commands
+            .filter((command) => command.site === site)
+            .flatMap((command) => [command.name, ...(command.aliases ?? [])]))]
+        .sort();
+}
+export function formatCommandListTerm(command) {
+    const positionalText = formatPositionals(positionals(command));
+    const optionText = commandOptions(command).length > 0 ? ' [options]' : '';
+    return `${command.name}${positionalText ? ` ${positionalText}` : ''}${optionText}`;
+}
+export function siteHelpData(site, commands) {
+    const unique = commandsForSite(site, commands);
+    return {
+        site,
+        command_count: unique.length,
+        commands: unique.map(compactCommand),
+        common_options: COMMON_OPTIONS.map(compactCommonOption),
+        ...(unique.some((command) => command.browser)
+            ? { browser_common_options: BROWSER_COMMON_OPTIONS.map(compactCommonOption) }
+            : {}),
+        next: [
+            `${CLI_COMMAND} ${site} <command> --help -f yaml`,
+            `${CLI_COMMAND} ${site} <command> -f yaml`,
+        ],
+    };
+}
+export function commandHelpData(command) {
+    return {
+        site: command.site,
+        ...compactCommand(command),
+        common_options: COMMON_OPTIONS.map(compactCommonOption),
+        ...(command.browser ? { browser_common_options: BROWSER_COMMON_OPTIONS.map(compactCommonOption) } : {}),
+        output_formats: ['table', 'plain', 'yaml', 'json', 'md', 'csv'],
+    };
+}
+export function formatCommonOptionsHelp() {
+    const rows = COMMON_OPTIONS.map((option) => {
+        const details = [option.help];
+        if ('default' in option)
+            details.push(`default: ${option.default}`);
+        if ('choices' in option)
+            details.push(`choices: ${option.choices.join(', ')}`);
+        return [option.flags, details.join('  ')];
+    });
+    return ['Common options:', ...formatRows(rows)].join('\n');
+}
+export function formatBrowserCommonOptionsHelp() {
+    const rows = BROWSER_COMMON_OPTIONS.map((option) => {
+        const details = [option.help];
+        if ('choices' in option)
+            details.push(`choices: ${option.choices.join(', ')}`);
+        return [option.flags, details.join('  ')];
+    });
+    return ['Browser common options:', ...formatRows(rows)].join('\n');
+}
+export function formatSiteHelp(site, commands) {
+    const unique = commandsForSite(site, commands);
+    const lines = [
+        `Usage: ${CLI_COMMAND} ${site} <command> [args] [options]`,
+        '',
+        wrapCommaList(unique.map((command) => command.name), { indent: '' }),
+        '',
+        'Commands:',
+        ...formatRows(unique.map((command) => [formatCommandListTerm(command), formatSiteCommandDescription(command)])),
+        '',
+        formatCommonOptionsHelp(),
+        ...(unique.some((command) => command.browser) ? ['', formatBrowserCommonOptionsHelp()] : []),
+        '',
+        `Agent tip: use '${CLI_COMMAND} ${site} --help -f yaml' to get all command args/options in one structured response.`,
+        '',
+    ];
+    return lines.join('\n');
+}
+export function formatCommandHelp(command) {
+    const lines = [
+        `Usage: ${formatUsage(command)}`,
+        '',
+        command.description,
+        '',
+    ];
+    const positionalRows = positionals(command).map((arg) => [
+        arg.name,
+        formatArgHelp(arg),
+    ]);
+    if (positionalRows.length)
+        lines.push('Arguments:', ...formatRows(positionalRows), '');
+    const optionRows = commandOptions(command).map((arg) => [
+        formatCommandOptionTerm(arg),
+        formatArgHelp(arg),
+    ]);
+    if (optionRows.length)
+        lines.push('Command options:', ...formatRows(optionRows), '');
+    lines.push(formatCommonOptionsHelp(), '');
+    if (command.browser)
+        lines.push(formatBrowserCommonOptionsHelp(), '');
+    const meta = [
+        `Access: ${command.access}`,
+        `Browser: ${command.browser ? 'yes' : 'no'}`,
+    ];
+    if (command.domain)
+        meta.push(`Domain: ${command.domain}`);
+    if (command.defaultFormat)
+        meta.push(`Default format: ${command.defaultFormat}`);
+    if (command.aliases.length)
+        meta.push(`Aliases: ${command.aliases.join(', ')}`);
+    lines.push(meta.join(' | '));
+    lines.push(`Example: ${formatPresentableCommandExample(command)}`);
+    if (command.columns.length)
+        lines.push(`Output columns: ${command.columns.join(', ')}`);
+    lines.push("Agent tip: use '--help -f yaml' for structured args/options.", '');
+    return lines.join('\n');
+}
+export function formatSiteCommandDescription(command) {
+    return `${command.access === 'write' ? '[write]' : '[read]'} ${command.description}`;
+}
+export function wrapCommaList(items, opts = {}) {
+    const width = Math.max(opts.width ?? process.stdout.columns ?? 100, 40);
+    const indent = opts.indent ?? '  ';
+    const sorted = [...items].sort((a, b) => a.localeCompare(b));
+    const lines = [];
+    let line = indent;
+    sorted.forEach((item, index) => {
+        const token = `${item}${index < sorted.length - 1 ? ',' : ''}`;
+        const prefix = line === indent ? '' : ' ';
+        if (line.length + prefix.length + token.length > width && line.trim()) {
+            lines.push(line);
+            line = `${indent}${token}`;
+        }
+        else {
+            line += `${prefix}${token}`;
+        }
+    });
+    if (line.trim())
+        lines.push(line);
+    return lines.join('\n');
+}
+function commandFullName(command) {
+    return `${command.site}/${command.name}`;
+}
+function uniqueCommands(commands) {
+    return [...new Map(commands.map((command) => [commandFullName(command), command])).values()]
+        .sort((a, b) => commandFullName(a).localeCompare(commandFullName(b)));
+}
+function commandsForSite(site, commands) {
+    return uniqueCommands(commands.filter((command) => command.site === site))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+function positionals(command) {
+    return command.args.filter((arg) => arg.positional);
+}
+function commandOptions(command) {
+    return command.args.filter((arg) => !arg.positional);
+}
+function formatPositionals(args) {
+    return args.map((arg) => arg.required ? `<${arg.name}>` : `[${arg.name}]`).join(' ');
+}
+function formatCommandOptionTerm(arg) {
+    return arg.required || arg.valueRequired ? `--${arg.name} <value>` : `--${arg.name} [value]`;
+}
+function formatUsage(command) {
+    const positionalText = formatPositionals(positionals(command));
+    return `${CLI_COMMAND} ${command.site} ${command.name}${positionalText ? ` ${positionalText}` : ''} [options]`;
+}
+function compactCommand(command) {
+    return {
+        name: command.name,
+        command: `${CLI_COMMAND} ${command.site} ${command.name}`,
+        usage: formatUsage(command),
+        access: command.access,
+        description: command.description,
+        browser: command.browser,
+        ...(command.domain ? { domain: command.domain } : {}),
+        ...(command.aliases.length ? { aliases: [...command.aliases] } : {}),
+        positionals: positionals(command).map(compactArg),
+        command_options: commandOptions(command).map(compactArg),
+        ...(command.browser ? { browser_common_options: BROWSER_COMMON_OPTIONS.map(compactCommonOption) } : {}),
+        example: formatPresentableCommandExample(command),
+        ...(command.siteSession ? { siteSession: command.siteSession } : {}),
+        ...(command.defaultFormat ? { defaultFormat: command.defaultFormat } : {}),
+        ...(command.columns.length ? { columns: [...command.columns] } : {}),
+    };
+}
+function compactArg(arg) {
+    return {
+        name: arg.name,
+        ...(arg.type && arg.type !== 'string' ? { type: arg.type } : {}),
+        ...(arg.positional ? { positional: true } : {}),
+        ...(arg.required ? { required: true } : {}),
+        ...(arg.valueRequired ? { valueRequired: true } : {}),
+        ...(arg.default !== undefined ? { default: arg.default } : {}),
+        ...(arg.choices?.length ? { choices: [...arg.choices] } : {}),
+        ...(arg.help ? { help: arg.help } : {}),
+    };
+}
+function compactCommonOption(option) {
+    return {
+        name: option.name,
+        flags: option.flags,
+        help: option.help,
+        ...('default' in option ? { default: option.default } : {}),
+        ...('choices' in option ? { choices: [...option.choices] } : {}),
+    };
+}
+export function serializePresentableArg(arg) {
+    return {
+        name: arg.name,
+        type: arg.type ?? 'string',
+        required: !!arg.required,
+        valueRequired: !!arg.valueRequired,
+        positional: !!arg.positional,
+        choices: [...(arg.choices ?? [])],
+        default: arg.default ?? null,
+        help: arg.help ?? '',
+    };
+}
+export function formatArgumentSummary(args) {
+    return args.map((arg) => {
+        if (arg.positional)
+            return arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+        return arg.required ? `--${arg.name}` : `[--${arg.name}]`;
+    }).join(' ');
+}
+export function formatPresentableCommandExample(command) {
+    if (command.example?.trim())
+        return command.example.trim();
+    const parts = [CLI_COMMAND, command.site, command.name];
+    for (const arg of command.args) {
+        if (arg.positional && arg.required)
+            parts.push(`<${arg.name}>`);
+    }
+    for (const arg of command.args) {
+        if (arg.positional || !arg.required)
+            continue;
+        parts.push(`--${arg.name}`);
+        if (arg.type !== 'bool' && arg.type !== 'boolean')
+            parts.push(`<${arg.name}>`);
+    }
+    parts.push('-f', 'yaml');
+    return parts.join(' ');
+}
+function formatRows(rows) {
+    if (rows.length === 0)
+        return [];
+    const width = Math.min(Math.max(...rows.map(([left]) => left.length)), 34);
+    return rows.map(([left, right]) => `  ${left.padEnd(width + 2)}${right}`);
+}
+function formatArgHelp(arg) {
+    const parts = [];
+    if (arg.help)
+        parts.push(arg.help);
+    if (arg.default !== undefined)
+        parts.push(`default: ${arg.default}`);
+    if (arg.choices?.length)
+        parts.push(`choices: ${arg.choices.join(', ')}`);
+    return parts.join('  ');
+}

package/dist/src/command-presentation.test.d.ts

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

package/dist/src/command-presentation.test.js

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import { Strategy } from './registry.js';
+import { commandListPresentation, commandListRows, formatCommandHelp, formatRootHelp, formatSiteHelp, getCommandCompletionCandidates, toPresentableCommand, } from './command-presentation.js';
+const args = [
+    { name: 'owner', positional: true, required: true, help: 'Repository owner' },
+    { name: 'limit', type: 'int', default: 20, help: 'Maximum issues' },
+];
+const localCommand = {
+    site: 'github',
+    name: 'issues',
+    aliases: ['issue-list'],
+    description: 'List repository issues',
+    access: 'read',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: args.map((arg) => ({ ...arg })),
+    columns: ['number', 'title'],
+    domain: 'github.com',
+    defaultFormat: 'yaml',
+};
+const hostedCommand = {
+    site: 'github',
+    name: 'issues',
+    aliases: ['issue-list'],
+    command: 'github/issues',
+    description: 'List repository issues',
+    access: 'read',
+    strategy: 'COOKIE',
+    browser: true,
+    args: args.map((arg) => ({ ...arg })),
+    columns: ['number', 'title'],
+    domain: 'github.com',
+    defaultFormat: 'yaml',
+};
+describe('shared command presentation', () => {
+    it('renders byte-identical root help for equal local and hosted surfaces', () => {
+        const local = {
+            description: 'Make any website your CLI. Zero setup. AI-powered.',
+            commands: [
+                { name: 'list', description: 'List all available CLI commands' },
+                { name: 'setup', description: 'Configure local or hosted mode' },
+            ],
+            options: [
+                { flags: '--profile <name>', description: 'Browser profile/context alias' },
+                { flags: '-h, --help', description: 'Display help for command' },
+            ],
+        };
+        const hosted = JSON.parse(JSON.stringify(local));
+        expect(formatRootHelp(hosted)).toBe(formatRootHelp(local));
+    });
+    it('normalizes local and hosted metadata to byte-identical site and command help', () => {
+        const local = toPresentableCommand(localCommand);
+        const hosted = toPresentableCommand(hostedCommand);
+        expect(formatSiteHelp('github', [hosted])).toBe(formatSiteHelp('github', [local]));
+        expect(formatCommandHelp(hosted)).toBe(formatCommandHelp(local));
+    });
+    it('builds byte-identical structured and display list rows', () => {
+        const local = toPresentableCommand(localCommand);
+        const hosted = toPresentableCommand(hostedCommand);
+        expect(commandListRows([hosted], true)).toEqual(commandListRows([local], true));
+        expect(commandListRows([hosted], false)).toEqual(commandListRows([local], false));
+    });
+    it('builds byte-identical canonical grouped list displays', () => {
+        const local = toPresentableCommand(localCommand);
+        const hosted = toPresentableCommand(hostedCommand);
+        const externalClis = [{ label: 'gh', installed: true, description: 'GitHub CLI' }];
+        const expected = [
+            '',
+            '  webcmd — available commands',
+            '',
+            '  Site adapters',
+            '',
+            '  github',
+            '    issues [cookie] (aliases: issue-list) — List repository issues',
+            '',
+            '  external CLIs',
+            '    gh [installed] — GitHub CLI',
+            '',
+            '  1 built-in commands across 0 apps + 1 sites, 1 external CLIs',
+            '',
+        ];
+        expect(commandListPresentation([hosted], 'table', { externalClis }).displayLines)
+            .toEqual(commandListPresentation([local], 'table', { externalClis }).displayLines);
+        expect(commandListPresentation([local], 'table', { externalClis }).displayLines).toEqual(expected);
+    });
+    it('builds byte-identical root, site, and alias completion candidates', () => {
+        const local = [toPresentableCommand(localCommand)];
+        const hosted = [toPresentableCommand(hostedCommand)];
+        const builtins = ['completion', 'list', 'setup'];
+        expect(getCommandCompletionCandidates(hosted, [], 1, builtins))
+            .toEqual(getCommandCompletionCandidates(local, [], 1, builtins));
+        expect(getCommandCompletionCandidates(hosted, ['github'], 2, builtins))
+            .toEqual(getCommandCompletionCandidates(local, ['github'], 2, builtins));
+        expect(getCommandCompletionCandidates(hosted, ['github'], 2, builtins))
+            .toEqual(['issue-list', 'issues']);
+    });
+});

package/dist/src/command-surface.d.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { ArgumentError } from './errors.js';
+import type { Arg } from './registry.js';
+export declare const OUTPUT_FORMATS: readonly ["table", "plain", "json", "yaml", "yml", "md", "markdown", "csv"];
+export declare const TRACE_MODES: readonly ["off", "on", "retain-on-failure"];
+export type OutputFormat = string;
+export type TraceMode = typeof TRACE_MODES[number];
+export interface CommandSurfaceMetadata {
+    args: readonly Arg[];
+    browser?: boolean;
+    defaultFormat?: string | null;
+    command?: string;
+    site?: string;
+    name?: string;
+}
+export interface ParsedCommandSurface {
+    args: Record<string, unknown>;
+    optionSources: Record<string, 'cli' | 'default'>;
+    format: OutputFormat;
+    formatExplicit: boolean;
+    trace: TraceMode;
+    profile?: string;
+    verbose: boolean;
+    help: boolean;
+}
+/** Identifies the one parser failure whose public bytes are owned by Commander. */
+export declare class MissingRequiredPositionalError extends ArgumentError {
+    readonly argumentName: string;
+    constructor(argumentName: string, help?: string);
+}
+/** Raw structural failure bytes/status owned by Commander. */
+export declare class CommanderStructuralError extends Error {
+    readonly output: string;
+    readonly exitCode: number;
+    constructor(output: string, exitCode: number);
+}
+/** Register the adapter argument grammar and its shared execution options. */
+export declare function configureCommandSurface(command: Command, metadata: CommandSurfaceMetadata): void;
+/** Parse one adapter invocation without requiring a local Commander program. */
+export declare function parseCommandSurface(metadata: CommandSurfaceMetadata, argv: string[]): ParsedCommandSurface;
+/** Apply the adapter's required/default/type/choice contract to raw values. */
+export declare function coerceCommandArguments(definitions: readonly Arg[], input: Record<string, unknown>): Record<string, unknown>;
+export declare function parseOutputFormat(value: unknown): OutputFormat;