tickflow-assist 0.2.19 → 0.3.2

package/dist/services/jin10-mcp-service.d.ts

@@ -0,0 +1,29 @@
+import type { Jin10FlashPage } from "../types/jin10.js";
+interface JsonRpcResponse<T> {
+    jsonrpc: "2.0";
+    id?: string | number;
+    result?: T;
+    error?: {
+        code?: number;
+        message?: string;
+        data?: unknown;
+    };
+}
+export declare class Jin10McpService {
+    private readonly serverUrl;
+    private readonly apiToken;
+    private requestId;
+    private initialized;
+    private sessionId;
+    constructor(serverUrl: string, apiToken: string);
+    isConfigured(): boolean;
+    getConfigurationError(): string | null;
+    listFlash(cursor?: string): Promise<Jin10FlashPage>;
+    private initialize;
+    private callTool;
+    private request;
+    private notify;
+    private buildHeaders;
+}
+export declare function parseJsonRpcResponse<T>(rawText: string, expectedId?: string | number): JsonRpcResponse<T>;
+export {};

package/dist/services/jin10-mcp-service.js

@@ -0,0 +1,242 @@
+export class Jin10McpService {
+    serverUrl;
+    apiToken;
+    requestId = 1;
+    initialized = false;
+    sessionId = null;
+    constructor(serverUrl, apiToken) {
+        this.serverUrl = serverUrl;
+        this.apiToken = apiToken;
+    }
+    isConfigured() {
+        return this.getConfigurationError() == null;
+    }
+    getConfigurationError() {
+        if (!this.serverUrl.trim()) {
+            return "Jin10 MCP 未配置接口地址，请设置 jin10McpUrl";
+        }
+        if (!this.apiToken.trim()) {
+            return "Jin10 MCP 未配置 API Token，请设置 jin10ApiToken";
+        }
+        return null;
+    }
+    async listFlash(cursor) {
+        const payload = await this.callTool("list_flash", cursor ? { cursor } : {});
+        return normalizeFlashPage(payload);
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        await this.request("initialize", {
+            protocolVersion: "2025-11-25",
+            capabilities: {},
+            clientInfo: {
+                name: "mcp-client",
+                version: "1.0.0",
+            },
+        });
+        await this.notify("notifications/initialized");
+        try {
+            await this.request("tools/list", {});
+            await this.request("resources/list", {});
+        }
+        catch {
+            // Tool listing is a best-effort handshake step.
+        }
+        this.initialized = true;
+    }
+    async callTool(name, args) {
+        await this.initialize();
+        const result = await this.request("tools/call", {
+            name,
+            arguments: args,
+        });
+        if (!result) {
+            throw new Error(`jin10 tool ${name} returned empty result`);
+        }
+        if (result.isError) {
+            throw new Error(`jin10 tool ${name} returned MCP error`);
+        }
+        if (result.structuredContent !== undefined) {
+            return result.structuredContent;
+        }
+        const structured = result.content?.find((item) => item.structuredContent !== undefined)?.structuredContent;
+        if (structured !== undefined) {
+            return structured;
+        }
+        const text = result.content?.find((item) => typeof item.text === "string")?.text;
+        if (typeof text === "string" && text.trim()) {
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        }
+        return result;
+    }
+    async request(method, params) {
+        const configError = this.getConfigurationError();
+        if (configError) {
+            throw new Error(configError);
+        }
+        const payload = {
+            jsonrpc: "2.0",
+            id: this.requestId++,
+            method,
+            params,
+        };
+        const response = await fetch(this.serverUrl, {
+            method: "POST",
+            headers: this.buildHeaders(),
+            body: JSON.stringify(payload),
+        });
+        const sessionId = response.headers.get("mcp-session-id");
+        if (sessionId) {
+            this.sessionId = sessionId;
+        }
+        const rawText = await response.text();
+        if (!response.ok) {
+            throw new Error(`jin10 MCP request failed: ${response.status} ${response.statusText} ${rawText}`);
+        }
+        const parsed = parseJsonRpcResponse(rawText, payload.id);
+        if (parsed.error) {
+            throw new Error(`jin10 MCP error (${parsed.error.code ?? "unknown"}): ${parsed.error.message ?? "unknown"}`);
+        }
+        return parsed.result;
+    }
+    async notify(method) {
+        const configError = this.getConfigurationError();
+        if (configError) {
+            throw new Error(configError);
+        }
+        const payload = {
+            jsonrpc: "2.0",
+            method,
+        };
+        const response = await fetch(this.serverUrl, {
+            method: "POST",
+            headers: this.buildHeaders(),
+            body: JSON.stringify(payload),
+        });
+        const sessionId = response.headers.get("mcp-session-id");
+        if (sessionId) {
+            this.sessionId = sessionId;
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`jin10 MCP notification failed: ${response.status} ${response.statusText} ${text}`);
+        }
+    }
+    buildHeaders() {
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiToken}`,
+        };
+        if (this.sessionId) {
+            headers["Mcp-Session-Id"] = this.sessionId;
+        }
+        return headers;
+    }
+}
+export function parseJsonRpcResponse(rawText, expectedId) {
+    const trimmed = rawText.trim();
+    if (!trimmed) {
+        throw new Error("jin10 MCP returned empty body");
+    }
+    if (!looksLikeSsePayload(trimmed)) {
+        return JSON.parse(trimmed);
+    }
+    const candidates = parseSseJsonRpcResponses(trimmed);
+    if (candidates.length === 0) {
+        throw new Error(`jin10 MCP SSE payload missing JSON-RPC data: ${truncate(trimmed, 160)}`);
+    }
+    if (expectedId !== undefined) {
+        const matched = candidates.find((entry) => entry.id === expectedId);
+        if (matched) {
+            return matched;
+        }
+    }
+    const withResult = candidates.find((entry) => entry.result !== undefined || entry.error !== undefined);
+    if (withResult) {
+        return withResult;
+    }
+    return candidates[candidates.length - 1];
+}
+function parseSseJsonRpcResponses(rawText) {
+    const events = rawText
+        .split(/\r?\n\r?\n/)
+        .map((chunk) => chunk.trim())
+        .filter(Boolean);
+    const responses = [];
+    for (const eventText of events) {
+        const payload = extractSseData(eventText);
+        if (!payload || payload === "[DONE]") {
+            continue;
+        }
+        try {
+            responses.push(JSON.parse(payload));
+        }
+        catch {
+            continue;
+        }
+    }
+    return responses;
+}
+function extractSseData(eventText) {
+    const dataLines = eventText
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.replace(/^data:\s?/, ""));
+    return dataLines.join("\n").trim();
+}
+function looksLikeSsePayload(value) {
+    return value.startsWith("data:")
+        || value.startsWith("event:")
+        || value.startsWith(":")
+        || /\r?\ndata:/.test(value)
+        || /\r?\nevent:/.test(value);
+}
+function truncate(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function normalizeFlashPage(value) {
+    const root = isRecord(value) ? value : {};
+    const data = isRecord(root.data) ? root.data : {};
+    const items = Array.isArray(data.items) ? data.items : [];
+    return {
+        hasMore: data.has_more === true,
+        items: items
+            .map((item) => normalizeFlashItem(item))
+            .filter((item) => item != null),
+        nextCursor: normalizeNullableString(data.next_cursor),
+    };
+}
+function normalizeFlashItem(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const content = String(value.content ?? "").trim();
+    const time = String(value.time ?? "").trim();
+    const url = String(value.url ?? "").trim();
+    if (!content || !time || !url) {
+        return null;
+    }
+    return {
+        content,
+        time,
+        url,
+        raw: value,
+    };
+}
+function normalizeNullableString(value) {
+    const text = typeof value === "string" ? value.trim() : "";
+    return text || null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/services/post-close-review-service.d.ts

@@ -8,6 +8,8 @@ import { KeyLevelsRepository } from "../storage/repositories/key-levels-repo.js"
 import { KeyLevelsHistoryRepository } from "../storage/repositories/key-levels-history-repo.js";
 import { KlinesRepository } from "../storage/repositories/klines-repo.js";
 import { IntradayKlinesRepository } from "../storage/repositories/intraday-klines-repo.js";
+import { Jin10FlashDeliveryRepository } from "../storage/repositories/jin10-flash-delivery-repo.js";
+import { Jin10FlashRepository } from "../storage/repositories/jin10-flash-repo.js";
 export interface PostCloseReviewRunResult {
     overviewMessage: string;
     detailMessages: string[];
@@ -22,11 +24,14 @@ export declare class PostCloseReviewService {
     private readonly keyLevelsHistoryRepository;
     private readonly klinesRepository;
     private readonly intradayKlinesRepository;
-    constructor(watchlistService: WatchlistService, compositeAnalysisOrchestrator: CompositeAnalysisOrchestrator, analysisService: AnalysisService, postCloseReviewTask: PostCloseReviewTask, keyLevelsRepository: KeyLevelsRepository, keyLevelsHistoryRepository: KeyLevelsHistoryRepository, klinesRepository: KlinesRepository, intradayKlinesRepository: IntradayKlinesRepository);
+    private readonly flashDeliveryRepository;
+    private readonly flashRepository;
+    constructor(watchlistService: WatchlistService, compositeAnalysisOrchestrator: CompositeAnalysisOrchestrator, analysisService: AnalysisService, postCloseReviewTask: PostCloseReviewTask, keyLevelsRepository: KeyLevelsRepository, keyLevelsHistoryRepository: KeyLevelsHistoryRepository, klinesRepository: KlinesRepository, intradayKlinesRepository: IntradayKlinesRepository, flashDeliveryRepository: Jin10FlashDeliveryRepository, flashRepository: Jin10FlashRepository);
     run(): Promise<PostCloseReviewRunResult>;
     private persistReview;
     private persistFallbackCompositeReview;
     private buildValidationContext;
+    private buildFlashContext;
     private formatOverviewMessage;
     private formatDetailMessage;
     private formatFailureMessage;

package/dist/services/post-close-review-service.js

@@ -1,6 +1,11 @@
 import { formatChinaDateTime } from "../utils/china-time.js";
 const LEVEL_BUFFER = 0.005;
 const INTRADAY_PERIOD = "1m";
+const MARKET_OVERVIEW_FLASH_KEYWORDS = [
+    "港股收评",
+    "金十数据整理：每日投行/机构观点梳理",
+    "金十数据整理：A股每日市场要闻回顾",
+];
 export class PostCloseReviewService {
     watchlistService;
     compositeAnalysisOrchestrator;
@@ -10,7 +15,9 @@ export class PostCloseReviewService {
     keyLevelsHistoryRepository;
     klinesRepository;
     intradayKlinesRepository;
-    constructor(watchlistService, compositeAnalysisOrchestrator, analysisService, postCloseReviewTask, keyLevelsRepository, keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository) {
+    flashDeliveryRepository;
+    flashRepository;
+    constructor(watchlistService, compositeAnalysisOrchestrator, analysisService, postCloseReviewTask, keyLevelsRepository, keyLevelsHistoryRepository, klinesRepository, intradayKlinesRepository, flashDeliveryRepository, flashRepository) {
         this.watchlistService = watchlistService;
         this.compositeAnalysisOrchestrator = compositeAnalysisOrchestrator;
         this.analysisService = analysisService;
@@ -19,6 +26,8 @@ export class PostCloseReviewService {
         this.keyLevelsHistoryRepository = keyLevelsHistoryRepository;
         this.klinesRepository = klinesRepository;
         this.intradayKlinesRepository = intradayKlinesRepository;
+        this.flashDeliveryRepository = flashDeliveryRepository;
+        this.flashRepository = flashRepository;
     }
     async run() {
         const watchlist = await this.watchlistService.list();
@@ -41,10 +50,12 @@ export class PostCloseReviewService {
                 const tradeDate = input.market.klines[input.market.klines.length - 1]?.trade_date ?? formatChinaDateTime().slice(0, 10);
                 const validation = await this.buildValidationContext(item.symbol, tradeDate);
                 compositeResult = await this.compositeAnalysisOrchestrator.analyzeInput(input);
+                const flashContext = await this.buildFlashContext(item.symbol, tradeDate);
                 const review = await this.analysisService.runTask(this.postCloseReviewTask, {
                     ...input,
                     compositeResult,
                     validation,
+                    flashContext,
                 });
                 const message = this.formatDetailMessage(item, validation, review);
                 await this.persistReview(item.symbol, message, review);
@@ -154,6 +165,25 @@ export class PostCloseReviewService {
             lines,
         };
     }
+    async buildFlashContext(symbol, datePrefix) {
+        const [deliveries, overviewFlashes] = await Promise.all([
+            this.flashDeliveryRepository.listBySymbolsAndDate([symbol], datePrefix),
+            this.flashRepository.searchByContentKeywords(MARKET_OVERVIEW_FLASH_KEYWORDS, datePrefix),
+        ]);
+        const stockAlerts = deliveries.map((entry) => ({
+            publishedAt: entry.published_at,
+            content: entry.reason,
+            headline: entry.headline,
+            source: "stock_alert",
+        }));
+        const marketOverviewFlashes = overviewFlashes.map((record) => ({
+            publishedAt: record.published_at,
+            content: record.content,
+            headline: extractHeadlineFromContent(record.content),
+            source: "market_overview",
+        }));
+        return { stockAlerts, marketOverviewFlashes };
+    }
     formatOverviewMessage(marketOverview, entries) {
         const successEntries = entries.filter((entry) => entry.ok);
         const failureCount = entries.length - successEntries.length;
@@ -496,3 +526,7 @@ function formatPriceRail(markers) {
         .map((entry) => `${entry.parts.join("/")} ${entry.value.toFixed(2)}`)
         .join(" → ");
 }
+function extractHeadlineFromContent(content) {
+    const firstLine = content.split(/[\n。！!]/)[0]?.trim() ?? "";
+    return firstLine.length > 60 ? `${firstLine.slice(0, 60)}...` : firstLine;
+}

package/dist/storage/repositories/jin10-flash-delivery-repo.d.ts

@@ -0,0 +1,11 @@
+import type { Jin10FlashDeliveryEntry } from "../../types/jin10.js";
+import { Database } from "../db.js";
+export declare class Jin10FlashDeliveryRepository {
+    private readonly db;
+    constructor(db: Database);
+    append(entry: Jin10FlashDeliveryEntry): Promise<void>;
+    hasDelivered(flashKey: string): Promise<boolean>;
+    countSinceDeliveredAt(deliveredAt: string): Promise<number>;
+    listBySymbolsAndDate(symbols: string[], datePrefix: string): Promise<Jin10FlashDeliveryEntry[]>;
+    pruneOlderThanDeliveredAt(deliveredAt: string): Promise<void>;
+}

package/dist/storage/repositories/jin10-flash-delivery-repo.js

@@ -0,0 +1,93 @@
+import { jin10FlashDeliverySchema } from "../schemas.js";
+const JIN10_FLASH_DELIVERY_TABLE = "jin10_flash_delivery";
+export class Jin10FlashDeliveryRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = toDeliveryRow(entry);
+        if (!(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            await this.db.createTable(JIN10_FLASH_DELIVERY_TABLE, [row], jin10FlashDeliverySchema);
+            return;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        await table.add([row]);
+    }
+    async hasDelivered(flashKey) {
+        if (!flashKey || !(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            return false;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        const rows = (await table
+            .query()
+            .where(`flash_key = '${escapeSqlString(flashKey)}'`)
+            .toArray());
+        return rows.length > 0;
+    }
+    async countSinceDeliveredAt(deliveredAt) {
+        if (!(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            return 0;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        return table.countRows(`delivered_at >= '${escapeSqlString(deliveredAt)}'`);
+    }
+    async listBySymbolsAndDate(symbols, datePrefix) {
+        if (symbols.length === 0 || !(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        const rows = (await table
+            .query()
+            .where(`delivered_at >= '${escapeSqlString(datePrefix)} 00:00:00'`)
+            .toArray());
+        const symbolSet = new Set(symbols);
+        return rows
+            .map((row) => fromDeliveryRow(row))
+            .filter((entry) => entry.symbols.some((s) => symbolSet.has(s)));
+    }
+    async pruneOlderThanDeliveredAt(deliveredAt) {
+        if (!(await this.db.hasTable(JIN10_FLASH_DELIVERY_TABLE))) {
+            return;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_DELIVERY_TABLE);
+        await table.delete(`delivered_at < '${escapeSqlString(deliveredAt)}'`);
+    }
+}
+function toDeliveryRow(entry) {
+    return {
+        flash_key: entry.flash_key,
+        published_at: entry.published_at,
+        symbols_json: JSON.stringify(entry.symbols),
+        headline: entry.headline,
+        reason: entry.reason,
+        importance: entry.importance,
+        message: entry.message,
+        delivered_at: entry.delivered_at,
+    };
+}
+function fromDeliveryRow(row) {
+    let symbols = [];
+    try {
+        const parsed = JSON.parse(String(row.symbols_json ?? "[]"));
+        if (Array.isArray(parsed)) {
+            symbols = parsed.map((v) => String(v));
+        }
+    }
+    catch {
+        // ignore
+    }
+    return {
+        flash_key: String(row.flash_key ?? ""),
+        published_at: String(row.published_at ?? ""),
+        symbols,
+        headline: String(row.headline ?? ""),
+        reason: String(row.reason ?? ""),
+        importance: String(row.importance ?? "medium"),
+        message: String(row.message ?? ""),
+        delivered_at: String(row.delivered_at ?? ""),
+    };
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/jin10-flash-repo.d.ts

@@ -0,0 +1,16 @@
+import type { Jin10FlashRecord } from "../../types/jin10.js";
+import { Database } from "../db.js";
+export declare class Jin10FlashRepository {
+    private readonly db;
+    constructor(db: Database);
+    saveAll(entries: Jin10FlashRecord[]): Promise<{
+        added: number;
+        skipped: number;
+        addedKeys: string[];
+    }>;
+    getLatest(): Promise<Jin10FlashRecord | null>;
+    countSincePublishedTs(publishedTs: number): Promise<number>;
+    searchByContentKeywords(keywords: string[], datePrefix: string): Promise<Jin10FlashRecord[]>;
+    pruneOlderThanPublishedTs(publishedTs: number): Promise<void>;
+    private listExistingKeys;
+}

package/dist/storage/repositories/jin10-flash-repo.js

@@ -0,0 +1,144 @@
+import { jin10FlashSchema } from "../schemas.js";
+const JIN10_FLASH_TABLE = "jin10_flash";
+export class Jin10FlashRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async saveAll(entries) {
+        const uniqueEntries = dedupeEntries(entries);
+        if (uniqueEntries.length === 0) {
+            return { added: 0, skipped: 0, addedKeys: [] };
+        }
+        const rows = uniqueEntries.map((entry) => toFlashRow(entry));
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            await this.db.createTable(JIN10_FLASH_TABLE, rows, jin10FlashSchema);
+            return {
+                added: rows.length,
+                skipped: 0,
+                addedKeys: uniqueEntries.map((entry) => entry.flash_key),
+            };
+        }
+        const existingKeys = await this.listExistingKeys(uniqueEntries.map((entry) => entry.flash_key));
+        const newEntries = uniqueEntries.filter((entry) => !existingKeys.has(entry.flash_key));
+        const newRows = newEntries.map((entry) => toFlashRow(entry));
+        if (newRows.length === 0) {
+            return {
+                added: 0,
+                skipped: rows.length,
+                addedKeys: [],
+            };
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        await table.add(newRows);
+        return {
+            added: newRows.length,
+            skipped: rows.length - newRows.length,
+            addedKeys: newEntries.map((entry) => entry.flash_key),
+        };
+    }
+    async getLatest() {
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return null;
+        }
+        const rows = await this.db.tableToArray(JIN10_FLASH_TABLE);
+        if (rows.length === 0) {
+            return null;
+        }
+        return fromFlashRow(rows[rows.length - 1]);
+    }
+    async countSincePublishedTs(publishedTs) {
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return 0;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        return table.countRows(`published_ts >= ${Math.trunc(publishedTs)}`);
+    }
+    async searchByContentKeywords(keywords, datePrefix) {
+        if (keywords.length === 0 || !(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return [];
+        }
+        const dayStart = `${datePrefix} 00:00:00`;
+        const dayStartTs = new Date(`${dayStart.replace(" ", "T")}+08:00`).getTime();
+        if (Number.isNaN(dayStartTs)) {
+            return [];
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        const rows = (await table
+            .query()
+            .where(`published_ts >= ${Math.trunc(dayStartTs)}`)
+            .toArray());
+        return rows
+            .map((row) => fromFlashRow(row))
+            .filter((record) => keywords.some((kw) => record.content.includes(kw)));
+    }
+    async pruneOlderThanPublishedTs(publishedTs) {
+        if (!(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return;
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        await table.delete(`published_ts < ${Math.trunc(publishedTs)}`);
+    }
+    async listExistingKeys(keys) {
+        if (keys.length === 0 || !(await this.db.hasTable(JIN10_FLASH_TABLE))) {
+            return new Set();
+        }
+        const table = await this.db.openTable(JIN10_FLASH_TABLE);
+        const rows = (await table
+            .query()
+            .where(`flash_key IN (${keys.map((key) => `'${escapeSqlString(key)}'`).join(", ")})`)
+            .toArray());
+        return new Set(rows.map((row) => String(row.flash_key ?? "")));
+    }
+}
+function toFlashRow(entry) {
+    return {
+        flash_key: entry.flash_key,
+        published_at: entry.published_at,
+        published_ts: Math.trunc(entry.published_ts),
+        content: entry.content,
+        url: entry.url,
+        ingested_at: entry.ingested_at,
+        raw_json: JSON.stringify(entry.raw),
+    };
+}
+function fromFlashRow(row) {
+    return {
+        flash_key: String(row.flash_key ?? ""),
+        published_at: String(row.published_at ?? ""),
+        published_ts: Number(row.published_ts ?? 0),
+        content: String(row.content ?? ""),
+        url: String(row.url ?? ""),
+        ingested_at: String(row.ingested_at ?? ""),
+        raw: parseJsonObject(row.raw_json),
+    };
+}
+function dedupeEntries(entries) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries) {
+        if (!entry.flash_key || seen.has(entry.flash_key)) {
+            continue;
+        }
+        seen.add(entry.flash_key);
+        result.push(entry);
+    }
+    return result;
+}
+function parseJsonObject(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/schemas.d.ts

@@ -11,3 +11,5 @@ export declare const financialAnalysisSchema: Schema<any>;
 export declare const newsAnalysisSchema: Schema<any>;
 export declare const compositeAnalysisSchema: Schema<any>;
 export declare const alertLogSchema: Schema<any>;
+export declare const jin10FlashSchema: Schema<any>;
+export declare const jin10FlashDeliverySchema: Schema<any>;

package/dist/storage/schemas.js

@@ -175,3 +175,22 @@ export const alertLogSchema = new Schema([
     new Field("message", new Utf8(), false),
     new Field("triggered_at", new Utf8(), false),
 ]);
+export const jin10FlashSchema = new Schema([
+    new Field("flash_key", new Utf8(), false),
+    new Field("published_at", new Utf8(), false),
+    new Field("published_ts", new Int64(), false),
+    new Field("content", new Utf8(), false),
+    new Field("url", new Utf8(), false),
+    new Field("ingested_at", new Utf8(), false),
+    new Field("raw_json", new Utf8(), false),
+]);
+export const jin10FlashDeliverySchema = new Schema([
+    new Field("flash_key", new Utf8(), false),
+    new Field("published_at", new Utf8(), false),
+    new Field("symbols_json", new Utf8(), false),
+    new Field("headline", new Utf8(), false),
+    new Field("reason", new Utf8(), false),
+    new Field("importance", new Utf8(), false),
+    new Field("message", new Utf8(), false),
+    new Field("delivered_at", new Utf8(), false),
+]);

package/dist/tools/flash-monitor-status.tool.d.ts

@@ -0,0 +1,6 @@
+import { Jin10FlashMonitorService } from "../services/jin10-flash-monitor-service.js";
+export declare function flashMonitorStatusTool(flashMonitorService: Jin10FlashMonitorService): {
+    name: string;
+    description: string;
+    run(): Promise<string>;
+};