tickflow-assist 0.2.10 → 0.2.11

package/README.md

@@ -2,6 +2,8 @@
 
 基于 [OpenClaw](https://openclaw.ai) 的 A 股监控与分析插件。它使用 [TickFlow](https://tickflow.org/auth/register?ref=BUJ54JEDGE) 获取行情与财务数据，结合 LLM 生成技术面、基本面、资讯面的综合判断，并把结果持久化到本地 LanceDB。
 
+最近更新：`v0.2.11` 优化复盘/告警文本样式，接入 PNG 告警卡发送与临时文件清理，并按 A 股习惯调整涨跌主色。
+
 ## 安装
 
 社区安装：

package/dist/bootstrap.js

@@ -26,6 +26,7 @@ import { QuoteService } from "./services/quote-service.js";
 import { TradingCalendarService } from "./services/trading-calendar-service.js";
 import { MonitorService } from "./services/monitor-service.js";
 import { AlertService } from "./services/alert-service.js";
+import { AlertMediaService } from "./services/alert-media-service.js";
 import { UpdateService } from "./services/update-service.js";
 import { KeyLevelsBacktestService } from "./services/key-levels-backtest-service.js";
 import { PostCloseReviewService } from "./services/post-close-review-service.js";
@@ -106,6 +107,7 @@ export function createAppContext(config, options = {}) {
             }
             : undefined,
     });
+    const alertMediaService = new AlertMediaService(config.databasePath);
     const indicatorService = new IndicatorService(config.pythonBin, config.pythonArgs, config.pythonWorkdir);
     const watchlistService = new WatchlistService(watchlistRepository, instrumentService, watchlistProfileService);
     const keyLevelsBacktestService = new KeyLevelsBacktestService(keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository, watchlistService);
@@ -121,7 +123,7 @@ export function createAppContext(config, options = {}) {
     const postCloseReviewTask = new PostCloseReviewTask();
     const compositeStockAnalysisTask = new CompositeStockAnalysisTask(keyLevelsRepository, analysisLogRepository);
     const compositeAnalysisOrchestrator = new CompositeAnalysisOrchestrator(analysisService, marketAnalysisProvider, financialAnalysisProvider, newsAnalysisProvider, klineTechnicalSignalTask, financialFundamentalTask, financialFundamentalLiteTask, newsCatalystTask, compositeStockAnalysisTask, technicalAnalysisRepository, financialAnalysisRepository, newsAnalysisRepository, compositeAnalysisRepository);
-    const monitorService = new MonitorService(config.databasePath, config.requestInterval, config.alertChannel, watchlistService, quoteService, tradingCalendarService, keyLevelsRepository, alertLogRepository, klinesRepository, alertService);
+    const monitorService = new MonitorService(config.databasePath, config.requestInterval, config.alertChannel, watchlistService, quoteService, tradingCalendarService, keyLevelsRepository, alertLogRepository, klinesRepository, intradayKlinesRepository, klineService, alertService, alertMediaService);
     const updateService = new UpdateService(klineService, config.tickflowApiKeyLevel, indicatorService, klinesRepository, indicatorsRepository, intradayKlinesRepository, watchlistService, tradingCalendarService);
     const postCloseReviewService = new PostCloseReviewService(watchlistService, compositeAnalysisOrchestrator, analysisService, postCloseReviewTask, keyLevelsRepository, keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository);
     const realtimeMonitorWorker = new RealtimeMonitorWorker(monitorService, config.requestInterval * 1000);

package/dist/services/alert-image-service.d.ts

@@ -0,0 +1,30 @@
+export type AlertImageTone = "support" | "breakthrough" | "stop_loss" | "take_profit" | "pressure";
+export interface AlertImagePoint {
+    time: string;
+    price: number;
+}
+export interface AlertImageLevels {
+    stopLoss?: number | null;
+    support?: number | null;
+    resistance?: number | null;
+    breakthrough?: number | null;
+    takeProfit?: number | null;
+}
+export interface AlertImageInput {
+    tone: AlertImageTone;
+    alertLabel: string;
+    name: string;
+    symbol: string;
+    timestampLabel: string;
+    currentPrice: number;
+    triggerPrice: number;
+    changePct?: number | null;
+    distancePct?: number | null;
+    costPrice?: number | null;
+    profitPct?: number | null;
+    note: string;
+    points: AlertImagePoint[];
+    levels: AlertImageLevels;
+}
+export declare function renderAlertCardSvg(input: AlertImageInput): string;
+export declare function renderAlertCardPng(input: AlertImageInput): Promise<Buffer>;

package/dist/services/alert-image-service.js

@@ -0,0 +1,435 @@
+import sharp from "sharp";
+const WIDTH = 960;
+const HEIGHT = 640;
+export function renderAlertCardSvg(input) {
+    if (input.points.length < 2) {
+        throw new Error("alert image requires at least 2 points");
+    }
+    const theme = resolveTheme(input.tone);
+    const direction = resolveMarketDirection(input);
+    const directionTheme = resolveDirectionTheme(direction);
+    const frame = {
+        x: 24,
+        y: 24,
+        width: 912,
+        height: HEIGHT - 48,
+    };
+    const chart = {
+        left: 44,
+        top: 214,
+        width: 650,
+        height: 228,
+    };
+    const levelPanel = {
+        x: 714,
+        y: 214,
+        width: 202,
+        height: 228,
+    };
+    const rail = {
+        left: 60,
+        top: 594,
+        width: 840,
+    };
+    const xAxisTextY = chart.top + chart.height + 28;
+    const noteTitleY = 500;
+    const noteTextY = 526;
+    const railTitleY = 562;
+    const priceValues = [
+        input.currentPrice,
+        input.triggerPrice,
+        ...input.points.map((point) => point.price),
+        input.levels.stopLoss ?? null,
+        input.levels.support ?? null,
+        input.levels.resistance ?? null,
+        input.levels.breakthrough ?? null,
+        input.levels.takeProfit ?? null,
+    ].filter((value) => value != null && Number.isFinite(value));
+    const minValue = Math.min(...priceValues);
+    const maxValue = Math.max(...priceValues);
+    const padding = Math.max((maxValue - minValue) * 0.18, 0.18);
+    const scaledMin = minValue - padding;
+    const scaledMax = maxValue + padding;
+    const valueRange = Math.max(0.01, scaledMax - scaledMin);
+    const scaleX = (index) => {
+        if (input.points.length === 1) {
+            return chart.left;
+        }
+        return chart.left + (index / (input.points.length - 1)) * chart.width;
+    };
+    const scaleY = (value) => (chart.top + ((scaledMax - value) / valueRange) * chart.height);
+    const linePath = input.points
+        .map((point, index) => `${index === 0 ? "M" : "L"} ${scaleX(index).toFixed(2)} ${scaleY(point.price).toFixed(2)}`)
+        .join(" ");
+    const areaPath = `${linePath} L ${(chart.left + chart.width).toFixed(2)} ${(chart.top + chart.height).toFixed(2)} L ${chart.left.toFixed(2)} ${(chart.top + chart.height).toFixed(2)} Z`;
+    const currentX = scaleX(input.points.length - 1);
+    const currentY = scaleY(input.points[input.points.length - 1]?.price ?? input.currentPrice);
+    const horizontalGrid = Array.from({ length: 5 }, (_, index) => {
+        const y = chart.top + (index / 4) * chart.height;
+        const value = scaledMax - (index / 4) * valueRange;
+        return {
+            y,
+            value,
+        };
+    });
+    const timeMarkers = buildTimeMarkers(input.points, scaleX);
+    const levelEntries = buildLevelEntries(input);
+    const levelPanelEntries = [...levelEntries].sort((left, right) => right.value - left.value);
+    const levelLines = buildLevelLines(levelEntries, scaleY);
+    const railMarkers = buildRailMarkers(input, rail.left, rail.width, rail.top, scaledMin, scaledMax);
+    const metricLines = buildMetricLines(input);
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<svg width="${WIDTH}" height="${HEIGHT}" viewBox="0 0 ${WIDTH} ${HEIGHT}" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="${WIDTH}" y2="${HEIGHT}" gradientUnits="userSpaceOnUse">
+      <stop stop-color="${directionTheme.backgroundStart}"/>
+      <stop offset="0.55" stop-color="${directionTheme.backgroundMid}"/>
+      <stop offset="1" stop-color="${directionTheme.backgroundEnd}"/>
+    </linearGradient>
+    <linearGradient id="chartFill" x1="${chart.left}" y1="${chart.top}" x2="${chart.left}" y2="${chart.top + chart.height}" gradientUnits="userSpaceOnUse">
+      <stop stop-color="${theme.accentSoft}" stop-opacity="0.55"/>
+      <stop offset="1" stop-color="${theme.accentSoft}" stop-opacity="0"/>
+    </linearGradient>
+    <linearGradient id="chartStroke" x1="${chart.left}" y1="${chart.top}" x2="${chart.left + chart.width}" y2="${chart.top}" gradientUnits="userSpaceOnUse">
+      <stop stop-color="${theme.accent}"/>
+      <stop offset="1" stop-color="${theme.accentStrong}"/>
+    </linearGradient>
+    <filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
+      <feDropShadow dx="0" dy="10" stdDeviation="14" flood-color="#02060C" flood-opacity="0.42"/>
+    </filter>
+  </defs>
+
+  <rect width="${WIDTH}" height="${HEIGHT}" rx="28" fill="url(#bg)"/>
+  <rect width="${WIDTH}" height="${HEIGHT}" rx="28" fill="${directionTheme.glowSoft}" fill-opacity="0.16"/>
+  <circle cx="842" cy="96" r="164" fill="${directionTheme.glowStrong}" fill-opacity="0.26"/>
+  <circle cx="760" cy="430" r="192" fill="${directionTheme.glowSoft}" fill-opacity="0.18"/>
+  <circle cx="120" cy="520" r="208" fill="${theme.accentSoft}" fill-opacity="0.12"/>
+
+  <rect x="${frame.x}" y="${frame.y}" width="${frame.width}" height="${frame.height}" rx="24" fill="${directionTheme.panelFill}" fill-opacity="0.90" stroke="${directionTheme.frameStroke}" stroke-width="1.4" stroke-opacity="0.95"/>
+  <rect x="${frame.x}" y="${frame.y}" width="${frame.width}" height="12" rx="24" fill="${directionTheme.ribbon}"/>
+
+  <text x="48" y="58" fill="#88A2BF" font-size="14" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif" letter-spacing="1.2">TICKFLOW ALERT PREVIEW</text>
+  <text x="48" y="108" fill="#F4F8FC" font-size="34" font-weight="700" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(input.name)}</text>
+  <text x="48" y="136" fill="#8FA8C4" font-size="18" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(input.symbol)} | ${escapeXml(input.timestampLabel)}</text>
+  <rect x="48" y="150" width="122" height="30" rx="15" fill="${directionTheme.marketPillFill}"/>
+  <text x="109" y="170" text-anchor="middle" fill="${directionTheme.marketPillText}" font-size="14" font-weight="700" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(directionTheme.marketLabel)}</text>
+
+  <rect x="710" y="42" width="198" height="42" rx="21" fill="${theme.signalPillFill}" />
+  <text x="809" y="69" text-anchor="middle" fill="${theme.signalPillText}" font-size="18" font-weight="700" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(input.alertLabel)}</text>
+
+  <text x="718" y="118" fill="#8AA3BE" font-size="15" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">当前价</text>
+  <text x="718" y="156" fill="#F6FBFF" font-size="34" font-weight="800" font-family="'JetBrains Mono','SFMono-Regular','Consolas',monospace">${input.currentPrice.toFixed(2)}</text>
+  ${metricLines.map((line, index) => `
+  <text x="718" y="${180 + index * 18}" fill="#A8BED7" font-size="14" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(line)}</text>`).join("")}
+
+  <rect x="${chart.left}" y="${chart.top}" width="${chart.width}" height="${chart.height}" rx="18" fill="${directionTheme.chartPanelFill}" stroke="${theme.panelBorder}" stroke-opacity="0.9"/>
+  ${horizontalGrid.map((line) => `
+  <line x1="${chart.left}" y1="${line.y.toFixed(2)}" x2="${chart.left + chart.width}" y2="${line.y.toFixed(2)}" stroke="#213247" stroke-dasharray="4 8"/>
+  <text x="${chart.left + 12}" y="${(line.y - 8).toFixed(2)}" fill="#6E88A5" font-size="12" font-family="'JetBrains Mono','SFMono-Regular','Consolas',monospace">${line.value.toFixed(2)}</text>`).join("")}
+
+  ${levelLines.map((line) => `
+  <line x1="${chart.left}" y1="${line.lineY.toFixed(2)}" x2="${chart.left + chart.width}" y2="${line.lineY.toFixed(2)}" stroke="${line.stroke}" stroke-width="${line.width}" stroke-dasharray="${line.dasharray}"/>`).join("")}
+
+  <path d="${areaPath}" fill="url(#chartFill)"/>
+  <path d="${linePath}" stroke="url(#chartStroke)" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" filter="url(#shadow)"/>
+  <circle cx="${currentX.toFixed(2)}" cy="${currentY.toFixed(2)}" r="7" fill="${theme.accentStrong}" stroke="#F4FBFF" stroke-width="3"/>
+
+  <rect x="${levelPanel.x}" y="${levelPanel.y}" width="${levelPanel.width}" height="${levelPanel.height}" rx="18" fill="${directionTheme.levelPanelFill}" stroke="${theme.panelBorder}" stroke-opacity="0.9"/>
+  <text x="${levelPanel.x + 18}" y="${levelPanel.y + 28}" fill="#8EA7C1" font-size="14" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">关键价位</text>
+  ${levelPanelEntries.map((entry, index) => {
+        const rowY = levelPanel.y + 60 + index * 34;
+        return `
+  <line x1="${levelPanel.x + 18}" y1="${rowY}" x2="${levelPanel.x + 42}" y2="${rowY}" stroke="${entry.stroke}" stroke-width="${entry.width + 0.5}" stroke-dasharray="${entry.dasharray}"/>
+  <text x="${levelPanel.x + 54}" y="${rowY + 5}" fill="#DCE8F5" font-size="14" font-weight="600" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(entry.label)}</text>
+  <text x="${levelPanel.x + levelPanel.width - 18}" y="${rowY + 5}" text-anchor="end" fill="${entry.text}" font-size="14" font-weight="700" font-family="'JetBrains Mono','SFMono-Regular','Consolas',monospace">${entry.value.toFixed(2)}</text>`;
+    }).join("")}
+
+  ${timeMarkers.map((marker) => `
+  <line x1="${marker.x.toFixed(2)}" y1="${chart.top + chart.height}" x2="${marker.x.toFixed(2)}" y2="${chart.top + chart.height + 8}" stroke="#48627E"/>
+  <text x="${marker.x.toFixed(2)}" y="${xAxisTextY}" text-anchor="middle" fill="#7791AD" font-size="12" font-family="'JetBrains Mono','SFMono-Regular','Consolas',monospace">${escapeXml(marker.label)}</text>`).join("")}
+
+  <text x="48" y="${noteTitleY}" fill="#8EA7C1" font-size="14" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">告警说明</text>
+  <text x="48" y="${noteTextY}" fill="#E8F1F8" font-size="16" font-weight="600" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(input.note)}</text>
+
+  <text x="48" y="${railTitleY}" fill="#8EA7C1" font-size="14" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">位阶带</text>
+  <line x1="${rail.left}" y1="${rail.top}" x2="${rail.left + rail.width}" y2="${rail.top}" stroke="#2E445D" stroke-width="8" stroke-linecap="round"/>
+  ${railMarkers.map((marker) => `
+  <line x1="${marker.x.toFixed(2)}" y1="${(rail.top - 14).toFixed(2)}" x2="${marker.x.toFixed(2)}" y2="${(rail.top + 14).toFixed(2)}" stroke="${marker.stroke}" stroke-width="${marker.width}" stroke-linecap="round"/>
+  <text x="${marker.x.toFixed(2)}" y="${marker.textY.toFixed(2)}" text-anchor="middle" fill="${marker.text}" font-size="12" font-weight="700" font-family="'Noto Sans CJK SC','Microsoft YaHei','PingFang SC',sans-serif">${escapeXml(marker.label)}</text>`).join("")}
+</svg>`;
+}
+export async function renderAlertCardPng(input) {
+    const svg = renderAlertCardSvg(input);
+    return sharp(Buffer.from(svg)).png().toBuffer();
+}
+function resolveMarketDirection(input) {
+    const basis = input.changePct ?? (((input.points[input.points.length - 1]?.price ?? input.currentPrice)
+        - (input.points[0]?.price ?? input.currentPrice))
+        / Math.max(0.01, input.points[0]?.price ?? input.currentPrice)) * 100;
+    if (basis > 0.01) {
+        return "up";
+    }
+    if (basis < -0.01) {
+        return "down";
+    }
+    return "flat";
+}
+function resolveTheme(tone) {
+    switch (tone) {
+        case "breakthrough":
+            return {
+                accent: "#67F3AE",
+                accentSoft: "#2AD97C",
+                accentStrong: "#9CFFCB",
+                panelBorder: "#2B7251",
+                priceTagFill: "#155A3D",
+                signalPillFill: "#163F2D",
+                signalPillText: "#BDF6D8",
+            };
+        case "stop_loss":
+            return {
+                accent: "#FF7C7C",
+                accentSoft: "#F55050",
+                accentStrong: "#FFC6C6",
+                panelBorder: "#7D3131",
+                priceTagFill: "#672727",
+                signalPillFill: "#471F1F",
+                signalPillText: "#FFD4D4",
+            };
+        case "take_profit":
+            return {
+                accent: "#D19BFF",
+                accentSoft: "#9D5CF2",
+                accentStrong: "#E6CCFF",
+                panelBorder: "#6B4398",
+                priceTagFill: "#4D2F71",
+                signalPillFill: "#38214F",
+                signalPillText: "#EDD7FF",
+            };
+        case "pressure":
+            return {
+                accent: "#FFC56A",
+                accentSoft: "#F19E2E",
+                accentStrong: "#FFE0A6",
+                panelBorder: "#8B6130",
+                priceTagFill: "#62441F",
+                signalPillFill: "#4A331A",
+                signalPillText: "#FFE3B8",
+            };
+        default:
+            return {
+                accent: "#6AD4FF",
+                accentSoft: "#2F8DFF",
+                accentStrong: "#B7ECFF",
+                panelBorder: "#285A8D",
+                priceTagFill: "#1D4F81",
+                signalPillFill: "#183957",
+                signalPillText: "#D0F2FF",
+            };
+    }
+}
+function resolveDirectionTheme(direction) {
+    switch (direction) {
+        case "up":
+            return {
+                backgroundStart: "#33080D",
+                backgroundMid: "#4C0F17",
+                backgroundEnd: "#29070C",
+                glowStrong: "#FF5D73",
+                glowSoft: "#BD2E49",
+                ribbon: "#FF6B81",
+                frameStroke: "#FF7488",
+                marketPillFill: "#5A1F2A",
+                marketPillText: "#FFE3E7",
+                marketLabel: "日内上涨",
+                panelFill: "#1D0C10",
+                chartPanelFill: "#271116",
+                levelPanelFill: "#2B1218",
+            };
+        case "down":
+            return {
+                backgroundStart: "#0A2B19",
+                backgroundMid: "#114124",
+                backgroundEnd: "#082214",
+                glowStrong: "#30F289",
+                glowSoft: "#10A85A",
+                ribbon: "#42F79C",
+                frameStroke: "#49ED98",
+                marketPillFill: "#195334",
+                marketPillText: "#D9FFE9",
+                marketLabel: "日内下跌",
+                panelFill: "#071A10",
+                chartPanelFill: "#0A2317",
+                levelPanelFill: "#0C2519",
+            };
+        default:
+            return {
+                backgroundStart: "#081730",
+                backgroundMid: "#0C2144",
+                backgroundEnd: "#08162B",
+                glowStrong: "#55AFFF",
+                glowSoft: "#2767B1",
+                ribbon: "#49A5FF",
+                frameStroke: "#5EB0FF",
+                marketPillFill: "#18456F",
+                marketPillText: "#DBF1FF",
+                marketLabel: "日内走平",
+                panelFill: "#091427",
+                chartPanelFill: "#0D1B35",
+                levelPanelFill: "#0F203C",
+            };
+    }
+}
+function buildMetricLines(input) {
+    const parts = [
+        `触发位 ${input.triggerPrice.toFixed(2)}`,
+        input.changePct == null ? null : `当日 ${formatSignedPercent(input.changePct)}`,
+        input.distancePct == null ? null : `偏离 ${formatSignedPercent(input.distancePct)}`,
+        input.profitPct == null ? null : `持仓 ${formatSignedPercent(input.profitPct)}`,
+    ].filter((value) => Boolean(value));
+    if (parts.length <= 2) {
+        return [parts.join(" | ")];
+    }
+    return [parts.slice(0, 2).join(" | "), parts.slice(2).join(" | ")];
+}
+function buildLevelEntries(input) {
+    return [
+        buildLevelEntry("止损", input.levels.stopLoss, "#FF6A6A", "rgba(92,30,35,0.94)", "#FFD3D3", 2.5, "6 6"),
+        buildLevelEntry("支撑", input.levels.support, "#78C7FF", "rgba(27,69,110,0.94)", "#DDF4FF", 2.5, "6 6"),
+        buildLevelEntry("压力", input.levels.resistance, "#FFCC66", "rgba(93,69,20,0.94)", "#FFF0C7", 2.5, "6 6"),
+        buildLevelEntry("突破", input.levels.breakthrough, "#7EF0B2", "rgba(22,74,49,0.94)", "#D9FFE9", 2.5, "6 6"),
+        buildLevelEntry("止盈", input.levels.takeProfit, "#D6A4FF", "rgba(76,43,117,0.94)", "#F1DFFF", 2.5, "6 6"),
+    ].filter((entry) => Boolean(entry));
+}
+function buildLevelLines(entries, scaleY) {
+    return entries.map((entry) => ({
+        lineY: scaleY(entry.value),
+        stroke: entry.stroke,
+        width: entry.width,
+        dasharray: entry.dasharray,
+    }));
+}
+function buildLevelEntry(label, value, stroke, fill, text, width, dasharray) {
+    if (!(value != null && Number.isFinite(value))) {
+        return null;
+    }
+    return {
+        value,
+        stroke,
+        fill,
+        text,
+        width,
+        dasharray,
+        label,
+    };
+}
+function buildTimeMarkers(points, scaleX) {
+    const preferred = ["09:30", "10:30", "11:30", "13:00", "14:00", "15:00"];
+    const markers = [];
+    for (const label of preferred) {
+        const exactIndex = points.findIndex((point) => point.time.startsWith(label));
+        if (exactIndex >= 0) {
+            markers.push({
+                x: scaleX(exactIndex),
+                label,
+            });
+        }
+    }
+    if (markers.length >= 3) {
+        return filterNearbyMarkers(markers, 56);
+    }
+    return filterNearbyMarkers([
+        { x: scaleX(0), label: points[0]?.time.slice(0, 5) ?? "" },
+        { x: scaleX(Math.floor((points.length - 1) / 2)), label: points[Math.floor((points.length - 1) / 2)]?.time.slice(0, 5) ?? "" },
+        { x: scaleX(points.length - 1), label: points[points.length - 1]?.time.slice(0, 5) ?? "" },
+    ], 56);
+}
+function buildRailMarkers(input, left, width, top, minValue, maxValue) {
+    const range = Math.max(0.01, maxValue - minValue);
+    const rawMarkers = [
+        { label: "止损", value: input.levels.stopLoss, stroke: "#FF7373", width: 5, text: "#FFCFCF" },
+        { label: "支撑", value: input.levels.support, stroke: "#74CFFF", width: 5, text: "#DBF4FF" },
+        { label: "现价", value: input.currentPrice, stroke: "#F7FBFF", width: 6, text: "#F7FBFF" },
+        { label: "压力", value: input.levels.resistance, stroke: "#FFCC6D", width: 5, text: "#FFF0C7" },
+        { label: "突破", value: input.levels.breakthrough, stroke: "#7DF2B4", width: 5, text: "#D8FFE8" },
+        { label: "止盈", value: input.levels.takeProfit, stroke: "#D9ABFF", width: 5, text: "#F2E2FF" },
+    ].filter((marker) => (marker.value != null && Number.isFinite(marker.value)));
+    const groupedMarkers = groupRailMarkers(rawMarkers).sort((leftMarker, rightMarker) => leftMarker.value - rightMarker.value);
+    const lanes = [
+        { y: top - 22, lastRight: -Infinity },
+        { y: Math.min(HEIGHT - 16, top + 38), lastRight: -Infinity },
+        { y: top - 46, lastRight: -Infinity },
+    ];
+    let previousX = -Infinity;
+    return groupedMarkers.map((marker) => {
+        const rawX = left + ((marker.value - minValue) / range) * width;
+        const x = Math.max(previousX + 22, Math.min(left + width, rawX));
+        const labelWidth = estimateRailLabelWidth(marker.label);
+        const preferredLane = lanes.find((lane) => x - labelWidth / 2 >= lane.lastRight + 10)
+            ?? lanes.reduce((best, lane) => (lane.lastRight < best.lastRight ? lane : best), lanes[0]);
+        preferredLane.lastRight = x + labelWidth / 2;
+        previousX = x;
+        return {
+            x,
+            label: marker.label,
+            stroke: marker.stroke,
+            width: marker.width,
+            text: marker.text,
+            textY: preferredLane.y,
+        };
+    });
+}
+function estimateRailLabelWidth(label) {
+    return label.length * 7 + 18;
+}
+function groupRailMarkers(markers) {
+    const groups = new Map();
+    for (const marker of markers) {
+        const key = marker.value.toFixed(4);
+        const group = groups.get(key) ?? [];
+        group.push(marker);
+        groups.set(key, group);
+    }
+    return [...groups.values()].map((group) => {
+        const label = `${group.map((item) => item.label).join("/")} ${group[0].value.toFixed(2)}`;
+        if (group.length === 1) {
+            return {
+                label,
+                value: group[0].value,
+                stroke: group[0].stroke,
+                width: group[0].width,
+                text: group[0].text,
+            };
+        }
+        return {
+            label,
+            value: group[0].value,
+            stroke: "#F3F7FB",
+            width: 6,
+            text: "#F7FBFF",
+        };
+    });
+}
+function formatSignedPercent(value) {
+    return `${value >= 0 ? "+" : ""}${value.toFixed(2)}%`;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function filterNearbyMarkers(markers, minGap) {
+    const filtered = [];
+    let previousX = -Infinity;
+    for (const marker of markers) {
+        if (marker.x - previousX < minGap) {
+            continue;
+        }
+        filtered.push(marker);
+        previousX = marker.x;
+    }
+    return filtered;
+}

package/dist/services/alert-media-service.d.ts

@@ -0,0 +1,23 @@
+import type { AlertImageInput } from "./alert-image-service.js";
+export interface AlertMediaFile {
+    filePath: string;
+    filename: string;
+    mediaLocalRoots: readonly string[];
+}
+export declare class AlertMediaService {
+    private readonly baseDir;
+    private readonly retentionHours;
+    private readonly cleanupIntervalMs;
+    private lastCleanupAt;
+    constructor(baseDir: string, retentionHours?: number, cleanupIntervalMs?: number);
+    getTempRootDir(): string;
+    writeAlertCard(params: {
+        symbol: string;
+        ruleName: string;
+        image: AlertImageInput;
+    }): Promise<AlertMediaFile>;
+    removeFile(filePath: string): Promise<void>;
+    maybeCleanupExpired(nowMs?: number): Promise<void>;
+    private cleanupDirectory;
+    private removeEmptyParents;
+}

package/dist/services/alert-media-service.js

@@ -0,0 +1,127 @@
+import { mkdir, readdir, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { renderAlertCardPng } from "./alert-image-service.js";
+import { formatChinaDateTime } from "../utils/china-time.js";
+const DEFAULT_RETENTION_HOURS = 24;
+const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+export class AlertMediaService {
+    baseDir;
+    retentionHours;
+    cleanupIntervalMs;
+    lastCleanupAt = 0;
+    constructor(baseDir, retentionHours = DEFAULT_RETENTION_HOURS, cleanupIntervalMs = DEFAULT_CLEANUP_INTERVAL_MS) {
+        this.baseDir = baseDir;
+        this.retentionHours = retentionHours;
+        this.cleanupIntervalMs = cleanupIntervalMs;
+    }
+    getTempRootDir() {
+        return path.resolve(this.baseDir, "..", "alert-media", "tmp");
+    }
+    async writeAlertCard(params) {
+        await this.maybeCleanupExpired();
+        const now = formatChinaDateTime();
+        const dateDir = now.slice(0, 10);
+        const outputDir = path.join(this.getTempRootDir(), dateDir);
+        await mkdir(outputDir, { recursive: true });
+        const filename = [
+            sanitizeFilePart(now.replace(/[: ]/g, "-")),
+            sanitizeFilePart(params.symbol),
+            sanitizeFilePart(params.ruleName),
+        ].join("_") + ".png";
+        const filePath = path.join(outputDir, filename);
+        const png = await renderAlertCardPng(params.image);
+        await writeFile(filePath, png);
+        return {
+            filePath,
+            filename,
+            mediaLocalRoots: [outputDir],
+        };
+    }
+    async removeFile(filePath) {
+        try {
+            await unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        await this.removeEmptyParents(path.dirname(filePath));
+    }
+    async maybeCleanupExpired(nowMs = Date.now()) {
+        if (nowMs - this.lastCleanupAt < this.cleanupIntervalMs) {
+            return;
+        }
+        this.lastCleanupAt = nowMs;
+        const cutoffMs = nowMs - this.retentionHours * 60 * 60 * 1000;
+        await this.cleanupDirectory(this.getTempRootDir(), cutoffMs);
+    }
+    async cleanupDirectory(dir, cutoffMs) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true, encoding: "utf8" });
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return true;
+            }
+            throw error;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const empty = await this.cleanupDirectory(fullPath, cutoffMs);
+                if (empty) {
+                    await safeRemoveDir(fullPath);
+                }
+                continue;
+            }
+            const fileStat = await stat(fullPath);
+            if (fileStat.mtimeMs < cutoffMs) {
+                await unlink(fullPath);
+            }
+        }
+        const remaining = await readdir(dir);
+        if (remaining.length === 0 && dir !== this.getTempRootDir()) {
+            await safeRemoveDir(dir);
+            return true;
+        }
+        return remaining.length === 0;
+    }
+    async removeEmptyParents(dir) {
+        const root = this.getTempRootDir();
+        let current = dir;
+        while (current.startsWith(root) && current !== root) {
+            let remaining;
+            try {
+                remaining = await readdir(current);
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    current = path.dirname(current);
+                    continue;
+                }
+                throw error;
+            }
+            if (remaining.length > 0) {
+                return;
+            }
+            await safeRemoveDir(current);
+            current = path.dirname(current);
+        }
+    }
+}
+async function safeRemoveDir(dir) {
+    try {
+        await rmdir(dir);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT" && code !== "ENOTEMPTY") {
+            throw error;
+        }
+    }
+}
+function sanitizeFilePart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}