tickflow-assist 0.2.0

package/dist/services/analysis-service.js

@@ -0,0 +1,73 @@
+export class AnalysisService {
+    llmBaseUrl;
+    llmApiKey;
+    llmModel;
+    analysisLogRepository;
+    constructor(llmBaseUrl, llmApiKey, llmModel, analysisLogRepository) {
+        this.llmBaseUrl = llmBaseUrl;
+        this.llmApiKey = llmApiKey;
+        this.llmModel = llmModel;
+        this.analysisLogRepository = analysisLogRepository;
+    }
+    isConfigured() {
+        return Boolean(this.llmBaseUrl.trim() && this.llmApiKey.trim() && this.llmModel.trim());
+    }
+    getConfigurationError() {
+        if (!this.llmBaseUrl.trim()) {
+            return "LLM 未配置接口地址，请设置 llmBaseUrl";
+        }
+        if (!this.llmApiKey.trim()) {
+            return "LLM 未配置 API Key，请设置 llmApiKey";
+        }
+        if (!this.llmModel.trim()) {
+            return "LLM 未配置模型，请设置 llmModel";
+        }
+        return null;
+    }
+    async runTask(task, input) {
+        const prepared = await task.prepare(input);
+        const analysisText = await this.generateText(prepared.systemPrompt, prepared.userPrompt);
+        const result = await task.parseResult(analysisText, input);
+        await task.persistResult(result, input);
+        return result;
+    }
+    async generateText(systemPrompt, userPrompt, options = {}) {
+        return this.callLlm(systemPrompt, userPrompt, options);
+    }
+    async getLatestAnalysis(symbol) {
+        return this.analysisLogRepository.getLatest(symbol);
+    }
+    async callLlm(systemPrompt, userPrompt, options) {
+        const configError = this.getConfigurationError();
+        if (configError) {
+            throw new Error(configError);
+        }
+        const url = new URL("/chat/completions", this.llmBaseUrl).toString();
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.llmApiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.llmModel,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userPrompt },
+                ],
+                max_tokens: options.maxTokens ?? 4096,
+                temperature: options.temperature ?? 0.3,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`LLM analyze request failed: ${response.status} ${response.statusText} ${text}`);
+        }
+        const json = (await response.json());
+        const content = json.choices?.[0]?.message?.content?.trim();
+        if (!content) {
+            throw new Error("LLM analyze response content is empty");
+        }
+        return content;
+    }
+}

package/dist/services/analysis-view-service.d.ts

@@ -0,0 +1,23 @@
+import { AnalysisLogRepository } from "../storage/repositories/analysis-log-repo.js";
+import { CompositeAnalysisRepository } from "../storage/repositories/composite-analysis-repo.js";
+import { FinancialAnalysisRepository } from "../storage/repositories/financial-analysis-repo.js";
+import { KeyLevelsRepository } from "../storage/repositories/key-levels-repo.js";
+import { NewsAnalysisRepository } from "../storage/repositories/news-analysis-repo.js";
+import { TechnicalAnalysisRepository } from "../storage/repositories/technical-analysis-repo.js";
+export type AnalysisViewProfile = "composite" | "technical" | "financial" | "news" | "all";
+export declare class AnalysisViewService {
+    private readonly analysisLogRepository;
+    private readonly keyLevelsRepository;
+    private readonly technicalAnalysisRepository;
+    private readonly financialAnalysisRepository;
+    private readonly newsAnalysisRepository;
+    private readonly compositeAnalysisRepository;
+    constructor(analysisLogRepository: AnalysisLogRepository, keyLevelsRepository: KeyLevelsRepository, technicalAnalysisRepository: TechnicalAnalysisRepository, financialAnalysisRepository: FinancialAnalysisRepository, newsAnalysisRepository: NewsAnalysisRepository, compositeAnalysisRepository: CompositeAnalysisRepository);
+    render(symbol: string, profile: AnalysisViewProfile, limit?: number): Promise<string>;
+    private renderComposite;
+    private renderTechnical;
+    private renderFinancial;
+    private renderNews;
+    private renderAll;
+    private getLegacyComposite;
+}

package/dist/services/analysis-view-service.js

@@ -0,0 +1,343 @@
+export class AnalysisViewService {
+    analysisLogRepository;
+    keyLevelsRepository;
+    technicalAnalysisRepository;
+    financialAnalysisRepository;
+    newsAnalysisRepository;
+    compositeAnalysisRepository;
+    constructor(analysisLogRepository, keyLevelsRepository, technicalAnalysisRepository, financialAnalysisRepository, newsAnalysisRepository, compositeAnalysisRepository) {
+        this.analysisLogRepository = analysisLogRepository;
+        this.keyLevelsRepository = keyLevelsRepository;
+        this.technicalAnalysisRepository = technicalAnalysisRepository;
+        this.financialAnalysisRepository = financialAnalysisRepository;
+        this.newsAnalysisRepository = newsAnalysisRepository;
+        this.compositeAnalysisRepository = compositeAnalysisRepository;
+    }
+    async render(symbol, profile, limit = 1) {
+        const normalizedLimit = Math.max(1, Math.trunc(limit));
+        switch (profile) {
+            case "technical":
+                return this.renderTechnical(symbol, normalizedLimit);
+            case "financial":
+                return this.renderFinancial(symbol, normalizedLimit);
+            case "news":
+                return this.renderNews(symbol, normalizedLimit);
+            case "all":
+                return this.renderAll(symbol, normalizedLimit);
+            case "composite":
+            default:
+                return this.renderComposite(symbol, normalizedLimit);
+        }
+    }
+    async renderComposite(symbol, limit) {
+        const entries = await this.compositeAnalysisRepository.listLatest(symbol, limit);
+        if (entries.length > 0) {
+            return renderEntryCollection(symbol, "综合分析", entries, formatCompositeEntry, limit);
+        }
+        const legacy = await this.getLegacyComposite(symbol);
+        if (!legacy) {
+            return `⚠️ 暂无 ${symbol} 的综合分析记录`;
+        }
+        if (limit > 1) {
+            return [
+                `🗂️ 最近 ${limit} 次综合分析: ${symbol}`,
+                "返回记录: 1",
+                "说明: 当前仅存在 legacy 综合分析记录，历史列表从第二阶段结果表开始累计。",
+                "",
+                formatLegacyCompositeEntry(symbol, legacy),
+            ].join("\n");
+        }
+        return formatLegacyCompositeEntry(symbol, legacy);
+    }
+    async renderTechnical(symbol, limit) {
+        const entries = await this.technicalAnalysisRepository.listLatest(symbol, limit);
+        if (entries.length > 0) {
+            return renderEntryCollection(symbol, "技术面分析", entries, formatTechnicalEntry, limit);
+        }
+        const legacy = await this.getLegacyComposite(symbol);
+        if (!legacy) {
+            return `⚠️ 暂无 ${symbol} 的技术面分析记录`;
+        }
+        if (limit > 1) {
+            return [
+                `🗂️ 最近 ${limit} 次技术面分析: ${symbol}`,
+                "返回记录: 1",
+                "说明: 当前仅存在 legacy 技术面记录，历史列表从第二阶段结果表开始累计。",
+                "",
+                formatLegacyTechnicalEntry(symbol, legacy),
+            ].join("\n");
+        }
+        return formatLegacyTechnicalEntry(symbol, legacy);
+    }
+    async renderFinancial(symbol, limit) {
+        const entries = await this.financialAnalysisRepository.listLatest(symbol, limit);
+        if (entries.length === 0) {
+            return `⚠️ 暂无 ${symbol} 的基本面分析记录`;
+        }
+        return renderEntryCollection(symbol, "基本面分析", entries, formatFinancialEntry, limit);
+    }
+    async renderNews(symbol, limit) {
+        const entries = await this.newsAnalysisRepository.listLatest(symbol, limit);
+        if (entries.length === 0) {
+            return `⚠️ 暂无 ${symbol} 的资讯面分析记录`;
+        }
+        return renderEntryCollection(symbol, "资讯面分析", entries, formatNewsEntry, limit);
+    }
+    async renderAll(symbol, limit) {
+        const [composite, technical, financial, news] = await Promise.all([
+            this.compositeAnalysisRepository.listLatest(symbol, limit),
+            this.technicalAnalysisRepository.listLatest(symbol, limit),
+            this.financialAnalysisRepository.listLatest(symbol, limit),
+            this.newsAnalysisRepository.listLatest(symbol, limit),
+        ]);
+        const legacy = composite.length === 0 || technical.length === 0
+            ? await this.getLegacyComposite(symbol)
+            : null;
+        const sections = [
+            composite.length > 0
+                ? renderEntryCollection(symbol, "综合分析", composite, formatCompositeEntry, limit)
+                : formatLegacyOrEmptyComposite(symbol, legacy, limit),
+            technical.length > 0
+                ? renderEntryCollection(symbol, "技术面分析", technical, formatTechnicalEntry, limit)
+                : formatLegacyOrEmptyTechnical(symbol, legacy, limit),
+            financial.length > 0
+                ? renderEntryCollection(symbol, "基本面分析", financial, formatFinancialEntry, limit)
+                : `⚠️ 暂无 ${symbol} 的基本面分析记录`,
+            news.length > 0
+                ? renderEntryCollection(symbol, "资讯面分析", news, formatNewsEntry, limit)
+                : `⚠️ 暂无 ${symbol} 的资讯面分析记录`,
+        ];
+        return sections.join("\n\n====================\n\n");
+    }
+    async getLegacyComposite(symbol) {
+        const [analysisLog, keyLevels] = await Promise.all([
+            this.analysisLogRepository.getLatest(symbol),
+            this.keyLevelsRepository.getBySymbol(symbol),
+        ]);
+        if (!analysisLog) {
+            return null;
+        }
+        return {
+            analysis_date: analysisLog.analysis_date,
+            analysis_text: analysisLog.analysis_text,
+            structured_ok: analysisLog.structured_ok,
+            levels: keyLevels && keyLevels.symbol === symbol ? keyLevels : null,
+        };
+    }
+}
+function formatCompositeEntry(symbol, entry) {
+    const lines = [
+        `📝 最近一次综合分析: ${symbol}`,
+        `日期: ${entry.analysis_date}`,
+        `结构化解析: ${entry.structured_ok ? "成功" : "失败"}`,
+        renderScoreLine("综合评分", entry.score),
+        renderScoreLine("技术面评分", entry.technical_score),
+        renderScoreLine("基本面评分", entry.financial_score),
+        renderScoreLine("资讯面评分", entry.news_score),
+        `财务倾向: ${renderBias(entry.financial_bias)}`,
+        `资讯倾向: ${renderBias(entry.news_bias)}`,
+    ];
+    if (entry.evidence.financial_mode && entry.evidence.financial_mode !== "none") {
+        lines.push(`基本面模式: ${entry.evidence.financial_mode}${entry.evidence.financial_source ? ` | 来源=${entry.evidence.financial_source}` : ""}`);
+    }
+    if (entry.evidence.financial_latest_period_end) {
+        lines.push(`最新财报期: ${entry.evidence.financial_latest_period_end}`);
+    }
+    else if (entry.evidence.financial_lite_as_of) {
+        lines.push(`指标日期: ${entry.evidence.financial_lite_as_of}`);
+    }
+    if (entry.evidence.news_query) {
+        lines.push(`资讯检索: ${entry.evidence.news_query}`);
+    }
+    lines.push(`资讯条数: ${entry.evidence.news_source_count}`);
+    lines.push(...renderLevels(entry));
+    lines.push("", entry.analysis_text);
+    return lines.join("\n");
+}
+function formatTechnicalEntry(symbol, entry) {
+    const lines = [
+        `📝 最近一次技术面分析: ${symbol}`,
+        `日期: ${entry.analysis_date}`,
+        `结构化解析: ${entry.structured_ok ? "成功" : "失败"}`,
+        renderScoreLine("技术面评分", entry.score),
+        ...renderLevels(entry),
+        "",
+        entry.analysis_text,
+    ];
+    return lines.join("\n");
+}
+function formatFinancialEntry(symbol, entry) {
+    const lines = [
+        `📝 最近一次基本面分析: ${symbol}`,
+        `日期: ${entry.analysis_date}`,
+        renderScoreLine("基本面评分", entry.score),
+        `基本面倾向: ${renderBias(entry.bias)}`,
+    ];
+    if (entry.evidence.mode && entry.evidence.mode !== "none") {
+        lines.push(`分析模式: ${entry.evidence.mode}${entry.evidence.source ? ` | 来源=${entry.evidence.source}` : ""}`);
+    }
+    if (entry.evidence.latest_period_end) {
+        lines.push(`最新财报期: ${entry.evidence.latest_period_end}`);
+    }
+    else if (entry.evidence.lite_as_of) {
+        lines.push(`指标日期: ${entry.evidence.lite_as_of}`);
+    }
+    if (entry.evidence.latest_announce_date) {
+        lines.push(`公告日期: ${entry.evidence.latest_announce_date}`);
+    }
+    if (entry.evidence.mode === "lite") {
+        lines.push(`指标覆盖: ${entry.evidence.lite_metric_count ?? 0}${entry.evidence.lite_metric_labels && entry.evidence.lite_metric_labels.length > 0 ? ` | ${entry.evidence.lite_metric_labels.join(" / ")}` : ""}`);
+        if (entry.evidence.lite_query) {
+            lines.push(`拖底检索: ${entry.evidence.lite_query}`);
+        }
+    }
+    else {
+        lines.push(`数据覆盖: income=${entry.evidence.income_count}, metrics=${entry.evidence.metrics_count}, cash_flow=${entry.evidence.cash_flow_count}, balance_sheet=${entry.evidence.balance_sheet_count}`);
+    }
+    if (entry.evidence.note) {
+        lines.push(`备注: ${entry.evidence.note}`);
+    }
+    lines.push(...renderStringSection("优势", entry.strengths));
+    lines.push(...renderStringSection("风险", entry.risks));
+    lines.push(...renderStringSection("关注点", entry.watch_items));
+    lines.push("", entry.analysis_text);
+    return lines.join("\n");
+}
+function formatNewsEntry(symbol, entry) {
+    const lines = [
+        `📝 最近一次资讯面分析: ${symbol}`,
+        `日期: ${entry.analysis_date}`,
+        renderScoreLine("资讯面评分", entry.score),
+        `资讯倾向: ${renderBias(entry.bias)}`,
+        `检索问句: ${entry.query}`,
+        `资讯条数: ${entry.source_count}`,
+    ];
+    lines.push(...renderStringSection("催化因素", entry.catalysts));
+    lines.push(...renderStringSection("风险因素", entry.risks));
+    lines.push(...renderStringSection("跟踪要点", entry.watch_items));
+    if (entry.evidence.documents.length > 0) {
+        lines.push("证据快照:");
+        entry.evidence.documents.forEach((document, index) => {
+            const parts = [document.title];
+            if (document.published_at) {
+                parts.push(document.published_at);
+            }
+            if (document.source) {
+                parts.push(document.source);
+            }
+            lines.push(`${index + 1}. ${parts.join(" | ")}`);
+        });
+    }
+    lines.push("", entry.analysis_text);
+    return lines.join("\n");
+}
+function formatLegacyCompositeEntry(symbol, entry) {
+    const lines = [
+        `📝 最近一次综合分析: ${symbol}`,
+        `日期: ${entry.analysis_date}`,
+        `结构化解析: ${entry.structured_ok ? "成功" : "失败"}`,
+        "来源: legacy analysis_log",
+        ...renderLevels(entry.levels),
+        "",
+        entry.analysis_text,
+    ];
+    return lines.join("\n");
+}
+function formatLegacyTechnicalEntry(symbol, entry) {
+    const lines = [
+        `📝 最近一次技术面分析: ${symbol}`,
+        `日期: ${entry.analysis_date}`,
+        `结构化解析: ${entry.structured_ok ? "成功" : "失败"}`,
+        "来源: legacy key_levels/analysis_log",
+        ...renderLevels(entry.levels),
+        "",
+        entry.analysis_text,
+    ];
+    return lines.join("\n");
+}
+function formatLegacyOrEmptyComposite(symbol, legacy, limit = 1) {
+    if (!legacy) {
+        return `⚠️ 暂无 ${symbol} 的综合分析记录`;
+    }
+    if (limit > 1) {
+        return [
+            `🗂️ 最近 ${limit} 次综合分析: ${symbol}`,
+            "返回记录: 1",
+            "说明: 当前仅存在 legacy 综合分析记录，历史列表从第二阶段结果表开始累计。",
+            "",
+            formatLegacyCompositeEntry(symbol, legacy),
+        ].join("\n");
+    }
+    return formatLegacyCompositeEntry(symbol, legacy);
+}
+function formatLegacyOrEmptyTechnical(symbol, legacy, limit = 1) {
+    if (!legacy) {
+        return `⚠️ 暂无 ${symbol} 的技术面分析记录`;
+    }
+    if (limit > 1) {
+        return [
+            `🗂️ 最近 ${limit} 次技术面分析: ${symbol}`,
+            "返回记录: 1",
+            "说明: 当前仅存在 legacy 技术面记录，历史列表从第二阶段结果表开始累计。",
+            "",
+            formatLegacyTechnicalEntry(symbol, legacy),
+        ].join("\n");
+    }
+    return formatLegacyTechnicalEntry(symbol, legacy);
+}
+function renderEntryCollection(symbol, title, entries, formatter, requestedLimit) {
+    if (entries.length === 1 && requestedLimit <= 1) {
+        return formatter(symbol, entries[0]);
+    }
+    const sections = entries.map((entry, index) => [`[${index + 1}]`, formatter(symbol, entry)].join("\n"));
+    return [
+        `🗂️ 最近 ${requestedLimit} 次${title}: ${symbol}`,
+        `返回记录: ${entries.length}`,
+        "",
+        sections.join("\n\n--------------------\n\n"),
+    ].join("\n");
+}
+function renderLevels(entry) {
+    if (!entry) {
+        return [];
+    }
+    const levelRows = [
+        ["当前价格", entry.current_price],
+        ["止损位", entry.stop_loss],
+        ["突破位", entry.breakthrough],
+        ["支撑位", entry.support],
+        ["成本位", entry.cost_level],
+        ["压力位", entry.resistance],
+        ["止盈位", entry.take_profit],
+        ["缺口位", entry.gap],
+        ["目标位", entry.target],
+        ["整数关", entry.round_number],
+    ];
+    return levelRows
+        .filter(([, value]) => value != null)
+        .map(([label, value]) => `${label}: ${formatPrice(value)}`);
+}
+function renderStringSection(title, items) {
+    if (items.length === 0) {
+        return [];
+    }
+    return [`${title}:`, ...items.map((item, index) => `${index + 1}. ${item}`)];
+}
+function renderScoreLine(label, score) {
+    return `${label}: ${score == null ? "暂无" : `${score}/10`}`;
+}
+function renderBias(bias) {
+    if (bias === "positive") {
+        return "偏多";
+    }
+    if (bias === "negative") {
+        return "偏空";
+    }
+    return "中性";
+}
+function formatPrice(value) {
+    if (!Number.isFinite(Number(value))) {
+        return "-";
+    }
+    return Number(value).toFixed(2);
+}

package/dist/services/financial-lite-service.d.ts

@@ -0,0 +1,23 @@
+import { MxApiService } from "./mx-search-service.js";
+export interface FinancialLiteMetric {
+    id: string;
+    label: string;
+    value: number | string | null;
+    unit: string | null;
+    asOf: string | null;
+}
+export interface FinancialLiteSnapshot {
+    symbol: string;
+    companyName: string;
+    query: string;
+    asOf: string | null;
+    parserText: string | null;
+    rowName: string | null;
+    metrics: FinancialLiteMetric[];
+}
+export declare class FinancialLiteService {
+    private readonly mxApiService;
+    constructor(mxApiService: MxApiService);
+    isConfigured(): boolean;
+    fetchSnapshot(symbol: string, companyName: string): Promise<FinancialLiteSnapshot | null>;
+}

package/dist/services/financial-lite-service.js

@@ -0,0 +1,201 @@
+const MAX_METRICS = 12;
+const METRIC_MATCHERS = [
+    { id: "roe", label: "ROE", patterns: [/(\b|_)roe(\b|_)/i, /净资产收益率/] },
+    { id: "roa", label: "ROA", patterns: [/(\b|_)roa(\b|_)/i, /总资产收益率/] },
+    { id: "gross_margin", label: "毛利率", patterns: [/gross[\s_-]*margin/i, /毛利率/] },
+    { id: "net_margin", label: "净利率", patterns: [/net[\s_-]*margin/i, /净利率/] },
+    {
+        id: "revenue_yoy",
+        label: "营收同比",
+        patterns: [/revenue[\s_-]*yoy/i, /营收同比/, /营业收入同比/],
+    },
+    {
+        id: "net_income_yoy",
+        label: "净利润同比",
+        patterns: [/net[\s_-]*income[\s_-]*yoy/i, /净利润同比/, /归母净利润同比/],
+    },
+    {
+        id: "debt_to_asset_ratio",
+        label: "资产负债率",
+        patterns: [/debt[\s_-]*to[\s_-]*asset/i, /资产负债率/],
+    },
+    {
+        id: "ocfps",
+        label: "每股经营现金流",
+        patterns: [/ocfps/i, /每股经营现金流/, /每股经营现金流量/],
+    },
+    {
+        id: "operating_cash_to_revenue",
+        label: "销售现金比率",
+        patterns: [/operating[\s_-]*cash[\s_-]*to[\s_-]*revenue/i, /销售现金比率/],
+    },
+    { id: "eps", label: "每股收益", patterns: [/(\b|_)(eps|basic_eps|eps_basic)(\b|_)/i, /每股收益/] },
+    { id: "bps", label: "每股净资产", patterns: [/(\b|_)bps(\b|_)/i, /每股净资产/] },
+];
+const CODE_PATTERNS = [/security[\s_-]*code/i, /secu[\s_-]*code/i, /股票代码/, /证券代码/, /^代码$/];
+const NAME_PATTERNS = [
+    /security[\s_-]*short[\s_-]*name/i,
+    /security[\s_-]*name/i,
+    /secu[\s_-]*name/i,
+    /股票简称/,
+    /证券简称/,
+    /^名称$/,
+];
+export class FinancialLiteService {
+    mxApiService;
+    constructor(mxApiService) {
+        this.mxApiService = mxApiService;
+    }
+    isConfigured() {
+        return this.mxApiService.isConfigured();
+    }
+    async fetchSnapshot(symbol, companyName) {
+        if (!this.isConfigured()) {
+            return null;
+        }
+        const query = buildFinancialLiteQuery(symbol, companyName);
+        const result = await this.mxApiService.selectStocks({
+            keyword: query,
+            pageNo: 1,
+            pageSize: 20,
+        });
+        const row = selectTargetRow(result, symbol, companyName);
+        if (!row) {
+            return null;
+        }
+        const metrics = selectFinancialMetrics(result.columns, row);
+        if (metrics.length === 0) {
+            return null;
+        }
+        return {
+            symbol,
+            companyName,
+            query,
+            asOf: resolveSnapshotAsOf(metrics),
+            parserText: result.parserText,
+            rowName: resolveRowName(result.columns, row),
+            metrics,
+        };
+    }
+}
+function buildFinancialLiteQuery(symbol, companyName) {
+    const securityName = companyName && companyName !== symbol ? `${companyName} ${symbol}` : symbol;
+    return `${securityName} 财务指标 ROE ROA 毛利率 净利率 营收同比 净利润同比 资产负债率 每股经营现金流 每股收益 每股净资产`;
+}
+function selectTargetRow(result, symbol, companyName) {
+    if (result.dataList.length === 0) {
+        return null;
+    }
+    const codeColumn = findIdentityColumn(result.columns, CODE_PATTERNS);
+    const nameColumn = findIdentityColumn(result.columns, NAME_PATTERNS);
+    const normalizedSymbol = normalizePlainText(symbol).replace(/\.(sz|sh|hk|us)$/i, "");
+    const normalizedName = normalizePlainText(companyName);
+    let bestRow = null;
+    let bestScore = -1;
+    for (const row of result.dataList) {
+        const codeValue = codeColumn ? normalizePlainText(row[codeColumn.key]).replace(/\.(sz|sh|hk|us)$/i, "") : "";
+        const nameValue = nameColumn ? normalizePlainText(row[nameColumn.key]) : "";
+        let score = 0;
+        if (codeValue && (codeValue === normalizedSymbol || normalizedSymbol.endsWith(codeValue))) {
+            score += 3;
+        }
+        if (normalizedName && nameValue && normalizedName.includes(nameValue)) {
+            score += 2;
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            bestRow = row;
+        }
+    }
+    return bestRow ?? result.dataList[0] ?? null;
+}
+function findIdentityColumn(columns, patterns) {
+    return (columns.find((column) => {
+        const normalized = normalizeColumnToken(column.title, column.key);
+        return patterns.some((pattern) => pattern.test(normalized));
+    }) ?? null);
+}
+function selectFinancialMetrics(columns, row) {
+    const metrics = [];
+    const usedIds = new Set();
+    for (const column of columns) {
+        const matcher = matchMetricColumn(column);
+        if (!matcher || usedIds.has(matcher.id)) {
+            continue;
+        }
+        const value = normalizeMetricValue(row[column.key]);
+        if (value == null || value === "") {
+            continue;
+        }
+        usedIds.add(matcher.id);
+        metrics.push({
+            id: matcher.id,
+            label: matcher.label,
+            value,
+            unit: column.unit,
+            asOf: column.dateMsg,
+        });
+        if (metrics.length >= MAX_METRICS) {
+            break;
+        }
+    }
+    return metrics;
+}
+function matchMetricColumn(column) {
+    const normalized = normalizeColumnToken(column.title, column.key);
+    for (const matcher of METRIC_MATCHERS) {
+        if (matcher.patterns.some((pattern) => pattern.test(normalized))) {
+            return {
+                id: matcher.id,
+                label: matcher.label,
+            };
+        }
+    }
+    return null;
+}
+function resolveSnapshotAsOf(metrics) {
+    const values = metrics
+        .map((metric) => metric.asOf?.trim() ?? "")
+        .filter(Boolean);
+    if (values.length === 0) {
+        return null;
+    }
+    const counts = new Map();
+    for (const value of values) {
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return [...counts.entries()].sort((left, right) => right[1] - left[1])[0]?.[0] ?? values[0];
+}
+function resolveRowName(columns, row) {
+    const nameColumn = findIdentityColumn(columns, NAME_PATTERNS);
+    if (!nameColumn) {
+        return null;
+    }
+    const value = row[nameColumn.key];
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizeMetricValue(value) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    const text = String(value).trim();
+    if (!text || text === "--" || text === "-") {
+        return null;
+    }
+    if (/^-?\d+(\.\d+)?$/.test(text)) {
+        const numeric = Number(text);
+        return Number.isFinite(numeric) ? numeric : text;
+    }
+    return text;
+}
+function normalizeColumnToken(title, key) {
+    return `${title} ${key}`.replace(/\s+/g, " ").trim();
+}
+function normalizePlainText(value) {
+    return String(value ?? "")
+        .trim()
+        .toLowerCase();
+}

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

@@ -0,0 +1,20 @@
+import type { TickFlowBalanceSheetRecord, TickFlowCashFlowRecord, TickFlowFinancialMetricsRecord, TickFlowFinancialQueryOptions, TickFlowIncomeRecord } from "../types/tickflow.js";
+import { TickFlowClient } from "./tickflow-client.js";
+export type FinancialSection = "income" | "metrics" | "cash_flow" | "balance_sheet";
+export declare const ALL_FINANCIAL_SECTIONS: FinancialSection[];
+export interface FinancialSnapshot {
+    symbol: string;
+    income: TickFlowIncomeRecord[];
+    metrics: TickFlowFinancialMetricsRecord[];
+    cashFlow: TickFlowCashFlowRecord[];
+    balanceSheet: TickFlowBalanceSheetRecord[];
+}
+export declare class FinancialService {
+    private readonly client;
+    constructor(client: TickFlowClient);
+    fetchIncome(symbol: string, options?: TickFlowFinancialQueryOptions): Promise<TickFlowIncomeRecord[]>;
+    fetchMetrics(symbol: string, options?: TickFlowFinancialQueryOptions): Promise<TickFlowFinancialMetricsRecord[]>;
+    fetchCashFlow(symbol: string, options?: TickFlowFinancialQueryOptions): Promise<TickFlowCashFlowRecord[]>;
+    fetchBalanceSheet(symbol: string, options?: TickFlowFinancialQueryOptions): Promise<TickFlowBalanceSheetRecord[]>;
+    fetchSnapshot(symbol: string, options?: TickFlowFinancialQueryOptions, sections?: FinancialSection[]): Promise<FinancialSnapshot>;
+}