tickflow-assist 0.2.0

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

@@ -0,0 +1,187 @@
+import { DEFAULT_MARKET_INDEXES } from "../../constants/market-indexes.js";
+import { formatTickflowApiKeyLevel, supportsIntradayKlines, } from "../../config/tickflow-access.js";
+const ANALYZE_INTRADAY_PERIOD = "1m";
+const ANALYZE_INTRADAY_RETENTION_DAYS = 30;
+export class MarketAnalysisProvider {
+    tickflowApiKeyLevel;
+    watchlistService;
+    klineService;
+    quoteService;
+    indicatorService;
+    reviewMemoryService;
+    tradingCalendarService;
+    klinesRepository;
+    intradayKlinesRepository;
+    indicatorsRepository;
+    constructor(tickflowApiKeyLevel, watchlistService, klineService, quoteService, indicatorService, reviewMemoryService, tradingCalendarService, klinesRepository, intradayKlinesRepository, indicatorsRepository) {
+        this.tickflowApiKeyLevel = tickflowApiKeyLevel;
+        this.watchlistService = watchlistService;
+        this.klineService = klineService;
+        this.quoteService = quoteService;
+        this.indicatorService = indicatorService;
+        this.reviewMemoryService = reviewMemoryService;
+        this.tradingCalendarService = tradingCalendarService;
+        this.klinesRepository = klinesRepository;
+        this.intradayKlinesRepository = intradayKlinesRepository;
+        this.indicatorsRepository = indicatorsRepository;
+    }
+    async load(symbol) {
+        const [watchlistItem, klines, indicators, quotes, reviewMemory, marketOverview] = await Promise.all([
+            this.watchlistService.getBySymbol(symbol, { refreshConceptBoards: true }),
+            this.klinesRepository.listBySymbol(symbol),
+            this.indicatorsRepository.listBySymbol(symbol),
+            this.quoteService.fetchQuotes([symbol]),
+            this.reviewMemoryService.getSymbolContext(symbol),
+            this.loadMarketOverview(),
+        ]);
+        let intradayKlines = [];
+        let intradayIndicators = [];
+        if (supportsIntradayKlines(this.tickflowApiKeyLevel)) {
+            try {
+                intradayKlines = await this.klineService.fetchIntradayKlines(symbol, {
+                    period: ANALYZE_INTRADAY_PERIOD,
+                });
+                if (intradayKlines.length > 0) {
+                    await this.intradayKlinesRepository.saveAll(symbol, ANALYZE_INTRADAY_PERIOD, intradayKlines);
+                    const keepTradeDates = await this.tradingCalendarService.getRecentTradingDays(ANALYZE_INTRADAY_RETENTION_DAYS, new Date(intradayKlines[intradayKlines.length - 1].timestamp));
+                    await this.intradayKlinesRepository.pruneToTradeDates(symbol, ANALYZE_INTRADAY_PERIOD, keepTradeDates);
+                    intradayIndicators = await this.indicatorService.calculate(intradayKlines);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[analyze] intraday fetch skipped for ${symbol} (${formatTickflowApiKeyLevel(this.tickflowApiKeyLevel)}): ${message}`);
+            }
+        }
+        return {
+            symbol,
+            companyName: watchlistItem?.name || symbol,
+            watchlistItem,
+            klines,
+            indicators,
+            intradayKlines,
+            intradayIndicators,
+            realtimeQuote: quotes[0] ?? null,
+            reviewMemory,
+            marketOverview,
+        };
+    }
+    async loadMarketOverview() {
+        const snapshots = (await Promise.all(DEFAULT_MARKET_INDEXES.map((spec) => this.loadIndexSnapshot(spec)))).filter((item) => item != null);
+        if (snapshots.length === 0) {
+            return {
+                available: false,
+                bias: "neutral",
+                summary: "未获取到上证指数/深证成指数据，本轮无法判断大盘顺风还是逆风。",
+                indices: [],
+            };
+        }
+        const bias = deriveMarketBias(snapshots);
+        const summary = [
+            ...snapshots.map((snapshot) => snapshot.summary),
+            `市场风格: ${formatMarketBiasLabel(bias)}`,
+        ].join("；");
+        return {
+            available: true,
+            bias,
+            summary,
+            indices: snapshots,
+        };
+    }
+    async loadIndexSnapshot(spec) {
+        const [klines, indicators, intradayRows] = await Promise.all([
+            this.klinesRepository.listBySymbol(spec.symbol),
+            this.indicatorsRepository.listBySymbol(spec.symbol),
+            this.intradayKlinesRepository.listBySymbol(spec.symbol, ANALYZE_INTRADAY_PERIOD),
+        ]);
+        const latest = klines[klines.length - 1];
+        if (!latest) {
+            return null;
+        }
+        const prevClose = latest.prev_close > 0 ? latest.prev_close : (klines[klines.length - 2]?.close ?? null);
+        const latestIndicator = indicators[indicators.length - 1] ?? null;
+        const changePct = prevClose != null && prevClose > 0
+            ? ((latest.close - prevClose) / prevClose) * 100
+            : null;
+        const snapshot = {
+            symbol: spec.symbol,
+            name: spec.name,
+            latestClose: latest.close,
+            prevClose,
+            changePct,
+            intradayClose: intradayRows[intradayRows.length - 1]?.close ?? null,
+            aboveMa5: isAbove(latest.close, latestIndicator?.ma5),
+            aboveMa10: isAbove(latest.close, latestIndicator?.ma10),
+            summary: "",
+        };
+        snapshot.summary = buildIndexSummary(snapshot);
+        return snapshot;
+    }
+}
+function isAbove(price, reference) {
+    if (!(reference != null && Number.isFinite(reference))) {
+        return null;
+    }
+    return price >= reference;
+}
+function buildIndexSummary(snapshot) {
+    const parts = [`${snapshot.name} ${formatMaybePrice(snapshot.latestClose)}`];
+    if (snapshot.changePct != null) {
+        parts.push(`${snapshot.changePct >= 0 ? "+" : ""}${snapshot.changePct.toFixed(2)}%`);
+    }
+    if (snapshot.aboveMa5 === true && snapshot.aboveMa10 === true) {
+        parts.push("站上 MA5/MA10");
+    }
+    else if (snapshot.aboveMa5 === true) {
+        parts.push("站上 MA5");
+    }
+    else if (snapshot.aboveMa10 === false) {
+        parts.push("位于 MA10 下方");
+    }
+    return parts.join(" | ");
+}
+function deriveMarketBias(snapshots) {
+    let score = 0;
+    for (const snapshot of snapshots) {
+        if (snapshot.changePct != null) {
+            if (snapshot.changePct >= 0.6) {
+                score += 2;
+            }
+            else if (snapshot.changePct > 0) {
+                score += 1;
+            }
+            else if (snapshot.changePct <= -0.6) {
+                score -= 2;
+            }
+            else if (snapshot.changePct < 0) {
+                score -= 1;
+            }
+        }
+        if (snapshot.aboveMa5 === true) {
+            score += 1;
+        }
+        else if (snapshot.aboveMa5 === false) {
+            score -= 1;
+        }
+    }
+    if (score >= 3) {
+        return "tailwind";
+    }
+    if (score <= -3) {
+        return "headwind";
+    }
+    return "neutral";
+}
+function formatMarketBiasLabel(bias) {
+    switch (bias) {
+        case "tailwind":
+            return "大盘偏顺风";
+        case "headwind":
+            return "大盘偏逆风";
+        default:
+            return "大盘中性";
+    }
+}
+function formatMaybePrice(value) {
+    return value == null ? "-" : value.toFixed(2);
+}

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

@@ -0,0 +1,9 @@
+import type { WatchlistItem } from "../../types/domain.js";
+import { MxApiService } from "../../services/mx-search-service.js";
+import type { NewsAnalysisContext } from "../types/composite-analysis.js";
+export declare class NewsAnalysisProvider {
+    private readonly mxApiService;
+    constructor(mxApiService: MxApiService);
+    load(symbol: string, companyName: string, watchlistItem?: WatchlistItem | null): Promise<NewsAnalysisContext>;
+    private searchDocuments;
+}

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

@@ -0,0 +1,60 @@
+import { buildBoardNewsQuery } from "../../services/watchlist-profile-service.js";
+const MAX_NEWS_DOCUMENTS = 8;
+const MAX_BOARD_DOCUMENTS = 6;
+export class NewsAnalysisProvider {
+    mxApiService;
+    constructor(mxApiService) {
+        this.mxApiService = mxApiService;
+    }
+    async load(symbol, companyName, watchlistItem = null) {
+        const query = buildNewsQuery(symbol, companyName);
+        const boardQuery = watchlistItem
+            ? buildBoardNewsQuery({
+                sector: watchlistItem.sector,
+                themes: watchlistItem.themes,
+            })
+            : null;
+        if (!this.mxApiService.isConfigured()) {
+            return {
+                symbol,
+                companyName,
+                query,
+                documents: [],
+                available: false,
+                boardQuery,
+                boardDocuments: [],
+                boardAvailable: false,
+            };
+        }
+        const [documents, boardDocuments] = await Promise.all([
+            this.searchDocuments(query, MAX_NEWS_DOCUMENTS, symbol, "company"),
+            boardQuery ? this.searchDocuments(boardQuery, MAX_BOARD_DOCUMENTS, symbol, "board") : Promise.resolve([]),
+        ]);
+        return {
+            symbol,
+            companyName,
+            query,
+            documents,
+            available: documents.length > 0,
+            boardQuery,
+            boardDocuments,
+            boardAvailable: boardDocuments.length > 0,
+        };
+    }
+    async searchDocuments(query, limit, symbol, scope) {
+        try {
+            return (await this.mxApiService.search(query)).slice(0, limit);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[analyze] ${scope} news fetch skipped for ${symbol}: ${message}`);
+            return [];
+        }
+    }
+}
+function buildNewsQuery(symbol, companyName) {
+    if (companyName && companyName !== symbol) {
+        return `${companyName} ${symbol} 最新新闻 公告 研报`;
+    }
+    return `${symbol} 最新新闻 公告 研报`;
+}

package/dist/analysis/tasks/analysis-step-task.d.ts

@@ -0,0 +1,11 @@
+export interface AnalysisStepTask<TInput, TResult> {
+    taskName: string;
+    prepare(input: TInput): Promise<{
+        systemPrompt: string;
+        userPrompt: string;
+    }> | {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string, input: TInput): Promise<TResult> | TResult;
+}

package/dist/analysis/tasks/analysis-step-task.js

@@ -0,0 +1 @@
+export {};

package/dist/analysis/tasks/analysis-task.d.ts

@@ -0,0 +1,13 @@
+export interface AnalysisTask<TInput, TResult> {
+    taskName: string;
+    prepare(input: TInput): Promise<{
+        systemPrompt: string;
+        userPrompt: string;
+    }> | {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string, input: TInput): Promise<TResult> | TResult;
+    persistResult(result: TResult, input: TInput): Promise<void> | void;
+    formatForUser(result: TResult): string;
+}

package/dist/analysis/tasks/analysis-task.js

@@ -0,0 +1 @@
+export {};

package/dist/analysis/tasks/composite-stock-analysis.task.d.ts

@@ -0,0 +1,17 @@
+import { KeyLevelsRepository } from "../../storage/repositories/key-levels-repo.js";
+import { AnalysisLogRepository } from "../../storage/repositories/analysis-log-repo.js";
+import type { AnalysisTask } from "./analysis-task.js";
+import type { CompositeAnalysisInput, CompositeAnalysisResult } from "../types/composite-analysis.js";
+export declare class CompositeStockAnalysisTask implements AnalysisTask<CompositeAnalysisInput, CompositeAnalysisResult> {
+    private readonly keyLevelsRepository;
+    private readonly analysisLogRepository;
+    readonly taskName = "composite_stock";
+    constructor(keyLevelsRepository: KeyLevelsRepository, analysisLogRepository: AnalysisLogRepository);
+    prepare(input: CompositeAnalysisInput): {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string, input: CompositeAnalysisInput): CompositeAnalysisResult;
+    persistResult(result: CompositeAnalysisResult, input: CompositeAnalysisInput): Promise<void>;
+    formatForUser(result: CompositeAnalysisResult): string;
+}

package/dist/analysis/tasks/composite-stock-analysis.task.js

@@ -0,0 +1,47 @@
+import { COMPOSITE_ANALYSIS_SYSTEM_PROMPT, buildCompositeAnalysisUserPrompt, } from "../../prompts/analysis/index.js";
+import { formatChinaDateTime } from "../../utils/china-time.js";
+import { formatKeyLevelsAnalysis, parseKeyLevels, validateKeyLevels, } from "../parsers/key-levels.parser.js";
+export class CompositeStockAnalysisTask {
+    keyLevelsRepository;
+    analysisLogRepository;
+    taskName = "composite_stock";
+    constructor(keyLevelsRepository, analysisLogRepository) {
+        this.keyLevelsRepository = keyLevelsRepository;
+        this.analysisLogRepository = analysisLogRepository;
+    }
+    prepare(input) {
+        return {
+            systemPrompt: COMPOSITE_ANALYSIS_SYSTEM_PROMPT,
+            userPrompt: buildCompositeAnalysisUserPrompt(input),
+        };
+    }
+    parseResult(analysisText, input) {
+        const parsed = parseKeyLevels(analysisText);
+        if (!parsed) {
+            return { analysisText, levels: null };
+        }
+        const levels = {
+            ...parsed,
+            symbol: input.market.symbol,
+            analysis_date: formatChinaDateTime().slice(0, 10),
+            analysis_text: analysisText,
+        };
+        validateKeyLevels(levels);
+        return { analysisText, levels };
+    }
+    async persistResult(result, input) {
+        const logEntry = {
+            symbol: input.market.symbol,
+            analysis_date: formatChinaDateTime().slice(0, 10),
+            analysis_text: result.analysisText,
+            structured_ok: result.levels != null,
+        };
+        if (result.levels) {
+            await this.keyLevelsRepository.save(input.market.symbol, result.levels);
+        }
+        await this.analysisLogRepository.append(logEntry);
+    }
+    formatForUser(result) {
+        return formatKeyLevelsAnalysis(result.analysisText, result.levels);
+    }
+}

package/dist/analysis/tasks/financial-fundamental-lite.task.d.ts

@@ -0,0 +1,10 @@
+import type { AnalysisStepTask } from "./analysis-step-task.js";
+import type { FinancialAnalysisContext, FinancialInsightResult } from "../types/composite-analysis.js";
+export declare class FinancialFundamentalLiteTask implements AnalysisStepTask<FinancialAnalysisContext, FinancialInsightResult> {
+    readonly taskName = "financial_fundamental_lite";
+    prepare(input: FinancialAnalysisContext): {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string): FinancialInsightResult;
+}

package/dist/analysis/tasks/financial-fundamental-lite.task.js

@@ -0,0 +1,21 @@
+import { FINANCIAL_LITE_ANALYSIS_SYSTEM_PROMPT, buildFinancialLiteAnalysisUserPrompt, } from "../../prompts/analysis/index.js";
+import { parseFinancialInsightResult, } from "./financial-fundamental.task.js";
+export class FinancialFundamentalLiteTask {
+    taskName = "financial_fundamental_lite";
+    prepare(input) {
+        if (!input.liteSnapshot) {
+            throw new Error(`没有找到 ${input.symbol} 的 lite 财务指标数据`);
+        }
+        return {
+            systemPrompt: FINANCIAL_LITE_ANALYSIS_SYSTEM_PROMPT,
+            userPrompt: buildFinancialLiteAnalysisUserPrompt({
+                symbol: input.symbol,
+                companyName: input.companyName,
+                snapshot: input.liteSnapshot,
+            }),
+        };
+    }
+    parseResult(analysisText) {
+        return parseFinancialInsightResult(analysisText);
+    }
+}

package/dist/analysis/tasks/financial-fundamental.task.d.ts

@@ -0,0 +1,12 @@
+import type { AnalysisStepTask } from "./analysis-step-task.js";
+import type { FinancialAnalysisContext, FinancialInsightResult } from "../types/composite-analysis.js";
+export declare class FinancialFundamentalTask implements AnalysisStepTask<FinancialAnalysisContext, FinancialInsightResult> {
+    readonly taskName = "financial_fundamental";
+    prepare(input: FinancialAnalysisContext): {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string): FinancialInsightResult;
+}
+export declare function buildFinancialFallbackResult(): FinancialInsightResult;
+export declare function parseFinancialInsightResult(analysisText: string): FinancialInsightResult;

package/dist/analysis/tasks/financial-fundamental.task.js

@@ -0,0 +1,64 @@
+import { FINANCIAL_ANALYSIS_SYSTEM_PROMPT, buildFinancialAnalysisUserPrompt, } from "../../prompts/analysis/index.js";
+import { parseJsonBlock } from "../parsers/json-block.parser.js";
+export class FinancialFundamentalTask {
+    taskName = "financial_fundamental";
+    prepare(input) {
+        if (input.mode !== "full" || !input.snapshot) {
+            throw new Error(`没有找到 ${input.symbol} 的财务数据`);
+        }
+        return {
+            systemPrompt: FINANCIAL_ANALYSIS_SYSTEM_PROMPT,
+            userPrompt: buildFinancialAnalysisUserPrompt({
+                symbol: input.symbol,
+                companyName: input.companyName,
+                snapshot: input.snapshot,
+            }),
+        };
+    }
+    parseResult(analysisText) {
+        return parseFinancialInsightResult(analysisText);
+    }
+}
+export function buildFinancialFallbackResult() {
+    return {
+        analysisText: "未获取到有效财务数据，本轮未执行基本面子分析。",
+        score: null,
+        bias: "neutral",
+        strengths: [],
+        risks: [],
+        watchItems: [],
+    };
+}
+export function parseFinancialInsightResult(analysisText) {
+    const parsed = parseJsonBlock(analysisText);
+    return {
+        analysisText: analysisText.trim(),
+        score: normalizeScore(parsed?.score),
+        bias: normalizeBias(parsed?.bias),
+        strengths: normalizeStringList(parsed?.strengths),
+        risks: normalizeStringList(parsed?.risks),
+        watchItems: normalizeStringList(parsed?.watch_items),
+    };
+}
+function normalizeScore(value) {
+    if (!Number.isFinite(Number(value))) {
+        return null;
+    }
+    const score = Math.trunc(Number(value));
+    return score >= 1 && score <= 10 ? score : null;
+}
+function normalizeBias(value) {
+    if (value === "positive" || value === "negative") {
+        return value;
+    }
+    return "neutral";
+}
+function normalizeStringList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => String(item ?? "").trim())
+        .filter(Boolean)
+        .slice(0, 3);
+}

package/dist/analysis/tasks/kline-technical-signal.task.d.ts

@@ -0,0 +1,10 @@
+import type { AnalysisStepTask } from "./analysis-step-task.js";
+import type { MarketAnalysisContext, TechnicalSignalResult } from "../types/composite-analysis.js";
+export declare class KlineTechnicalSignalTask implements AnalysisStepTask<MarketAnalysisContext, TechnicalSignalResult> {
+    readonly taskName = "kline_technical_signal";
+    prepare(input: MarketAnalysisContext): {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string, input: MarketAnalysisContext): TechnicalSignalResult;
+}

package/dist/analysis/tasks/kline-technical-signal.task.js

@@ -0,0 +1,41 @@
+import { ANALYSIS_COMMON_SYSTEM_PROMPT, buildKlineAnalysisUserPrompt, } from "../../prompts/analysis/index.js";
+import { formatChinaDateTime } from "../../utils/china-time.js";
+import { parseKeyLevels, validateKeyLevels } from "../parsers/key-levels.parser.js";
+export class KlineTechnicalSignalTask {
+    taskName = "kline_technical_signal";
+    prepare(input) {
+        if (input.klines.length === 0) {
+            throw new Error(`没有找到 ${input.symbol} 的K线数据，请先执行 fetch-klines`);
+        }
+        if (input.indicators.length === 0) {
+            throw new Error(`没有找到 ${input.symbol} 的指标数据，请先执行 fetch-klines`);
+        }
+        return {
+            systemPrompt: ANALYSIS_COMMON_SYSTEM_PROMPT,
+            userPrompt: buildKlineAnalysisUserPrompt({
+                symbol: input.symbol,
+                costPrice: input.watchlistItem?.costPrice ?? null,
+                klines: input.klines,
+                indicators: input.indicators,
+                intradayKlines: input.intradayKlines,
+                intradayIndicators: input.intradayIndicators,
+                realtimeQuote: input.realtimeQuote,
+                reviewMemory: input.reviewMemory,
+            }),
+        };
+    }
+    parseResult(analysisText, input) {
+        const parsed = parseKeyLevels(analysisText);
+        if (!parsed) {
+            return { analysisText, levels: null };
+        }
+        const levels = {
+            ...parsed,
+            symbol: input.symbol,
+            analysis_date: formatChinaDateTime().slice(0, 10),
+            analysis_text: analysisText,
+        };
+        validateKeyLevels(levels);
+        return { analysisText, levels };
+    }
+}

package/dist/analysis/tasks/kline-technical.task.d.ts

@@ -0,0 +1,32 @@
+import type { KeyLevels, WatchlistItem } from "../../types/domain.js";
+import type { IndicatorRow } from "../../types/indicator.js";
+import type { TickFlowIntradayKlineRow, TickFlowKlineRow, TickFlowQuote } from "../../types/tickflow.js";
+import { KeyLevelsRepository } from "../../storage/repositories/key-levels-repo.js";
+import { AnalysisLogRepository } from "../../storage/repositories/analysis-log-repo.js";
+import { AnalysisTask } from "./analysis-task.js";
+export interface KlineTechnicalAnalysisInput {
+    symbol: string;
+    watchlistItem: WatchlistItem | null;
+    klines: TickFlowKlineRow[];
+    indicators: IndicatorRow[];
+    intradayKlines: TickFlowIntradayKlineRow[];
+    intradayIndicators: IndicatorRow[];
+    realtimeQuote: TickFlowQuote | null;
+}
+export interface KlineTechnicalAnalysisResult {
+    analysisText: string;
+    levels: KeyLevels | null;
+}
+export declare class KlineTechnicalAnalysisTask implements AnalysisTask<KlineTechnicalAnalysisInput, KlineTechnicalAnalysisResult> {
+    private readonly keyLevelsRepository;
+    private readonly analysisLogRepository;
+    readonly taskName = "kline_technical";
+    constructor(keyLevelsRepository: KeyLevelsRepository, analysisLogRepository: AnalysisLogRepository);
+    prepare(input: KlineTechnicalAnalysisInput): {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string, input: KlineTechnicalAnalysisInput): KlineTechnicalAnalysisResult;
+    persistResult(result: KlineTechnicalAnalysisResult, input: KlineTechnicalAnalysisInput): Promise<void>;
+    formatForUser(result: KlineTechnicalAnalysisResult): string;
+}

package/dist/analysis/tasks/kline-technical.task.js

@@ -0,0 +1,61 @@
+import { ANALYSIS_COMMON_SYSTEM_PROMPT, buildKlineAnalysisUserPrompt, } from "../../prompts/analysis/index.js";
+import { formatChinaDateTime } from "../../utils/china-time.js";
+import { formatKeyLevelsAnalysis, parseKeyLevels, validateKeyLevels, } from "../parsers/key-levels.parser.js";
+export class KlineTechnicalAnalysisTask {
+    keyLevelsRepository;
+    analysisLogRepository;
+    taskName = "kline_technical";
+    constructor(keyLevelsRepository, analysisLogRepository) {
+        this.keyLevelsRepository = keyLevelsRepository;
+        this.analysisLogRepository = analysisLogRepository;
+    }
+    prepare(input) {
+        if (input.klines.length === 0) {
+            throw new Error(`没有找到 ${input.symbol} 的K线数据，请先执行 fetch-klines`);
+        }
+        if (input.indicators.length === 0) {
+            throw new Error(`没有找到 ${input.symbol} 的指标数据，请先执行 fetch-klines`);
+        }
+        return {
+            systemPrompt: ANALYSIS_COMMON_SYSTEM_PROMPT,
+            userPrompt: buildKlineAnalysisUserPrompt({
+                symbol: input.symbol,
+                costPrice: input.watchlistItem?.costPrice ?? null,
+                klines: input.klines,
+                indicators: input.indicators,
+                intradayKlines: input.intradayKlines,
+                intradayIndicators: input.intradayIndicators,
+                realtimeQuote: input.realtimeQuote,
+            }),
+        };
+    }
+    parseResult(analysisText, input) {
+        const parsed = parseKeyLevels(analysisText);
+        if (!parsed) {
+            return { analysisText, levels: null };
+        }
+        const levels = {
+            ...parsed,
+            symbol: input.symbol,
+            analysis_date: formatChinaDateTime().slice(0, 10),
+            analysis_text: analysisText,
+        };
+        validateKeyLevels(levels);
+        return { analysisText, levels };
+    }
+    async persistResult(result, input) {
+        const logEntry = {
+            symbol: input.symbol,
+            analysis_date: formatChinaDateTime().slice(0, 10),
+            analysis_text: result.analysisText,
+            structured_ok: result.levels != null,
+        };
+        if (result.levels) {
+            await this.keyLevelsRepository.save(input.symbol, result.levels);
+        }
+        await this.analysisLogRepository.append(logEntry);
+    }
+    formatForUser(result) {
+        return formatKeyLevelsAnalysis(result.analysisText, result.levels);
+    }
+}

package/dist/analysis/tasks/news-catalyst.task.d.ts

@@ -0,0 +1,11 @@
+import type { AnalysisStepTask } from "./analysis-step-task.js";
+import type { NewsAnalysisContext, NewsInsightResult } from "../types/composite-analysis.js";
+export declare class NewsCatalystTask implements AnalysisStepTask<NewsAnalysisContext, NewsInsightResult> {
+    readonly taskName = "news_catalyst";
+    prepare(input: NewsAnalysisContext): {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+    parseResult(analysisText: string): NewsInsightResult;
+}
+export declare function buildNewsFallbackResult(): NewsInsightResult;