@hithink-tech/hithink-finance-cli 0.1.0

package/dist/cli/program.js

@@ -0,0 +1,111 @@
+import { Command, CommanderError, Option } from 'commander';
+import { localizeText, translate } from './i18n.js';
+import { successEnvelope } from '../contracts/envelope.js';
+import { CliError } from '../contracts/errors.js';
+import { renderResult } from '../output/renderer.js';
+import { registerAuthCommands } from '../commands/auth/index.js';
+import { registerSymbolCommands } from '../commands/symbol/index.js';
+import { registerMarketCommands } from '../commands/market/index.js';
+import { registerSpecialCommands } from '../commands/special/index.js';
+import { registerFinancialCommands } from '../commands/financials/index.js';
+import { registerIndexCommands } from '../commands/index/index.js';
+import { registerCapabilitiesCommand } from '../commands/system/capabilities.js';
+import { registerSchemaCommand } from '../commands/system/schema.js';
+import { registerSkillsCommands } from '../commands/skills/index.js';
+import { registerUpdateCommand } from '../commands/system/update.js';
+import { registerUninstallCommand } from '../commands/system/uninstall.js';
+import { registerDoctorCommand } from '../commands/system/doctor.js';
+import { registerDataCommands } from '../commands/data/index.js';
+import { registerDbCommands } from '../commands/db/index.js';
+import { registerLocalMarketCommands } from '../commands/market/local.js';
+import { registerConfigCommands } from '../commands/config/index.js';
+export function createProgram(metadata, context, dependencies) {
+    const program = new Command();
+    program
+        .name('hithink-finance')
+        .description(translate(context.language, 'rootDescription'))
+        .addOption(new Option('--format <format>', localizeText(context.language, 'output format'))
+        .choices(['auto', 'json', 'ndjson', 'csv', 'table'])
+        .default(dependencies.resolvedConfig.format))
+        .addOption(new Option('--lang <lang>', localizeText(context.language, 'human interface language')).choices(['zh-CN', 'en']))
+        .option('--profile <name>', localizeText(context.language, 'configuration and credential profile'), dependencies.resolvedConfig.profile)
+        .option('--config <path>', localizeText(context.language, 'explicit JSON configuration file'))
+        .option('--api-key <value>', localizeText(context.language, 'API key for this process'))
+        .option('--api-key-stdin', localizeText(context.language, 'read an API key from stdin'))
+        .option('--no-input', localizeText(context.language, 'disable interactive input'))
+        .option('--yes', localizeText(context.language, 'confirm non-interactive operations'))
+        .option('--source <source>', localizeText(context.language, 'data source: auto, local, or remote'), 'auto')
+        .option('--db <path>', localizeText(context.language, 'local DuckDB path'))
+        .option('--request-id <id>', localizeText(context.language, 'caller-supplied correlation ID'))
+        .option('--debug', localizeText(context.language, 'enable diagnostic details on stderr'))
+        .option('--no-color', localizeText(context.language, 'disable terminal colors'))
+        .showHelpAfterError(false)
+        .exitOverride()
+        .configureOutput({
+        writeOut: (value) => context.stdout.write(value),
+        writeErr: () => undefined,
+    });
+    program.hook('preAction', (_root, action) => {
+        const options = action.optsWithGlobals();
+        if (options.apiKey !== undefined && options.apiKeyStdin === true)
+            throw new CliError({
+                code: 'CLI_CONFLICTING_ARGUMENTS',
+                category: 'validation',
+                message: '--api-key and --api-key-stdin cannot be used together.',
+                hint: 'Choose exactly one API key input method.',
+                retryable: false,
+                exitCode: 2,
+            });
+    });
+    const versionDescriptor = {
+        id: 'version',
+        path: ['version'],
+        describe: (language) => translate(language, 'versionDescription'),
+        register(root) {
+            root
+                .command('version')
+                .description(this.describe(context.language))
+                .action(async () => {
+                await renderResult(successEnvelope('version', { package: metadata.name, version: metadata.version, node: process.version }, { requestId: context.requestId }), context);
+            });
+        },
+    };
+    versionDescriptor.register(program);
+    registerAuthCommands(program, context, metadata, dependencies.authProvider);
+    registerConfigCommands(program, context, dependencies.resolvedConfig);
+    const remoteDependencies = {
+        authProvider: dependencies.authProvider,
+        baseUrl: dependencies.fuyaoBaseUrl,
+        defaultDbPath: dependencies.platformPaths.defaultDbPath,
+    };
+    registerSymbolCommands(program, context, remoteDependencies);
+    registerMarketCommands(program, context, remoteDependencies);
+    registerSpecialCommands(program, context, remoteDependencies);
+    registerFinancialCommands(program, context, remoteDependencies);
+    registerIndexCommands(program, context, remoteDependencies);
+    registerCapabilitiesCommand(program, context);
+    registerSchemaCommand(program, context);
+    registerSkillsCommands(program, context, dependencies.packageRoot);
+    registerUpdateCommand(program, context, metadata, dependencies);
+    registerUninstallCommand(program, context, metadata, dependencies);
+    registerDoctorCommand(program, context);
+    registerDataCommands(program, context, dependencies.platformPaths, {
+        ...remoteDependencies,
+        cliVersion: metadata.version,
+    });
+    registerDbCommands(program, context, dependencies.platformPaths.defaultDbPath);
+    registerLocalMarketCommands(program, context, dependencies.platformPaths.defaultDbPath);
+    return program;
+}
+export function commanderError(error, language) {
+    const isUnknownCommand = error.code === 'commander.unknownCommand';
+    return new CliError({
+        code: isUnknownCommand ? 'CLI_UNKNOWN_COMMAND' : 'CLI_BAD_ARGUMENT',
+        category: 'validation',
+        message: isUnknownCommand ? translate(language, 'unknownCommand') : error.message,
+        hint: translate(language, 'unknownCommandHint'),
+        retryable: false,
+        exitCode: 2,
+    });
+}
+//# sourceMappingURL=program.js.map

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

@@ -0,0 +1,10 @@
+import type { Readable } from 'node:stream';
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+import type { PackageMetadata } from '../../cli/program.js';
+import type { ApiKeyAuthProvider } from '../../infrastructure/credentials/api-key-provider.js';
+export declare function readHiddenApiKey(context: CliContext, input?: Readable & {
+    isTTY?: boolean;
+}): Promise<string>;
+export declare function registerAuthCommands(program: Command, context: CliContext, metadata: PackageMetadata, provider: ApiKeyAuthProvider): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/auth/index.js

@@ -0,0 +1,131 @@
+import { createInterface } from 'node:readline/promises';
+import { Writable } from 'node:stream';
+import { localizeText, translate } from '../../cli/i18n.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { CliError } from '../../contracts/errors.js';
+import { renderResult } from '../../output/renderer.js';
+import { readStdin } from '../../infrastructure/filesystem/stdin.js';
+const apiKeyHint = 'Get an API key at https://fuyao.aicubes.cn/admin, then run `hithink-finance auth login` and paste it into the hidden prompt. In non-interactive shells, use `hithink-finance auth login --api-key-stdin`.';
+export async function readHiddenApiKey(context, input = process.stdin) {
+    if (input.isTTY !== true) {
+        throw new CliError({
+            code: 'CLI_MISSING_ARGUMENT',
+            category: 'validation',
+            message: 'An API key is required in non-interactive mode.',
+            hint: apiKeyHint,
+            retryable: false,
+            exitCode: 2,
+        });
+    }
+    const muted = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
+    const readline = createInterface({ input, output: muted, terminal: true });
+    context.stderr.write(context.language === 'zh-CN'
+        ? [
+            '欢迎使用同花顺金融数据 CLI',
+            '',
+            '请前往同花顺金融数据服务官网，登录同花顺账号，创建您的 API Key，复制到当前终端后按 Enter 完成登录。',
+            '',
+            '官网 API Key 获取地址：https://fuyao.aicubes.cn/admin',
+            '',
+            '下方为隐藏输入模式，粘贴或输入时不会显示在终端中；输入完成后按 Enter。',
+            '',
+            '在此处填写您的 API Key：',
+        ].join('\n')
+        : [
+            'Welcome to HiThink Finance CLI',
+            '',
+            'Visit the HiThink Finance Data Service website, sign in with your HiThink account, create an API key, paste it into this terminal, then press Enter to finish login.',
+            '',
+            'API key page: https://fuyao.aicubes.cn/admin',
+            '',
+            'The prompt below uses hidden input mode. Typed or pasted characters will not be shown; press Enter when done.',
+            '',
+            'Paste your API key here:',
+        ].join('\n'));
+    try {
+        return await readline.question('');
+    }
+    finally {
+        readline.close();
+        context.stderr.write('\n');
+    }
+}
+export function registerAuthCommands(program, context, metadata, provider) {
+    const auth = program
+        .command('auth')
+        .description(localizeText(context.language, 'Manage API key authentication'));
+    const login = auth
+        .command('login')
+        .description(localizeText(context.language, 'Store an API key in the system credential store'));
+    login.action(async () => {
+        const options = login.optsWithGlobals();
+        if (options.apiKey !== undefined && options.apiKeyStdin === true) {
+            throw new CliError({
+                code: 'CLI_CONFLICTING_ARGUMENTS',
+                category: 'validation',
+                message: '--api-key and --api-key-stdin cannot be used together.',
+                hint: 'Choose exactly one API key input method.',
+                retryable: false,
+                exitCode: 2,
+            });
+        }
+        if (options.apiKey === undefined && options.apiKeyStdin !== true && options.input === false) {
+            throw new CliError({
+                code: 'CLI_MISSING_ARGUMENT',
+                category: 'validation',
+                message: 'An API key is required when --no-input is set.',
+                hint: apiKeyHint,
+                retryable: false,
+                exitCode: 2,
+            });
+        }
+        const profile = options.profile ?? 'default';
+        const existing = await provider.status(profile);
+        if (existing.configured) {
+            await renderResult(successEnvelope('auth.login', {
+                ...existing,
+                alreadyLoggedIn: true,
+                nextStep: translate(context.language, 'authLoginAlreadyConfigured'),
+            }, { requestId: context.requestId }), context);
+            return;
+        }
+        let apiKey;
+        if (options.apiKey !== undefined) {
+            context.stderr.write('Warning: --api-key may be visible in shell history and process listings. Prefer --api-key-stdin.\n');
+            apiKey = options.apiKey;
+        }
+        else if (options.apiKeyStdin === true) {
+            apiKey = await readStdin(process.stdin, { stripFinalNewlines: true });
+        }
+        else {
+            apiKey = await readHiddenApiKey(context);
+        }
+        const status = await provider.login({ profile, apiKey });
+        await renderResult(successEnvelope('auth.login', status, { requestId: context.requestId }), context);
+    });
+    const status = auth
+        .command('status')
+        .description(localizeText(context.language, 'Show whether an API key is configured'));
+    status.action(async () => {
+        const options = status.optsWithGlobals();
+        const result = await provider.status(options.profile ?? 'default');
+        await renderResult(successEnvelope('auth.status', result, { requestId: context.requestId }), context);
+    });
+    const logout = auth
+        .command('logout')
+        .description(localizeText(context.language, 'Delete API key credentials'))
+        .option('--all', localizeText(context.language, 'delete every hithink-finance profile'));
+    logout.action(async () => {
+        const options = logout.optsWithGlobals();
+        if (options.all === true)
+            await provider.logoutAll();
+        else
+            await provider.logout(options.profile ?? 'default');
+        await renderResult(successEnvelope('auth.logout', { removed: true, all: options.all === true, cliVersion: metadata.version }, { requestId: context.requestId }), context);
+    });
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,13 @@
+import type { ResolvedConfig } from '../../application/config.js';
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+export interface PublicConfig {
+    dbPath: string;
+    profile: string;
+    format: ResolvedConfig['format'];
+    language?: ResolvedConfig['language'];
+    updateCheck: boolean;
+}
+export declare function publicConfig(config: ResolvedConfig): PublicConfig;
+export declare function registerConfigCommands(program: Command, context: CliContext, config: ResolvedConfig): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/config/index.js

@@ -0,0 +1,26 @@
+import { localizeText } from '../../cli/i18n.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { renderResult } from '../../output/renderer.js';
+export function publicConfig(config) {
+    const result = {
+        dbPath: config.dbPath,
+        profile: config.profile,
+        format: config.format,
+        updateCheck: config.updateCheck,
+    };
+    if (config.language !== undefined)
+        result.language = config.language;
+    return result;
+}
+export function registerConfigCommands(program, context, config) {
+    const command = program
+        .command('config')
+        .description(localizeText(context.language, 'Inspect resolved non-secret configuration'));
+    command
+        .command('show')
+        .description(localizeText(context.language, 'Show resolved non-secret configuration'))
+        .action(async () => {
+        await renderResult(successEnvelope('config.show', publicConfig(config), { requestId: context.requestId }), context);
+    });
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,10 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+import type { PlatformPaths } from '../../infrastructure/filesystem/platform-paths.js';
+import type { ApiKeyAuthProvider } from '../../infrastructure/credentials/api-key-provider.js';
+export declare function registerDataCommands(program: Command, context: CliContext, paths: PlatformPaths, remote: {
+    authProvider: ApiKeyAuthProvider;
+    baseUrl: string;
+    cliVersion: string;
+}): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/data/index.js

@@ -0,0 +1,185 @@
+import { localizeText } from '../../cli/i18n.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { CliError } from '../../contracts/errors.js';
+import { openDatabase } from '../../infrastructure/duckdb/connection.js';
+import { applyMigrations, assertSchemaCompatibility, planMigrations, } from '../../infrastructure/duckdb/migrations.js';
+import { rebuildAdjustmentFactors } from '../../infrastructure/duckdb/factors.js';
+import { validateDatabase } from '../../infrastructure/duckdb/quality.js';
+import { renderResult } from '../../output/renderer.js';
+import { initializeData } from '../../application/use-cases/data-init.js';
+import { syncDataFromFuyao } from '../../application/use-cases/data-sync.js';
+import { cleanManagedCache } from '../../application/use-cases/data-clean.js';
+import { removeDatabase } from '../../application/use-cases/data-remove.js';
+import { mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { withExclusiveDataLock } from '../../infrastructure/filesystem/process-lock.js';
+function dbPath(command, fallback) {
+    return (command.optsWithGlobals().db ?? process.env.HITHINK_FINANCE_DB_PATH ?? fallback);
+}
+async function withDataLock(paths, command, cliVersion, action) {
+    await mkdir(paths.stateDir, { recursive: true });
+    return withExclusiveDataLock(path.join(paths.stateDir, 'data.lock'), { command, cliVersion }, action);
+}
+async function stdinText() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    return Buffer.concat(chunks).toString('utf8').trim();
+}
+export function registerDataCommands(program, context, paths, remote) {
+    const data = program
+        .command('data')
+        .description(localizeText(context.language, 'Manage local DuckDB data'));
+    const init = data
+        .command('init')
+        .description(localizeText(context.language, 'Initialize local data from a verified dump'))
+        .option('--kline <path>')
+        .option('--events <path>')
+        .option('--symbols <path>');
+    init.action(async () => withDataLock(paths, 'data.init', remote.cliVersion, async () => {
+        await mkdir(paths.dataDir, { recursive: true });
+        const db = await openDatabase(dbPath(init, paths.defaultDbPath));
+        try {
+            const options = init.opts();
+            const hasKline = options.kline !== undefined;
+            const hasEvents = options.events !== undefined;
+            if (hasKline !== hasEvents)
+                throw new CliError({
+                    code: 'CLI_BAD_ARGUMENT',
+                    category: 'validation',
+                    message: '--kline and --events must be provided together.',
+                    hint: 'Provide both local dump files, or omit both to initialize from Fuyao.',
+                    retryable: false,
+                    exitCode: 2,
+                });
+            const result = options.kline !== undefined && options.events !== undefined
+                ? {
+                    decision: 'FULL',
+                    factorRows: await initializeData(db.connection, {
+                        klinePath: options.kline,
+                        eventsPath: options.events,
+                        ...(options.symbols === undefined ? {} : { symbolsPath: options.symbols }),
+                        batchId: `local-${Date.now()}`,
+                        source: 'local-files',
+                    }),
+                }
+                : await syncDataFromFuyao(db.connection, {
+                    baseUrl: remote.baseUrl,
+                    apiKey: (await remote.authProvider.resolve(init.optsWithGlobals().profile ?? 'default', init.optsWithGlobals()
+                        .apiKeyStdin === true
+                        ? await stdinText()
+                        : init.optsWithGlobals().apiKey)).apiKey,
+                    cacheDir: paths.cacheDir,
+                });
+            await renderResult(successEnvelope('data.init', { initialized: true, path: db.path, ...result }, { requestId: context.requestId }), context);
+        }
+        finally {
+            db.close();
+        }
+    }));
+    const sync = data
+        .command('sync')
+        .description(localizeText(context.language, 'Synchronize local data'));
+    sync.action(async () => withDataLock(paths, 'data.sync', remote.cliVersion, async () => {
+        await mkdir(paths.dataDir, { recursive: true });
+        const db = await openDatabase(dbPath(sync, paths.defaultDbPath));
+        try {
+            const globals = sync.optsWithGlobals();
+            const auth = await remote.authProvider.resolve(globals.profile ?? 'default', globals.apiKeyStdin === true ? await stdinText() : globals.apiKey);
+            const result = await syncDataFromFuyao(db.connection, {
+                baseUrl: remote.baseUrl,
+                apiKey: auth.apiKey,
+                cacheDir: paths.cacheDir,
+            });
+            await renderResult(successEnvelope('data.sync', result, { requestId: context.requestId }), context);
+        }
+        finally {
+            db.close();
+        }
+    }));
+    data
+        .command('status')
+        .description(localizeText(context.language, 'Show local database status'))
+        .action(async () => {
+        const db = await openDatabase(dbPath(data, paths.defaultDbPath));
+        try {
+            const schema = await assertSchemaCompatibility(db.connection);
+            await renderResult(successEnvelope('data.status', { path: db.path, ...schema }, { requestId: context.requestId }), context);
+        }
+        finally {
+            db.close();
+        }
+    });
+    data
+        .command('validate')
+        .description(localizeText(context.language, 'Validate local data quality'))
+        .action(async () => {
+        const db = await openDatabase(dbPath(data, paths.defaultDbPath));
+        try {
+            await applyMigrations(db.connection);
+            await renderResult(successEnvelope('data.validate', await validateDatabase(db.connection), {
+                requestId: context.requestId,
+            }), context);
+        }
+        finally {
+            db.close();
+        }
+    });
+    data
+        .command('repair')
+        .description(localizeText(context.language, 'Rebuild derived factors'))
+        .action(async () => withDataLock(paths, 'data.repair', remote.cliVersion, async () => {
+        const db = await openDatabase(dbPath(data, paths.defaultDbPath));
+        try {
+            await applyMigrations(db.connection);
+            const factorRows = await rebuildAdjustmentFactors(db.connection);
+            await renderResult(successEnvelope('data.repair', { factorRows }, { requestId: context.requestId }), context);
+        }
+        finally {
+            db.close();
+        }
+    }));
+    const migrate = data
+        .command('migrate')
+        .description(localizeText(context.language, 'Plan or apply schema migrations'))
+        .option('--apply')
+        .option('--allow-heavy');
+    migrate.action(async () => withDataLock(paths, 'data.migrate', remote.cliVersion, async () => {
+        const db = await openDatabase(dbPath(migrate, paths.defaultDbPath));
+        try {
+            const options = migrate.opts();
+            const plan = await planMigrations(db.connection);
+            if (options.apply === true)
+                await applyMigrations(db.connection, undefined, {
+                    allowHeavy: options.allowHeavy === true,
+                });
+            await renderResult(successEnvelope('data.migrate', { applied: options.apply === true, versions: plan.map((item) => item.version) }, { requestId: context.requestId }), context);
+        }
+        finally {
+            db.close();
+        }
+    }));
+    const clean = data
+        .command('clean')
+        .description(localizeText(context.language, 'Clean managed download caches'))
+        .option('--cache');
+    clean.action(async () => {
+        await cleanManagedCache(paths.cacheDir, paths.cacheDir);
+        await renderResult(successEnvelope('data.clean', { cacheRemoved: true, path: paths.cacheDir }, { requestId: context.requestId }), context);
+    });
+    const remove = data
+        .command('remove')
+        .description(localizeText(context.language, 'Remove the explicitly confirmed database'))
+        .option('--plan');
+    remove.action(async () => withDataLock(paths, 'data.remove', remote.cliVersion, async () => {
+        const target = dbPath(remove, paths.defaultDbPath);
+        const globals = remove.optsWithGlobals();
+        const size = await stat(target)
+            .then((value) => value.size)
+            .catch(() => 0);
+        if (remove.opts().plan !== true)
+            await removeDatabase(target, target, globals.yes === true);
+        await renderResult(successEnvelope('data.remove', { path: target, size, removed: remove.opts().plan !== true }, { requestId: context.requestId }), context);
+    }));
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+export declare function registerDbCommands(program: Command, context: CliContext, fallback: string): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/db/index.js

@@ -0,0 +1,72 @@
+import { localizeText } from '../../cli/i18n.js';
+import { exportQuery, queryReadOnly } from '../../application/use-cases/local-query.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { CliError } from '../../contracts/errors.js';
+import { openDatabase } from '../../infrastructure/duckdb/connection.js';
+import { applyMigrations } from '../../infrastructure/duckdb/migrations.js';
+import { renderResult } from '../../output/renderer.js';
+function databasePath(command, fallback) {
+    return (command.optsWithGlobals().db ?? process.env.HITHINK_FINANCE_DB_PATH ?? fallback);
+}
+export function registerDbCommands(program, context, fallback) {
+    const db = program
+        .command('db')
+        .description(localizeText(context.language, 'Query the local DuckDB'));
+    db.command('describe')
+        .description(localizeText(context.language, 'Describe local database objects'))
+        .action(async () => {
+        const opened = await openDatabase(databasePath(db, fallback));
+        try {
+            await applyMigrations(opened.connection);
+            const rows = await queryReadOnly(opened.connection, "SELECT table_name,table_type FROM information_schema.tables WHERE table_schema='main' ORDER BY table_name");
+            await renderResult(successEnvelope('db.describe', rows, {
+                requestId: context.requestId,
+                count: rows.length,
+            }), context);
+        }
+        finally {
+            opened.close();
+        }
+    });
+    const query = db
+        .command('query')
+        .description(localizeText(context.language, 'Run a read-only SQL query'))
+        .requiredOption('--sql <sql>');
+    query.action(async () => {
+        const opened = await openDatabase(databasePath(query, fallback));
+        try {
+            const rows = await queryReadOnly(opened.connection, query.opts().sql);
+            await renderResult(successEnvelope('db.query', rows, { requestId: context.requestId, count: rows.length }), context);
+        }
+        finally {
+            opened.close();
+        }
+    });
+    const exportCommand = db
+        .command('export')
+        .description(localizeText(context.language, 'Export a read-only SQL query'))
+        .requiredOption('--sql <sql>')
+        .requiredOption('--output <path>')
+        .option('--file-format <format>', localizeText(context.language, 'ndjson, csv, or parquet'), 'ndjson');
+    exportCommand.action(async () => {
+        const options = exportCommand.opts();
+        if (!['ndjson', 'csv', 'parquet'].includes(options.fileFormat))
+            throw new CliError({
+                code: 'CLI_BAD_ARGUMENT',
+                category: 'validation',
+                message: '--file-format must be ndjson, csv, or parquet',
+                hint: 'Use --file-format ndjson, --file-format csv, or --file-format parquet.',
+                retryable: false,
+                exitCode: 2,
+            });
+        const opened = await openDatabase(databasePath(exportCommand, fallback));
+        try {
+            const count = await exportQuery(opened.connection, options.sql, options.output, options.fileFormat);
+            await renderResult(successEnvelope('db.export', { path: options.output, format: options.fileFormat, count }, { requestId: context.requestId }), context);
+        }
+        finally {
+            opened.close();
+        }
+    });
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+import { type RemoteCommandDependencies } from '../remote.js';
+export declare function registerFinancialCommands(program: Command, context: CliContext, dependencies: RemoteCommandDependencies): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/financials/index.js

@@ -0,0 +1,6 @@
+import { remoteCapabilities } from '../../contracts/remote-capabilities.js';
+import { registerRemoteCapabilityGroup } from '../remote.js';
+export function registerFinancialCommands(program, context, dependencies) {
+    registerRemoteCapabilityGroup(program, 'financials', remoteCapabilities.filter((item) => item.command[0] === 'financials'), context, dependencies);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+import { type RemoteCommandDependencies } from '../remote.js';
+export declare function registerIndexCommands(program: Command, context: CliContext, dependencies: RemoteCommandDependencies): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index/index.js

@@ -0,0 +1,6 @@
+import { remoteCapabilities } from '../../contracts/remote-capabilities.js';
+import { registerRemoteCapabilityGroup } from '../remote.js';
+export function registerIndexCommands(program, context, dependencies) {
+    registerRemoteCapabilityGroup(program, 'index', remoteCapabilities.filter((item) => item.command[0] === 'index'), context, dependencies);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+import { type RemoteCommandDependencies } from '../remote.js';
+export declare function registerMarketCommands(program: Command, context: CliContext, dependencies: RemoteCommandDependencies): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/market/index.js

@@ -0,0 +1,6 @@
+import { remoteCapabilities } from '../../contracts/remote-capabilities.js';
+import { registerRemoteCapabilityGroup } from '../remote.js';
+export function registerMarketCommands(program, context, dependencies) {
+    registerRemoteCapabilityGroup(program, 'market', remoteCapabilities.filter((item) => item.command[0] === 'market'), context, dependencies);
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/market/local.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+export declare function registerLocalMarketCommands(program: Command, context: CliContext, fallbackDbPath: string): void;
+//# sourceMappingURL=local.d.ts.map