burgee 0.11.1 → 0.12.1

package/dist/migrate.js

@@ -1,17 +1,40 @@
-import { readdirSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ambientRuntime, run } from 'bellpull';
-import { GRADED } from './compat.js';
+import { DROP_INS, GRADED, GRADED_VERSIONS, isLevel } from './compat.js';
 import { ExitCode } from './exit-code.js';
-export const MAPPING = {
-    commander: 'burgee/commander',
-    yargs: 'burgee/yargs',
-    'yargs/yargs': 'burgee/yargs',
-    'yargs/helpers': 'burgee/yargs/helpers',
-};
-export const HOSTS = ['commander', 'yargs'];
+export function packageOf(specifier) {
+    const parts = specifier.split('/');
+    return parts.slice(0, specifier.startsWith('@') ? 2 : 1).join('/');
+}
+export const MAPPING = Object.fromEntries(DROP_INS.filter((d) => isLevel(d.host)).flatMap((d) => (d.from === 'yargs' ? [[d.from, d.to], ['yargs/yargs', d.to]] : [[d.from, d.to]])));
+export const HOSTS = [...new Set(Object.keys(MAPPING).map(packageOf))];
+const PARTIAL = DROP_INS.filter((d) => !isLevel(d.host));
+export function majorOf(version) {
+    const digits = /\d+/.exec(version);
+    return digits === null ? undefined : Number(digits[0]);
+}
+const HOST_OF = new Map(DROP_INS.map((d) => [packageOf(d.from), d.host]));
 export const FACADE_EXPORTS = {
+    'bellpull/cross-spawn': [
+        'ChildProcess',
+        'Parsed',
+        'SpawnOptions',
+        'SpawnSyncReturns',
+        '_enoent',
+        'crossSpawn',
+        'default',
+        'module.exports',
+        'parse',
+        'spawn',
+        'sync',
+    ],
+    'bellpull/node-which': [
+        'NodeWhichOptions',
+        'default',
+        'module.exports',
+    ],
     'burgee/commander': [
         'AddHelpTextContext',
         'AddHelpTextPosition',
@@ -88,12 +111,312 @@ export const FACADE_EXPORTS = {
         'isPromise',
         'isYargsInstance',
         'looksLikeNumber',
+        'module.exports',
         'objFilter',
         'parseCommand',
         'platformShim',
     ],
-    'burgee/yargs/helpers': ['Parser', 'applyExtends', 'hideBin'],
+    'burgee/yargs/helpers': [
+        'Parser',
+        'applyExtends',
+        'hideBin',
+    ],
+    'burgee/yargs/parser': [
+        'Arguments',
+        'Configuration',
+        'DetailedArguments',
+        'Options',
+        'Parser',
+        'ParserMixin',
+        'YargsParser',
+        'camelCase',
+        'decamelize',
+        'default',
+        'looksLikeNumber',
+        'module.exports',
+        'tokenizeArgString',
+    ],
+    'caique/inquirer': [
+        'AbortPromptError',
+        'CancelPromptError',
+        'CancelablePromise',
+        'Context',
+        'ExitPromptError',
+        'HookError',
+        'Keybinding',
+        'KeypressEvent',
+        'PartialTheme',
+        'Prompt',
+        'Separator',
+        'SetState',
+        'Status',
+        'Theme',
+        'ValidationError',
+        'ViewFunction',
+        'createPrompt',
+        'defaultTheme',
+        'getDefaultKeybindings',
+        'getDefaultTheme',
+        'isBackspaceKey',
+        'isDownKey',
+        'isEnterKey',
+        'isNumberKey',
+        'isShiftKey',
+        'isSpaceKey',
+        'isTabKey',
+        'isUpKey',
+        'makeTheme',
+        'useEffect',
+        'useKeypress',
+        'useMemo',
+        'usePrefix',
+        'useRef',
+        'useState',
+    ],
+    'closeout/exit-hook': [
+        'AsyncExitHookOptions',
+        'ExitHookCallback',
+        'Options',
+        'asyncExitHook',
+        'default',
+        'gracefulExit',
+    ],
+    'closeout/restore-cursor': [
+        'default',
+    ],
+    'closeout/signal-exit': [
+        'load',
+        'onExit',
+        'signals',
+        'unload',
+    ],
+    'closeout/signal-exit/signals': [
+        'signals',
+    ],
+    'flagstaff/boxen': [
+        'BoxenBorderStyle',
+        'BoxenOptions',
+        'Boxes',
+        'CustomBorderStyle',
+        'Options',
+        'Spacing',
+        '_borderStyles',
+        'default',
+    ],
+    'flagstaff/cli-table3': [
+        'Cell',
+        'ColSpanCell',
+        'RowSpanCell',
+        'Table',
+        'TableChars',
+        'TableOptions',
+        'TableStyle',
+        'computeHeights',
+        'computeWidths',
+        'default',
+        'hyperlink',
+        'makeTableLayout',
+        'mergeOptions',
+        'module.exports',
+        'pad',
+        'strlen',
+        'truncate',
+        'wordWrap',
+    ],
+    'flagstaff/log-update': [
+        'LogUpdate',
+        'LogUpdateOptions',
+        'LogUpdateStream',
+        'Options',
+        'createLogUpdate',
+        'default',
+        'logUpdateStderr',
+    ],
+    'flagstaff/ora': [
+        'Affix',
+        'Color',
+        'Options',
+        'Ora',
+        'OraStream',
+        'PersistOptions',
+        'PrefixTextGenerator',
+        'PromiseOptions',
+        'Spinner',
+        'SpinnerDefinition',
+        'SuffixTextGenerator',
+        'default',
+        'oraPromise',
+        'spinners',
+    ],
+    'linegauge': [
+        'Options',
+        'TruncateOptions',
+        'WidthOptions',
+        'WrapOptions',
+        'default',
+        'lineCount',
+        'measure',
+        'slice',
+        'strip',
+        'truncate',
+        'widest',
+        'width',
+        'wrap',
+    ],
+    'linegauge/slice': [
+        'default',
+        'slice',
+    ],
+    'linegauge/strip': [
+        'default',
+        'strip',
+    ],
+    'linegauge/wrap': [
+        'Options',
+        'WrapOptions',
+        'default',
+        'visibleWidth',
+        'wrap',
+    ],
+    'paratext': [
+        'AnsiEscapes',
+        'Capability',
+        'CapabilityError',
+        'ConEmu',
+        'DEPRECATED',
+        'Fields',
+        'ImageOptions',
+        'NotImplemented',
+        'Runtime',
+        'Support',
+        'ansiEscapesFor',
+        'beep',
+        'beginSynchronizedOutput',
+        'bell',
+        'builtins',
+        'capabilities',
+        'capability',
+        'check',
+        'clearScreen',
+        'clearTerminal',
+        'clearViewport',
+        'clipboard',
+        'cursorBackward',
+        'cursorDown',
+        'cursorForward',
+        'cursorGetPosition',
+        'cursorHide',
+        'cursorLeft',
+        'cursorMove',
+        'cursorNextLine',
+        'cursorPrevLine',
+        'cursorRestorePosition',
+        'cursorSavePosition',
+        'cursorShow',
+        'cursorTo',
+        'cursorUp',
+        'cwd',
+        'default',
+        'emit',
+        'endSynchronizedOutput',
+        'enterAlternativeScreen',
+        'eraseDown',
+        'eraseEndLine',
+        'eraseLine',
+        'eraseLines',
+        'eraseScreen',
+        'eraseStartLine',
+        'eraseUp',
+        'exitAlternativeScreen',
+        'fieldsUsed',
+        'iTerm',
+        'image',
+        'isDeprecation',
+        'link',
+        'notify',
+        'processRuntime',
+        'refusals',
+        'register',
+        'registerBuiltins',
+        'render',
+        'reset',
+        'scrollDown',
+        'scrollUp',
+        'setCwd',
+        'supports',
+        'synchronizedOutput',
+        'title',
+    ],
+    'paratext/terminal-link': [
+        'LinkOptions',
+        'Options',
+        'Target',
+        'TerminalLink',
+        'default',
+        'terminalLinkFor',
+    ],
+    'roundel/chalk': [
+        'BackgroundColor',
+        'BackgroundColorName',
+        'Chalk',
+        'ChalkInstance',
+        'ChalkOptions',
+        'Color',
+        'ColorInfo',
+        'ColorName',
+        'ColorSupport',
+        'ColorSupportLevel',
+        'ForegroundColor',
+        'ForegroundColorName',
+        'ModifierName',
+        'Modifiers',
+        'Options',
+        'UnderlineColorName',
+        'backgroundColorNames',
+        'chalkStderr',
+        'colorNames',
+        'default',
+        'foregroundColorNames',
+        'modifierNames',
+        'supportsColor',
+        'supportsColorStderr',
+        'underlineColorNames',
+    ],
+    'seniority/lilconfig': [
+        'AsyncSearcher',
+        'LilconfigResult',
+        'Loader',
+        'LoaderSync',
+        'Loaders',
+        'LoadersSync',
+        'Options',
+        'OptionsSync',
+        'SyncSearcher',
+        'Transform',
+        'TransformSync',
+        'defaultLoaders',
+        'defaultLoadersSync',
+        'lilconfig',
+        'lilconfigSync',
+    ],
+    'seniority/rc': [
+        'RcConfig',
+        'RcOptions',
+        'RcParse',
+        'default',
+        'module.exports',
+        'parse',
+        'rc',
+    ],
 };
+export const REQUIRE_NAMESPACE = ['ansi-escapes', 'chalk', 'ora', 'log-update', 'boxen', 'string-width', 'strip-ansi', 'wrap-ansi', 'slice-ansi', 'restore-cursor', 'exit-hook', 'terminal-link'];
+function requireShapesDiffer(from, to) {
+    const exported = FACADE_EXPORTS[to] ?? [];
+    const toGivesDefault = exported.includes('module.exports');
+    if (REQUIRE_NAMESPACE.includes(from))
+        return toGivesDefault;
+    return exported.includes('default') && !toGivesDefault;
+}
 const WORD = /[A-Za-z0-9_$]/;
 const DIVIDES = new Set([')', ']', '}']);
 function startsRegex(previous) {
@@ -220,6 +543,8 @@ function siteOf(source, at, tokens) {
     const site = { specifier: source.slice(open + 1, close - 1), start: open + 1, end: close - 1, line };
     if (tokens.previous === 'from' && tokens.clause !== undefined)
         site.clause = tokens.clause.slice(0, -1);
+    if (tokens.previous === '(' && tokens.before === 'require')
+        site.require = true;
     return site;
 }
 export function scan(source) {
@@ -293,27 +618,40 @@ function missingFrom(site, to) {
     const { typeOnly, names } = bindingsOf(site.clause);
     return { typeOnly, missing: names.filter((name) => !exported.includes(name)) };
 }
-export function rewriteSource(source) {
+function classify(site) {
+    const to = MAPPING[site.specifier];
+    if (to === undefined)
+        return 'unmapped';
+    if (site.require === true && requireShapesDiffer(site.specifier, to))
+        return { line: site.line, specifier: site.specifier, reason: 'require-of-default' };
+    const { typeOnly, missing } = missingFrom(site, to);
+    if (missing.length === 0)
+        return 'moves';
+    if (typeOnly)
+        return { line: site.line, specifier: site.specifier, names: missing, note: `${to} does not export ${missing.join(', ')}; this type-only import stays on '${site.specifier}', so keep its types installed` };
+    return { line: site.line, specifier: site.specifier, reason: 'unknown-export', names: missing };
+}
+const NONE = new Set();
+export function rewriteSource(source, skip = NONE) {
     if (!mentionsAHost(source))
         return { source, mapped: [], refused: [], kept: [], relevant: false };
     const { sites, nonLiteral } = scan(source);
-    const hits = sites.filter((s) => MAPPING[s.specifier] !== undefined || isDeep(s.specifier));
+    const hits = sites.filter((s) => !skip.has(packageOf(s.specifier)) && (MAPPING[s.specifier] !== undefined || isDeep(s.specifier)));
     if (hits.length === 0)
         return { source, mapped: [], refused: [], kept: [], relevant: false };
     const kept = [];
     const unknown = [];
     const moving = [];
     for (const site of hits) {
-        const to = MAPPING[site.specifier];
-        if (to === undefined)
+        const verdict = classify(site);
+        if (verdict === 'unmapped')
             continue;
-        const { typeOnly, missing } = missingFrom(site, to);
-        if (missing.length === 0)
+        if (verdict === 'moves')
             moving.push(site);
-        else if (typeOnly)
-            kept.push({ line: site.line, specifier: site.specifier, names: missing, note: `${to} does not export ${missing.join(', ')}; this type-only import stays on '${site.specifier}', so keep its types installed` });
+        else if ('note' in verdict)
+            kept.push(verdict);
         else
-            unknown.push({ line: site.line, specifier: site.specifier, reason: 'unknown-export', names: missing });
+            unknown.push(verdict);
     }
     const refused = [
         ...hits.filter((s) => isDeep(s.specifier)).map((s) => ({ line: s.line, specifier: s.specifier, reason: 'deep-import' })),
@@ -345,16 +683,48 @@ export function sourceFiles(dir, at = '', found = []) {
     }
     return found;
 }
-async function declaredHosts(dir) {
+async function declaredDependencies(dir) {
     try {
         const raw = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'));
-        const declared = { ...raw.dependencies, ...raw.devDependencies };
-        return HOSTS.filter((host) => declared[host] !== undefined);
+        return new Map(Object.entries({ ...raw.dependencies, ...raw.devDependencies }));
     }
     catch {
-        return [];
+        return new Map();
     }
 }
+async function installedVersion(dir, name) {
+    try {
+        return JSON.parse(await readFile(join(dir, 'node_modules', name, 'package.json'), 'utf8')).version;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function offMajorOf(dir, dependencies) {
+    const found = await Promise.all(HOSTS.map(async (from) => ({ from, found: (await installedVersion(dir, from)) ?? dependencies.get(from) })));
+    return found.flatMap(({ from, found: version }) => {
+        const graded = GRADED_VERSIONS[from];
+        if (version === undefined || graded === undefined)
+            return [];
+        const major = majorOf(version);
+        return major === undefined || major === majorOf(graded) ? [] : [{ from, found: version, graded }];
+    });
+}
+function installer(dir) {
+    const has = (file) => existsSync(join(dir, file));
+    if (has('pnpm-lock.yaml'))
+        return { add: 'pnpm add', remove: 'pnpm remove' };
+    if (has('yarn.lock'))
+        return { add: 'yarn add', remove: 'yarn remove' };
+    if (has('bun.lockb') || has('bun.lock'))
+        return { add: 'bun add', remove: 'bun remove' };
+    return { add: 'npm install', remove: 'npm uninstall' };
+}
+function nextStep(dir, add, remove) {
+    const pm = installer(dir);
+    const steps = [add.length > 0 ? `${pm.add} ${add.join(' ')}` : '', remove.length > 0 ? `${pm.remove} ${remove.join(' ')}` : ''];
+    return steps.filter((c) => c !== '').join(' && ');
+}
 export async function workingTree(dir) {
     const result = await run('git', ['-C', dir, 'status', '--porcelain'], { runtime: ambientRuntime(), stdio: 'pipe' });
     if (!result.ok)
@@ -371,9 +741,9 @@ export class DirtyTreeError extends Error {
     }
 }
 const EMPTY = { source: '', mapped: [], refused: [], kept: [], relevant: false };
-async function migrateBatch(dir, batch, write) {
+async function migrateBatch(dir, batch, write, skip) {
     const sources = await Promise.all(batch.map(async (file) => await readFile(join(dir, file))));
-    const results = sources.map((bytes) => (mentionsAHost(bytes) ? rewriteSource(bytes.toString('utf8')) : EMPTY));
+    const results = sources.map((bytes) => (mentionsAHost(bytes) ? rewriteSource(bytes.toString('utf8'), skip) : EMPTY));
     if (write)
         await Promise.all(results.map(async (r, i) => (r.mapped.length === 0 ? undefined : await writeFile(join(dir, batch[i]), r.source))));
     return results;
@@ -386,7 +756,8 @@ function rollup(all) {
     })
         .filter((row) => row.imports > 0);
 }
-function gradedFor(hosts) {
+function gradedFor(packages) {
+    const hosts = [...new Set(packages.map((p) => HOST_OF.get(p)).filter((h) => h !== undefined))];
     return hosts.filter((host) => GRADED[host] !== undefined).map((host) => ({ host, ...GRADED[host] }));
 }
 const BATCH = 256;
@@ -395,30 +766,38 @@ export async function migrate(options) {
     const entries = await (options.status ?? workingTree)(dir);
     if (!dryRun && !force && entries !== undefined && entries.length > 0)
         throw new DirtyTreeError(entries);
+    const dependencies = await declaredDependencies(dir);
+    const offMajor = await offMajorOf(dir, dependencies);
+    const skip = new Set(offMajor.map((o) => o.from));
     const files = sourceFiles(dir);
     const results = [];
     for (let i = 0; i < files.length; i += BATCH) {
         const batch = files.slice(i, i + BATCH);
-        const done = await migrateBatch(dir, batch, !dryRun);
+        const done = await migrateBatch(dir, batch, !dryRun, skip);
         results.push(...done.map((result, k) => ({ file: batch[k], result })));
     }
     const all = results.flatMap(({ file, result }) => result.mapped.map((m) => ({ ...m, file })));
     const refused = results.flatMap(({ file, result }) => result.refused.map((r) => ({ file, ...r })));
     const kept = results.flatMap(({ file, result }) => result.kept.map((k) => ({ file, ...k })));
-    const imported = [...new Set(results.flatMap(({ result }) => (result.relevant ? [...result.mapped.map((m) => m.from), ...result.kept.map((k) => k.specifier)] : [])))];
-    const declared = await declaredHosts(dir);
-    const stillUsed = new Set([...refused, ...kept].map((r) => r.specifier.split('/')[0] ?? ''));
-    const removable = declared.filter((host) => !stillUsed.has(host));
+    const imported = [...new Set(results.flatMap(({ result }) => (result.relevant ? [...result.mapped.map((m) => packageOf(m.from)), ...result.kept.map((k) => packageOf(k.specifier))] : [])))].sort();
+    const declared = HOSTS.filter((host) => dependencies.has(host));
+    const stillUsed = new Set([...refused, ...kept].map((r) => packageOf(r.specifier)));
+    const removable = declared.filter((host) => !stillUsed.has(host) && !skip.has(host));
     const touched = [...new Set(all.map((m) => m.file))];
+    const add = [...new Set(all.map((m) => packageOf(m.to)))].filter((p) => !dependencies.has(p)).sort();
+    const partial = PARTIAL.filter((d) => dependencies.has(d.from)).map((d) => ({ from: d.from, to: d.to, ...GRADED[d.host] }));
     return {
         files: touched.length,
         imports: all.length,
         mapped: rollup(all),
         refused,
         kept,
-        detected: { declared, imported: [...new Set(imported.map((s) => s.split('/')[0] ?? s))].sort() },
-        dependencies: { before: declared, removable, after: declared.length - removable.length },
-        graded: gradedFor([...new Set([...declared, ...imported.map((s) => s.split('/')[0] ?? s)])].sort()),
+        detected: { declared, imported },
+        dependencies: { before: declared, removable, after: declared.length - removable.length, add },
+        graded: gradedFor([...new Set([...declared, ...imported])].sort()),
+        partial,
+        offMajor,
+        next: nextStep(dir, add, removable),
         dryRun,
         changed: !dryRun && touched.length > 0,
         exitCode: refused.length > 0 ? ExitCode.RUNTIME : ExitCode.OK,

package/dist/parse-hooks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2026 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+import { type Plugin } from './plugin.js';
+export declare function runParseHooks(plugins: readonly Plugin[], argv: string[]): Promise<string[]>;

package/dist/parse-hooks.js

@@ -0,0 +1,17 @@
+import { hookApplies } from './manifest.js';
+export async function runParseHooks(plugins, argv) {
+    let current = argv;
+    for (const plugin of plugins) {
+        const hook = plugin.hooks?.parse;
+        const typed = current.join(' ');
+        if (!hookApplies(hook, typed))
+            continue;
+        const next = await hook.handler({ command: typed, options: {}, argv: [...current] });
+        if (next === undefined)
+            continue;
+        if (!Array.isArray(next) || !next.every((a) => typeof a === 'string'))
+            throw new Error(`burgee: plugin "${plugin.name}"'s parse hook returned ${typeof next}; return string[] or nothing`);
+        current = next;
+    }
+    return current;
+}

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CommandNode, type Hook } from './manifest.js';
+import { type CommandNode, type Hook, type HookStage } from './manifest.js';
 /**
  * The plugin contract version. One number for the family — the same `1` flagstaff, caique and
  * closeout declare, written out rather than imported because a layer never imports a layer.
@@ -12,11 +12,7 @@ export interface Plugin {
     name: string;
     contract?: number;
     commands?: CommandNode[];
-    hooks?: {
-        preRun?: Hook;
-        postRun?: Hook;
-        onError?: Hook;
-    };
+    hooks?: Partial<Record<HookStage, Hook>>;
     enforce?: 'pre' | 'post';
 }
 export type PluginErrorCode = 'E_PLUGIN_SCHEMA' | 'E_PLUGIN_CONTRACT' | 'E_NO_CONTRIBUTION';

package/dist/plugin.js

@@ -13,7 +13,7 @@ export class PluginError extends Error {
 }
 const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 const ENFORCE = ['pre', 'post'];
-const STAGES = ['preRun', 'postRun', 'onError'];
+const STAGES = ['parse', 'preRun', 'postRun', 'onError', 'shutdown'];
 const schema = (message, fix) => new PluginError('E_PLUGIN_SCHEMA', message, fix);
 export function validate(plugin, taken = []) {
     if (!isRecord(plugin))

package/dist/program-schema.json

@@ -0,0 +1 @@
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://burgee.dev/program-schema.json","title":"burgee --schema","description":"The document `<program> --schema` prints: the program as data, for an agent or an MCP host to read without running anything. Published so a reader can validate what a program says about itself (burgee F1, D-123); burgee's own test validates `--schema` output against this file on every run.","type":"object","required":["schemaVersion","name","exitCodes","commands"],"additionalProperties":false,"properties":{"schemaVersion":{"const":1,"description":"Bumped only when a field changes meaning."},"name":{"type":"string","description":"The program as typed."},"version":{"type":"string"},"description":{"type":"string"},"exitCodes":{"type":"object","additionalProperties":{"type":"integer"},"description":"What each exit code means (F1): the contract's names and numbers, so a caller branches on the code without reading prose."},"commands":{"type":"array","description":"Every runnable, visible command, in declaration order.","items":{"$ref":"#/$defs/command"}}},"$defs":{"command":{"type":"object","required":["name","arguments","options","examples","inputSchema"],"additionalProperties":false,"properties":{"name":{"type":"string","description":"The command as typed, without the program name: `config get`."},"description":{"type":"string"},"summary":{"type":"string"},"effects":{"type":"string","pattern":"^(read_only|idempotent|non_idempotent|withheld)$","description":"What running it does to the world, or `withheld` (N6)."},"deprecated":{"description":"`true`, or the replacement's name (M5)."},"group":{"type":"string"},"lazy":{"const":true,"description":"Its handler loads on dispatch (M2)."},"plugin":{"type":"string","description":"The plugin that contributed it (M3)."},"fields":{"type":"array","items":{"type":"string"},"description":"The result's top-level fields, what `--json=` selects from (N14)."},"arguments":{"type":"array","items":{"$ref":"#/$defs/argument"}},"options":{"type":"object","additionalProperties":{"$ref":"#/$defs/option"}},"relations":{"type":"array","items":{"type":"object"},"description":"Constraints between options (S2, S6): exactlyOneOf, atLeastOneOf, atMostOneOf, conflicts, implies."},"examples":{"type":"array","items":{"$ref":"#/$defs/example"}},"inputSchema":{"$ref":"#/$defs/inputSchema"}}},"argument":{"type":"object","required":["name"],"additionalProperties":false,"properties":{"name":{"type":"string"},"description":{"type":"string"},"required":{"type":"boolean"},"variadic":{"type":"boolean"},"default":{"type":"string"},"type":{"type":"string","pattern":"^file$","description":"`file`: `-` means standard input (S4)."}}},"option":{"type":"object","required":["type"],"additionalProperties":false,"properties":{"type":{"type":"string","pattern":"^(string|boolean|number)$"},"description":{"type":"string"},"required":{"type":"boolean"},"short":{"type":"string"},"default":{"description":"A string, boolean, number, or a list of strings or numbers."},"env":{"type":"string"},"choices":{"type":"array","items":{"type":"string"}},"multiple":{"type":"boolean"},"separator":{"type":"string"},"dependsOn":{"type":"array","items":{"type":"string"}},"exclusive":{"type":"array","items":{"type":"string"}},"minimum":{"type":"number"},"maximum":{"type":"number"},"integer":{"type":"boolean"},"schema":{"type":"object","description":"A Standard Schema validator, as its own library serialises it."},"placeholder":{"type":"string"},"deprecated":{"description":"`true`, or the replacement's name."},"hidden":{"type":"boolean"},"sharedFrom":{"type":"string"}}},"example":{"type":"object","required":["command"],"additionalProperties":false,"properties":{"command":{"type":"string"},"description":{"type":"string"}}},"inputSchema":{"type":"object","required":["type","properties","required","additionalProperties"],"additionalProperties":false,"description":"The arguments and options as one JSON Schema object — what an MCP tool call takes.","properties":{"type":{"const":"object"},"properties":{"type":"object"},"required":{"type":"array","items":{"type":"string"}},"additionalProperties":{"const":false}}}}}