tickflow-assist 0.2.0

package/dist/analysis/orchestrators/composite-analysis.orchestrator.d.ts

@@ -0,0 +1,35 @@
+import { AnalysisService } from "../../services/analysis-service.js";
+import { CompositeAnalysisRepository } from "../../storage/repositories/composite-analysis-repo.js";
+import { FinancialAnalysisRepository } from "../../storage/repositories/financial-analysis-repo.js";
+import { NewsAnalysisRepository } from "../../storage/repositories/news-analysis-repo.js";
+import { TechnicalAnalysisRepository } from "../../storage/repositories/technical-analysis-repo.js";
+import { FinancialAnalysisProvider } from "../providers/financial-analysis.provider.js";
+import { MarketAnalysisProvider } from "../providers/market-analysis.provider.js";
+import { NewsAnalysisProvider } from "../providers/news-analysis.provider.js";
+import { CompositeStockAnalysisTask } from "../tasks/composite-stock-analysis.task.js";
+import { FinancialFundamentalTask } from "../tasks/financial-fundamental.task.js";
+import { FinancialFundamentalLiteTask } from "../tasks/financial-fundamental-lite.task.js";
+import { KlineTechnicalSignalTask } from "../tasks/kline-technical-signal.task.js";
+import { NewsCatalystTask } from "../tasks/news-catalyst.task.js";
+import type { CompositeAnalysisInput, CompositeAnalysisResult } from "../types/composite-analysis.js";
+export declare class CompositeAnalysisOrchestrator {
+    private readonly analysisService;
+    private readonly marketProvider;
+    private readonly financialProvider;
+    private readonly newsProvider;
+    private readonly technicalTask;
+    private readonly financialTask;
+    private readonly financialLiteTask;
+    private readonly newsTask;
+    private readonly compositeTask;
+    private readonly technicalAnalysisRepository;
+    private readonly financialAnalysisRepository;
+    private readonly newsAnalysisRepository;
+    private readonly compositeAnalysisRepository;
+    constructor(analysisService: AnalysisService, marketProvider: MarketAnalysisProvider, financialProvider: FinancialAnalysisProvider, newsProvider: NewsAnalysisProvider, technicalTask: KlineTechnicalSignalTask, financialTask: FinancialFundamentalTask, financialLiteTask: FinancialFundamentalLiteTask, newsTask: NewsCatalystTask, compositeTask: CompositeStockAnalysisTask, technicalAnalysisRepository: TechnicalAnalysisRepository, financialAnalysisRepository: FinancialAnalysisRepository, newsAnalysisRepository: NewsAnalysisRepository, compositeAnalysisRepository: CompositeAnalysisRepository);
+    buildInput(symbol: string): Promise<CompositeAnalysisInput>;
+    analyze(symbol: string): Promise<CompositeAnalysisResult>;
+    analyzeInput(compositeInput: CompositeAnalysisInput): Promise<CompositeAnalysisResult>;
+    formatForUser(result: CompositeAnalysisResult): string;
+    private runStep;
+}

package/dist/analysis/orchestrators/composite-analysis.orchestrator.js

@@ -0,0 +1,232 @@
+import { formatChinaDateTime } from "../../utils/china-time.js";
+import { buildFinancialFallbackResult, } from "../tasks/financial-fundamental.task.js";
+import { buildNewsFallbackResult } from "../tasks/news-catalyst.task.js";
+export class CompositeAnalysisOrchestrator {
+    analysisService;
+    marketProvider;
+    financialProvider;
+    newsProvider;
+    technicalTask;
+    financialTask;
+    financialLiteTask;
+    newsTask;
+    compositeTask;
+    technicalAnalysisRepository;
+    financialAnalysisRepository;
+    newsAnalysisRepository;
+    compositeAnalysisRepository;
+    constructor(analysisService, marketProvider, financialProvider, newsProvider, technicalTask, financialTask, financialLiteTask, newsTask, compositeTask, technicalAnalysisRepository, financialAnalysisRepository, newsAnalysisRepository, compositeAnalysisRepository) {
+        this.analysisService = analysisService;
+        this.marketProvider = marketProvider;
+        this.financialProvider = financialProvider;
+        this.newsProvider = newsProvider;
+        this.technicalTask = technicalTask;
+        this.financialTask = financialTask;
+        this.financialLiteTask = financialLiteTask;
+        this.newsTask = newsTask;
+        this.compositeTask = compositeTask;
+        this.technicalAnalysisRepository = technicalAnalysisRepository;
+        this.financialAnalysisRepository = financialAnalysisRepository;
+        this.newsAnalysisRepository = newsAnalysisRepository;
+        this.compositeAnalysisRepository = compositeAnalysisRepository;
+    }
+    async buildInput(symbol) {
+        const market = await this.marketProvider.load(symbol);
+        const [financial, news] = await Promise.all([
+            this.financialProvider.load(symbol, market.companyName),
+            this.newsProvider.load(symbol, market.companyName, market.watchlistItem),
+        ]);
+        const technicalPromise = this.runStep(this.technicalTask, market);
+        const financialPromise = financial.available
+            ? financial.mode === "lite"
+                ? this.runStep(this.financialLiteTask, financial)
+                : this.runStep(this.financialTask, financial)
+            : Promise.resolve(buildFinancialFallbackResult());
+        const newsPromise = news.available
+            ? this.runStep(this.newsTask, news)
+            : Promise.resolve(buildNewsFallbackResult());
+        const [technicalResult, financialResult, newsResult] = await Promise.all([
+            technicalPromise,
+            financialPromise,
+            newsPromise,
+        ]);
+        return {
+            market,
+            financial,
+            news,
+            technicalResult,
+            financialResult,
+            newsResult,
+        };
+    }
+    async analyze(symbol) {
+        const input = await this.buildInput(symbol);
+        return this.analyzeInput(input);
+    }
+    async analyzeInput(compositeInput) {
+        const analysisDate = formatChinaDateTime().slice(0, 10);
+        await Promise.all([
+            this.technicalAnalysisRepository.append(buildTechnicalAnalysisEntry(compositeInput.market.symbol, analysisDate, compositeInput.technicalResult)),
+            this.financialAnalysisRepository.append(buildFinancialAnalysisEntry(analysisDate, compositeInput.financial, compositeInput.financialResult)),
+            this.newsAnalysisRepository.append(buildNewsAnalysisEntry(analysisDate, compositeInput.news, compositeInput.newsResult)),
+        ]);
+        const result = await this.analysisService.runTask(this.compositeTask, compositeInput);
+        await this.compositeAnalysisRepository.append(buildCompositeAnalysisEntry(analysisDate, compositeInput, result));
+        return result;
+    }
+    formatForUser(result) {
+        return this.compositeTask.formatForUser(result);
+    }
+    async runStep(task, input) {
+        const prepared = await task.prepare(input);
+        const analysisText = await this.analysisService.generateText(prepared.systemPrompt, prepared.userPrompt);
+        return task.parseResult(analysisText, input);
+    }
+}
+function buildTechnicalAnalysisEntry(symbol, analysisDate, result) {
+    return {
+        symbol,
+        analysis_date: analysisDate,
+        analysis_text: result.analysisText,
+        structured_ok: result.levels != null,
+        ...toLevelsSnapshot(result.levels),
+    };
+}
+function buildFinancialAnalysisEntry(analysisDate, context, result) {
+    const evidence = buildFinancialEvidence(context);
+    return {
+        symbol: context.symbol,
+        analysis_date: analysisDate,
+        analysis_text: result.analysisText,
+        score: normalizeScore(result.score),
+        bias: result.bias,
+        strengths: result.strengths,
+        risks: result.risks,
+        watch_items: result.watchItems,
+        evidence,
+    };
+}
+function buildNewsAnalysisEntry(analysisDate, context, result) {
+    return {
+        symbol: context.symbol,
+        analysis_date: analysisDate,
+        query: context.query,
+        analysis_text: result.analysisText,
+        score: normalizeScore(result.score),
+        bias: result.bias,
+        catalysts: result.catalysts,
+        risks: result.risks,
+        watch_items: result.watchItems,
+        source_count: context.documents.length,
+        evidence: {
+            available: context.available,
+            source_count: context.documents.length,
+            documents: context.documents.slice(0, 5).map((document) => ({
+                title: document.title,
+                source: document.source,
+                published_at: document.publishedAt,
+                securities: document.secuList
+                    .map((security) => [security.secuCode, security.secuName].filter(Boolean).join(":"))
+                    .filter(Boolean),
+            })),
+        },
+    };
+}
+function buildCompositeAnalysisEntry(analysisDate, input, result) {
+    return {
+        symbol: input.market.symbol,
+        analysis_date: analysisDate,
+        analysis_text: result.analysisText,
+        structured_ok: result.levels != null,
+        ...toLevelsSnapshot(result.levels),
+        technical_score: normalizeScore(input.technicalResult.levels?.score ?? null),
+        financial_score: normalizeScore(input.financialResult.score),
+        news_score: normalizeScore(input.newsResult.score),
+        financial_bias: input.financialResult.bias,
+        news_bias: input.newsResult.bias,
+        evidence: {
+            technical_structured: input.technicalResult.levels != null,
+            financial_available: input.financial.available,
+            financial_mode: input.financial.mode,
+            financial_source: input.financial.source,
+            financial_latest_period_end: getLatestFinancialPeriodEnd(input.financial.snapshot),
+            financial_lite_as_of: input.financial.liteSnapshot?.asOf ?? null,
+            news_available: input.news.available,
+            news_query: input.news.query,
+            news_source_count: input.news.documents.length,
+        },
+    };
+}
+function buildFinancialEvidence(context) {
+    const latest = getLatestFinancialMeta(context.snapshot);
+    return {
+        available: context.available,
+        mode: context.mode,
+        source: context.source,
+        note: context.note,
+        latest_period_end: latest.periodEnd,
+        latest_announce_date: latest.announceDate,
+        income_count: context.snapshot?.income.length ?? 0,
+        metrics_count: context.snapshot?.metrics.length ?? 0,
+        cash_flow_count: context.snapshot?.cashFlow.length ?? 0,
+        balance_sheet_count: context.snapshot?.balanceSheet.length ?? 0,
+        lite_as_of: context.liteSnapshot?.asOf ?? null,
+        lite_query: context.liteSnapshot?.query ?? null,
+        lite_metric_count: context.liteSnapshot?.metrics.length ?? 0,
+        lite_metric_labels: buildLiteMetricLabels(context.liteSnapshot),
+    };
+}
+function getLatestFinancialMeta(snapshot) {
+    if (!snapshot) {
+        return {
+            periodEnd: null,
+            announceDate: null,
+        };
+    }
+    const records = [
+        ...snapshot.metrics,
+        ...snapshot.income,
+        ...snapshot.cashFlow,
+        ...snapshot.balanceSheet,
+    ];
+    const latest = records
+        .filter((record) => Boolean(record.period_end))
+        .sort((left, right) => right.period_end.localeCompare(left.period_end))[0];
+    return {
+        periodEnd: latest?.period_end ?? null,
+        announceDate: latest?.announce_date ?? null,
+    };
+}
+function getLatestFinancialPeriodEnd(snapshot) {
+    return getLatestFinancialMeta(snapshot).periodEnd;
+}
+function buildLiteMetricLabels(snapshot) {
+    if (!snapshot) {
+        return [];
+    }
+    return snapshot.metrics.map((metric) => metric.label).slice(0, 8);
+}
+function toLevelsSnapshot(levels) {
+    return {
+        current_price: toNullableNumber(levels?.current_price),
+        stop_loss: toNullableNumber(levels?.stop_loss),
+        breakthrough: toNullableNumber(levels?.breakthrough),
+        support: toNullableNumber(levels?.support),
+        cost_level: toNullableNumber(levels?.cost_level),
+        resistance: toNullableNumber(levels?.resistance),
+        take_profit: toNullableNumber(levels?.take_profit),
+        gap: toNullableNumber(levels?.gap),
+        target: toNullableNumber(levels?.target),
+        round_number: toNullableNumber(levels?.round_number),
+        score: normalizeScore(levels?.score ?? null),
+    };
+}
+function toNullableNumber(value) {
+    return Number.isFinite(Number(value)) ? Number(value) : null;
+}
+function normalizeScore(value) {
+    if (!Number.isFinite(Number(value))) {
+        return null;
+    }
+    return Math.trunc(Number(value));
+}

package/dist/analysis/parsers/json-block.parser.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonBlock<T>(responseText: string): T | null;

package/dist/analysis/parsers/json-block.parser.js

@@ -0,0 +1,13 @@
+export function parseJsonBlock(responseText) {
+    const fenced = responseText.match(/```json\s*([\s\S]*?)\s*```/i);
+    const candidate = fenced?.[1] ?? responseText.match(/\{[\s\S]*\}/)?.[0];
+    if (!candidate) {
+        return null;
+    }
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/analysis/parsers/key-levels.parser.d.ts

@@ -0,0 +1,5 @@
+import type { KeyLevels } from "../../types/domain.js";
+export declare function parseKeyLevels(responseText: string): KeyLevels | null;
+export declare function extractAnalysisConclusion(analysisText: string): string;
+export declare function validateKeyLevels(levels: KeyLevels): void;
+export declare function formatKeyLevelsAnalysis(analysisText: string, levels: KeyLevels | null): string;

package/dist/analysis/parsers/key-levels.parser.js

@@ -0,0 +1,61 @@
+const PRICE_FIELDS = [
+    ["当前价格", "current_price"],
+    ["止损位", "stop_loss"],
+    ["突破位", "breakthrough"],
+    ["支撑位", "support"],
+    ["成本位", "cost_level"],
+    ["压力位", "resistance"],
+    ["止盈位", "take_profit"],
+    ["缺口位", "gap"],
+    ["目标位", "target"],
+    ["整数关", "round_number"],
+];
+export function parseKeyLevels(responseText) {
+    const fenced = responseText.match(/```json\s*([\s\S]*?)\s*```/);
+    const candidate = fenced?.[1] ?? responseText.match(/\{[\s\S]*"current_price"[\s\S]*\}/)?.[0];
+    if (!candidate) {
+        return null;
+    }
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        return null;
+    }
+}
+export function extractAnalysisConclusion(analysisText) {
+    return analysisText.replace(/```json\s*[\s\S]*?\s*```/g, "").trim();
+}
+export function validateKeyLevels(levels) {
+    if (!(levels.current_price > 0)) {
+        throw new Error(`current_price must be > 0, got ${levels.current_price}`);
+    }
+    if (!Number.isInteger(levels.score) || levels.score < 1 || levels.score > 10) {
+        throw new Error(`score must be integer 1-10, got ${levels.score}`);
+    }
+    for (const [, key] of PRICE_FIELDS.slice(1)) {
+        if (key === "gap") {
+            continue;
+        }
+        const value = levels[key];
+        if (value != null && value < 0) {
+            throw new Error(`${String(key)} must be >= 0, got ${value}`);
+        }
+    }
+    if (levels.gap != null && !Number.isFinite(levels.gap)) {
+        throw new Error(`gap must be a finite number, got ${levels.gap}`);
+    }
+}
+export function formatKeyLevelsAnalysis(analysisText, levels) {
+    const conclusion = extractAnalysisConclusion(analysisText);
+    const lines = [conclusion];
+    if (levels) {
+        lines.push("", "📊 关键价位汇总:");
+        for (const [label, key] of PRICE_FIELDS) {
+            const value = levels[key];
+            lines.push(`  ${label}: ${value != null ? value.toFixed(2) : "暂无"}`);
+        }
+        lines.push("", `  技术面评分: ${levels.score}/10`);
+    }
+    return lines.join("\n");
+}

package/dist/analysis/parsers/post-close-review.parser.d.ts

@@ -0,0 +1,2 @@
+import type { PostCloseReviewResult } from "../types/composite-analysis.js";
+export declare function parsePostCloseReviewPayload(analysisText: string): Omit<PostCloseReviewResult, "analysisText">;

package/dist/analysis/parsers/post-close-review.parser.js

@@ -0,0 +1,79 @@
+import { parseJsonBlock } from "./json-block.parser.js";
+export function parsePostCloseReviewPayload(analysisText) {
+    const parsed = parseJsonBlock(analysisText) ?? {};
+    return {
+        decision: normalizeDecision(parsed.decision),
+        decisionReason: normalizeText(parsed.decision_reason),
+        sessionSummary: normalizeText(parsed.session_summary),
+        marketSectorSummary: normalizeText(parsed.market_sector_summary),
+        newsSummary: normalizeText(parsed.news_summary),
+        actionAdvice: normalizeText(parsed.action_advice),
+        marketBias: normalizeMarketBias(parsed.market_bias),
+        sectorBias: normalizeMarketBias(parsed.sector_bias),
+        newsImpact: normalizeNewsImpact(parsed.news_impact),
+        levels: normalizeLevels(parsed.levels),
+    };
+}
+function normalizeDecision(value) {
+    switch (String(value ?? "").trim().toLowerCase()) {
+        case "keep":
+        case "adjust":
+        case "recompute":
+        case "invalidate":
+            return String(value).trim().toLowerCase();
+        default:
+            return "recompute";
+    }
+}
+function normalizeMarketBias(value) {
+    switch (String(value ?? "").trim().toLowerCase()) {
+        case "tailwind":
+        case "headwind":
+            return String(value).trim().toLowerCase();
+        default:
+            return "neutral";
+    }
+}
+function normalizeNewsImpact(value) {
+    switch (String(value ?? "").trim().toLowerCase()) {
+        case "supportive":
+        case "disruptive":
+            return String(value).trim().toLowerCase();
+        default:
+            return "neutral";
+    }
+}
+function normalizeText(value) {
+    return String(value ?? "").trim();
+}
+function normalizeLevels(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const currentPrice = Number(value.current_price ?? NaN);
+    const score = Number(value.score ?? NaN);
+    if (!Number.isFinite(currentPrice) || !Number.isFinite(score)) {
+        return null;
+    }
+    return {
+        current_price: currentPrice,
+        stop_loss: toNullableNumber(value.stop_loss),
+        breakthrough: toNullableNumber(value.breakthrough),
+        support: toNullableNumber(value.support),
+        cost_level: toNullableNumber(value.cost_level),
+        resistance: toNullableNumber(value.resistance),
+        take_profit: toNullableNumber(value.take_profit),
+        gap: toNullableNumber(value.gap),
+        target: toNullableNumber(value.target),
+        round_number: toNullableNumber(value.round_number),
+        score: Math.max(1, Math.min(10, Math.trunc(score))),
+        analysis_text: "",
+    };
+}
+function toNullableNumber(value) {
+    if (value == null || value === "") {
+        return null;
+    }
+    const num = Number(value);
+    return Number.isFinite(num) ? num : null;
+}

package/dist/analysis/parsers/watchlist-profile.parser.d.ts

@@ -0,0 +1,6 @@
+export interface WatchlistProfileExtraction {
+    sector: string | null;
+    themes: string[];
+    confidence: "low" | "medium" | "high";
+}
+export declare function parseWatchlistProfileExtraction(responseText: string): WatchlistProfileExtraction | null;

package/dist/analysis/parsers/watchlist-profile.parser.js

@@ -0,0 +1,93 @@
+import { parseJsonBlock } from "./json-block.parser.js";
+const MAX_THEMES = 20;
+const GENERIC_THEME_LABELS = new Set([
+    "公司新闻",
+    "最新公告",
+    "最新新闻",
+    "市场快讯",
+    "公司公告",
+    "行业动态",
+    "板块动态",
+    "题材动态",
+    "概念动态",
+    "资金流向",
+    "龙虎榜",
+]);
+export function parseWatchlistProfileExtraction(responseText) {
+    const parsed = parseJsonBlock(responseText);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        sector: normalizeSector(parsed.sector),
+        themes: normalizeThemes(parsed.themes),
+        confidence: normalizeConfidence(parsed.confidence),
+    };
+}
+function normalizeSector(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const text = cleanLabel(value);
+    if (!text || isNullLike(text)) {
+        return null;
+    }
+    return text;
+}
+function normalizeThemes(value) {
+    const rawItems = Array.isArray(value)
+        ? value
+        : typeof value === "string"
+            ? [value]
+            : [];
+    const result = [];
+    const seen = new Set();
+    for (const rawItem of rawItems) {
+        const parts = splitThemeItem(String(rawItem ?? ""));
+        for (const part of parts) {
+            const cleaned = cleanLabel(part);
+            if (!cleaned || isNullLike(cleaned) || isGenericTheme(cleaned) || seen.has(cleaned)) {
+                continue;
+            }
+            seen.add(cleaned);
+            result.push(cleaned);
+            if (result.length >= MAX_THEMES) {
+                return result;
+            }
+        }
+    }
+    return result;
+}
+function splitThemeItem(value) {
+    return value
+        .split(/[、,，;；|]/)
+        .flatMap((item) => item.split(/\s*\/\s*/))
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function cleanLabel(value) {
+    return value
+        .trim()
+        .replace(/[《》"'“”]/g, "")
+        .replace(/^[：:、，,；;\-]+/, "")
+        .replace(/[：:、，,；;。]+$/g, "")
+        .replace(/等+$/g, "")
+        .replace(/[（(].*?[）)]/g, "")
+        .replace(/\s+/g, "")
+        .trim();
+}
+function isNullLike(value) {
+    return ["无", "暂无", "未知", "未识别", "未提及", "null", "none", "n/a"].includes(value.toLowerCase());
+}
+function isGenericTheme(value) {
+    if (GENERIC_THEME_LABELS.has(value)) {
+        return true;
+    }
+    return /(新闻|公告|快讯|资讯|消息|复盘)$/.test(value);
+}
+function normalizeConfidence(value) {
+    if (value === "high" || value === "medium") {
+        return value;
+    }
+    return "low";
+}

package/dist/analysis/providers/financial-analysis.provider.d.ts

@@ -0,0 +1,12 @@
+import type { TickflowApiKeyLevel } from "../../config/tickflow-access.js";
+import { FinancialService } from "../../services/financial-service.js";
+import { FinancialLiteService } from "../../services/financial-lite-service.js";
+import type { FinancialAnalysisContext } from "../types/composite-analysis.js";
+export declare class FinancialAnalysisProvider {
+    private readonly tickflowApiKeyLevel;
+    private readonly financialService;
+    private readonly financialLiteService;
+    constructor(tickflowApiKeyLevel: TickflowApiKeyLevel, financialService: FinancialService, financialLiteService: FinancialLiteService);
+    load(symbol: string, companyName: string): Promise<FinancialAnalysisContext>;
+    private loadLite;
+}

package/dist/analysis/providers/financial-analysis.provider.js

@@ -0,0 +1,85 @@
+export class FinancialAnalysisProvider {
+    tickflowApiKeyLevel;
+    financialService;
+    financialLiteService;
+    constructor(tickflowApiKeyLevel, financialService, financialLiteService) {
+        this.tickflowApiKeyLevel = tickflowApiKeyLevel;
+        this.financialService = financialService;
+        this.financialLiteService = financialLiteService;
+    }
+    async load(symbol, companyName) {
+        if (this.tickflowApiKeyLevel === "expert") {
+            try {
+                const snapshot = await this.financialService.fetchSnapshot(symbol, { latest: true });
+                const available = snapshot.income.length > 0 ||
+                    snapshot.metrics.length > 0 ||
+                    snapshot.cashFlow.length > 0 ||
+                    snapshot.balanceSheet.length > 0;
+                if (available) {
+                    return {
+                        symbol,
+                        companyName,
+                        mode: "full",
+                        source: "tickflow",
+                        snapshot,
+                        liteSnapshot: null,
+                        available: true,
+                        note: null,
+                    };
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[analyze] financial full fetch skipped for ${symbol}: ${message}`);
+                const liteContext = await this.loadLite(symbol, companyName, `tickflow_full_failed: ${message}`);
+                if (liteContext) {
+                    return liteContext;
+                }
+                return buildUnavailableFinancialContext(symbol, companyName, `tickflow_full_failed: ${message}`);
+            }
+        }
+        const liteReason = this.tickflowApiKeyLevel === "expert"
+            ? "tickflow_full_empty"
+            : `tickflow_level_${this.tickflowApiKeyLevel}_uses_lite`;
+        const liteContext = await this.loadLite(symbol, companyName, liteReason);
+        if (liteContext) {
+            return liteContext;
+        }
+        return buildUnavailableFinancialContext(symbol, companyName, liteReason);
+    }
+    async loadLite(symbol, companyName, note) {
+        try {
+            const snapshot = await this.financialLiteService.fetchSnapshot(symbol, companyName);
+            if (!snapshot || snapshot.metrics.length === 0) {
+                return null;
+            }
+            return {
+                symbol,
+                companyName,
+                mode: "lite",
+                source: "mx_select_stock",
+                snapshot: null,
+                liteSnapshot: snapshot,
+                available: true,
+                note,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[analyze] financial lite fetch skipped for ${symbol}: ${message}`);
+            return null;
+        }
+    }
+}
+function buildUnavailableFinancialContext(symbol, companyName, note) {
+    return {
+        symbol,
+        companyName,
+        mode: "none",
+        source: "none",
+        snapshot: null,
+        liteSnapshot: null,
+        available: false,
+        note,
+    };
+}

package/dist/analysis/providers/market-analysis.provider.d.ts

@@ -0,0 +1,27 @@
+import { type TickflowApiKeyLevel } from "../../config/tickflow-access.js";
+import { WatchlistService } from "../../services/watchlist-service.js";
+import { KlineService } from "../../services/kline-service.js";
+import { QuoteService } from "../../services/quote-service.js";
+import { IndicatorService } from "../../services/indicator-service.js";
+import { ReviewMemoryService } from "../../services/review-memory-service.js";
+import { TradingCalendarService } from "../../services/trading-calendar-service.js";
+import { KlinesRepository } from "../../storage/repositories/klines-repo.js";
+import { IntradayKlinesRepository } from "../../storage/repositories/intraday-klines-repo.js";
+import { IndicatorsRepository } from "../../storage/repositories/indicators-repo.js";
+import type { MarketAnalysisContext } from "../types/composite-analysis.js";
+export declare class MarketAnalysisProvider {
+    private readonly tickflowApiKeyLevel;
+    private readonly watchlistService;
+    private readonly klineService;
+    private readonly quoteService;
+    private readonly indicatorService;
+    private readonly reviewMemoryService;
+    private readonly tradingCalendarService;
+    private readonly klinesRepository;
+    private readonly intradayKlinesRepository;
+    private readonly indicatorsRepository;
+    constructor(tickflowApiKeyLevel: TickflowApiKeyLevel, watchlistService: WatchlistService, klineService: KlineService, quoteService: QuoteService, indicatorService: IndicatorService, reviewMemoryService: ReviewMemoryService, tradingCalendarService: TradingCalendarService, klinesRepository: KlinesRepository, intradayKlinesRepository: IntradayKlinesRepository, indicatorsRepository: IndicatorsRepository);
+    load(symbol: string): Promise<MarketAnalysisContext>;
+    private loadMarketOverview;
+    private loadIndexSnapshot;
+}