@hithink-tech/hithink-finance-cli 0.1.0

package/dist/infrastructure/duckdb/quality.js

@@ -0,0 +1,56 @@
+async function count(connection, sql) {
+    const reader = await connection.runAndReadAll(sql);
+    return Number(reader.getRowsJson()[0]?.[0] ?? 0);
+}
+export async function validateDatabase(connection) {
+    const checks = [
+        [
+            'QUALITY_DUPLICATE_KEY',
+            'duplicate daily keys',
+            `SELECT count(*) FROM (SELECT thscode,date FROM raw_kline_daily GROUP BY thscode,date HAVING count(*)>1)`,
+        ],
+        [
+            'QUALITY_INVALID_OHLC',
+            'invalid OHLC relationships',
+            `SELECT count(*) FROM raw_kline_daily WHERE high<GREATEST(open,close,low) OR low>LEAST(open,close,high)`,
+        ],
+        [
+            'QUALITY_NEGATIVE_VOLUME',
+            'negative volume or amount',
+            `SELECT count(*) FROM raw_kline_daily WHERE volume<0 OR amount<0`,
+        ],
+        [
+            'QUALITY_FACTOR_GAP',
+            'missing adjustment factors',
+            `SELECT count(*) FROM raw_kline_daily k LEFT JOIN calc_adjust_factor_daily f USING(thscode,date) WHERE f.date IS NULL`,
+        ],
+        [
+            'QUALITY_VIEW_MISMATCH',
+            'stable view row mismatch',
+            `SELECT abs((SELECT count(*) FROM raw_kline_daily)-(SELECT count(*) FROM v_daily))`,
+        ],
+        [
+            'QUALITY_SYMBOL_COVERAGE',
+            'daily rows without symbols',
+            `SELECT count(*) FROM raw_kline_daily k LEFT JOIN dim_symbol s USING(thscode) WHERE s.thscode IS NULL`,
+        ],
+        [
+            'QUALITY_INCOMPLETE_BATCH',
+            'incomplete import batches',
+            `SELECT count(*) FROM _import_batches WHERE status<>'complete'`,
+        ],
+        [
+            'QUALITY_INVALID_DATE',
+            'dates outside supported range',
+            `SELECT count(*) FROM raw_kline_daily WHERE date<DATE '1990-01-01' OR date>CURRENT_DATE`,
+        ],
+    ];
+    const issues = [];
+    for (const [code, message, sql] of checks) {
+        const issueCount = await count(connection, sql);
+        if (issueCount > 0)
+            issues.push({ code, count: issueCount, message });
+    }
+    return { ok: issues.length === 0, issues };
+}
+//# sourceMappingURL=quality.js.map

package/dist/infrastructure/duckdb/schema.d.ts

@@ -0,0 +1,4 @@
+export declare const CORE_TABLES: readonly ["_meta", "_import_batches", "raw_kline_daily", "raw_adjustment_events", "dim_symbol", "calc_adjust_factor_daily", "stg_kline_daily", "stg_adjustment_events", "stg_symbol"];
+export declare const STABLE_VIEWS: readonly ["v_symbol", "v_daily", "v_daily_qfq", "v_daily_hfq"];
+export declare const SUPPORTED_SCHEMA_VERSION = 1;
+//# sourceMappingURL=schema.d.ts.map

package/dist/infrastructure/duckdb/schema.js

@@ -0,0 +1,14 @@
+export const CORE_TABLES = [
+    '_meta',
+    '_import_batches',
+    'raw_kline_daily',
+    'raw_adjustment_events',
+    'dim_symbol',
+    'calc_adjust_factor_daily',
+    'stg_kline_daily',
+    'stg_adjustment_events',
+    'stg_symbol',
+];
+export const STABLE_VIEWS = ['v_symbol', 'v_daily', 'v_daily_qfq', 'v_daily_hfq'];
+export const SUPPORTED_SCHEMA_VERSION = 1;
+//# sourceMappingURL=schema.js.map

package/dist/infrastructure/filesystem/atomic-file.d.ts

@@ -0,0 +1,2 @@
+export declare function writeJsonAtomic(targetPath: string, value: unknown): Promise<void>;
+//# sourceMappingURL=atomic-file.d.ts.map

package/dist/infrastructure/filesystem/atomic-file.js

@@ -0,0 +1,38 @@
+import { mkdir, open, rename, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+function errorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+export async function writeJsonAtomic(targetPath, value) {
+    const absoluteTarget = path.resolve(targetPath);
+    const directory = path.dirname(absoluteTarget);
+    const temporaryPath = path.join(directory, `.${path.basename(absoluteTarget)}.${process.pid}.${randomUUID()}.tmp`);
+    await mkdir(directory, { recursive: true });
+    const handle = await open(temporaryPath, 'wx', 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporaryPath, absoluteTarget);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (process.platform !== 'win32' || (code !== 'EEXIST' && code !== 'EPERM')) {
+            await unlink(temporaryPath).catch(() => undefined);
+            throw error;
+        }
+        await unlink(absoluteTarget).catch((unlinkError) => {
+            if (errorCode(unlinkError) !== 'ENOENT')
+                throw unlinkError;
+        });
+        await rename(temporaryPath, absoluteTarget);
+    }
+}
+//# sourceMappingURL=atomic-file.js.map

package/dist/infrastructure/filesystem/platform-paths.d.ts

@@ -0,0 +1,15 @@
+export interface PlatformPaths {
+    configDir: string;
+    dataDir: string;
+    cacheDir: string;
+    stateDir: string;
+    userConfigFile: string;
+    defaultDbPath: string;
+}
+export interface PlatformPathInput {
+    platform?: NodeJS.Platform;
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function createPlatformPaths(input?: PlatformPathInput): PlatformPaths;
+//# sourceMappingURL=platform-paths.d.ts.map

package/dist/infrastructure/filesystem/platform-paths.js

@@ -0,0 +1,42 @@
+import os from 'node:os';
+import path from 'node:path';
+export function createPlatformPaths(input = {}) {
+    const platform = input.platform ?? process.platform;
+    const homeDir = input.homeDir ?? os.homedir();
+    const env = input.env ?? process.env;
+    const pathApi = platform === 'win32' ? path.win32 : path.posix;
+    let configDir;
+    let dataDir;
+    let cacheDir;
+    let stateDir;
+    if (platform === 'win32') {
+        const roaming = env.APPDATA ?? pathApi.join(homeDir, 'AppData', 'Roaming');
+        const local = env.LOCALAPPDATA ?? pathApi.join(homeDir, 'AppData', 'Local');
+        configDir = pathApi.join(roaming, 'hithink-finance');
+        dataDir = pathApi.join(local, 'hithink-finance', 'data');
+        cacheDir = pathApi.join(local, 'hithink-finance', 'cache');
+        stateDir = pathApi.join(local, 'hithink-finance', 'state');
+    }
+    else if (platform === 'darwin') {
+        const applicationSupport = pathApi.join(homeDir, 'Library', 'Application Support');
+        configDir = pathApi.join(applicationSupport, 'hithink-finance');
+        dataDir = pathApi.join(applicationSupport, 'hithink-finance', 'data');
+        cacheDir = pathApi.join(homeDir, 'Library', 'Caches', 'hithink-finance');
+        stateDir = pathApi.join(applicationSupport, 'hithink-finance', 'state');
+    }
+    else {
+        configDir = pathApi.join(env.XDG_CONFIG_HOME ?? pathApi.join(homeDir, '.config'), 'hithink-finance');
+        dataDir = pathApi.join(env.XDG_DATA_HOME ?? pathApi.join(homeDir, '.local', 'share'), 'hithink-finance');
+        cacheDir = pathApi.join(env.XDG_CACHE_HOME ?? pathApi.join(homeDir, '.cache'), 'hithink-finance');
+        stateDir = pathApi.join(env.XDG_STATE_HOME ?? pathApi.join(homeDir, '.local', 'state'), 'hithink-finance');
+    }
+    return {
+        configDir,
+        dataDir,
+        cacheDir,
+        stateDir,
+        userConfigFile: pathApi.join(configDir, 'config.json'),
+        defaultDbPath: pathApi.join(dataDir, 'market.duckdb'),
+    };
+}
+//# sourceMappingURL=platform-paths.js.map

package/dist/infrastructure/filesystem/process-lock.d.ts

@@ -0,0 +1,6 @@
+export interface LockMetadata {
+    command: string;
+    cliVersion: string;
+}
+export declare function withExclusiveDataLock<T>(lockPath: string, metadata: LockMetadata, action: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=process-lock.d.ts.map

package/dist/infrastructure/filesystem/process-lock.js

@@ -0,0 +1,56 @@
+import { hostname } from 'node:os';
+import { open, readFile, rm } from 'node:fs/promises';
+import { CliError } from '../../contracts/errors.js';
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function withExclusiveDataLock(lockPath, metadata, action) {
+    const payload = {
+        pid: process.pid,
+        host: hostname(),
+        command: metadata.command,
+        startedAt: new Date().toISOString(),
+        cliVersion: metadata.cliVersion,
+    };
+    let handle;
+    try {
+        handle = await open(lockPath, 'wx', 0o600);
+    }
+    catch (error) {
+        let existing;
+        try {
+            existing = JSON.parse(await readFile(lockPath, 'utf8'));
+        }
+        catch {
+            throw new CliError({
+                code: 'DATA_LOCK_CORRUPT',
+                category: 'local-data',
+                message: 'The data lock file is corrupted.',
+                hint: `Inspect and remove the lock file if no hithink-finance data command is running: ${lockPath}`,
+                retryable: false,
+                exitCode: 5,
+            });
+        }
+        if (typeof existing.pid === 'number' && !alive(existing.pid)) {
+            await rm(lockPath, { force: true });
+            return withExclusiveDataLock(lockPath, metadata, action);
+        }
+        throw error;
+    }
+    try {
+        await handle.writeFile(JSON.stringify(payload));
+        await handle.close();
+        return await action();
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+        await rm(lockPath, { force: true });
+    }
+}
+//# sourceMappingURL=process-lock.js.map

package/dist/infrastructure/filesystem/stdin.d.ts

@@ -0,0 +1,5 @@
+export interface ReadStdinOptions {
+    stripFinalNewlines?: boolean;
+}
+export declare function readStdin(input?: AsyncIterable<string | Buffer>, options?: ReadStdinOptions): Promise<string>;
+//# sourceMappingURL=stdin.d.ts.map

package/dist/infrastructure/filesystem/stdin.js

@@ -0,0 +1,9 @@
+export async function readStdin(input = process.stdin, options = {}) {
+    const chunks = [];
+    for await (const chunk of input) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    return options.stripFinalNewlines === true ? text.replace(/[\r\n]+$/u, '') : text;
+}
+//# sourceMappingURL=stdin.js.map

package/dist/infrastructure/fuyao/client.d.ts

@@ -0,0 +1,31 @@
+import type { AuthSession } from '../../application/ports/auth-provider.js';
+import type { ZodType } from 'zod';
+export interface FuyaoRequest<T> {
+    path: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    schema: ZodType<T>;
+}
+export interface FuyaoSuccess<T> {
+    data: T;
+    requestId?: string;
+}
+export interface FuyaoClientOptions {
+    baseUrl: string;
+    auth: AuthSession;
+    timeoutMs?: number;
+    maxAttempts?: number;
+    fetch?: typeof globalThis.fetch;
+    sleep?: (milliseconds: number) => Promise<void>;
+    random?: () => number;
+}
+export declare class FuyaoClient {
+    private readonly options;
+    private readonly timeoutMs;
+    private readonly maxAttempts;
+    private readonly fetchImplementation;
+    private readonly sleep;
+    private readonly random;
+    constructor(options: FuyaoClientOptions);
+    request<T>(request: FuyaoRequest<T>): Promise<FuyaoSuccess<T>>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/infrastructure/fuyao/client.js

@@ -0,0 +1,145 @@
+import { CliError } from '../../contracts/errors.js';
+import { fuyaoEnvelopeSchema } from './envelope.js';
+import { defaultSleep, parseRetryAfter, RETRYABLE_BUSINESS_CODES, retryDelayMs } from './retry.js';
+function cliError(options, requestId) {
+    const complete = { ...options };
+    if (requestId !== undefined)
+        complete.requestId = requestId;
+    return new CliError(complete);
+}
+function businessError(code, message, requestId) {
+    if (code >= 2000 && code < 3000) {
+        return cliError({
+            code: `FUYAO_${code}`,
+            category: 'authentication',
+            message,
+            hint: 'Run `hithink-finance auth status` and verify API key permissions.',
+            retryable: false,
+            exitCode: 3,
+        }, requestId);
+    }
+    if (code >= 1000 && code < 2000) {
+        return cliError({
+            code: `FUYAO_${code}`,
+            category: 'validation',
+            message,
+            hint: 'Check the command schema and correct the supplied parameters.',
+            retryable: false,
+            exitCode: 2,
+        }, requestId);
+    }
+    return cliError({
+        code: `FUYAO_${code}`,
+        category: 'upstream',
+        message,
+        hint: 'Retry later and retain the request ID when reporting a persistent failure.',
+        retryable: RETRYABLE_BUSINESS_CODES.has(code),
+        exitCode: 4,
+    }, requestId);
+}
+export class FuyaoClient {
+    options;
+    timeoutMs;
+    maxAttempts;
+    fetchImplementation;
+    sleep;
+    random;
+    constructor(options) {
+        this.options = options;
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.maxAttempts = options.maxAttempts ?? 3;
+        this.fetchImplementation = options.fetch ?? globalThis.fetch;
+        this.sleep = options.sleep ?? defaultSleep;
+        this.random = options.random ?? Math.random;
+    }
+    async request(request) {
+        const url = new URL(request.path, this.options.baseUrl);
+        for (const [key, value] of Object.entries(request.query ?? {})) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+        for (let attempt = 0; attempt < this.maxAttempts; attempt += 1) {
+            let response;
+            try {
+                response = await this.fetchImplementation(url, {
+                    method: 'GET',
+                    headers: { 'X-api-key': this.options.auth.apiKey, accept: 'application/json' },
+                    signal: AbortSignal.timeout(this.timeoutMs),
+                });
+            }
+            catch {
+                if (attempt < this.maxAttempts - 1) {
+                    await this.sleep(retryDelayMs(attempt, this.random));
+                    continue;
+                }
+                throw cliError({
+                    code: 'UPSTREAM_NETWORK_FAILURE',
+                    category: 'upstream',
+                    message: 'The Fuyao service could not be reached before the timeout.',
+                    hint: 'Check network connectivity and retry the command.',
+                    retryable: true,
+                    exitCode: 4,
+                });
+            }
+            let body;
+            try {
+                body = await response.json();
+            }
+            catch {
+                throw cliError({
+                    code: 'UPSTREAM_INVALID_RESPONSE',
+                    category: 'upstream',
+                    message: 'The Fuyao service returned invalid JSON.',
+                    hint: 'Retry later and report the failure if it persists.',
+                    retryable: false,
+                    exitCode: 4,
+                });
+            }
+            const parsedEnvelope = fuyaoEnvelopeSchema.safeParse(body);
+            if (!parsedEnvelope.success) {
+                throw cliError({
+                    code: 'UPSTREAM_INVALID_RESPONSE',
+                    category: 'upstream',
+                    message: 'The Fuyao response envelope does not match the supported contract.',
+                    hint: 'Upgrade the CLI or report a possible upstream contract change.',
+                    retryable: false,
+                    exitCode: 4,
+                });
+            }
+            const envelope = parsedEnvelope.data;
+            if (envelope.code === 0) {
+                const parsedData = request.schema.safeParse(envelope.data);
+                if (!parsedData.success) {
+                    throw cliError({
+                        code: 'UPSTREAM_INVALID_DATA',
+                        category: 'upstream',
+                        message: 'Fuyao data does not match the command response schema.',
+                        hint: 'Upgrade the CLI or report a possible upstream contract change.',
+                        retryable: false,
+                        exitCode: 4,
+                    }, envelope.request_id);
+                }
+                const result = { data: parsedData.data };
+                if (envelope.request_id !== undefined)
+                    result.requestId = envelope.request_id;
+                return result;
+            }
+            const error = businessError(envelope.code, envelope.message, envelope.request_id);
+            if (RETRYABLE_BUSINESS_CODES.has(envelope.code) && attempt < this.maxAttempts - 1) {
+                const retryAfter = parseRetryAfter(response.headers.get('retry-after'));
+                await this.sleep(retryAfter ?? retryDelayMs(attempt, this.random));
+                continue;
+            }
+            throw error;
+        }
+        throw cliError({
+            code: 'UPSTREAM_NETWORK_FAILURE',
+            category: 'upstream',
+            message: 'The Fuyao request failed after all attempts.',
+            hint: 'Retry later.',
+            retryable: true,
+            exitCode: 4,
+        });
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/infrastructure/fuyao/envelope.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const fuyaoEnvelopeSchema: z.ZodObject<{
+    code: z.ZodNumber;
+    message: z.ZodString;
+    request_id: z.ZodOptional<z.ZodString>;
+    data: z.ZodUnknown;
+}, z.core.$strip>;
+export type FuyaoEnvelope = z.infer<typeof fuyaoEnvelopeSchema>;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/infrastructure/fuyao/envelope.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const fuyaoEnvelopeSchema = z.object({
+    code: z.number().int(),
+    message: z.string(),
+    request_id: z.string().optional(),
+    data: z.unknown(),
+});
+//# sourceMappingURL=envelope.js.map

package/dist/infrastructure/fuyao/pagination.d.ts

@@ -0,0 +1,16 @@
+export interface Page<T> {
+    items: T[];
+    hasMore: boolean;
+}
+export interface PaginationOptions {
+    maxPages?: number;
+    maxRows?: number;
+    streamed?: boolean;
+}
+export interface PaginationResult<T> {
+    items: T[];
+    truncated: boolean;
+    pages: number;
+}
+export declare function paginate<T>(fetchPage: (page: number) => Promise<Page<T>>, options: PaginationOptions): Promise<PaginationResult<T>>;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/infrastructure/fuyao/pagination.js

@@ -0,0 +1,44 @@
+import { CliError } from '../../contracts/errors.js';
+export async function paginate(fetchPage, options) {
+    if (options.maxPages === undefined &&
+        options.maxRows === undefined &&
+        options.streamed !== true) {
+        throw new CliError({
+            code: 'CLI_PAGINATION_BOUND_REQUIRED',
+            category: 'validation',
+            message: 'Paginated output requires a maximum page count, maximum row count, or a stream.',
+            hint: 'Set --limit/--max-pages or provide --output.',
+            retryable: false,
+            exitCode: 2,
+        });
+    }
+    const items = [];
+    let pageNumber = 0;
+    let truncated = false;
+    while (true) {
+        if (options.maxPages !== undefined && pageNumber >= options.maxPages) {
+            truncated = true;
+            break;
+        }
+        const page = await fetchPage(pageNumber);
+        pageNumber += 1;
+        const remaining = options.maxRows === undefined ? page.items.length : options.maxRows - items.length;
+        if (remaining <= 0) {
+            truncated = true;
+            break;
+        }
+        items.push(...page.items.slice(0, remaining));
+        if (page.items.length > remaining) {
+            truncated = true;
+            break;
+        }
+        if (!page.hasMore)
+            break;
+        if (options.maxRows !== undefined && items.length >= options.maxRows) {
+            truncated = true;
+            break;
+        }
+    }
+    return { items, truncated, pages: pageNumber };
+}
+//# sourceMappingURL=pagination.js.map

package/dist/infrastructure/fuyao/retry.d.ts

@@ -0,0 +1,5 @@
+export declare const RETRYABLE_BUSINESS_CODES: Set<number>;
+export declare function parseRetryAfter(value: string | null, now?: number): number | undefined;
+export declare function retryDelayMs(attempt: number, random: () => number): number;
+export declare function defaultSleep(milliseconds: number): Promise<void>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/infrastructure/fuyao/retry.js

@@ -0,0 +1,18 @@
+export const RETRYABLE_BUSINESS_CODES = new Set([4001, 5001, 5002, 5003]);
+export function parseRetryAfter(value, now = Date.now()) {
+    if (value === null)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.round(seconds * 1000);
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? undefined : Math.max(0, date - now);
+}
+export function retryDelayMs(attempt, random) {
+    const base = Math.min(1000 * 2 ** attempt, 8000);
+    return Math.round(base + base * 0.2 * random());
+}
+export async function defaultSleep(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+//# sourceMappingURL=retry.js.map

package/dist/infrastructure/fuyao/windowing.d.ts

@@ -0,0 +1,8 @@
+export declare const TEN_YEARS_MS: number;
+export interface TimeSlice {
+    start: number;
+    end: number;
+}
+export declare function sliceTimeWindow(start: number, end: number, size?: number): TimeSlice[];
+export declare function deduplicateAndSort<T>(values: readonly T[], key: (value: T) => string | number): T[];
+//# sourceMappingURL=windowing.d.ts.map

package/dist/infrastructure/fuyao/windowing.js

@@ -0,0 +1,25 @@
+export const TEN_YEARS_MS = Math.floor(10 * 365.25 * 24 * 60 * 60 * 1000);
+export function sliceTimeWindow(start, end, size = TEN_YEARS_MS) {
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || end < start || size < 1) {
+        throw new RangeError('Invalid time window.');
+    }
+    const slices = [];
+    let cursor = start;
+    while (cursor <= end) {
+        const sliceEnd = Math.min(cursor + size, end);
+        slices.push({ start: cursor, end: sliceEnd });
+        cursor = sliceEnd + 1;
+    }
+    return slices;
+}
+export function deduplicateAndSort(values, key) {
+    const unique = new Map();
+    for (const value of values)
+        unique.set(key(value), value);
+    return [...unique.values()].sort((left, right) => {
+        const leftKey = key(left);
+        const rightKey = key(right);
+        return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+    });
+}
+//# sourceMappingURL=windowing.js.map

package/dist/infrastructure/skills/drift.d.ts

@@ -0,0 +1,3 @@
+import { type ManagedSkillManifest } from './manifest.js';
+export declare function detectSkillDrift(targetRoot: string, canonical: ManagedSkillManifest): Promise<string[]>;
+//# sourceMappingURL=drift.d.ts.map

package/dist/infrastructure/skills/drift.js

@@ -0,0 +1,8 @@
+import { buildSkillManifest } from './manifest.js';
+export async function detectSkillDrift(targetRoot, canonical) {
+    const installed = await buildSkillManifest(targetRoot, canonical.cliVersion);
+    return Object.entries(canonical.files)
+        .filter(([file, hash]) => installed.files[file] !== hash)
+        .map(([file]) => file);
+}
+//# sourceMappingURL=drift.js.map

package/dist/infrastructure/skills/installer.d.ts

@@ -0,0 +1,13 @@
+export declare function syncSkills(packageRoot: string): Promise<{
+    code: number;
+}>;
+export declare function removeSkills(packageRoot: string): Promise<{
+    code: number;
+}>;
+export declare function skillsRemoveArguments(packageRoot: string): ReturnType<typeof skillsCliArguments>;
+export declare function skillsCliArguments(packageRoot: string): {
+    command: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+};
+//# sourceMappingURL=installer.d.ts.map

package/dist/infrastructure/skills/installer.js

@@ -0,0 +1,48 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+export async function syncSkills(packageRoot) {
+    const invocation = skillsCliArguments(packageRoot);
+    return run(invocation);
+}
+export async function removeSkills(packageRoot) {
+    return run(skillsRemoveArguments(packageRoot));
+}
+function run(invocation) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(invocation.command, invocation.args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: invocation.env,
+            windowsHide: true,
+        });
+        child.once('error', reject);
+        child.once('exit', (code) => resolve({ code: code ?? 1 }));
+    });
+}
+const skillNames = [
+    'hithink-finance-shared',
+    'hithink-finance-symbol',
+    'hithink-finance-market',
+    'hithink-finance-special-data',
+    'hithink-finance-financials',
+    'hithink-finance-index',
+    'hithink-finance-data',
+    'hithink-finance-research',
+];
+export function skillsRemoveArguments(packageRoot) {
+    const cli = path.join(packageRoot, 'node_modules', 'skills', 'bin', 'cli.mjs');
+    return {
+        command: process.execPath,
+        args: [cli, 'remove', ...skillNames, '--global', '--yes'],
+        env: { ...process.env, DISABLE_TELEMETRY: '1' },
+    };
+}
+export function skillsCliArguments(packageRoot) {
+    const cli = path.join(packageRoot, 'node_modules', 'skills', 'bin', 'cli.mjs');
+    const source = path.join(packageRoot, 'skills');
+    return {
+        command: process.execPath,
+        args: [cli, 'add', source, '--global', '--copy', '--all', '--full-depth'],
+        env: { ...process.env, DISABLE_TELEMETRY: '1' },
+    };
+}
+//# sourceMappingURL=installer.js.map