tickflow-assist 0.2.0

package/dist/services/post-close-review-service.js

@@ -0,0 +1,402 @@
+import { formatChinaDateTime } from "../utils/china-time.js";
+const LEVEL_BUFFER = 0.005;
+const INTRADAY_PERIOD = "1m";
+export class PostCloseReviewService {
+    watchlistService;
+    compositeAnalysisOrchestrator;
+    analysisService;
+    postCloseReviewTask;
+    keyLevelsRepository;
+    keyLevelsHistoryRepository;
+    klinesRepository;
+    intradayKlinesRepository;
+    constructor(watchlistService, compositeAnalysisOrchestrator, analysisService, postCloseReviewTask, keyLevelsRepository, keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository) {
+        this.watchlistService = watchlistService;
+        this.compositeAnalysisOrchestrator = compositeAnalysisOrchestrator;
+        this.analysisService = analysisService;
+        this.postCloseReviewTask = postCloseReviewTask;
+        this.keyLevelsRepository = keyLevelsRepository;
+        this.keyLevelsHistoryRepository = keyLevelsHistoryRepository;
+        this.klinesRepository = klinesRepository;
+        this.intradayKlinesRepository = intradayKlinesRepository;
+    }
+    async run() {
+        const watchlist = await this.watchlistService.list();
+        if (watchlist.length === 0) {
+            const overviewMessage = "🧭 收盘复盘总览\n\n关注列表为空，已跳过收盘复盘。";
+            return {
+                overviewMessage,
+                detailMessages: [],
+                combinedText: overviewMessage,
+            };
+        }
+        const entries = [];
+        const detailMessages = [];
+        let marketOverview = null;
+        for (const item of watchlist) {
+            let compositeResult = null;
+            try {
+                const input = await this.compositeAnalysisOrchestrator.buildInput(item.symbol);
+                marketOverview ??= input.market.marketOverview;
+                const tradeDate = input.market.klines[input.market.klines.length - 1]?.trade_date ?? formatChinaDateTime().slice(0, 10);
+                const validation = await this.buildValidationContext(item.symbol, tradeDate);
+                compositeResult = await this.compositeAnalysisOrchestrator.analyzeInput(input);
+                const review = await this.analysisService.runTask(this.postCloseReviewTask, {
+                    ...input,
+                    compositeResult,
+                    validation,
+                });
+                const message = this.formatDetailMessage(item, validation, review);
+                await this.persistReview(item.symbol, message, review);
+                entries.push({
+                    ok: true,
+                    item,
+                    validation,
+                    review,
+                });
+                detailMessages.push(message);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (compositeResult?.levels) {
+                    await this.persistFallbackCompositeReview(item.symbol, compositeResult);
+                }
+                entries.push({ ok: false, item, errorMessage: message });
+                detailMessages.push(this.formatFailureMessage(item, message, compositeResult));
+            }
+        }
+        const overviewMessage = this.formatOverviewMessage(marketOverview, entries);
+        return {
+            overviewMessage,
+            detailMessages,
+            combinedText: [overviewMessage, ...detailMessages].join("\n\n"),
+        };
+    }
+    async persistReview(symbol, message, review) {
+        if (review.decision === "invalidate" || !review.levels) {
+            await this.keyLevelsRepository.remove(symbol);
+            return;
+        }
+        const levels = {
+            ...review.levels,
+            analysis_text: message,
+        };
+        await this.keyLevelsRepository.save(symbol, levels);
+        await this.keyLevelsHistoryRepository.saveDailySnapshot(toHistoryEntry(symbol, message, levels));
+    }
+    async persistFallbackCompositeReview(symbol, result) {
+        if (!result.levels) {
+            return;
+        }
+        await this.keyLevelsHistoryRepository.saveDailySnapshot(toHistoryEntry(symbol, result.analysisText, result.levels));
+    }
+    async buildValidationContext(symbol, tradeDate) {
+        const snapshots = await this.keyLevelsHistoryRepository.listBySymbol(symbol);
+        const snapshot = snapshots.find((item) => item.analysis_date < tradeDate) ?? null;
+        if (!snapshot) {
+            return {
+                available: false,
+                snapshotDate: null,
+                evaluatedTradeDate: tradeDate,
+                verdict: "unavailable",
+                snapshot: null,
+                summary: "昨日无可验证的活动关键位快照，本轮只能基于今日数据直接重算。",
+                lines: ["暂无昨日活动关键位快照。"],
+            };
+        }
+        const dailyRows = await this.klinesRepository.listBySymbol(symbol);
+        const row = dailyRows.find((item) => item.trade_date === tradeDate)
+            ?? dailyRows.find((item) => item.trade_date > snapshot.analysis_date)
+            ?? null;
+        if (!row) {
+            return {
+                available: false,
+                snapshotDate: snapshot.analysis_date,
+                evaluatedTradeDate: null,
+                verdict: "unavailable",
+                snapshot,
+                summary: `已找到 ${snapshot.analysis_date} 的关键位快照，但尚无后续交易日数据可供验证。`,
+                lines: ["缺少后续交易日数据。"],
+            };
+        }
+        const intradayRows = (await this.intradayKlinesRepository.listBySymbol(symbol, INTRADAY_PERIOD))
+            .filter((item) => item.trade_date === row.trade_date);
+        const support = evaluateSupport(snapshot, row);
+        const resistance = evaluateResistance(snapshot, row);
+        const stopLoss = evaluateStopLoss(snapshot, row);
+        const takeProfit = evaluateTakeProfit(snapshot, row);
+        const breakthrough = evaluateBreakthrough(snapshot, row);
+        const path = evaluatePath(snapshot, row, intradayRows);
+        const verdict = deriveValidationVerdict({
+            support,
+            stopLoss,
+            takeProfit,
+            breakthrough,
+            path,
+        });
+        const lines = [
+            `快照日期 ${snapshot.analysis_date}，验证交易日 ${row.trade_date}。`,
+            `当日K线: 高 ${row.high.toFixed(2)} | 低 ${row.low.toFixed(2)} | 收 ${row.close.toFixed(2)}`,
+            support,
+            resistance,
+            stopLoss,
+            takeProfit,
+            breakthrough,
+            path,
+        ];
+        return {
+            available: true,
+            snapshotDate: snapshot.analysis_date,
+            evaluatedTradeDate: row.trade_date,
+            verdict,
+            snapshot,
+            summary: `昨日关键位${formatValidationVerdictLabel(verdict)}。`,
+            lines,
+        };
+    }
+    formatOverviewMessage(marketOverview, entries) {
+        const successEntries = entries.filter((entry) => entry.ok);
+        const failureCount = entries.length - successEntries.length;
+        const validationCounts = countBy(successEntries.map((entry) => entry.validation.verdict));
+        const decisionCounts = countBy(successEntries.map((entry) => entry.review.decision));
+        const marketBiasCounts = countBy(successEntries.map((entry) => entry.review.marketBias));
+        const sectorBiasCounts = countBy(successEntries.map((entry) => entry.review.sectorBias));
+        const newsImpactCounts = countBy(successEntries.map((entry) => entry.review.newsImpact));
+        const lines = [
+            marketOverview?.summary ?? "未获取到大盘总览，本轮仅输出个股复盘。",
+            "",
+            `复盘数量: ${entries.length} 只 | 成功 ${successEntries.length} | 失败 ${failureCount}`,
+            `关键位验证: 有效 ${validationCounts.validated ?? 0} | 混合 ${validationCounts.mixed ?? 0} | 失效 ${validationCounts.invalidated ?? 0} | 缺样本 ${validationCounts.unavailable ?? 0}`,
+            `明日处理: 沿用 ${decisionCounts.keep ?? 0} | 微调 ${decisionCounts.adjust ?? 0} | 重算 ${decisionCounts.recompute ?? 0} | 暂停 ${decisionCounts.invalidate ?? 0}`,
+            `大盘风向: 顺风 ${marketBiasCounts.tailwind ?? 0} | 中性 ${marketBiasCounts.neutral ?? 0} | 逆风 ${marketBiasCounts.headwind ?? 0}`,
+            `板块风向: 顺风 ${sectorBiasCounts.tailwind ?? 0} | 中性 ${sectorBiasCounts.neutral ?? 0} | 逆风 ${sectorBiasCounts.headwind ?? 0}`,
+            `新闻影响: 支持 ${newsImpactCounts.supportive ?? 0} | 中性 ${newsImpactCounts.neutral ?? 0} | 扰动 ${newsImpactCounts.disruptive ?? 0}`,
+        ];
+        return `🧭 收盘复盘总览\n\n${lines.join("\n")}`.trim();
+    }
+    formatDetailMessage(item, validation, review) {
+        const lines = [
+            `📘 收盘复盘 | ${item.name}（${item.symbol}）`,
+            "",
+            "昨日关键位验证",
+            `• ${validation.summary}`,
+            ...validation.lines.map((line) => `• ${line}`),
+            "",
+            "今日盘面",
+            review.sessionSummary || "未生成盘面一句话总结。",
+            "",
+            "大盘与板块",
+            review.marketSectorSummary || "未生成大盘/板块总结。",
+            `风向判断: 大盘${formatMarketBiasLabel(review.marketBias)} | 板块${formatMarketBiasLabel(review.sectorBias)}`,
+            "",
+            "新闻与公告",
+            review.newsSummary || "未生成新闻影响总结。",
+            `新闻影响: ${formatNewsImpactLabel(review.newsImpact)}`,
+            "",
+            "明日关键位处理",
+            `结论: ${formatDecisionLabel(review.decision)}`,
+            review.decisionReason || "未生成处理理由。",
+            "",
+            "更新后关键位",
+        ];
+        if (review.decision === "invalidate" || !review.levels) {
+            lines.push("• 已暂停沿用昨日关键位，等待下一轮重算。", "", "操作建议", review.actionAdvice || "明日先观察，等待新的关键位再执行。");
+            return lines.join("\n");
+        }
+        lines.push(`• 支撑 ${formatMaybePrice(review.levels.support)} | 压力 ${formatMaybePrice(review.levels.resistance)} | 突破 ${formatMaybePrice(review.levels.breakthrough)}`, `• 止损 ${formatMaybePrice(review.levels.stop_loss)} | 止盈 ${formatMaybePrice(review.levels.take_profit)} | 评分 ${review.levels.score}/10`, "", "操作建议", review.actionAdvice || "按关键位和次日量价配合再决定是否执行。");
+        return lines.join("\n");
+    }
+    formatFailureMessage(item, errorMessage, compositeResult) {
+        const fallback = compositeResult?.levels
+            ? "已保留综合分析生成的关键位，可稍后用 view_analysis 或 analyze 复核。"
+            : "本轮未生成可用关键位。";
+        return [
+            `⚠️ 收盘复盘 | ${item.name}（${item.symbol}）`,
+            "",
+            `失败原因: ${errorMessage}`,
+            fallback,
+        ].join("\n");
+    }
+}
+function toHistoryEntry(symbol, analysisText, levels) {
+    return {
+        symbol,
+        analysis_date: levels.analysis_date ?? formatChinaDateTime().slice(0, 10),
+        activated_at: formatChinaDateTime(),
+        profile: "composite",
+        current_price: levels.current_price,
+        stop_loss: levels.stop_loss ?? null,
+        breakthrough: levels.breakthrough ?? null,
+        support: levels.support ?? null,
+        cost_level: levels.cost_level ?? null,
+        resistance: levels.resistance ?? null,
+        take_profit: levels.take_profit ?? null,
+        gap: levels.gap ?? null,
+        target: levels.target ?? null,
+        round_number: levels.round_number ?? null,
+        analysis_text: analysisText,
+        score: levels.score,
+    };
+}
+function evaluateSupport(snapshot, row) {
+    if (!(snapshot.support != null && snapshot.support > 0)) {
+        return "支撑: 昨日未设置支撑位。";
+    }
+    const touchUpper = snapshot.support * (1 + LEVEL_BUFFER);
+    const holdLower = snapshot.support * (1 - LEVEL_BUFFER);
+    if (row.low > touchUpper) {
+        return `支撑 ${snapshot.support.toFixed(2)}: 当日未触达。`;
+    }
+    if (row.close < holdLower) {
+        return `支撑 ${snapshot.support.toFixed(2)}: 盘中触达后收盘失守，验证失败。`;
+    }
+    return `支撑 ${snapshot.support.toFixed(2)}: 盘中触达后收盘仍守住，验证有效。`;
+}
+function evaluateResistance(snapshot, row) {
+    if (!(snapshot.resistance != null && snapshot.resistance > 0)) {
+        return "压力: 昨日未设置压力位。";
+    }
+    const touchLower = snapshot.resistance * (1 - LEVEL_BUFFER);
+    const holdUpper = snapshot.resistance * (1 + LEVEL_BUFFER);
+    if (row.high < touchLower) {
+        return `压力 ${snapshot.resistance.toFixed(2)}: 当日未触达。`;
+    }
+    if (row.close > holdUpper) {
+        return `压力 ${snapshot.resistance.toFixed(2)}: 当日已被有效站上，原压力失效。`;
+    }
+    return `压力 ${snapshot.resistance.toFixed(2)}: 盘中触达但未有效站上，压制仍在。`;
+}
+function evaluateStopLoss(snapshot, row) {
+    if (!(snapshot.stop_loss != null && snapshot.stop_loss > 0)) {
+        return "止损: 昨日未设置止损位。";
+    }
+    if (row.low <= snapshot.stop_loss) {
+        return `止损 ${snapshot.stop_loss.toFixed(2)}: 已触发。`;
+    }
+    return `止损 ${snapshot.stop_loss.toFixed(2)}: 未触发。`;
+}
+function evaluateTakeProfit(snapshot, row) {
+    if (!(snapshot.take_profit != null && snapshot.take_profit > 0)) {
+        return "止盈: 昨日未设置止盈位。";
+    }
+    if (row.high >= snapshot.take_profit) {
+        return `止盈 ${snapshot.take_profit.toFixed(2)}: 已触发。`;
+    }
+    return `止盈 ${snapshot.take_profit.toFixed(2)}: 未触发。`;
+}
+function evaluateBreakthrough(snapshot, row) {
+    if (!(snapshot.breakthrough != null && snapshot.breakthrough > 0)) {
+        return "突破: 昨日未设置突破位。";
+    }
+    if (row.high < snapshot.breakthrough) {
+        return `突破 ${snapshot.breakthrough.toFixed(2)}: 未触发。`;
+    }
+    if (row.close >= snapshot.breakthrough * (1 + LEVEL_BUFFER)) {
+        return `突破 ${snapshot.breakthrough.toFixed(2)}: 已触发且收盘确认。`;
+    }
+    return `突破 ${snapshot.breakthrough.toFixed(2)}: 盘中试探但收盘未确认。`;
+}
+function evaluatePath(snapshot, row, intradayRows) {
+    if (!(snapshot.stop_loss != null && snapshot.stop_loss > 0 && snapshot.take_profit != null && snapshot.take_profit > 0)) {
+        return "路径: 缺少双目标，无法判断先止损还是先止盈。";
+    }
+    const hitsStop = row.low <= snapshot.stop_loss;
+    const hitsTakeProfit = row.high >= snapshot.take_profit;
+    if (!hitsStop && !hitsTakeProfit) {
+        return "路径: 当日未触发双目标。";
+    }
+    if (hitsStop && !hitsTakeProfit) {
+        return `路径: 当日先到止损 ${snapshot.stop_loss.toFixed(2)}。`;
+    }
+    if (!hitsStop && hitsTakeProfit) {
+        return `路径: 当日先到止盈 ${snapshot.take_profit.toFixed(2)}。`;
+    }
+    for (const intradayRow of intradayRows) {
+        const intradayHitsStop = intradayRow.low <= snapshot.stop_loss;
+        const intradayHitsTakeProfit = intradayRow.high >= snapshot.take_profit;
+        if (!intradayHitsStop && !intradayHitsTakeProfit) {
+            continue;
+        }
+        if (intradayHitsStop && !intradayHitsTakeProfit) {
+            return `路径: 同日双触发中，分钟线判定先到止损 ${snapshot.stop_loss.toFixed(2)}。`;
+        }
+        if (!intradayHitsStop && intradayHitsTakeProfit) {
+            return `路径: 同日双触发中，分钟线判定先到止盈 ${snapshot.take_profit.toFixed(2)}。`;
+        }
+        if (intradayRow.open <= snapshot.stop_loss) {
+            return `路径: 同日双触发中，分钟线按开盘位置判定先到止损 ${snapshot.stop_loss.toFixed(2)}。`;
+        }
+        if (intradayRow.open >= snapshot.take_profit) {
+            return `路径: 同日双触发中，分钟线按开盘位置判定先到止盈 ${snapshot.take_profit.toFixed(2)}。`;
+        }
+        return "路径: 同日双触发，但分钟线仍无法明确先后。";
+    }
+    return "路径: 同日双触发，但缺少有效分钟线判定先后。";
+}
+function deriveValidationVerdict(input) {
+    if (input.support.includes("验证失败")
+        || input.stopLoss.includes("已触发")
+        || input.path.includes("先到止损")) {
+        return "invalidated";
+    }
+    if (input.takeProfit.includes("已触发")
+        || input.breakthrough.includes("收盘确认")
+        || input.support.includes("验证有效")
+        || input.path.includes("先到止盈")) {
+        return "validated";
+    }
+    return "mixed";
+}
+function countBy(values) {
+    return values.reduce((acc, value) => {
+        acc[value] = (acc[value] ?? 0) + 1;
+        return acc;
+    }, {});
+}
+function formatDecisionLabel(value) {
+    switch (value) {
+        case "keep":
+            return "沿用";
+        case "adjust":
+            return "微调";
+        case "invalidate":
+            return "暂停沿用";
+        default:
+            return "重算";
+    }
+}
+function formatMarketBiasLabel(value) {
+    switch (value) {
+        case "tailwind":
+            return "顺风";
+        case "headwind":
+            return "逆风";
+        default:
+            return "中性";
+    }
+}
+function formatNewsImpactLabel(value) {
+    switch (value) {
+        case "supportive":
+            return "支持";
+        case "disruptive":
+            return "扰动";
+        default:
+            return "中性";
+    }
+}
+function formatValidationVerdictLabel(value) {
+    switch (value) {
+        case "validated":
+            return "验证有效";
+        case "invalidated":
+            return "明显失效";
+        case "mixed":
+            return "效果偏混合";
+        default:
+            return "暂无可验证样本";
+    }
+}
+function formatMaybePrice(value) {
+    return value == null ? "-" : value.toFixed(2);
+}

package/dist/services/quote-service.d.ts

@@ -0,0 +1,7 @@
+import type { TickFlowQuote } from "../types/tickflow.js";
+import { TickFlowClient } from "./tickflow-client.js";
+export declare class QuoteService {
+    private readonly client;
+    constructor(client: TickFlowClient);
+    fetchQuotes(symbols: string[]): Promise<TickFlowQuote[]>;
+}

package/dist/services/quote-service.js

@@ -0,0 +1,9 @@
+export class QuoteService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async fetchQuotes(symbols) {
+        return this.client.fetchQuotes(symbols);
+    }
+}

package/dist/services/review-memory-service.d.ts

@@ -0,0 +1,7 @@
+import type { ReviewMemoryContext } from "../analysis/types/composite-analysis.js";
+import { KeyLevelsBacktestService } from "./key-levels-backtest-service.js";
+export declare class ReviewMemoryService {
+    private readonly keyLevelsBacktestService;
+    constructor(keyLevelsBacktestService: KeyLevelsBacktestService);
+    getSymbolContext(symbol: string): Promise<ReviewMemoryContext>;
+}

package/dist/services/review-memory-service.js

@@ -0,0 +1,76 @@
+const RECENT_SNAPSHOTS_LIMIT = 2;
+export class ReviewMemoryService {
+    keyLevelsBacktestService;
+    constructor(keyLevelsBacktestService) {
+        this.keyLevelsBacktestService = keyLevelsBacktestService;
+    }
+    async getSymbolContext(symbol) {
+        const report = await this.keyLevelsBacktestService.buildReport({
+            symbol,
+            recentLimit: RECENT_SNAPSHOTS_LIMIT,
+        });
+        const asOf = report.recentSnapshots[0]?.analysis_date ?? null;
+        if (report.snapshots.length === 0) {
+            return {
+                available: false,
+                summary: "",
+                asOf,
+            };
+        }
+        const primary = [...report.horizons].reverse().find((stats) => countSamples(stats) > 0);
+        const lines = [
+            "历史关键位复盘经验仅用于校准当前判断；若与最新K线、实时价或资讯催化冲突，以当前证据为主。",
+        ];
+        if (primary) {
+            lines.push(`近${primary.horizon}日窗口：支撑守住 ${formatRate(primary.support.validCount, primary.support.touchCount)}，压力压制 ${formatRate(primary.resistance.validCount, primary.resistance.touchCount)}，止损触发 ${formatRate(primary.stopLoss.hitCount, primary.stopLoss.sampleCount)}，止盈触发 ${formatRate(primary.takeProfit.hitCount, primary.takeProfit.sampleCount)}，突破确认 ${formatRate(primary.breakthrough.confirmCount, primary.breakthrough.hitCount)}。`);
+            if (primary.tradePath.sampleCount > 0) {
+                lines.push(`双目标路径：先止盈 ${formatRate(primary.tradePath.takeProfitFirstCount, primary.tradePath.sampleCount)}，先止损 ${formatRate(primary.tradePath.stopFirstCount, primary.tradePath.sampleCount)}，未决 ${formatRate(primary.tradePath.unresolvedCount, primary.tradePath.sampleCount)}。`);
+            }
+        }
+        else {
+            lines.push("历史复盘样本仍少，暂时只能作为弱参考。");
+        }
+        if (report.recentSnapshots.length > 0) {
+            lines.push(`最近活动价位：${report.recentSnapshots.map(formatSnapshot).join("；")}`);
+        }
+        const conclusion = report.conclusion.replace(/^💡\s*结论:\s*/, "").trim();
+        if (conclusion) {
+            lines.push(`复盘结论：${conclusion}`);
+        }
+        return {
+            available: true,
+            summary: lines.join("\n"),
+            asOf,
+        };
+    }
+}
+function countSamples(stats) {
+    return (stats.support.sampleCount +
+        stats.resistance.sampleCount +
+        stats.stopLoss.sampleCount +
+        stats.takeProfit.sampleCount +
+        stats.breakthrough.sampleCount +
+        stats.tradePath.sampleCount);
+}
+function formatRate(numerator, denominator) {
+    if (!(denominator > 0)) {
+        return "样本不足";
+    }
+    return `${((numerator / denominator) * 100).toFixed(1)}%`;
+}
+function formatSnapshot(snapshot) {
+    return [
+        snapshot.analysis_date,
+        `评分${formatMaybeInt(snapshot.score)}`,
+        `支撑${formatMaybePrice(snapshot.support)}`,
+        `压力${formatMaybePrice(snapshot.resistance)}`,
+        `止损${formatMaybePrice(snapshot.stop_loss)}`,
+        `止盈${formatMaybePrice(snapshot.take_profit)}`,
+    ].join(" ");
+}
+function formatMaybePrice(value) {
+    return value == null ? "-" : value.toFixed(2);
+}
+function formatMaybeInt(value) {
+    return value == null ? "-" : String(Math.trunc(value));
+}

package/dist/services/tickflow-client.d.ts

@@ -0,0 +1,43 @@
+import type { TickFlowBalanceSheetRecord, TickFlowCashFlowRecord, TickFlowFinancialMetricsRecord, TickFlowFinancialQueryOptions, TickFlowIncomeRecord, TickFlowInstrument, TickFlowQuote } from "../types/tickflow.js";
+export declare class TickFlowClientError extends Error {
+    constructor(message: string);
+}
+export declare class TickFlowClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    getBaseUrl(): string;
+    getApiKey(): string;
+    fetchInstruments(symbols: string[]): Promise<TickFlowInstrument[]>;
+    fetchQuotes(symbols: string[]): Promise<TickFlowQuote[]>;
+    fetchKlinesBatch<T = unknown>(symbols: string[], params?: {
+        period?: string;
+        count?: number;
+        adjust?: string;
+        startTime?: number;
+        endTime?: number;
+    }): Promise<{
+        data?: Record<string, T>;
+    }>;
+    fetchIntradayKlinesBatch<T = unknown>(symbols: string[], params?: {
+        period?: string;
+        count?: number;
+    }): Promise<{
+        data?: Record<string, T>;
+    }>;
+    fetchBalanceSheet(symbols: string[], params?: TickFlowFinancialQueryOptions): Promise<{
+        data?: Record<string, TickFlowBalanceSheetRecord[]>;
+    }>;
+    fetchCashFlow(symbols: string[], params?: TickFlowFinancialQueryOptions): Promise<{
+        data?: Record<string, TickFlowCashFlowRecord[]>;
+    }>;
+    fetchIncome(symbols: string[], params?: TickFlowFinancialQueryOptions): Promise<{
+        data?: Record<string, TickFlowIncomeRecord[]>;
+    }>;
+    fetchFinancialMetrics(symbols: string[], params?: TickFlowFinancialQueryOptions): Promise<{
+        data?: Record<string, TickFlowFinancialMetricsRecord[]>;
+    }>;
+    private fetchFinancialRecords;
+    private requestJson;
+    private handleResponse;
+}

package/dist/services/tickflow-client.js

@@ -0,0 +1,126 @@
+export class TickFlowClientError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TickFlowClientError";
+    }
+}
+export class TickFlowClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    getApiKey() {
+        return this.apiKey;
+    }
+    async fetchInstruments(symbols) {
+        if (symbols.length === 0) {
+            return [];
+        }
+        const url = new URL("/v1/instruments", this.baseUrl);
+        url.searchParams.set("symbols", symbols.join(","));
+        const response = await this.requestJson(url.toString(), {
+            method: "GET",
+        });
+        return response.data ?? [];
+    }
+    async fetchQuotes(symbols) {
+        if (symbols.length === 0) {
+            return [];
+        }
+        const url = new URL("/v1/quotes", this.baseUrl);
+        const response = await this.requestJson(url.toString(), {
+            method: "POST",
+            body: JSON.stringify({ symbols }),
+        });
+        return response.data ?? [];
+    }
+    async fetchKlinesBatch(symbols, params = {}) {
+        if (symbols.length === 0) {
+            return { data: {} };
+        }
+        const url = new URL("/v1/klines/batch", this.baseUrl);
+        url.searchParams.set("symbols", symbols.join(","));
+        url.searchParams.set("period", params.period ?? "1d");
+        url.searchParams.set("count", String(params.count ?? 90));
+        url.searchParams.set("adjust", params.adjust ?? "forward");
+        if (params.startTime != null) {
+            url.searchParams.set("start_time", String(params.startTime));
+        }
+        if (params.endTime != null) {
+            url.searchParams.set("end_time", String(params.endTime));
+        }
+        return this.requestJson(url.toString(), {
+            method: "GET",
+        });
+    }
+    async fetchIntradayKlinesBatch(symbols, params = {}) {
+        if (symbols.length === 0) {
+            return { data: {} };
+        }
+        const url = new URL("/v1/klines/intraday/batch", this.baseUrl);
+        url.searchParams.set("symbols", symbols.join(","));
+        url.searchParams.set("period", params.period ?? "1m");
+        if (params.count != null) {
+            url.searchParams.set("count", String(params.count));
+        }
+        return this.requestJson(url.toString(), {
+            method: "GET",
+        });
+    }
+    async fetchBalanceSheet(symbols, params = {}) {
+        return this.fetchFinancialRecords("/v1/financials/balance-sheet", symbols, params);
+    }
+    async fetchCashFlow(symbols, params = {}) {
+        return this.fetchFinancialRecords("/v1/financials/cash-flow", symbols, params);
+    }
+    async fetchIncome(symbols, params = {}) {
+        return this.fetchFinancialRecords("/v1/financials/income", symbols, params);
+    }
+    async fetchFinancialMetrics(symbols, params = {}) {
+        return this.fetchFinancialRecords("/v1/financials/metrics", symbols, params);
+    }
+    async fetchFinancialRecords(endpoint, symbols, params = {}) {
+        if (symbols.length === 0) {
+            return { data: {} };
+        }
+        const url = new URL(endpoint, this.baseUrl);
+        url.searchParams.set("symbols", symbols.join(","));
+        if (params.start_date) {
+            url.searchParams.set("start_date", params.start_date);
+        }
+        if (params.end_date) {
+            url.searchParams.set("end_date", params.end_date);
+        }
+        if (params.latest != null) {
+            url.searchParams.set("latest", String(params.latest));
+        }
+        return this.requestJson(url.toString(), {
+            method: "GET",
+        });
+    }
+    async requestJson(url, init) {
+        const headers = new Headers(init.headers ?? {});
+        headers.set("x-api-key", this.apiKey);
+        headers.set("Content-Type", "application/json");
+        const first = await fetch(url, { ...init, headers });
+        if (first.status === 429) {
+            const retryAfter = Number(first.headers.get("Retry-After") ?? "5");
+            await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
+            const retry = await fetch(url, { ...init, headers });
+            return this.handleResponse(retry, url);
+        }
+        return this.handleResponse(first, url);
+    }
+    async handleResponse(response, url) {
+        if (!response.ok) {
+            const text = await response.text();
+            throw new TickFlowClientError(`TickFlow request failed: ${response.status} ${response.statusText} (${url}) ${text}`.trim());
+        }
+        return (await response.json());
+    }
+}