tickflow-assist 0.2.0

package/dist/prompts/analysis/post-close-review-user-prompt.js

@@ -0,0 +1,129 @@
+import { formatCostPrice } from "../../utils/cost-price.js";
+export const POST_CLOSE_REVIEW_SYSTEM_PROMPT = `
+你是一位A股收盘复盘分析师，需要在收盘后同时完成“昨日关键位验证 + 今日盘面复盘 + 明日关键位处理决定”。
+
+输出要求：
+1. 正文按以下标题输出，每节 2-4 句：
+- 昨日关键位验证
+- 今日盘面
+- 大盘与板块
+- 新闻与公告
+- 明日关键位处理
+- 操作建议
+2. “昨日关键位验证”必须严格依据输入里给出的验证结果，不得改写成与数据冲突的结论。
+3. “明日关键位处理”必须明确给出四选一结论：keep / adjust / recompute / invalidate。
+4. 最后输出一个 \`\`\`json 代码块，结构必须为：
+{
+  "session_summary": "",
+  "market_sector_summary": "",
+  "news_summary": "",
+  "decision": "keep|adjust|recompute|invalidate",
+  "decision_reason": "",
+  "action_advice": "",
+  "market_bias": "tailwind|neutral|headwind",
+  "sector_bias": "tailwind|neutral|headwind",
+  "news_impact": "supportive|neutral|disruptive",
+  "levels": {
+    "current_price": 0.0,
+    "stop_loss": 0.0,
+    "breakthrough": 0.0,
+    "support": 0.0,
+    "cost_level": 0.0,
+    "resistance": 0.0,
+    "take_profit": 0.0,
+    "gap": 0.0,
+    "target": 0.0,
+    "round_number": 0.0,
+    "score": 5
+  }
+}
+
+规则：
+- 若 decision=invalidate，levels 可以为 null；否则 levels 必须完整给出。
+- current_price 必须使用提供的最新收盘价或最新实时价。
+- 若大盘顺风但行业分类/概念板块偏逆风，必须明确指出冲突，不得笼统给多头结论。
+- 若新闻只是噪音，也要明确写“未构成主要解释”或类似表述。
+- 不要凭空编造概念板块、指数表现或公告内容。
+`;
+export function buildPostCloseReviewUserPrompt(input) {
+    const latestClose = input.market.klines[input.market.klines.length - 1]?.close ?? 0;
+    const latestRealtimePrice = input.market.realtimeQuote?.last_price ?? latestClose;
+    const watchlistItem = input.market.watchlistItem;
+    return [
+        `请对 ${input.market.companyName}（${input.market.symbol}）生成收盘复盘。`,
+        `用户成本价: ${formatCostPrice(watchlistItem?.costPrice ?? null)}`,
+        `最新收盘价: ${latestClose.toFixed(2)}`,
+        `最新实时价: ${latestRealtimePrice.toFixed(2)}`,
+        `申万行业分类: ${watchlistItem?.sector ?? "未记录"}`,
+        `概念板块: ${watchlistItem?.themes.length ? watchlistItem.themes.join("；") : "未记录"}`,
+        "",
+        "## 昨日关键位验证（必须严格依据）",
+        input.validation.summary,
+        ...input.validation.lines.map((line) => `- ${line}`),
+        "",
+        "## 当前综合分析基线",
+        extractNarrative(input.compositeResult.analysisText),
+        "",
+        "## 大盘环境",
+        input.market.marketOverview.summary,
+        "",
+        "## 个股资讯摘要",
+        formatDocuments(input.news.documents),
+        "",
+        "## 行业分类/概念板块资讯摘要",
+        input.news.boardDocuments.length > 0 ? formatDocuments(input.news.boardDocuments) : "未获取到有效行业分类/概念板块资讯。",
+        "",
+        "## 结构化参考",
+        `当前综合关键位: ${formatLevels(input.compositeResult.levels ?? input.technicalResult.levels)}`,
+        `基本面评分/倾向: ${input.financialResult.score ?? "-"} / ${input.financialResult.bias}`,
+        `资讯面评分/倾向: ${input.newsResult.score ?? "-"} / ${input.newsResult.bias}`,
+        `基本面优势: ${joinList(input.financialResult.strengths)}`,
+        `基本面风险: ${joinList(input.financialResult.risks)}`,
+        `资讯催化: ${joinList(input.newsResult.catalysts)}`,
+        `资讯风险: ${joinList(input.newsResult.risks)}`,
+        "",
+        "请按系统要求输出正文和最终 JSON。正文重点回答：昨天关键位到底是否有效；今天盘面是否得到大盘、行业分类/概念板块、新闻的解释；明天该沿用、微调、重算还是暂停关键位。",
+    ].join("\n");
+}
+function formatDocuments(documents) {
+    if (documents.length === 0) {
+        return "未获取到有效资讯。";
+    }
+    return documents.slice(0, 3).map((document) => {
+        const meta = [document.source, document.publishedAt].filter(Boolean).join(" | ");
+        const excerpt = truncate(document.trunk, 120);
+        return [`标题: ${document.title}`, meta ? `来源: ${meta}` : null, excerpt ? `摘要: ${excerpt}` : null]
+            .filter(Boolean)
+            .join("\n");
+    }).join("\n\n");
+}
+function formatLevels(levels) {
+    if (!levels) {
+        return "暂无结构化关键位";
+    }
+    return [
+        `current=${formatMaybePrice(levels.current_price)}`,
+        `support=${formatMaybePrice(levels.support)}`,
+        `resistance=${formatMaybePrice(levels.resistance)}`,
+        `breakthrough=${formatMaybePrice(levels.breakthrough)}`,
+        `stop_loss=${formatMaybePrice(levels.stop_loss)}`,
+        `take_profit=${formatMaybePrice(levels.take_profit)}`,
+        `score=${levels.score}`,
+    ].join(", ");
+}
+function formatMaybePrice(value) {
+    return value == null ? "-" : value.toFixed(2);
+}
+function truncate(value, maxLength) {
+    const text = value.trim();
+    if (!text) {
+        return "";
+    }
+    return text.length <= maxLength ? text : `${text.slice(0, maxLength)}...`;
+}
+function extractNarrative(text) {
+    return text.replace(/```json\s*[\s\S]*?\s*```/gi, "").trim();
+}
+function joinList(items) {
+    return items.length > 0 ? items.join("；") : "无";
+}

package/dist/prompts/analysis/watchlist-profile-extraction-prompt.d.ts

@@ -0,0 +1,7 @@
+import type { MxSearchDocument } from "../../types/mx-search.js";
+export declare const WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT: string;
+export declare function buildWatchlistProfileExtractionUserPrompt(input: {
+    symbol: string;
+    companyName: string;
+    documents: MxSearchDocument[];
+}): string;

package/dist/prompts/analysis/watchlist-profile-extraction-prompt.js

@@ -0,0 +1,52 @@
+const MAX_PROMPT_DOCUMENTS = 8;
+const MAX_TRUNK_LENGTH = 600;
+export const WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT = [
+    "你是A股证券资料结构化抽取助手。",
+    "",
+    "你的唯一任务：根据给定的妙想搜索结果，提取该股票的行业分类与概念板块，并严格输出 JSON。",
+    "",
+    "硬性要求：",
+    "1. 只能依据提供的资料，不得编造。",
+    "2. 只输出 JSON 对象或 ```json 代码块，不要输出解释文字。",
+    "3. JSON 结构固定为：",
+    "{",
+    '  "sector": string | null,',
+    '  "themes": string[],',
+    '  "confidence": "low" | "medium" | "high"',
+    "}",
+    "4. sector 优先提取申万行业/行业分类，保留完整层级；没有可靠信息时填 null。",
+    "5. themes 尽量完整列出概念板块，去重后输出数组；优先保留明确的概念/题材/板块名称。",
+    "6. themes 中不要输出泛词，例如公司新闻、最新公告、市场快讯；也不要输出等。",
+    "7. 若资料中是组合表达，拆成独立概念更优，例如华为昇腾 / 华为昇思应拆成两个数组项。",
+    "8. 若资料仅出现业务描述而没有足够证据支持概念标签，不要强行扩写。",
+    "9. confidence 仅反映你对提取结果的把握，不要附加解释。",
+].join("\n");
+export function buildWatchlistProfileExtractionUserPrompt(input) {
+    const documents = input.documents.slice(0, MAX_PROMPT_DOCUMENTS);
+    return [
+        `股票名称: ${input.companyName}`,
+        `股票代码: ${input.symbol}`,
+        "",
+        "请根据下面的妙想搜索结果，提取该股票的行业分类与概念板块，并严格按要求输出 JSON。",
+        "",
+        "## 妙想搜索结果",
+        documents.length > 0 ? formatDocuments(documents) : "未获取到任何搜索结果。",
+        "",
+        "再次提醒：不要输出解释，只输出 JSON。",
+    ].join("\n");
+}
+function formatDocuments(documents) {
+    return documents.map((document, index) => formatDocument(document, index + 1)).join("\n\n");
+}
+function formatDocument(document, index) {
+    const trunk = document.trunk.trim();
+    const safeTrunk = trunk.length > MAX_TRUNK_LENGTH
+        ? `${trunk.slice(0, MAX_TRUNK_LENGTH)}...`
+        : trunk;
+    return [
+        `${index}. 标题: ${document.title}`,
+        `来源: ${document.source ?? "未知"}`,
+        `时间: ${document.publishedAt ?? "未知"}`,
+        `正文: ${safeTrunk || "无"}`,
+    ].join("\n");
+}

package/dist/prompts/analysis-system-prompt.d.ts

@@ -0,0 +1 @@
+export { ANALYSIS_COMMON_SYSTEM_PROMPT as ANALYSIS_SYSTEM_PROMPT } from "./analysis/index.js";

package/dist/prompts/analysis-system-prompt.js

@@ -0,0 +1 @@
+export { ANALYSIS_COMMON_SYSTEM_PROMPT as ANALYSIS_SYSTEM_PROMPT } from "./analysis/index.js";

package/dist/prompts/analysis-user-prompt.d.ts

@@ -0,0 +1 @@
+export { buildKlineAnalysisUserPrompt as buildAnalysisUserPrompt } from "./analysis/index.js";

package/dist/prompts/analysis-user-prompt.js

@@ -0,0 +1 @@
+export { buildKlineAnalysisUserPrompt as buildAnalysisUserPrompt } from "./analysis/index.js";

package/dist/runtime/daily-update-process.d.ts

@@ -0,0 +1,3 @@
+import type { PluginConfig } from "../config/schema.js";
+export declare function spawnDailyUpdateLoop(config: PluginConfig, configSource: "openclaw_plugin" | "local_config"): number | null;
+export declare function isPidAlive(pid: number): boolean;

package/dist/runtime/daily-update-process.js

@@ -0,0 +1,24 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { buildProcessConfigEnv } from "./process-config.js";
+const PROJECT_ROOT = fileURLToPath(new URL("../../", import.meta.url));
+const DAILY_UPDATE_LOOP_SCRIPT = fileURLToPath(new URL("../dev/run-daily-update-loop.js", import.meta.url));
+export function spawnDailyUpdateLoop(config, configSource) {
+    const child = spawn(process.execPath, [DAILY_UPDATE_LOOP_SCRIPT], {
+        cwd: PROJECT_ROOT,
+        detached: true,
+        stdio: "ignore",
+        env: buildProcessConfigEnv(config, configSource),
+    });
+    child.unref();
+    return child.pid ?? null;
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/runtime/monitor-process.d.ts

@@ -0,0 +1,3 @@
+import type { PluginConfig } from "../config/schema.js";
+export declare function spawnMonitorLoop(config: PluginConfig, configSource: "openclaw_plugin" | "local_config"): number | null;
+export declare function isPidAlive(pid: number): boolean;

package/dist/runtime/monitor-process.js

@@ -0,0 +1,24 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { buildProcessConfigEnv } from "./process-config.js";
+const PROJECT_ROOT = fileURLToPath(new URL("../../", import.meta.url));
+const MONITOR_LOOP_SCRIPT = fileURLToPath(new URL("../dev/run-monitor-loop.js", import.meta.url));
+export function spawnMonitorLoop(config, configSource) {
+    const child = spawn(process.execPath, [MONITOR_LOOP_SCRIPT], {
+        cwd: PROJECT_ROOT,
+        detached: true,
+        stdio: "ignore",
+        env: buildProcessConfigEnv(config, configSource),
+    });
+    child.unref();
+    return child.pid ?? null;
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/runtime/plugin-api.d.ts

@@ -0,0 +1,22 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import type { AnyAgentTool, OpenClawConfig, OpenClawPluginApi, OpenClawPluginCommandDefinition, OpenClawPluginService, OpenClawPluginServiceContext, PluginCommandContext, PluginLogger } from "openclaw/plugin-sdk/plugin-entry";
+import type { PluginRuntime } from "openclaw/plugin-sdk/runtime-store";
+export { definePluginEntry };
+export interface ToolContext {
+    rawInput?: unknown;
+}
+export interface LocalTool {
+    name: string;
+    description: string;
+    optional?: boolean;
+    run: (context: ToolContext) => Promise<string> | string;
+}
+export type PluginApi = OpenClawPluginApi;
+export type RegisteredAgentTool = AnyAgentTool;
+export type RegisteredService = OpenClawPluginService;
+export type ServiceContext = OpenClawPluginServiceContext;
+export type RegisteredCommand = OpenClawPluginCommandDefinition;
+export type CommandContext = PluginCommandContext;
+export type OpenClawPluginConfig = OpenClawConfig;
+export type OpenClawPluginRuntime = PluginRuntime;
+export type OpenClawPluginLogger = PluginLogger;

package/dist/runtime/plugin-api.js

@@ -0,0 +1,2 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+export { definePluginEntry };

package/dist/runtime/process-config.d.ts

@@ -0,0 +1,8 @@
+import type { PluginConfig } from "../config/schema.js";
+export interface LoadedProcessConfig {
+    config: PluginConfig;
+    configSource: "openclaw_plugin" | "local_config";
+}
+export declare function buildProcessConfigEnv(config: PluginConfig, configSource: "openclaw_plugin" | "local_config"): NodeJS.ProcessEnv;
+export declare function loadProcessConfig(): Promise<LoadedProcessConfig>;
+export declare function loadLocalConfig(): Promise<PluginConfig>;

package/dist/runtime/process-config.js

@@ -0,0 +1,35 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { normalizePluginConfig, resolvePluginConfigPaths } from "../config/normalize.js";
+const CONFIG_B64_ENV = "TICKFLOW_ASSIST_CONFIG_B64";
+const CONFIG_SOURCE_ENV = "TICKFLOW_ASSIST_CONFIG_SOURCE";
+export function buildProcessConfigEnv(config, configSource) {
+    return {
+        ...process.env,
+        [CONFIG_B64_ENV]: Buffer.from(JSON.stringify(config), "utf-8").toString("base64"),
+        [CONFIG_SOURCE_ENV]: configSource,
+    };
+}
+export async function loadProcessConfig() {
+    const encoded = process.env[CONFIG_B64_ENV];
+    if (encoded) {
+        const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+        return {
+            config: resolvePluginConfigPaths(normalizePluginConfig(JSON.parse(decoded)), process.cwd()),
+            configSource: normalizeConfigSource(process.env[CONFIG_SOURCE_ENV]),
+        };
+    }
+    return {
+        config: await loadLocalConfig(),
+        configSource: "local_config",
+    };
+}
+export async function loadLocalConfig() {
+    const configPath = path.resolve("local.config.json");
+    const raw = await readFile(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return resolvePluginConfigPaths(normalizePluginConfig(parsed.plugin ?? {}), process.cwd());
+}
+function normalizeConfigSource(value) {
+    return value === "openclaw_plugin" ? "openclaw_plugin" : "local_config";
+}

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

@@ -0,0 +1,45 @@
+import type { OpenClawPluginConfig, OpenClawPluginRuntime } from "../runtime/plugin-api.js";
+interface AlertRuntimeContext {
+    config: OpenClawPluginConfig;
+    runtime: OpenClawPluginRuntime;
+}
+interface AlertServiceOptions {
+    openclawCliBin: string;
+    channel: string;
+    account: string;
+    target: string;
+    runtime?: AlertRuntimeContext;
+}
+export declare class AlertService {
+    private readonly options;
+    private lastError;
+    constructor(options: AlertServiceOptions);
+    send(message: string): Promise<boolean>;
+    getLastError(): string | null;
+    getCliBinary(): string;
+    formatSystemNotification(title: string, lines: string[]): string;
+    formatPriceAlert(params: {
+        symbol: string;
+        name: string;
+        currentPrice: number;
+        ruleName: string;
+        ruleDescription: string;
+        levelPrice: number;
+        costPrice: number | null;
+    }): string;
+    formatVolumeAlert(params: {
+        symbol: string;
+        name: string;
+        currentPrice: number;
+        currentVolume: number;
+        avgVolume: number;
+        ratio: number;
+    }): string;
+    private get channel();
+    private combineErrors;
+    private trySendViaRuntime;
+    private trySendViaRuntimeCommand;
+    private trySendViaSpawn;
+    private buildCliArgs;
+}
+export {};

package/dist/services/alert-service.js

@@ -0,0 +1,198 @@
+import { spawn } from "node:child_process";
+import { calculateProfitPct, formatCostPrice } from "../utils/cost-price.js";
+export class AlertService {
+    options;
+    lastError = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async send(message) {
+        this.lastError = null;
+        const runtimeError = await this.trySendViaRuntime(message);
+        if (runtimeError === null) {
+            return true;
+        }
+        const fallbackError = this.options.runtime
+            ? await this.trySendViaRuntimeCommand(message)
+            : await this.trySendViaSpawn(message);
+        if (fallbackError === null) {
+            return true;
+        }
+        this.lastError = this.combineErrors(runtimeError, fallbackError);
+        return false;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+    getCliBinary() {
+        return this.options.openclawCliBin;
+    }
+    formatSystemNotification(title, lines) {
+        return [title, lines.join("\n")].filter(Boolean).join("\n\n").trim();
+    }
+    formatPriceAlert(params) {
+        const profitPct = calculateProfitPct(params.currentPrice, params.costPrice);
+        return [
+            `🚨 ${params.ruleName}告警`,
+            "",
+            `📌 ${params.name}（${params.symbol}）`,
+            `💹 当前价: ${params.currentPrice.toFixed(2)}`,
+            `📊 触发价位: ${params.levelPrice.toFixed(2)}`,
+            `📝 ${params.ruleDescription}`,
+            ...(profitPct == null
+                ? []
+                : [
+                    `💰 持仓盈亏: ${profitPct >= 0 ? "+" : ""}${profitPct.toFixed(2)}%（成本 ${formatCostPrice(params.costPrice)}）`,
+                ]),
+            "",
+            "⏰ 请及时关注！",
+        ].join("\n");
+    }
+    formatVolumeAlert(params) {
+        return [
+            "📊 成交量异动",
+            "",
+            `📌 ${params.name}（${params.symbol}）`,
+            `💹 当前价: ${params.currentPrice.toFixed(2)}`,
+            `📈 当前成交量: ${params.currentVolume.toLocaleString("en-US")}`,
+            `📉 近5日均量: ${params.avgVolume.toFixed(0)}`,
+            `⚡ 量比: ${params.ratio.toFixed(1)}倍`,
+            "",
+            "⚠️ 成交量显著放大，请关注盘面变化！",
+        ].join("\n");
+    }
+    get channel() {
+        return this.options.channel.trim().toLowerCase();
+    }
+    combineErrors(runtimeError, fallbackError) {
+        if (!runtimeError || runtimeError === "runtime delivery unavailable") {
+            return fallbackError;
+        }
+        return `${runtimeError}; ${fallbackError}`;
+    }
+    async trySendViaRuntime(message) {
+        const runtimeContext = this.options.runtime;
+        if (!runtimeContext || !this.options.target.trim()) {
+            return "runtime delivery unavailable";
+        }
+        const baseOptions = {
+            accountId: this.options.account || undefined,
+            cfg: runtimeContext.config,
+        };
+        try {
+            switch (this.channel) {
+                case "telegram":
+                    await runtimeContext.runtime.channel.telegram.sendMessageTelegram(this.options.target, message, baseOptions);
+                    return null;
+                case "discord":
+                    await runtimeContext.runtime.channel.discord.sendMessageDiscord(this.options.target, message, baseOptions);
+                    return null;
+                case "slack":
+                    await runtimeContext.runtime.channel.slack.sendMessageSlack(this.options.target, message, baseOptions);
+                    return null;
+                case "signal":
+                    await runtimeContext.runtime.channel.signal.sendMessageSignal(this.options.target, message, baseOptions);
+                    return null;
+                case "imessage":
+                    await runtimeContext.runtime.channel.imessage.sendMessageIMessage(this.options.target, message, {
+                        accountId: this.options.account || undefined,
+                        config: runtimeContext.config,
+                    });
+                    return null;
+                case "whatsapp":
+                    await runtimeContext.runtime.channel.whatsapp.sendMessageWhatsApp(this.options.target, message, {
+                        verbose: false,
+                        cfg: runtimeContext.config,
+                        accountId: this.options.account || undefined,
+                    });
+                    return null;
+                default:
+                    return `runtime delivery not supported for channel: ${this.channel}`;
+            }
+        }
+        catch (error) {
+            return `runtime delivery failed: ${formatErrorMessage(error)}`;
+        }
+    }
+    async trySendViaRuntimeCommand(message) {
+        const runtimeContext = this.options.runtime;
+        if (!runtimeContext) {
+            return "runtime command unavailable";
+        }
+        try {
+            const result = await runtimeContext.runtime.system.runCommandWithTimeout(this.buildCliArgs(message), { timeoutMs: 15_000 });
+            if (result.code === 0) {
+                return null;
+            }
+            return (result.stderr.trim()
+                || result.stdout.trim()
+                || `command exited with ${result.code ?? "unknown"}`);
+        }
+        catch (error) {
+            return `runtime command failed: ${formatErrorMessage(error)}`;
+        }
+    }
+    async trySendViaSpawn(message) {
+        const argv = this.buildCliArgs(message);
+        const [command, ...args] = argv;
+        return new Promise((resolve) => {
+            const child = spawn(command, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            let settled = false;
+            const finish = (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(value);
+            };
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk.toString();
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.on("error", (error) => {
+                finish(`spawn failed: ${error.message}`);
+            });
+            child.on("close", (code) => {
+                finish(code === 0 ? null : (stderr || stdout || `exit code ${code}`).trim());
+            });
+        });
+    }
+    buildCliArgs(message) {
+        const args = [
+            this.options.openclawCliBin,
+            "message",
+            "send",
+            "--channel",
+            this.channel,
+            "--message",
+            message,
+        ];
+        if (this.options.target) {
+            args.push("--target", this.options.target);
+        }
+        if (this.options.account) {
+            args.push("--account", this.options.account);
+        }
+        return args;
+    }
+}
+function formatErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}

package/dist/services/analysis-service.d.ts

@@ -0,0 +1,20 @@
+import { AnalysisTask } from "../analysis/tasks/analysis-task.js";
+import { AnalysisLogRepository } from "../storage/repositories/analysis-log-repo.js";
+import type { AnalysisLogEntry } from "../types/domain.js";
+export interface GenerateTextOptions {
+    maxTokens?: number;
+    temperature?: number;
+}
+export declare class AnalysisService {
+    private readonly llmBaseUrl;
+    private readonly llmApiKey;
+    private readonly llmModel;
+    private readonly analysisLogRepository;
+    constructor(llmBaseUrl: string, llmApiKey: string, llmModel: string, analysisLogRepository: AnalysisLogRepository);
+    isConfigured(): boolean;
+    getConfigurationError(): string | null;
+    runTask<TInput, TResult>(task: AnalysisTask<TInput, TResult>, input: TInput): Promise<TResult>;
+    generateText(systemPrompt: string, userPrompt: string, options?: GenerateTextOptions): Promise<string>;
+    getLatestAnalysis(symbol: string): Promise<AnalysisLogEntry | null>;
+    private callLlm;
+}