tickflow-assist 0.3.2 → 0.3.4

package/dist/services/monitor-service.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { formatChinaDateTime } from "../utils/china-time.js";
 import { calculateProfitPct, formatCostPrice } from "../utils/cost-price.js";
@@ -20,6 +20,8 @@ const DEFAULT_STATE = {
     sessionNotificationsSent: [],
 };
 const INTRADAY_PERIOD = "1m";
+const MONITOR_RUN_LOCK_MIN_STALE_MS = 90_000;
+const ALERT_CLAIM_MIN_STALE_MS = 90_000;
 export class MonitorService {
     baseDir;
     requestInterval;
@@ -178,50 +180,60 @@ export class MonitorService {
         return lines.join("\n");
     }
     async runMonitorOnce() {
-        await this.alertMediaService.maybeCleanupExpired();
-        const phase = await this.tradingCalendarService.getTradingPhase();
-        let alertCount = await this.maybeSendSessionNotification(phase);
-        if (phase !== "trading") {
-            return alertCount;
-        }
-        const watchlist = await this.watchlistService.list();
-        if (watchlist.length === 0) {
-            return alertCount;
+        const runLease = await this.tryAcquireRunLease();
+        if (!runLease) {
+            return 0;
         }
-        const quotes = await this.quoteService.fetchQuotes(watchlist.map((item) => item.symbol));
-        const quoteMap = new Map(quotes.map((quote) => [quote.symbol, quote]));
-        for (const item of watchlist) {
-            const quote = quoteMap.get(item.symbol);
-            if (!quote || !(Number(quote.last_price) > 0)) {
-                continue;
+        try {
+            await this.alertMediaService.maybeCleanupExpired();
+            const phase = await this.tradingCalendarService.getTradingPhase();
+            let alertCount = await this.maybeSendSessionNotification(phase);
+            if (phase !== "trading") {
+                return alertCount;
             }
-            const levels = await this.keyLevelsRepository.getBySymbol(item.symbol);
-            let intradayRowsPromise = null;
-            const getIntradayRows = () => {
-                intradayRowsPromise ??= this.loadIntradayRows(item.symbol);
-                return intradayRowsPromise;
-            };
-            if (levels) {
-                for (const candidate of buildPriceAlerts(item, quote, levels, this.alertService)) {
-                    const delivery = await this.buildAlertDelivery(item, quote, candidate, levels, getIntradayRows);
-                    if (await this.trySendAlert(item.symbol, candidate.ruleName, delivery)) {
+            const watchlist = await this.watchlistService.list();
+            if (watchlist.length === 0) {
+                return alertCount;
+            }
+            const quotes = await this.quoteService.fetchQuotes(watchlist.map((item) => item.symbol));
+            const quoteMap = new Map(quotes.map((quote) => [quote.symbol, quote]));
+            for (const item of watchlist) {
+                const quote = quoteMap.get(item.symbol);
+                if (!quote || !(Number(quote.last_price) > 0)) {
+                    continue;
+                }
+                const levels = await this.keyLevelsRepository.getBySymbol(item.symbol);
+                let intradayRowsPromise = null;
+                const getIntradayRows = () => {
+                    intradayRowsPromise ??= this.loadIntradayRows(item.symbol);
+                    return intradayRowsPromise;
+                };
+                const priceAlert = levels
+                    ? selectPrimaryAlertCandidate(buildPriceAlerts(item, quote, levels, this.alertService))
+                    : null;
+                if (priceAlert) {
+                    if (await this.trySendCandidate(item, quote, priceAlert, levels, getIntradayRows)) {
                         alertCount += 1;
                     }
+                    continue;
                 }
-            }
-            const changeAlert = buildChangeAlert(item, quote, levels, this.alertService);
-            if (changeAlert) {
-                const delivery = await this.buildAlertDelivery(item, quote, changeAlert, levels, getIntradayRows);
-                if (await this.trySendAlert(item.symbol, changeAlert.ruleName, delivery)) {
+                const changeAlert = buildChangeAlert(item, quote, levels, this.alertService);
+                if (changeAlert) {
+                    if (await this.trySendCandidate(item, quote, changeAlert, levels, getIntradayRows)) {
+                        alertCount += 1;
+                    }
+                    continue;
+                }
+                const volumeAlert = await this.buildVolumeAlert(item, quote, levels);
+                if (volumeAlert && (await this.trySendAlert(item.symbol, volumeAlert.ruleName, volumeAlert.message))) {
                     alertCount += 1;
                 }
             }
-            const volumeAlert = await this.buildVolumeAlert(item, quote, levels);
-            if (volumeAlert && (await this.trySendAlert(item.symbol, volumeAlert.ruleName, volumeAlert.message))) {
-                alertCount += 1;
-            }
+            return alertCount;
+        }
+        finally {
+            await runLease.release();
         }
-        return alertCount;
     }
     async maybeSendSessionNotification(phase) {
         const now = formatChinaDateTime();
@@ -357,27 +369,135 @@ export class MonitorService {
             lastLoopErrorAt: formatChinaDateTime(),
         });
     }
+    async tryAcquireRunLease() {
+        const lockPath = this.getRunLockFilePath();
+        await mkdir(path.dirname(lockPath), { recursive: true });
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                await writeFile(lockPath, JSON.stringify({
+                    pid: process.pid,
+                    acquiredAt: formatChinaDateTime(),
+                }), { flag: "wx" });
+                return {
+                    release: async () => {
+                        await rm(lockPath, { force: true });
+                    },
+                };
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== "EEXIST") {
+                    throw error;
+                }
+                const cleared = await this.removeStaleRunLock(lockPath);
+                if (!cleared) {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    async removeStaleRunLock(lockPath) {
+        try {
+            const lockStat = await stat(lockPath);
+            const staleMs = Math.max(this.requestInterval * 4 * 1000, MONITOR_RUN_LOCK_MIN_STALE_MS);
+            if (Date.now() - lockStat.mtimeMs <= staleMs) {
+                return false;
+            }
+            await rm(lockPath, { force: true });
+            return true;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return true;
+            }
+            throw error;
+        }
+    }
+    async tryAcquireAlertClaim(symbol, ruleName, sessionKey) {
+        const lockPath = this.getAlertClaimFilePath(symbol, ruleName, sessionKey);
+        await mkdir(path.dirname(lockPath), { recursive: true });
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                await writeFile(lockPath, JSON.stringify({
+                    pid: process.pid,
+                    symbol,
+                    ruleName,
+                    sessionKey,
+                    acquiredAt: formatChinaDateTime(),
+                }), { flag: "wx" });
+                return {
+                    release: async () => {
+                        await rm(lockPath, { force: true });
+                    },
+                };
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== "EEXIST") {
+                    throw error;
+                }
+                const cleared = await this.removeStaleAlertClaim(lockPath);
+                if (!cleared) {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    async removeStaleAlertClaim(lockPath) {
+        try {
+            const lockStat = await stat(lockPath);
+            const staleMs = Math.max(this.requestInterval * 4 * 1000, ALERT_CLAIM_MIN_STALE_MS);
+            if (Date.now() - lockStat.mtimeMs <= staleMs) {
+                return false;
+            }
+            await rm(lockPath, { force: true });
+            return true;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return true;
+            }
+            throw error;
+        }
+    }
     async trySendAlert(symbol, ruleName, input) {
         const sessionKey = getSessionKey();
-        if (await this.alertLogRepository.isSentThisSession(symbol, ruleName, sessionKey)) {
+        const claim = await this.tryAcquireAlertClaim(symbol, ruleName, sessionKey);
+        if (!claim) {
+            await this.cleanupAlertMedia(input);
             return false;
         }
-        const result = await this.alertService.sendWithResult(input);
-        if (!result.ok) {
-            return false;
+        try {
+            if (await this.alertLogRepository.isSentThisSession(symbol, ruleName, sessionKey)) {
+                await this.cleanupAlertMedia(input);
+                return false;
+            }
+            const result = await this.sendAlertAndCleanupMedia(input);
+            if (!result.ok) {
+                return false;
+            }
+            const message = typeof input === "string" ? input : input.message;
+            await this.alertLogRepository.append({
+                symbol,
+                alert_date: sessionKey,
+                rule_name: ruleName,
+                message,
+                triggered_at: formatChinaDateTime(),
+            });
+            return true;
         }
-        if (typeof input !== "string" && input.mediaPath && result.mediaDelivered) {
-            await this.alertMediaService.removeFile(input.mediaPath);
+        finally {
+            await claim.release();
         }
-        const message = typeof input === "string" ? input : input.message;
-        await this.alertLogRepository.append({
-            symbol,
-            alert_date: sessionKey,
-            rule_name: ruleName,
-            message,
-            triggered_at: formatChinaDateTime(),
-        });
-        return true;
+    }
+    async trySendCandidate(item, quote, candidate, levels, getIntradayRows) {
+        if (await this.hasSentAlert(item.symbol, candidate.ruleName)) {
+            return false;
+        }
+        const delivery = await this.buildAlertDelivery(item, quote, candidate, levels, getIntradayRows);
+        return this.trySendAlert(item.symbol, candidate.ruleName, delivery);
     }
     async buildAlertDelivery(item, quote, candidate, levels, getIntradayRows) {
         if (!candidate.image || !levels) {
@@ -473,6 +593,29 @@ export class MonitorService {
             }),
         };
     }
+    async hasSentAlert(symbol, ruleName) {
+        return this.alertLogRepository.isSentThisSession(symbol, ruleName, getSessionKey());
+    }
+    async sendAlertAndCleanupMedia(input) {
+        try {
+            return await this.alertService.sendWithResult(input);
+        }
+        finally {
+            await this.cleanupAlertMedia(input);
+        }
+    }
+    async cleanupAlertMedia(input) {
+        if (typeof input === "string" || !input.mediaPath) {
+            return;
+        }
+        await this.alertMediaService.removeFile(input.mediaPath).catch(() => { });
+    }
+    getRunLockFilePath() {
+        return path.join(this.baseDir, "monitor-run.lock");
+    }
+    getAlertClaimFilePath(symbol, ruleName, sessionKey) {
+        return path.join(this.baseDir, "alert-claims", `${sanitizeAlertClaimPart(sessionKey)}_${sanitizeAlertClaimPart(symbol)}_${sanitizeAlertClaimPart(ruleName)}.lock`);
+    }
 }
 function formatRunningState(state, requestInterval) {
     const heartbeat = getHeartbeatStatus(state, requestInterval);
@@ -523,6 +666,9 @@ function parseChinaDateTime(value) {
     const [, year, month, day, hour, minute, second] = match;
     return Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour) - 8, Number(minute), Number(second));
 }
+function sanitizeAlertClaimPart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
 function formatRuntimeHost(state) {
     return state.runtimeHost === "plugin_service"
         ? "plugin_service"
@@ -658,23 +804,58 @@ function buildPriceAlerts(item, quote, levels, alertService) {
     if (levels.stop_loss && currentPrice <= levels.stop_loss) {
         push("stop_loss_hit", "⛔ 触及止损", "价格已触及止损位，建议立即执行止损", levels.stop_loss);
     }
-    else if (levels.stop_loss && currentPrice <= levels.stop_loss * (1 + buffer)) {
+    else if (levels.stop_loss
+        && currentPrice > levels.stop_loss
+        && isWithinPriceBuffer(currentPrice, levels.stop_loss, buffer)) {
         push("stop_loss_near", "⚠️ 接近止损", "价格接近止损位，请保持警惕", levels.stop_loss);
     }
+    if (levels.take_profit && currentPrice >= levels.take_profit) {
+        push("take_profit_hit", "💰 触及止盈", "价格已达止盈位，建议分批止盈", levels.take_profit);
+    }
     if (levels.breakthrough && currentPrice >= levels.breakthrough) {
         push("breakthrough_hit", "🚀 突破", "价格已突破关键压力位，可能开启新行情", levels.breakthrough);
     }
-    if (levels.support && currentPrice <= levels.support * (1 + buffer)) {
+    if (levels.support && isWithinPriceBuffer(currentPrice, levels.support, buffer)) {
         push("support_near", "📉 触及支撑", "价格接近支撑位，关注是否企稳", levels.support);
     }
-    if (levels.resistance && currentPrice >= levels.resistance * (1 - buffer)) {
+    if (levels.resistance && isWithinPriceBuffer(currentPrice, levels.resistance, buffer)) {
         push("resistance_near", "📈 接近压力", "价格接近压力位，关注能否突破", levels.resistance);
     }
-    if (levels.take_profit && currentPrice >= levels.take_profit) {
-        push("take_profit_hit", "💰 触及止盈", "价格已达止盈位，建议分批止盈", levels.take_profit);
-    }
     return alerts;
 }
+function selectPrimaryAlertCandidate(candidates) {
+    let best = null;
+    let bestPriority = Number.NEGATIVE_INFINITY;
+    for (const candidate of candidates) {
+        const priority = getAlertPriority(candidate.ruleName);
+        if (priority > bestPriority) {
+            best = candidate;
+            bestPriority = priority;
+        }
+    }
+    return best;
+}
+function getAlertPriority(ruleName) {
+    switch (ruleName) {
+        case "stop_loss_hit":
+            return 600;
+        case "take_profit_hit":
+            return 500;
+        case "breakthrough_hit":
+            return 400;
+        case "stop_loss_near":
+            return 300;
+        case "support_near":
+            return 200;
+        case "resistance_near":
+            return 100;
+        default:
+            return 0;
+    }
+}
+function isWithinPriceBuffer(currentPrice, levelPrice, buffer) {
+    return currentPrice >= levelPrice * (1 - buffer) && currentPrice <= levelPrice * (1 + buffer);
+}
 function buildChangeAlert(item, quote, levels, alertService) {
     const currentPrice = Number(quote.last_price);
     const prevClose = Number(quote.prev_close ?? 0);

package/dist/services/pre-market-brief-service.d.ts

@@ -0,0 +1,21 @@
+import { Jin10FlashRepository } from "../storage/repositories/jin10-flash-repo.js";
+import type { DailyUpdateResultType } from "../types/daily-update.js";
+import { AnalysisService } from "./analysis-service.js";
+import { Jin10McpService } from "./jin10-mcp-service.js";
+import { WatchlistService } from "./watchlist-service.js";
+export interface PreMarketBriefRunResult {
+    resultType: DailyUpdateResultType;
+    message: string;
+    sourceCount: number;
+    matchedWatchlistCount: number;
+}
+export declare class PreMarketBriefService {
+    private readonly watchlistService;
+    private readonly jin10McpService;
+    private readonly flashRepository;
+    private readonly analysisService;
+    constructor(watchlistService: WatchlistService, jin10McpService: Jin10McpService, flashRepository: Jin10FlashRepository, analysisService: AnalysisService);
+    run(now?: Date): Promise<PreMarketBriefRunResult>;
+    private syncWindow;
+    private buildSummary;
+}

package/dist/services/pre-market-brief-service.js

@@ -0,0 +1,289 @@
+import { createHash } from "node:crypto";
+import { PRE_MARKET_BRIEF_SYSTEM_PROMPT, buildPreMarketBriefUserPrompt, } from "../prompts/analysis/index.js";
+import { formatChinaDateTime } from "../utils/china-time.js";
+const PRE_MARKET_BRIEF_KEYWORD = "金十数据整理";
+const PRE_MARKET_READY_TIME = "09:20:00";
+const PRE_MARKET_SYNC_MAX_PAGES = 12;
+const OPPORTUNITY_KEYWORDS = [
+    "政策",
+    "订单",
+    "中标",
+    "业绩",
+    "回购",
+    "增持",
+    "涨价",
+    "算力",
+    "并购",
+    "并购重组",
+    "AI",
+    "人工智能",
+    "机器人",
+];
+const RISK_KEYWORDS = [
+    "减持",
+    "监管",
+    "问询",
+    "处罚",
+    "停牌",
+    "复牌",
+    "下调",
+    "风险",
+    "不确定",
+    "制裁",
+    "关税",
+];
+export class PreMarketBriefService {
+    watchlistService;
+    jin10McpService;
+    flashRepository;
+    analysisService;
+    constructor(watchlistService, jin10McpService, flashRepository, analysisService) {
+        this.watchlistService = watchlistService;
+        this.jin10McpService = jin10McpService;
+        this.flashRepository = flashRepository;
+        this.analysisService = analysisService;
+    }
+    async run(now = new Date()) {
+        const watchlist = await this.watchlistService.list();
+        if (watchlist.length === 0) {
+            return {
+                resultType: "skipped",
+                message: "🚫 开盘前资讯简报已跳过：关注列表为空。",
+                sourceCount: 0,
+                matchedWatchlistCount: 0,
+            };
+        }
+        const configError = this.jin10McpService.getConfigurationError();
+        if (configError) {
+            return {
+                resultType: "skipped",
+                message: `🚫 开盘前资讯简报已跳过：${configError}`,
+                sourceCount: 0,
+                matchedWatchlistCount: 0,
+            };
+        }
+        const window = buildPreMarketWindow(now);
+        await this.syncWindow(window);
+        const flashes = (await this.flashRepository.listByPublishedRange(window.startTs, window.endTs))
+            .filter((record) => matchesPreMarketBrief(record));
+        if (flashes.length === 0) {
+            return {
+                resultType: "success",
+                message: [
+                    `**🌅 开盘前资讯简报｜${window.endAt.slice(0, 10)}**`,
+                    `信息窗口: ${window.startAt} ~ ${window.endAt}`,
+                    `整理快讯: 0 条 | 自选: ${watchlist.length} 只`,
+                    "",
+                    `本窗口未检索到标题含“${PRE_MARKET_BRIEF_KEYWORD}”的快讯，今日无新增盘前整理摘要。`,
+                ].join("\n"),
+                sourceCount: 0,
+                matchedWatchlistCount: 0,
+            };
+        }
+        const matchContexts = flashes.map((flash) => ({
+            flash,
+            matchedItems: findMatchedItems(flash, watchlist),
+        }));
+        const matchedWatchlistCount = new Set(matchContexts.flatMap((context) => context.matchedItems.map((item) => item.symbol))).size;
+        const summary = await this.buildSummary(window, watchlist, matchContexts);
+        return {
+            resultType: "success",
+            message: [
+                `**🌅 开盘前资讯简报｜${window.endAt.slice(0, 10)}**`,
+                `信息窗口: ${window.startAt} ~ ${window.endAt}`,
+                `整理快讯: ${flashes.length} 条 | 自选: ${watchlist.length} 只 | 规则命中: ${matchedWatchlistCount} 只`,
+                "",
+                summary.trim(),
+            ].join("\n"),
+            sourceCount: flashes.length,
+            matchedWatchlistCount,
+        };
+    }
+    async syncWindow(window) {
+        let cursor;
+        const collected = [];
+        for (let pageIndex = 0; pageIndex < PRE_MARKET_SYNC_MAX_PAGES; pageIndex += 1) {
+            const page = await this.jin10McpService.listFlash(cursor);
+            const records = page.items
+                .map((item) => toFlashRecord(item))
+                .filter((item) => item != null);
+            if (records.length === 0) {
+                break;
+            }
+            collected.push(...records);
+            const oldestPublishedTs = records[records.length - 1]?.published_ts ?? Number.MAX_SAFE_INTEGER;
+            if (oldestPublishedTs < window.startTs || !page.hasMore || !page.nextCursor) {
+                break;
+            }
+            cursor = page.nextCursor;
+        }
+        if (collected.length > 0) {
+            await this.flashRepository.saveAll(collected);
+        }
+    }
+    async buildSummary(window, watchlist, matchContexts) {
+        const promptInput = {
+            windowStartAt: window.startAt,
+            windowEndAt: window.endAt,
+            watchlist,
+            flashes: matchContexts.map((context) => ({
+                publishedAt: context.flash.published_at,
+                headline: extractHeadlineFromContent(context.flash.content),
+                content: context.flash.content,
+                url: context.flash.url,
+                matchedSymbols: context.matchedItems.map((item) => item.symbol),
+            })),
+        };
+        if (this.analysisService.isConfigured()) {
+            try {
+                return await this.analysisService.generateText(PRE_MARKET_BRIEF_SYSTEM_PROMPT, buildPreMarketBriefUserPrompt(promptInput), {
+                    maxTokens: 1600,
+                    temperature: 0.2,
+                });
+            }
+            catch {
+                // Fall through to deterministic fallback so the scheduled push still lands.
+            }
+        }
+        return buildFallbackSummary(matchContexts);
+    }
+}
+function buildPreMarketWindow(now) {
+    const chinaToday = formatChinaDate(now);
+    const previousDay = formatChinaDate(new Date(toChinaTimestamp(`${chinaToday} ${PRE_MARKET_READY_TIME}`) - 24 * 60 * 60 * 1000));
+    const startAt = `${previousDay} 17:00:00`;
+    const endAt = `${chinaToday} ${PRE_MARKET_READY_TIME}`;
+    return {
+        startAt,
+        endAt,
+        startTs: toChinaTimestamp(startAt),
+        endTs: toChinaTimestamp(endAt),
+    };
+}
+function toChinaTimestamp(value) {
+    return new Date(`${value.replace(" ", "T")}+08:00`).getTime();
+}
+function formatChinaDate(date) {
+    const formatter = new Intl.DateTimeFormat("zh-CN", {
+        timeZone: "Asia/Shanghai",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    });
+    const map = Object.fromEntries(formatter
+        .formatToParts(date)
+        .filter((part) => part.type !== "literal")
+        .map((part) => [part.type, part.value]));
+    return `${map.year}-${map.month}-${map.day}`;
+}
+function matchesPreMarketBrief(record) {
+    return extractHeadlineText(record.content).includes(PRE_MARKET_BRIEF_KEYWORD);
+}
+function findMatchedItems(flash, watchlist) {
+    const normalizedContent = normalizeText(flash.content);
+    return watchlist.filter((item) => {
+        const directKeywords = [item.symbol, item.symbol.slice(0, 6), item.name];
+        const boardKeywords = [item.sector ?? "", ...item.themes]
+            .map((keyword) => keyword.replace(/\s+/g, "").trim())
+            .filter((keyword) => keyword.length >= 2);
+        return [...directKeywords, ...boardKeywords]
+            .map((keyword) => normalizeText(keyword))
+            .some((keyword) => keyword && normalizedContent.includes(keyword));
+    });
+}
+function buildFallbackSummary(matchContexts) {
+    const opportunityContexts = matchContexts.filter((context) => containsAnyKeyword(context.flash.content, OPPORTUNITY_KEYWORDS));
+    const riskContexts = matchContexts.filter((context) => containsAnyKeyword(context.flash.content, RISK_KEYWORDS));
+    return [
+        formatSectionTitle("🧭", "重大要闻"),
+        formatFlashBullets(matchContexts, 5),
+        "",
+        formatSectionTitle("🎯", "自选相关"),
+        formatMatchedBullets(matchContexts, 5),
+        "",
+        formatSectionTitle("💡", "潜在机会"),
+        opportunityContexts.length > 0
+            ? formatFlashBullets(opportunityContexts, 4)
+            : "• 未发现基于当前整理快讯可直接确认的新增机会方向。",
+        "",
+        formatSectionTitle("⚠️", "风险提示"),
+        riskContexts.length > 0
+            ? formatFlashBullets(riskContexts, 4)
+            : "• 当前整理快讯中未发现特别突出的新增风险，但仍需留意开盘后的情绪变化。",
+        "",
+        formatSectionTitle("📌", "开盘前关注清单"),
+        buildFocusBullets(matchContexts),
+    ].join("\n");
+}
+function formatFlashBullets(contexts, limit) {
+    return contexts
+        .slice(0, limit)
+        .map((context) => {
+        const time = context.flash.published_at.slice(11, 16);
+        return `• [${time}] ${extractHeadlineFromContent(context.flash.content)}`;
+    })
+        .join("\n");
+}
+function formatMatchedBullets(contexts, limit) {
+    const matched = contexts.filter((context) => context.matchedItems.length > 0).slice(0, limit);
+    if (matched.length === 0) {
+        return "• 未发现直接命中自选股、行业或题材的盘前整理快讯。";
+    }
+    return matched.map((context) => {
+        const labels = context.matchedItems.map((item) => `${item.name}（${item.symbol}）`).join("、");
+        return `• ${labels}: ${extractHeadlineFromContent(context.flash.content)}`;
+    }).join("\n");
+}
+function buildFocusBullets(contexts) {
+    const bullets = [];
+    const matchedContexts = contexts.filter((context) => context.matchedItems.length > 0);
+    for (const context of matchedContexts.slice(0, 3)) {
+        const labels = context.matchedItems.map((item) => item.name).join("、");
+        bullets.push(`• 关注 ${labels} 开盘后的量价反馈，核实“${extractHeadlineFromContent(context.flash.content)}”是否继续发酵。`);
+    }
+    if (bullets.length < 3) {
+        for (const context of contexts.slice(0, 3 - bullets.length)) {
+            bullets.push(`• 关注“${extractHeadlineFromContent(context.flash.content)}”对应板块是否出现竞价强化或高开分歧。`);
+        }
+    }
+    return bullets.slice(0, 5).join("\n");
+}
+function containsAnyKeyword(content, keywords) {
+    return keywords.some((keyword) => content.includes(keyword));
+}
+function normalizeText(value) {
+    return value.toLowerCase().replace(/\s+/g, "");
+}
+function formatSectionTitle(icon, title) {
+    return `**【${icon} ${title}】**`;
+}
+function extractHeadlineFromContent(content) {
+    const firstLine = extractHeadlineText(content);
+    return firstLine.length > 72 ? `${firstLine.slice(0, 72)}...` : firstLine;
+}
+function extractHeadlineText(content) {
+    return content.split(/[\n。！!]/)[0]?.trim() ?? "";
+}
+function toFlashRecord(item) {
+    const published = new Date(item.time);
+    if (Number.isNaN(published.getTime())) {
+        return null;
+    }
+    return {
+        flash_key: buildFlashKey(item.url, item.time, item.content),
+        published_at: formatChinaDateTime(published),
+        published_ts: published.getTime(),
+        content: item.content.trim(),
+        url: item.url.trim(),
+        ingested_at: formatChinaDateTime(),
+        raw: item.raw,
+    };
+}
+function buildFlashKey(url, time, content) {
+    if (url.trim()) {
+        return url.trim();
+    }
+    return createHash("sha1")
+        .update(`${time}\n${content}`)
+        .digest("hex");
+}