tickflow-assist 0.2.0

package/dist/tools/query-database.tool.js

@@ -0,0 +1,283 @@
+const DEFAULT_LIMIT = 10;
+const MAX_LIMIT = 100;
+const TABLE_ALIASES = {
+    watchlist: "watchlist",
+    watchlists: "watchlist",
+    自选: "watchlist",
+    自选股: "watchlist",
+    klines: "klines_daily",
+    kline: "klines_daily",
+    klines_daily: "klines_daily",
+    日k: "klines_daily",
+    日线: "klines_daily",
+    intraday: "klines_intraday",
+    minute: "klines_intraday",
+    minutes: "klines_intraday",
+    klines_intraday: "klines_intraday",
+    分钟k: "klines_intraday",
+    分钟线: "klines_intraday",
+    分时: "klines_intraday",
+    indicators: "indicators",
+    indicator: "indicators",
+    指标: "indicators",
+    key_levels: "key_levels",
+    keylevel: "key_levels",
+    关键价位: "key_levels",
+    key_levels_history: "key_levels_history",
+    keylevel_history: "key_levels_history",
+    active_key_levels: "key_levels_history",
+    活动价位历史: "key_levels_history",
+    关键价位历史: "key_levels_history",
+    analysis_log: "analysis_log",
+    analysis: "analysis_log",
+    分析日志: "analysis_log",
+    technical_analysis: "technical_analysis",
+    technical: "technical_analysis",
+    technicals: "technical_analysis",
+    技术分析: "technical_analysis",
+    financial_analysis: "financial_analysis",
+    financial: "financial_analysis",
+    fundamentals: "financial_analysis",
+    基本面分析: "financial_analysis",
+    财务分析: "financial_analysis",
+    news_analysis: "news_analysis",
+    news: "news_analysis",
+    research: "news_analysis",
+    资讯分析: "news_analysis",
+    composite_analysis: "composite_analysis",
+    composite: "composite_analysis",
+    综合分析: "composite_analysis",
+    alert_log: "alert_log",
+    alert: "alert_log",
+    告警日志: "alert_log",
+};
+function parseInput(rawInput) {
+    if (rawInput == null || rawInput === "") {
+        return { action: "tables" };
+    }
+    if (typeof rawInput === "object" && rawInput !== null) {
+        const input = rawInput;
+        const action = input.action == null ? undefined : String(input.action).trim().toLowerCase();
+        const table = input.table == null ? undefined : normalizeTableName(String(input.table));
+        const symbol = input.symbol == null ? undefined : String(input.symbol).trim();
+        const limit = input.limit == null ? undefined : Number(input.limit);
+        const sortBy = input.sortBy == null ? undefined : String(input.sortBy).trim();
+        const sortOrderRaw = input.sortOrder == null ? undefined : String(input.sortOrder).trim().toLowerCase();
+        const fields = Array.isArray(input.fields)
+            ? input.fields.map((value) => String(value).trim()).filter(Boolean)
+            : undefined;
+        const filters = typeof input.filters === "object" && input.filters !== null
+            ? input.filters
+            : undefined;
+        const contains = input.contains == null ? undefined : String(input.contains).trim();
+        return {
+            action: normalizeAction(action),
+            table,
+            symbol,
+            limit: normalizeLimit(limit),
+            sortBy,
+            sortOrder: normalizeSortOrder(sortOrderRaw),
+            fields,
+            filters,
+            contains,
+        };
+    }
+    if (typeof rawInput === "string") {
+        const text = rawInput.trim();
+        if (!text) {
+            return { action: "tables" };
+        }
+        const parts = text.split(/\s+/);
+        const command = parts[0]?.toLowerCase();
+        if (command === "tables") {
+            return { action: "tables" };
+        }
+        if (command === "schema") {
+            return { action: "schema", table: normalizeTableName(parts[1] ?? "") };
+        }
+        return {
+            action: "query",
+            table: normalizeTableName(parts[0] ?? ""),
+            symbol: parts[1],
+            limit: normalizeLimit(parts[2] ? Number(parts[2]) : undefined),
+        };
+    }
+    throw new Error("invalid query-database input");
+}
+function normalizeAction(value) {
+    if (value === "schema" || value === "query" || value === "tables") {
+        return value;
+    }
+    return "query";
+}
+function normalizeTableName(value) {
+    const raw = (value ?? "").trim();
+    if (!raw) {
+        return undefined;
+    }
+    return TABLE_ALIASES[raw.toLowerCase()] ?? raw;
+}
+function normalizeLimit(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error("query-database limit must be > 0");
+    }
+    return Math.min(Math.floor(value), MAX_LIMIT);
+}
+function normalizeSortOrder(value) {
+    if (value === "asc" || value === "desc") {
+        return value;
+    }
+    return undefined;
+}
+export function queryDatabaseTool(database) {
+    return {
+        name: "query_database",
+        description: "Inspect LanceDB tables, schemas, and rows for the plugin data store.",
+        async run({ rawInput }) {
+            const input = parseInput(rawInput);
+            if (input.action === "tables") {
+                return renderTableList(await database.listTables());
+            }
+            if (input.action === "schema") {
+                if (!input.table) {
+                    throw new Error("query_database schema requires table");
+                }
+                return renderTableSchema(input.table, await database.describeTable(input.table));
+            }
+            if (!input.table) {
+                throw new Error("query_database query requires table");
+            }
+            const tables = await database.listTables();
+            if (!tables.includes(input.table)) {
+                return `⚠️ 数据表不存在: ${input.table}\n可用表: ${tables.join(", ") || "无"}`;
+            }
+            const rows = await database.tableToArray(input.table);
+            const filtered = filterRows(rows, input);
+            const sorted = sortRows(filtered, input.sortBy, input.sortOrder);
+            const limit = input.limit ?? DEFAULT_LIMIT;
+            const selected = sorted.slice(0, limit);
+            return renderQueryResult(input.table, rows.length, filtered.length, selected, input.fields);
+        },
+    };
+}
+function filterRows(rows, input) {
+    return rows.filter((row) => {
+        if (input.symbol != null && String(row.symbol ?? "") !== input.symbol) {
+            return false;
+        }
+        if (input.contains) {
+            const haystack = JSON.stringify(normalizeForDisplay(row)).toLowerCase();
+            if (!haystack.includes(input.contains.toLowerCase())) {
+                return false;
+            }
+        }
+        if (input.filters) {
+            for (const [key, expected] of Object.entries(input.filters)) {
+                if (!matchesFilter(row[key], expected)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    });
+}
+function matchesFilter(actual, expected) {
+    if (Array.isArray(expected)) {
+        return expected.some((item) => matchesFilter(actual, item));
+    }
+    if (typeof expected === "string") {
+        return String(actual ?? "") === expected;
+    }
+    if (typeof expected === "number") {
+        return Number(actual) === expected;
+    }
+    if (typeof expected === "boolean") {
+        return Boolean(actual) === expected;
+    }
+    return String(actual ?? "") === String(expected ?? "");
+}
+function sortRows(rows, sortBy, sortOrder) {
+    if (!sortBy) {
+        return rows;
+    }
+    const direction = sortOrder === "asc" ? 1 : -1;
+    return [...rows].sort((left, right) => compareValues(left[sortBy], right[sortBy]) * direction);
+}
+function compareValues(left, right) {
+    if (left == null && right == null) {
+        return 0;
+    }
+    if (left == null) {
+        return -1;
+    }
+    if (right == null) {
+        return 1;
+    }
+    if (typeof left === "number" ||
+        typeof right === "number" ||
+        typeof left === "bigint" ||
+        typeof right === "bigint") {
+        return Number(left) - Number(right);
+    }
+    return String(left).localeCompare(String(right));
+}
+function renderTableList(tableNames) {
+    if (tableNames.length === 0) {
+        return "📚 当前 LanceDB 没有任何数据表";
+    }
+    return ["📚 当前 LanceDB 数据表:", ...tableNames.map((name) => `- ${name}`)].join("\n");
+}
+function renderTableSchema(table, fields) {
+    if (fields.length === 0) {
+        return `⚠️ 数据表不存在或没有结构信息: ${table}`;
+    }
+    const lines = [`🧱 表结构: ${table}`, `字段数: ${fields.length}`];
+    for (const field of fields) {
+        lines.push(`- ${field.name}: ${field.type} | nullable=${field.nullable ? "yes" : "no"}`);
+    }
+    return lines.join("\n");
+}
+function renderQueryResult(table, totalRows, filteredRows, rows, fields) {
+    const lines = [
+        `📦 数据表: ${table}`,
+        `总记录: ${totalRows}`,
+        `匹配记录: ${filteredRows}`,
+        `返回记录: ${rows.length}`,
+    ];
+    if (rows.length === 0) {
+        lines.push("⚠️ 没有匹配到数据");
+        return lines.join("\n");
+    }
+    rows.forEach((row, index) => {
+        lines.push(`${index + 1}. ${JSON.stringify(normalizeForDisplay(selectFields(row, fields)), null, 0)}`);
+    });
+    return lines.join("\n");
+}
+function selectFields(row, fields) {
+    if (!fields || fields.length === 0) {
+        return row;
+    }
+    const selected = {};
+    for (const field of fields) {
+        selected[field] = row[field];
+    }
+    return selected;
+}
+function normalizeForDisplay(value) {
+    if (typeof value === "bigint") {
+        return Number(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeForDisplay(item));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            normalizeForDisplay(item),
+        ]));
+    }
+    return value;
+}

package/dist/tools/refresh-watchlist-names.tool.d.ts

@@ -0,0 +1,7 @@
+import { WatchlistService } from "../services/watchlist-service.js";
+export declare function refreshWatchlistNamesTool(watchlistService: WatchlistService): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run(): Promise<string>;
+};

package/dist/tools/refresh-watchlist-names.tool.js

@@ -0,0 +1,17 @@
+export function refreshWatchlistNamesTool(watchlistService) {
+    return {
+        name: "refresh_watchlist_names",
+        description: "Refresh instrument names in watchlist from TickFlow metadata.",
+        optional: true,
+        async run() {
+            const result = await watchlistService.refreshNames();
+            const lines = [
+                `🔄 名称刷新完成: 更新 ${result.updated.length} 只, 保持不变 ${result.unchanged.length} 只`,
+            ];
+            for (const item of result.updated) {
+                lines.push(`• ${item.symbol} -> ${item.name}`);
+            }
+            return lines.join("\n");
+        },
+    };
+}

package/dist/tools/refresh-watchlist-profiles.tool.d.ts

@@ -0,0 +1,9 @@
+import { WatchlistService } from "../services/watchlist-service.js";
+export declare function refreshWatchlistProfilesTool(watchlistService: WatchlistService): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run({ rawInput }: {
+        rawInput?: unknown;
+    }): Promise<string>;
+};

package/dist/tools/refresh-watchlist-profiles.tool.js

@@ -0,0 +1,67 @@
+import { normalizeSymbol } from "../utils/symbol.js";
+function parseInput(rawInput) {
+    if (typeof rawInput === "object" && rawInput !== null) {
+        const input = rawInput;
+        const symbol = String(input.symbol ?? "").trim();
+        const forceRaw = input.force;
+        return {
+            symbol: symbol || undefined,
+            force: typeof forceRaw === "boolean" ? forceRaw : undefined,
+        };
+    }
+    if (typeof rawInput === "string") {
+        const symbol = rawInput.trim();
+        return symbol ? { symbol } : {};
+    }
+    return {};
+}
+export function refreshWatchlistProfilesTool(watchlistService) {
+    return {
+        name: "refresh_watchlist_profiles",
+        description: "Refresh industry and concept metadata for the whole watchlist or one symbol.",
+        optional: true,
+        async run({ rawInput }) {
+            const input = parseInput(rawInput);
+            const result = await watchlistService.refreshProfiles({
+                symbol: input.symbol,
+                force: input.force ?? true,
+            });
+            if (result.targetCount === 0) {
+                return input.symbol
+                    ? `⚠️ 自选列表中未找到该股票: ${normalizeSymbol(input.symbol)}`
+                    : "⚠️ 当前自选列表为空";
+            }
+            const lines = [
+                `🔄 行业分类/概念板块刷新完成: 目标 ${result.targetCount} 只 | 资料更新 ${result.updated.length} | 已复核 ${result.rechecked.length} | 失败 ${result.failed.length}`,
+            ];
+            if (result.updated.length > 0) {
+                lines.push("", "已更新:");
+                for (const item of result.updated) {
+                    lines.push(formatProfileLine(item));
+                }
+            }
+            if (input.symbol && result.rechecked.length > 0) {
+                lines.push("", "复核结果:");
+                for (const item of result.rechecked) {
+                    lines.push(formatProfileLine(item));
+                }
+            }
+            if (!input.symbol && result.rechecked.length > 0) {
+                lines.push("", `• 已复核 ${result.rechecked.length} 只，资料未变化`);
+            }
+            if (result.failed.length > 0) {
+                lines.push("", "失败:");
+                for (const item of result.failed) {
+                    lines.push(`• ${item.name || item.symbol}（${item.symbol}）: ${item.error}`);
+                }
+            }
+            return lines.join("\n");
+        },
+    };
+}
+function formatProfileLine(item) {
+    const sector = item.sector ?? "未识别";
+    const themes = item.themes.length > 0 ? item.themes.join("、") : "未识别";
+    const updatedAt = item.themeUpdatedAt ?? "未记录";
+    return `• ${item.name}（${item.symbol}） | 行业分类: ${sector} | 概念板块: ${themes} | 更新时间: ${updatedAt}`;
+}

package/dist/tools/remove-stock.tool.d.ts

@@ -0,0 +1,9 @@
+import { WatchlistService } from "../services/watchlist-service.js";
+export declare function removeStockTool(watchlistService: WatchlistService): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run({ rawInput }: {
+        rawInput?: unknown;
+    }): Promise<string>;
+};

package/dist/tools/remove-stock.tool.js

@@ -0,0 +1,27 @@
+function parseSymbol(rawInput) {
+    if (typeof rawInput === "string" && rawInput.trim()) {
+        return rawInput.trim();
+    }
+    if (typeof rawInput === "object" && rawInput !== null) {
+        const symbol = String(rawInput.symbol ?? "").trim();
+        if (symbol) {
+            return symbol;
+        }
+    }
+    throw new Error("remove-stock requires a symbol");
+}
+export function removeStockTool(watchlistService) {
+    return {
+        name: "remove_stock",
+        description: "Remove a symbol from the watchlist.",
+        optional: true,
+        async run({ rawInput }) {
+            const symbol = parseSymbol(rawInput);
+            const removed = await watchlistService.remove(symbol);
+            if (!removed) {
+                return `⚠️ 未找到该股票: ${symbol}`;
+            }
+            return `✅ 已从关注列表移除: ${symbol}`;
+        },
+    };
+}

package/dist/tools/start-daily-update.tool.d.ts

@@ -0,0 +1,10 @@
+import type { PluginConfig } from "../config/schema.js";
+import { DailyUpdateWorker } from "../background/daily-update.worker.js";
+export declare function startDailyUpdateTool(dailyUpdateWorker: DailyUpdateWorker, config: PluginConfig, configSource: "openclaw_plugin" | "local_config", runtime: {
+    pluginManagedServices: boolean;
+}): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run(): Promise<string>;
+};

package/dist/tools/start-daily-update.tool.js

@@ -0,0 +1,23 @@
+export function startDailyUpdateTool(dailyUpdateWorker, config, configSource, runtime) {
+    return {
+        name: "start_daily_update",
+        description: "Start the TickFlow daily-update scheduler.",
+        optional: true,
+        async run() {
+            const result = runtime.pluginManagedServices
+                ? await dailyUpdateWorker.enableManagedLoop(configSource)
+                : await dailyUpdateWorker.ensureLoopRunning(config, configSource);
+            if (!result.started) {
+                return await dailyUpdateWorker.getStatusReport();
+            }
+            const lines = [
+                "✅ TickFlow 定时日更已启动",
+                `PID: ${result.pid ?? "托管服务"}`,
+                `运行方式: ${runtime.pluginManagedServices ? "plugin_service" : "project_scheduler"}`,
+                `配置来源: ${configSource}`,
+                "说明: 后台按 15 分钟对齐轮询，交易日 15:25 后最多执行一次日更，20:00 后最多执行一次复盘",
+            ];
+            return lines.join("\n");
+        },
+    };
+}

package/dist/tools/start-monitor.tool.d.ts

@@ -0,0 +1,9 @@
+import { MonitorService } from "../services/monitor-service.js";
+export declare function startMonitorTool(monitorService: MonitorService, runtime: {
+    pluginManagedServices: boolean;
+}): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run(): Promise<string>;
+};

package/dist/tools/start-monitor.tool.js

@@ -0,0 +1,52 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+export function startMonitorTool(monitorService, runtime) {
+    return {
+        name: "start_monitor",
+        description: "Start logical monitor state and return startup summary.",
+        optional: true,
+        async run() {
+            if (runtime.pluginManagedServices) {
+                const result = await monitorService.enableManagedLoop();
+                if (!result.started) {
+                    return await monitorService.getStatusReport();
+                }
+                return [
+                    "✅ TickFlow 实时监控已启动",
+                    "运行方式: plugin_service",
+                    `轮询间隔: 由后台服务管理`,
+                    "说明: 后台服务按配置间隔轮询，交易时段自动执行监控",
+                ].join("\n");
+            }
+            const currentState = await monitorService.getState();
+            if (currentState.running
+                && currentState.workerPid != null
+                && isPidAlive(currentState.workerPid)) {
+                return await monitorService.getStatusReport();
+            }
+            const summary = await monitorService.start();
+            const workerPid = spawnMonitorLoop();
+            await monitorService.setWorkerPid(workerPid);
+            return summary;
+        },
+    };
+}
+function spawnMonitorLoop() {
+    const scriptPath = path.resolve("dist/dev/run-monitor-loop.js");
+    const child = spawn(process.execPath, [scriptPath], {
+        cwd: process.cwd(),
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    return child.pid ?? null;
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/stop-daily-update.tool.d.ts

@@ -0,0 +1,9 @@
+import { DailyUpdateWorker } from "../background/daily-update.worker.js";
+export declare function stopDailyUpdateTool(dailyUpdateWorker: DailyUpdateWorker, runtime: {
+    pluginManagedServices: boolean;
+}): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run(): Promise<string>;
+};

package/dist/tools/stop-daily-update.tool.js

@@ -0,0 +1,20 @@
+export function stopDailyUpdateTool(dailyUpdateWorker, runtime) {
+    return {
+        name: "stop_daily_update",
+        description: "Stop the TickFlow daily-update scheduler.",
+        optional: true,
+        async run() {
+            const result = runtime.pluginManagedServices
+                ? { stopped: (await dailyUpdateWorker.getState()).running, pid: null }
+                : await dailyUpdateWorker.stopLoop();
+            await dailyUpdateWorker.markSchedulerStopped();
+            if (!result.stopped) {
+                return "✅ TickFlow 定时日更已停止";
+            }
+            return [
+                "🛑 TickFlow 定时日更已停止",
+                `PID: ${result.pid ?? "托管服务"}`,
+            ].join("\n");
+        },
+    };
+}

package/dist/tools/stop-monitor.tool.d.ts

@@ -0,0 +1,9 @@
+import { MonitorService } from "../services/monitor-service.js";
+export declare function stopMonitorTool(monitorService: MonitorService, runtime: {
+    pluginManagedServices: boolean;
+}): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run(): Promise<string>;
+};

package/dist/tools/stop-monitor.tool.js

@@ -0,0 +1,44 @@
+export function stopMonitorTool(monitorService, runtime) {
+    return {
+        name: "stop_monitor",
+        description: "Stop logical monitor state and return stop summary.",
+        optional: true,
+        async run() {
+            if (runtime.pluginManagedServices) {
+                const wasRunning = (await monitorService.getState()).running;
+                await monitorService.markStopped();
+                if (!wasRunning) {
+                    return "✅ TickFlow 实时监控已停止";
+                }
+                return [
+                    "🛑 TickFlow 实时监控已停止",
+                    "运行方式: plugin_service（后台服务循环仍在，但不再执行监控）",
+                ].join("\n");
+            }
+            const state = await monitorService.getState();
+            const shouldSignalWorker = state.workerPid != null && isPidAlive(state.workerPid);
+            if (shouldSignalWorker) {
+                await monitorService.setExpectedStop(true);
+            }
+            const summary = await monitorService.stop();
+            if (shouldSignalWorker && state.workerPid) {
+                try {
+                    process.kill(state.workerPid, "SIGTERM");
+                }
+                catch {
+                    // Best-effort stop for the dev/VPS worker.
+                }
+            }
+            return summary;
+        },
+    };
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/test-alert.tool.d.ts

@@ -0,0 +1,7 @@
+import { AlertService } from "../services/alert-service.js";
+export declare function testAlertTool(alertService: AlertService): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run(): Promise<string>;
+};

package/dist/tools/test-alert.tool.js

@@ -0,0 +1,21 @@
+import { formatChinaDateTime } from "../utils/china-time.js";
+export function testAlertTool(alertService) {
+    return {
+        name: "test_alert",
+        description: "Send a test alert through the configured OpenClaw alert delivery path.",
+        optional: true,
+        async run() {
+            const ok = await alertService.send(alertService.formatSystemNotification("🧪 TickFlow 测试告警", [
+                `时间: ${formatChinaDateTime()}`,
+                "说明: 这是一条手动触发的测试消息，用于验证 channel 投递链路正常。",
+            ]));
+            if (ok) {
+                return "✅ 测试告警发送成功";
+            }
+            const detail = alertService.getLastError();
+            return detail
+                ? `❌ 测试告警发送失败\n原因: ${detail}`
+                : "❌ 测试告警发送失败";
+        },
+    };
+}

package/dist/tools/update-all.tool.d.ts

@@ -0,0 +1,9 @@
+import { DailyUpdateWorker } from "../background/daily-update.worker.js";
+export declare function updateAllTool(dailyUpdateWorker: DailyUpdateWorker): {
+    name: string;
+    description: string;
+    optional: boolean;
+    run({ rawInput }: {
+        rawInput?: unknown;
+    }): Promise<string>;
+};

package/dist/tools/update-all.tool.js

@@ -0,0 +1,17 @@
+export function updateAllTool(dailyUpdateWorker) {
+    return {
+        name: "update_all",
+        description: "Batch update daily/intraday market data for all watchlist symbols, then run post-close analysis and key-level backtest.",
+        optional: true,
+        async run({ rawInput }) {
+            let force = false;
+            if (typeof rawInput === "object" && rawInput !== null) {
+                force = Boolean(rawInput.force);
+            }
+            if (typeof rawInput === "string") {
+                force = rawInput.includes("--force");
+            }
+            return dailyUpdateWorker.run(force);
+        },
+    };
+}