@dinoxx/dinox-cli 1.0.18 → 1.0.20

package/dist/commands/boxes/index.js

@@ -1,12 +1,17 @@
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { loadConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
-import { DinoxError } from '../../utils/errors.js';
-import { printYaml } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
-import { resolveAuthIdentity } from '../../auth/userInfo.js';
-import { addBox, listBoxes } from './repo.js';
+import { registerCommandGroup } from '../descriptor/register.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { buildBoxAddDryRunPreview } from '../writeDryRun.js';
+import { printDryRunPreview } from '../../utils/dryRun.js';
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { addBox, inspectAddBox, listBoxes } from './repo.js';
+const BOX_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 async function syncBeforeBoxCommand(db, offline, timeoutMs) {
     if (offline) {
         return;
@@ -14,85 +19,124 @@ async function syncBeforeBoxCommand(db, offline, timeoutMs) {
     await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
     await syncNoteTokenIndex(db);
 }
-async function runBoxListCommand(options, command) {
-    const globals = command.optsWithGlobals?.() ?? {};
-    const offline = Boolean(options.offline ?? globals.offline);
-    const config = resolveConfig(await loadConfig());
-    const timeoutMs = parseSyncTimeoutMs(options.syncTimeout ?? globals.syncTimeout) ?? config.sync.timeoutMs;
-    const { db } = await connectPowerSync({ config, offline, timeoutMs });
+async function withBoxDb(context, run) {
+    const rawConfig = await loadConfig();
+    const config = resolveConfig(rawConfig);
+    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? config.sync.timeoutMs;
+    const offline = Boolean(context.globals.offline);
+    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
     try {
-        await syncBeforeBoxCommand(db, offline, timeoutMs);
-        const boxes = await listBoxes(db);
-        printYaml(boxes);
+        await run({ db, config, rawConfig, offline, timeoutMs, stale });
     }
     finally {
         await db.close().catch(() => undefined);
     }
 }
-export function registerBoxesCommand(program) {
-    const box = program.command('box').description('Manage zettel boxes');
-    box
-        .command('list')
-        .description('List zettel boxes (id and name) from c_zettel_box')
-        .option('--offline', 'skip connect/sync and only use local cache')
-        .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
-        .action(runBoxListCommand);
-    box
-        .command('add')
-        .description('Create a new zettel box in c_zettel_box')
-        .argument('[name]', 'box name')
-        .option('--name <string>', 'box name (alternative to positional name)')
-        .option('--description <string>', 'box purpose/usage description (helps AI route notes to this box)')
-        .option('--color <string>', 'box color')
-        .option('--json', 'output machine-readable YAML')
-        .option('--offline', 'skip connect/sync and only use local cache')
-        .option('--sync-timeout <ms>', 'override sync/connect timeout (milliseconds)')
-        .action(async (nameArg, options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(options.offline ?? globals.offline);
-        const jsonOutput = Boolean(options.json ?? globals.json);
-        const optionName = typeof options.name === 'string' ? options.name : undefined;
-        const name = (nameArg ?? optionName ?? '').trim();
-        if (!name) {
-            throw new DinoxError('Box name is required. Use `dino box add <name>` or `dino box add --name <name>`.');
+async function runBoxList(context) {
+    await withBoxDb(context, async ({ db, offline, timeoutMs }) => {
+        await syncBeforeBoxCommand(db, offline, timeoutMs);
+        printSuccess(await listBoxes(db));
+    });
+}
+async function runBoxAdd(context) {
+    const nameArg = context.args.name;
+    const optionName = typeof context.options.name === 'string' ? context.options.name : undefined;
+    const name = (nameArg ?? optionName ?? '').trim();
+    if (!name) {
+        throw new DinoxError('Box name is required. Use `dino box add <name>` or `dino box add --name <name>`.');
+    }
+    if (nameArg && optionName && nameArg.trim() !== optionName.trim()) {
+        throw new DinoxError('Conflicting box name values from positional argument and --name option.');
+    }
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withBoxDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        await syncBeforeBoxCommand(db, offline, timeoutMs);
+        const description = typeof context.options.description === 'string' ? context.options.description : undefined;
+        const color = typeof context.options.color === 'string' ? context.options.color : undefined;
+        if (Boolean(context.options.dryRun)) {
+            printDryRunPreview(buildBoxAddDryRunPreview({
+                config,
+                offline,
+                ...(await inspectAddBox(db, {
+                    name,
+                    userId: identity.userId,
+                    description,
+                    color,
+                })),
+            }));
+            return;
         }
-        if (nameArg && optionName && nameArg.trim() !== optionName.trim()) {
-            throw new DinoxError('Conflicting box name values from positional argument and --name option.');
+        const result = await addBox(db, {
+            name,
+            userId: identity.userId,
+            description,
+            color,
+        });
+        if (!offline && !config.powersync.uploadBaseUrl) {
+            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
         }
-        const rawConfig = await loadConfig();
-        const config = resolveConfig(rawConfig);
-        const timeoutMs = parseSyncTimeoutMs(options.syncTimeout ?? globals.syncTimeout) ?? config.sync.timeoutMs;
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-        try {
-            await syncBeforeBoxCommand(db, offline, timeoutMs);
-            const result = await addBox(db, {
-                name,
-                userId: identity.userId,
-                description: typeof options.description === 'string' ? options.description : undefined,
-                color: typeof options.color === 'string' ? options.color : undefined,
-            });
-            if (!offline && !config.powersync.uploadBaseUrl) {
-                console.log('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
-            }
-            if (!offline) {
-                await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
-            }
-            const payload = { ok: true, stale: offline ? true : stale, ...result };
-            if (jsonOutput) {
-                printYaml(payload);
-                return;
-            }
-            console.log(result.id);
-            if (stale && !offline) {
-                console.log('warning: sync timed out; results may be stale');
-            }
+        if (!offline) {
+            await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
         }
-        finally {
-            await db.close().catch(() => undefined);
+        const payload = { ok: true, stale: offline ? true : stale, ...result };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(result.id);
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; results may be stale');
         }
     });
-    box.action((_options, command) => {
-        command.outputHelp();
-    });
+}
+export const boxCommandGroup = {
+    name: 'box',
+    description: 'Manage zettel boxes',
+    commands: [
+        {
+            name: 'list',
+            description: 'List all zettel boxes from c_zettel_box',
+            schema: {
+                path: 'box.list',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Box list payload',
+                    fields: ['id', 'name', 'description'],
+                },
+                examples: ['dino box list --format json'],
+            },
+            action: runBoxList,
+        },
+        {
+            name: 'add',
+            description: 'Create a zettel box, restoring a deleted row when possible',
+            arguments: [{ syntax: '[name]', description: 'Box name' }],
+            options: [
+                { flags: '--name <string>', description: 'Box name (alternative to positional name)' },
+                { flags: '--description <string>', description: 'Box purpose/usage description' },
+                { flags: '--color <string>', description: 'Box color' },
+                { flags: '--dry-run', description: 'Preview the write without executing it' },
+            ],
+            schema: {
+                path: 'box.add',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: BOX_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Box creation acknowledgement',
+                    fields: ['id', 'name', 'description', 'color', 'restored', 'stale'],
+                },
+                examples: ['dino box add "Inbox" --description "用于存放待整理的想法和资料" --format json --dry-run'],
+            },
+            action: runBoxAdd,
+        },
+    ],
+};
+export function registerBoxesCommand(program) {
+    registerCommandGroup(program, boxCommandGroup);
 }

package/dist/commands/boxes/repo.d.ts

@@ -17,5 +17,13 @@ export type AddBoxResult = {
     color: string;
     restored: boolean;
 };
+export type InspectAddBoxResult = {
+    name: string;
+    description: string;
+    color: string;
+    restored: boolean;
+    existingId?: string;
+};
 export declare function listBoxes(db: AbstractPowerSyncDatabase): Promise<BoxListItem[]>;
 export declare function addBox(db: AbstractPowerSyncDatabase, input: AddBoxInput): Promise<AddBoxResult>;
+export declare function inspectAddBox(db: AbstractPowerSyncDatabase, input: AddBoxInput): Promise<InspectAddBoxResult>;

package/dist/commands/boxes/repo.js

@@ -152,3 +152,44 @@ export async function addBox(db, input) {
         restored: false,
     };
 }
+export async function inspectAddBox(db, input) {
+    const userId = input.userId.trim();
+    const name = normalizeName(input.name);
+    if (!name) {
+        throw new DinoxError('Box name is required');
+    }
+    const description = normalizeName(input.description ?? '');
+    const color = normalizeName(input.color ?? '');
+    const lookup = normalizeLookup(name);
+    const columnNames = await getBoxColumns(db);
+    const requiredColumns = ['id', 'name', 'user_no'];
+    const missingRequired = requiredColumns.filter((column) => !columnNames.has(column));
+    if (missingRequired.length > 0) {
+        throw new DinoxError(`c_zettel_box table is missing required columns: ${missingRequired.join(', ')}`);
+    }
+    if (!userId) {
+        throw new DinoxError('c_zettel_box insert requires user_no. Missing persisted userId. Run `dino auth login` first.');
+    }
+    const rows = await listBoxRowsForWrite(db);
+    const sameNameRows = rows.filter((row) => normalizeLookup(row.name ?? '') === lookup);
+    const activeRows = sameNameRows.filter((row) => row.is_del !== 1);
+    if (activeRows.length > 0) {
+        const ids = activeRows.map((row) => row.id?.trim() ?? '').filter(Boolean);
+        throw new DinoxError(`Zettel box already exists: ${name}`, {
+            details: {
+                type: 'box_exists',
+                name,
+                ids,
+                question: 'This box already exists. Do you want to keep using the existing box?',
+            },
+        });
+    }
+    const deletedRow = sameNameRows.find((row) => (row.id?.trim() ?? '').length > 0);
+    return {
+        name,
+        description,
+        color,
+        restored: Boolean(deletedRow?.id),
+        ...(deletedRow?.id ? { existingId: deletedRow.id } : {}),
+    };
+}

package/dist/commands/config/index.d.ts

@@ -1,3 +1,5 @@
 import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
 export declare function sanitizeConfigForDisplay(config: unknown): unknown;
+export declare const configCommandGroup: CommandGroupDescriptor;
 export declare function registerConfigCommands(program: Command): void;

package/dist/commands/config/index.js

@@ -1,8 +1,10 @@
 import { isConfigKey, isFixedConfigKey, isReadableConfigKey } from '../../config/keys.js';
 import { getConfigValue, setConfigValue } from '../../config/store.js';
-import { redactAuthorization } from '../../utils/redact.js';
+import { registerCommandGroup } from '../descriptor/register.js';
+import { FORMAT_OPTIONS } from '../schema/globalOptions.js';
 import { DinoxError } from '../../utils/errors.js';
-import { printYaml } from '../../utils/output.js';
+import { getRequestedStructuredOutputFormat, printSuccess } from '../../utils/output.js';
+import { redactAuthorization } from '../../utils/redact.js';
 export function sanitizeConfigForDisplay(config) {
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
         return config;
@@ -15,40 +17,87 @@ export function sanitizeConfigForDisplay(config) {
     delete clone.powersync;
     return clone;
 }
-export function registerConfigCommands(program) {
-    const configCmd = program.command('config').description('Read and write Dinox configuration');
-    configCmd
-        .command('get')
-        .description('Get configuration value')
-        .argument('[key]', 'config key (dot path)')
-        .action(async (key) => {
-        if (key && !isReadableConfigKey(key)) {
-            throw new DinoxError(`Unknown config key: ${key}`);
-        }
-        const value = await getConfigValue(key);
-        const redacted = key ? value : sanitizeConfigForDisplay(value);
-        printYaml(redacted);
-    });
-    configCmd
-        .command('set')
-        .description('Set configuration value')
-        .argument('<key>', 'config key (dot path)')
-        .argument('<value>', 'value')
-        .action(async (key, value) => {
-        if (isFixedConfigKey(key)) {
-            throw new DinoxError(`${key} is fixed and cannot be changed`);
-        }
-        if (!isConfigKey(key)) {
-            throw new DinoxError(`Unknown config key: ${key}`);
+async function runConfigGet(context) {
+    const key = context.args.key;
+    if (key && !isReadableConfigKey(key)) {
+        throw new DinoxError(`Unknown config key: ${key}`);
+    }
+    const value = await getConfigValue(key);
+    printSuccess(key ? value : sanitizeConfigForDisplay(value));
+}
+async function runConfigSet(context) {
+    const key = context.args.key;
+    const value = context.args.value;
+    if (!key || value === undefined) {
+        throw new DinoxError('Config key and value are required');
+    }
+    if (isFixedConfigKey(key)) {
+        throw new DinoxError(`${key} is fixed and cannot be changed`);
+    }
+    if (!isConfigKey(key)) {
+        throw new DinoxError(`Unknown config key: ${key}`);
+    }
+    if (key === 'sync.timeoutMs') {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            throw new DinoxError('sync.timeoutMs must be a positive integer');
         }
-        if (key === 'sync.timeoutMs') {
-            const parsed = Number(value);
-            if (!Number.isFinite(parsed) || parsed <= 0) {
-                throw new DinoxError('sync.timeoutMs must be a positive integer');
-            }
-            await setConfigValue(key, Math.trunc(parsed));
-            return;
+        await setConfigValue(key, Math.trunc(parsed));
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, key, value: Math.trunc(parsed) });
         }
-        await setConfigValue(key, value);
-    });
+        return;
+    }
+    await setConfigValue(key, value);
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({ ok: true, key, value });
+    }
+}
+export const configCommandGroup = {
+    name: 'config',
+    description: 'Read and write Dinox configuration',
+    commands: [
+        {
+            name: 'get',
+            description: 'Read sanitized Dinox CLI configuration values',
+            arguments: [{ syntax: '[key]', description: 'Optional config key (dot path)' }],
+            schema: {
+                path: 'config.get',
+                risk: 'read',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Requested config value or sanitized config object',
+                    fields: ['sync.timeoutMs', 'auth'],
+                },
+                examples: ['dino config get --format json', 'dino config get sync.timeoutMs --format json'],
+            },
+            action: runConfigGet,
+        },
+        {
+            name: 'set',
+            description: 'Write configurable Dinox CLI settings',
+            arguments: [
+                { syntax: '<key>', description: 'Config key (dot path)' },
+                { syntax: '<value>', description: 'Config value' },
+            ],
+            schema: {
+                path: 'config.set',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Config write acknowledgement',
+                    fields: ['key', 'value'],
+                },
+                examples: ['dino config set sync.timeoutMs 20000 --format json'],
+            },
+            action: runConfigSet,
+        },
+    ],
+};
+export function registerConfigCommands(program) {
+    registerCommandGroup(program, configCommandGroup);
 }

package/dist/commands/descriptor/register.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'commander';
+import type { CommandSchema } from '../schema/types.js';
+import type { CommandDescriptor, CommandGroupDescriptor } from './types.js';
+export declare function registerCommandGroup(program: Command, group: CommandGroupDescriptor): Command;
+export declare function registerStandaloneCommand(program: Command, descriptor: CommandDescriptor): Command;
+export declare function commandSchemaFromDescriptor(groupName: string, descriptor: CommandDescriptor): CommandSchema;
+export declare function commandSchemasFromGroupDescriptor(group: CommandGroupDescriptor): CommandSchema[];
+export declare function standaloneCommandSchemaFromDescriptor(descriptor: CommandDescriptor): CommandSchema;

package/dist/commands/descriptor/register.js

@@ -0,0 +1,113 @@
+import { toSchemaArgument, toSchemaOption } from './types.js';
+function deriveArgumentKey(syntax) {
+    const normalized = syntax.trim().replace(/^[<[.]+|[>\].]+$/g, '');
+    return normalized.replace(/[-_]+([a-zA-Z0-9])/g, (_match, segment) => segment.toUpperCase());
+}
+function addArgument(command, argument) {
+    command.argument(argument.syntax, argument.description);
+}
+function addOption(command, option) {
+    if (option.required) {
+        if (option.parser && option.defaultValue !== undefined) {
+            command.requiredOption(option.flags, option.description, option.parser, option.defaultValue);
+            return;
+        }
+        if (option.parser) {
+            command.requiredOption(option.flags, option.description, option.parser);
+            return;
+        }
+        if (option.defaultValue !== undefined) {
+            command.requiredOption(option.flags, option.description, option.defaultValue);
+            return;
+        }
+        command.requiredOption(option.flags, option.description);
+        return;
+    }
+    if (option.parser && option.defaultValue !== undefined) {
+        command.option(option.flags, option.description, option.parser, option.defaultValue);
+        return;
+    }
+    if (option.parser) {
+        command.option(option.flags, option.description, option.parser);
+        return;
+    }
+    if (option.defaultValue !== undefined) {
+        command.option(option.flags, option.description, option.defaultValue);
+        return;
+    }
+    command.option(option.flags, option.description);
+}
+function buildExecutionContext(command, descriptors, values) {
+    const namedArgs = Object.fromEntries(descriptors.map((descriptor, index) => [deriveArgumentKey(descriptor.syntax), values[index]]));
+    return {
+        command,
+        globals: (command.optsWithGlobals?.() ?? {}),
+        options: (command.opts() ?? {}),
+        args: namedArgs,
+    };
+}
+export function registerCommandGroup(program, group) {
+    const parent = program.command(group.name).description(group.description);
+    for (const descriptor of group.commands) {
+        const subcommand = parent.command(descriptor.name).description(descriptor.description);
+        const argumentsList = descriptor.arguments ?? [];
+        for (const argument of argumentsList) {
+            addArgument(subcommand, argument);
+        }
+        for (const option of descriptor.options ?? []) {
+            addOption(subcommand, option);
+        }
+        subcommand.action(async (...actionArgs) => {
+            const command = actionArgs[actionArgs.length - 1];
+            const positionalValues = actionArgs.slice(0, argumentsList.length);
+            await descriptor.action(buildExecutionContext(command, argumentsList, positionalValues));
+        });
+    }
+    parent.action((_options, command) => {
+        command.outputHelp();
+    });
+    return parent;
+}
+function buildCommandInvocation(groupName, descriptor) {
+    return `dino ${groupName} ${descriptor.name}`.trimEnd();
+}
+function registerCommandDescriptor(command, descriptor) {
+    const argumentsList = descriptor.arguments ?? [];
+    for (const argument of argumentsList) {
+        addArgument(command, argument);
+    }
+    for (const option of descriptor.options ?? []) {
+        addOption(command, option);
+    }
+    command.action(async (...actionArgs) => {
+        const currentCommand = actionArgs[actionArgs.length - 1];
+        const positionalValues = actionArgs.slice(0, argumentsList.length);
+        await descriptor.action(buildExecutionContext(currentCommand, argumentsList, positionalValues));
+    });
+    return command;
+}
+export function registerStandaloneCommand(program, descriptor) {
+    const command = program.command(descriptor.name).description(descriptor.description);
+    return registerCommandDescriptor(command, descriptor);
+}
+export function commandSchemaFromDescriptor(groupName, descriptor) {
+    return {
+        ...descriptor.schema,
+        command: buildCommandInvocation(groupName, descriptor),
+        summary: descriptor.description,
+        ...(descriptor.arguments?.length ? { arguments: descriptor.arguments.map(toSchemaArgument) } : {}),
+        ...(descriptor.options?.length ? { options: descriptor.options.map(toSchemaOption) } : {}),
+    };
+}
+export function commandSchemasFromGroupDescriptor(group) {
+    return group.commands.map((descriptor) => commandSchemaFromDescriptor(group.name, descriptor));
+}
+export function standaloneCommandSchemaFromDescriptor(descriptor) {
+    return {
+        ...descriptor.schema,
+        command: `dino ${descriptor.name}`,
+        summary: descriptor.description,
+        ...(descriptor.arguments?.length ? { arguments: descriptor.arguments.map(toSchemaArgument) } : {}),
+        ...(descriptor.options?.length ? { options: descriptor.options.map(toSchemaOption) } : {}),
+    };
+}

package/dist/commands/descriptor/types.d.ts

@@ -0,0 +1,37 @@
+import type { Command } from 'commander';
+import type { CommandSchema, CommandSchemaArgument, CommandSchemaOption } from '../schema/types.js';
+export type CommandOptionDescriptor = {
+    flags: string;
+    description: string;
+    type?: 'string' | 'number' | 'boolean' | 'string[]';
+    required?: boolean;
+    parser?: (value: string, previous: unknown) => unknown;
+    defaultValue?: unknown;
+    enum?: string[];
+};
+export type CommandArgumentDescriptor = {
+    syntax: string;
+    description: string;
+};
+export type CommandExecutionContext = {
+    command: Command;
+    globals: Record<string, unknown>;
+    options: Record<string, unknown>;
+    args: Record<string, string | undefined>;
+};
+export type CommandDescriptorSchema = Omit<CommandSchema, 'command' | 'summary' | 'arguments' | 'options'>;
+export type CommandDescriptor = {
+    name: string;
+    description: string;
+    arguments?: CommandArgumentDescriptor[];
+    options?: CommandOptionDescriptor[];
+    schema: CommandDescriptorSchema;
+    action: (context: CommandExecutionContext) => Promise<void> | void;
+};
+export type CommandGroupDescriptor = {
+    name: string;
+    description: string;
+    commands: CommandDescriptor[];
+};
+export declare function toSchemaArgument(argument: CommandArgumentDescriptor): CommandSchemaArgument;
+export declare function toSchemaOption(option: CommandOptionDescriptor): CommandSchemaOption;

package/dist/commands/descriptor/types.js

@@ -0,0 +1,17 @@
+export function toSchemaArgument(argument) {
+    return {
+        name: argument.syntax,
+        required: argument.syntax.trim().startsWith('<'),
+        description: argument.description,
+    };
+}
+export function toSchemaOption(option) {
+    return {
+        name: option.flags,
+        description: option.description,
+        ...(option.type ? { type: option.type } : {}),
+        ...(option.required ? { required: true } : {}),
+        ...(option.defaultValue !== undefined ? { defaultValue: option.defaultValue } : {}),
+        ...(option.enum ? { enum: option.enum } : {}),
+    };
+}

package/dist/commands/graph/index.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare const graphCommandGroup: CommandGroupDescriptor;
 export declare function registerGraphCommands(program: Command): void;