@hithink-tech/hithink-finance-cli 0.1.0

package/dist/commands/market/local.js

@@ -0,0 +1,97 @@
+import { localizeText } from '../../cli/i18n.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { exportQuery, queryReadOnly } from '../../application/use-cases/local-query.js';
+import { openDatabase } from '../../infrastructure/duckdb/connection.js';
+import { renderResult } from '../../output/renderer.js';
+import { chooseSource } from '../../application/source-policy.js';
+import { CliError } from '../../contracts/errors.js';
+function quote(value) {
+    return value.replaceAll("'", "''");
+}
+function assertDate(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/u.test(value))
+        throw new CliError({
+            code: 'CLI_BAD_ARGUMENT',
+            category: 'validation',
+            message: 'dates must use YYYY-MM-DD',
+            hint: 'Pass dates like 2026-07-09.',
+            retryable: false,
+            exitCode: 2,
+        });
+}
+export function registerLocalMarketCommands(program, context, fallbackDbPath) {
+    const market = program.commands.find((command) => command.name() === 'market');
+    if (market === undefined)
+        throw new Error('market command group is not registered');
+    const panel = market
+        .command('panel')
+        .description(localizeText(context.language, 'Export a local full-market panel'))
+        .requiredOption('--start <date>')
+        .requiredOption('--end <date>')
+        .requiredOption('--output <path>')
+        .option('--file-format <format>', localizeText(context.language, 'ndjson, csv, or parquet'), 'parquet');
+    panel.action(async () => {
+        const options = panel.opts();
+        assertDate(options.start);
+        assertDate(options.end);
+        chooseSource({
+            kind: 'panel',
+            requested: panel.optsWithGlobals().source ?? 'auto',
+        }, { exists: true, coversWindow: true });
+        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 globals = panel.optsWithGlobals();
+        const opened = await openDatabase(globals.db ?? process.env.HITHINK_FINANCE_DB_PATH ?? fallbackDbPath);
+        try {
+            const sql = `SELECT * FROM v_daily_qfq WHERE date BETWEEN DATE '${options.start}' AND DATE '${options.end}' ORDER BY date,thscode`;
+            const count = await exportQuery(opened.connection, sql, options.output, options.fileFormat);
+            await renderResult(successEnvelope('market.panel', { path: options.output, format: options.fileFormat }, { requestId: context.requestId, source: 'local', count }), context);
+        }
+        finally {
+            opened.close();
+        }
+    });
+    const factors = market
+        .command('adjustment-factors')
+        .description(localizeText(context.language, 'Query local daily adjustment factors'))
+        .requiredOption('--thscode <code>')
+        .option('--start <date>')
+        .option('--end <date>');
+    factors.action(async () => {
+        const options = factors.opts();
+        if (options.start !== undefined)
+            assertDate(options.start);
+        if (options.end !== undefined)
+            assertDate(options.end);
+        chooseSource({
+            kind: 'factors',
+            requested: factors.optsWithGlobals().source ?? 'auto',
+        }, { exists: true, coversWindow: true });
+        const filters = [`thscode='${quote(options.thscode)}'`];
+        if (options.start !== undefined)
+            filters.push(`date >= DATE '${options.start}'`);
+        if (options.end !== undefined)
+            filters.push(`date <= DATE '${options.end}'`);
+        const globals = factors.optsWithGlobals();
+        const opened = await openDatabase(globals.db ?? process.env.HITHINK_FINANCE_DB_PATH ?? fallbackDbPath);
+        try {
+            const rows = await queryReadOnly(opened.connection, `SELECT * FROM calc_adjust_factor_daily WHERE ${filters.join(' AND ')} ORDER BY date`);
+            await renderResult(successEnvelope('market.adjustment-factors', rows, {
+                requestId: context.requestId,
+                source: 'local',
+                count: rows.length,
+            }), context);
+        }
+        finally {
+            opened.close();
+        }
+    });
+}
+//# sourceMappingURL=local.js.map

package/dist/commands/remote.d.ts

@@ -0,0 +1,11 @@
+import { type Command } from 'commander';
+import type { CliContext } from '../cli/context.js';
+import type { RemoteCapabilityDescriptor } from '../contracts/remote-capabilities.js';
+import type { ApiKeyAuthProvider } from '../infrastructure/credentials/api-key-provider.js';
+export interface RemoteCommandDependencies {
+    authProvider: ApiKeyAuthProvider;
+    baseUrl: string;
+    defaultDbPath: string;
+}
+export declare function registerRemoteCapabilityGroup(program: Command, groupName: string, capabilities: readonly RemoteCapabilityDescriptor[], context: CliContext, dependencies: RemoteCommandDependencies): void;
+//# sourceMappingURL=remote.d.ts.map

package/dist/commands/remote.js

@@ -0,0 +1,195 @@
+import { InvalidArgumentError, Option } from 'commander';
+import { localizeText } from '../cli/i18n.js';
+import { successEnvelope } from '../contracts/envelope.js';
+import { CliError } from '../contracts/errors.js';
+import { executeRemoteQuery } from '../application/use-cases/remote-query.js';
+import { FuyaoClient } from '../infrastructure/fuyao/client.js';
+import { renderResult } from '../output/renderer.js';
+import { chooseSource } from '../application/source-policy.js';
+import { openDatabase } from '../infrastructure/duckdb/connection.js';
+import { getHistory } from '../application/use-cases/market-history.js';
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { readStdin } from '../infrastructure/filesystem/stdin.js';
+import { renderJson } from '../output/json.js';
+function integer(value) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        throw new InvalidArgumentError('expected a safe integer');
+    return parsed;
+}
+function addDescriptorOption(command, descriptor, context) {
+    const option = new Option(descriptor.flags, localizeText(context.language, descriptor.description));
+    if (descriptor.type === 'integer')
+        option.argParser(integer);
+    if (descriptor.flags.startsWith('--thscodes '))
+        option.argParser((value, previous) => previous === undefined ? value : `${previous},${value}`);
+    if (descriptor.choices !== undefined)
+        option.choices([...descriptor.choices]);
+    if (descriptor.defaultValue !== undefined)
+        option.default(descriptor.defaultValue);
+    if (descriptor.required === true)
+        option.makeOptionMandatory();
+    command.addOption(option);
+}
+function normalizedCodes(...inputs) {
+    const codes = inputs
+        .flatMap((input) => input?.split(/[\s,]+/u) ?? [])
+        .map((code) => code.trim())
+        .filter(Boolean);
+    return codes.length === 0 ? undefined : [...new Set(codes)].join(',');
+}
+async function writeOutputEnvelope(outputPath, envelope) {
+    const absolutePath = path.resolve(process.cwd(), outputPath);
+    await mkdir(path.dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, renderJson(envelope), 'utf8');
+    return absolutePath;
+}
+export function registerRemoteCapabilityGroup(program, groupName, capabilities, context, dependencies) {
+    const group = program
+        .command(groupName)
+        .description(localizeText(context.language, `${groupName} remote data commands`));
+    for (const capability of capabilities) {
+        const leaf = group
+            .command(capability.command[1])
+            .description(localizeText(context.language, capability.description));
+        for (const option of capability.options)
+            addDescriptorOption(leaf, option, context);
+        leaf.option('--output <path>', localizeText(context.language, 'write the full JSON response envelope to a file'));
+        const acceptsMultipleCodes = capability.options.some((option) => option.flags.startsWith('--thscodes '));
+        if (acceptsMultipleCodes) {
+            leaf.option('--codes-file <path>', localizeText(context.language, 'read thscodes from a comma/newline-delimited file'));
+            leaf.option('--codes-stdin', localizeText(context.language, 'read thscodes from stdin'));
+        }
+        leaf.action(async () => {
+            const raw = leaf.opts();
+            const stdinGlobals = leaf.optsWithGlobals();
+            if (raw.codesStdin === true && stdinGlobals.apiKeyStdin === true)
+                throw new CliError({
+                    code: 'CLI_CONFLICTING_ARGUMENTS',
+                    category: 'validation',
+                    message: '--codes-stdin and --api-key-stdin cannot be used together.',
+                    hint: 'Store the key with `auth login --api-key-stdin`, then pipe codes.',
+                    retryable: false,
+                    exitCode: 2,
+                });
+            if (raw.codesFile !== undefined && raw.codesStdin === true)
+                throw new CliError({
+                    code: 'CLI_CONFLICTING_ARGUMENTS',
+                    category: 'validation',
+                    message: '--codes-file and --codes-stdin cannot be used together.',
+                    hint: 'Choose one batch-code input method.',
+                    retryable: false,
+                    exitCode: 2,
+                });
+            const fileCodes = raw.codesFile === undefined ? undefined : await readFile(raw.codesFile, 'utf8');
+            const stdinCodes = raw.codesStdin === true ? await readStdin() : undefined;
+            const schemaInput = { ...raw };
+            delete schemaInput.codesFile;
+            delete schemaInput.codesStdin;
+            delete schemaInput.output;
+            const combinedCodes = normalizedCodes(raw.thscodes, fileCodes, stdinCodes);
+            if (combinedCodes !== undefined)
+                schemaInput.thscodes = combinedCodes;
+            const parsed = capability.inputSchema.safeParse(schemaInput);
+            if (!parsed.success) {
+                throw new CliError({
+                    code: 'CLI_BAD_ARGUMENT',
+                    category: 'validation',
+                    message: parsed.error.issues.map((issue) => issue.message).join('; '),
+                    hint: `Run \`hithink-finance ${capability.command.join(' ')} --help\` and correct the arguments.`,
+                    retryable: false,
+                    exitCode: 2,
+                });
+            }
+            const globals = leaf.optsWithGlobals();
+            const explicitApiKey = globals.apiKeyStdin === true ? (await readStdin()).trim() : globals.apiKey;
+            const requested = globals.source ?? 'auto';
+            if (capability.id === 'market.history') {
+                const input = parsed.data;
+                const databasePath = globals.db ?? process.env.HITHINK_FINANCE_DB_PATH ?? dependencies.defaultDbPath;
+                const exists = await stat(databasePath)
+                    .then((value) => value.isFile())
+                    .catch(() => false);
+                let coversWindow = false;
+                if (exists) {
+                    const opened = await openDatabase(databasePath);
+                    try {
+                        const start = new Date(input.startMs).toISOString().slice(0, 10);
+                        const end = new Date(input.endMs).toISOString().slice(0, 10);
+                        const coverage = await opened.connection.runAndReadAll('SELECT min(date)::VARCHAR,max(date)::VARCHAR FROM raw_kline_daily');
+                        const row = coverage.getRowsJson()[0];
+                        coversWindow = String(row?.[0] ?? '') <= start && String(row?.[1] ?? '') >= end;
+                        const source = chooseSource({ kind: 'history', requested, symbolCount: 1 }, { exists, coversWindow });
+                        if (source === 'local') {
+                            const rows = await getHistory(opened.connection, {
+                                thscodes: [input.thscode],
+                                start,
+                                end,
+                                adjust: input.adjust,
+                            });
+                            const envelope = successEnvelope(capability.id, rows, {
+                                source: 'local',
+                                requestId: context.requestId,
+                                count: rows.length,
+                            });
+                            if (raw.output !== undefined) {
+                                const outputPath = await writeOutputEnvelope(raw.output, envelope);
+                                await renderResult(successEnvelope(capability.id, { path: outputPath, format: 'json', count: rows.length }, {
+                                    source: 'local',
+                                    requestId: context.requestId,
+                                    count: rows.length,
+                                }), context);
+                            }
+                            else {
+                                await renderResult(envelope, context);
+                            }
+                            return;
+                        }
+                    }
+                    finally {
+                        opened.close();
+                    }
+                }
+                else {
+                    chooseSource({ kind: 'history', requested, symbolCount: 1 }, { exists, coversWindow });
+                }
+            }
+            else if (requested === 'local') {
+                chooseSource({
+                    kind: capability.command[0] === 'financials'
+                        ? 'financials'
+                        : capability.command[0] === 'index'
+                            ? 'index'
+                            : capability.command[0] === 'special'
+                                ? 'special'
+                                : capability.command[1] === 'calendar'
+                                    ? 'calendar'
+                                    : 'snapshot',
+                    requested,
+                }, { exists: false, coversWindow: false });
+            }
+            const auth = await dependencies.authProvider.resolve(globals.profile ?? 'default', explicitApiKey);
+            const result = await executeRemoteQuery(capability, parsed.data, new FuyaoClient({ baseUrl: dependencies.baseUrl, auth }));
+            const count = result.data !== null &&
+                typeof result.data === 'object' &&
+                'item' in result.data &&
+                Array.isArray(result.data.item)
+                ? result.data.item.length
+                : undefined;
+            const meta = {
+                source: 'remote',
+                requestId: result.requestId ?? context.requestId,
+                ...(count === undefined ? {} : { count }),
+            };
+            const envelope = successEnvelope(capability.id, result.data, meta);
+            if (raw.output !== undefined) {
+                const outputPath = await writeOutputEnvelope(raw.output, envelope);
+                await renderResult(successEnvelope(capability.id, { path: outputPath, format: 'json', count }, meta), context);
+                return;
+            }
+            await renderResult(envelope, context);
+        });
+    }
+}
+//# sourceMappingURL=remote.js.map

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

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

package/dist/commands/skills/index.js

@@ -0,0 +1,43 @@
+import { localizeText } from '../../cli/i18n.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { CliError } from '../../contracts/errors.js';
+import { removeSkills, syncSkills } from '../../infrastructure/skills/installer.js';
+import { renderResult } from '../../output/renderer.js';
+export function registerSkillsCommands(program, context, packageRoot) {
+    const skills = program
+        .command('skills')
+        .description(localizeText(context.language, 'Manage Agent Skills'));
+    skills
+        .command('status')
+        .action(async () => renderResult(successEnvelope('skills.status', { canonical: `${packageRoot}/skills`, managed: true }, { requestId: context.requestId }), context));
+    skills
+        .command('sync')
+        .option('--repair')
+        .action(async () => {
+        const result = await syncSkills(packageRoot);
+        if (result.code !== 0)
+            throw new CliError({
+                code: 'SKILLS_SYNC_PARTIAL',
+                category: 'internal',
+                message: 'One or more Agent Skill targets failed to synchronize.',
+                hint: 'Run `hithink-finance skills sync --repair` after checking Agent installations.',
+                retryable: true,
+                exitCode: 6,
+            });
+        await renderResult(successEnvelope('skills.sync', { synchronized: true }, { requestId: context.requestId }), context);
+    });
+    skills.command('remove').action(async () => {
+        const result = await removeSkills(packageRoot);
+        if (result.code !== 0)
+            throw new CliError({
+                code: 'SKILLS_REMOVE_PARTIAL',
+                category: 'internal',
+                message: 'One or more managed Agent Skills could not be removed.',
+                hint: 'Check Agent discovery directories and retry `hithink-finance skills remove`.',
+                retryable: true,
+                exitCode: 6,
+            });
+        await renderResult(successEnvelope('skills.remove', { removed: true }, { requestId: context.requestId }), context);
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/special/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 registerSpecialCommands(program: Command, context: CliContext, dependencies: RemoteCommandDependencies): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/special/index.js

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

package/dist/commands/symbol/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 registerSymbolCommands(program: Command, context: CliContext, dependencies: RemoteCommandDependencies): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/symbol/index.js

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

package/dist/commands/system/capabilities.d.ts

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

package/dist/commands/system/capabilities.js

@@ -0,0 +1,24 @@
+import { localizeText } from '../../cli/i18n.js';
+import { remoteCapabilities } from '../../contracts/remote-capabilities.js';
+import { localCapabilities } from '../../contracts/local-capabilities.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { renderResult } from '../../output/renderer.js';
+export function registerCapabilitiesCommand(program, context) {
+    program
+        .command('capabilities')
+        .description(localizeText(context.language, 'List machine-readable command capabilities'))
+        .action(async () => {
+        await renderResult(successEnvelope('capabilities', [
+            ...remoteCapabilities.map(({ id, command, endpoint, paging, window }) => ({
+                id,
+                command,
+                endpoint,
+                paging,
+                window,
+                source: 'remote',
+            })),
+            ...localCapabilities.map((item) => ({ ...item, source: 'local' })),
+        ], { requestId: context.requestId }), context);
+    });
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/commands/system/doctor.d.ts

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

package/dist/commands/system/doctor.js

@@ -0,0 +1,15 @@
+import { localizeText } from '../../cli/i18n.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { renderResult } from '../../output/renderer.js';
+export function registerDoctorCommand(program, context) {
+    program
+        .command('doctor')
+        .description(localizeText(context.language, 'Run local environment diagnostics'))
+        .action(async () => renderResult(successEnvelope('doctor', {
+        nodeVersion: process.versions.node,
+        platform: process.platform,
+        arch: process.arch,
+        apiKeyPresent: Boolean(process.env.HITHINK_FINANCE_API_KEY),
+    }, { requestId: context.requestId }), context));
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/system/schema.d.ts

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

package/dist/commands/system/schema.js

@@ -0,0 +1,47 @@
+import { localizeText } from '../../cli/i18n.js';
+import { remoteCapabilities, } from '../../contracts/remote-capabilities.js';
+import { localCapabilities } from '../../contracts/local-capabilities.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { CliError } from '../../contracts/errors.js';
+import { renderResult } from '../../output/renderer.js';
+const remoteOutputOption = {
+    flags: '--output <path>',
+    description: 'write the full JSON response envelope to a file',
+    type: 'string',
+};
+export function registerSchemaCommand(program, context) {
+    program
+        .command('schema <command>')
+        .description(localizeText(context.language, 'Show a command contract'))
+        .action(async (id) => {
+        const capability = [...remoteCapabilities, ...localCapabilities].find((item) => item.id === id || item.command.join('.') === id);
+        if (capability === undefined)
+            throw new CliError({
+                code: 'CLI_UNKNOWN_COMMAND_SCHEMA',
+                category: 'validation',
+                message: `No schema exists for ${id}.`,
+                hint: 'Run capabilities first.',
+                retryable: false,
+                exitCode: 2,
+            });
+        await renderResult(successEnvelope('schema', isRemote(capability)
+            ? {
+                id: capability.id,
+                command: capability.command,
+                options: [...capability.options, remoteOutputOption],
+                paging: capability.paging,
+                window: capability.window,
+            }
+            : {
+                id: capability.id,
+                command: capability.command,
+                description: capability.description,
+                options: capability.options,
+                source: 'local',
+            }, { requestId: context.requestId }), context);
+    });
+}
+function isRemote(capability) {
+    return 'endpoint' in capability;
+}
+//# sourceMappingURL=schema.js.map

package/dist/commands/system/uninstall.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+import type { PackageMetadata } from '../../cli/program.js';
+import type { PlatformPaths } from '../../infrastructure/filesystem/platform-paths.js';
+import type { ApiKeyAuthProvider } from '../../infrastructure/credentials/api-key-provider.js';
+export declare function registerUninstallCommand(program: Command, context: CliContext, metadata: PackageMetadata, dependencies: {
+    packageRoot: string;
+    platformPaths: PlatformPaths;
+    authProvider: ApiKeyAuthProvider;
+}): void;
+//# sourceMappingURL=uninstall.d.ts.map

package/dist/commands/system/uninstall.js

@@ -0,0 +1,68 @@
+import { rm } from 'node:fs/promises';
+import { localizeText } from '../../cli/i18n.js';
+import { successEnvelope } from '../../contracts/envelope.js';
+import { CliError } from '../../contracts/errors.js';
+import { removeSkills } from '../../infrastructure/skills/installer.js';
+import { uninstallGlobalPackage } from '../../infrastructure/updater/install.js';
+import { renderResult } from '../../output/renderer.js';
+export function registerUninstallCommand(program, context, metadata, dependencies) {
+    const command = program
+        .command('uninstall')
+        .description(localizeText(context.language, 'Plan or run CLI uninstall cleanup'))
+        .option('--plan', localizeText(context.language, 'Show the uninstall plan without deleting anything'))
+        .option('--purge-data', localizeText(context.language, 'Delete local data during uninstall'))
+        .option('--purge-config', localizeText(context.language, 'Delete local configuration during uninstall'))
+        .option('--purge-credentials', localizeText(context.language, 'Delete all CLI-managed API key credentials'));
+    command.action(async () => {
+        const options = command.opts();
+        const globals = command.optsWithGlobals();
+        const npmCommand = ['npm', 'uninstall', '-g', metadata.name];
+        if (options.plan !== true) {
+            if (globals.yes !== true)
+                throw new CliError({
+                    code: 'CONFIRMATION_REQUIRED',
+                    category: 'validation',
+                    message: 'Uninstall requires explicit confirmation.',
+                    hint: 'Review `uninstall --plan`, then rerun with `--yes`.',
+                    retryable: false,
+                    exitCode: 2,
+                });
+            const skillResult = await removeSkills(dependencies.packageRoot);
+            if (skillResult.code !== 0)
+                throw new CliError({
+                    code: 'UNINSTALL_SKILLS_PARTIAL',
+                    category: 'internal',
+                    message: 'Managed Skills could not be fully removed.',
+                    hint: 'Run `hithink-finance skills remove` and retry.',
+                    retryable: true,
+                    exitCode: 6,
+                });
+            if (options.purgeData === true)
+                await rm(dependencies.platformPaths.dataDir, { recursive: true, force: true });
+            if (options.purgeConfig === true)
+                await rm(dependencies.platformPaths.configDir, { recursive: true, force: true });
+            if (options.purgeCredentials === true)
+                await dependencies.authProvider.logoutAll();
+            const npm = process.env.HITHINK_FINANCE_NPM_EXECUTABLE ??
+                (process.platform === 'win32' ? 'npm.cmd' : 'npm');
+            const code = await uninstallGlobalPackage(npm, metadata.name);
+            if (code !== 0)
+                throw new CliError({
+                    code: 'UNINSTALL_NPM_FAILED',
+                    category: 'internal',
+                    message: 'npm global uninstall failed.',
+                    hint: `Run ${npmCommand.join(' ')} manually.`,
+                    retryable: true,
+                    exitCode: 1,
+                });
+        }
+        await renderResult(successEnvelope('uninstall', {
+            planned: options.plan === true,
+            purgeData: options.purgeData === true,
+            purgeConfig: options.purgeConfig === true,
+            purgeCredentials: options.purgeCredentials === true,
+            npmCommand,
+        }, { requestId: context.requestId }), context);
+    });
+}
+//# sourceMappingURL=uninstall.js.map

package/dist/commands/system/update.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from 'commander';
+import type { CliContext } from '../../cli/context.js';
+import type { PackageMetadata } from '../../cli/program.js';
+import type { ResolvedConfig } from '../../application/config.js';
+import type { PlatformPaths } from '../../infrastructure/filesystem/platform-paths.js';
+export declare function registerUpdateCommand(program: Command, context: CliContext, metadata: PackageMetadata, dependencies: {
+    packageRoot: string;
+    platformPaths: PlatformPaths;
+    resolvedConfig: ResolvedConfig;
+}): void;
+//# sourceMappingURL=update.d.ts.map