@openfinclaw/openfinclaw-strategy 2026.3.14 → 2026.3.26

package/src/datahub/tools.ts

@@ -0,0 +1,347 @@
+/**
+ * DataHub market data tools registration.
+ * Tools: fin_price, fin_kline, fin_crypto, fin_compare, fin_slim_search
+ */
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openfinclaw/plugin-sdk";
+import type { UnifiedPluginConfig, MarketType } from "../types.js";
+import { DataHubClient, guessMarket } from "./client.js";
+
+/** JSON tool result helper. */
+function json(payload: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
+    details: payload,
+  };
+}
+
+/** Helper to pick params. */
+function pick(params: Record<string, unknown>, ...keys: string[]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const k of keys) {
+    if (params[k] != null) out[k] = String(params[k]);
+  }
+  return out;
+}
+
+const NO_KEY =
+  "API key not configured. Set apiKey in plugin config or OPENFINCLAW_API_KEY env var.";
+
+/**
+ * Register DataHub market data tools.
+ */
+export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPluginConfig): void {
+  const datahubClient = config.apiKey
+    ? new DataHubClient(config.datahubGatewayUrl, config.apiKey, config.requestTimeoutMs)
+    : null;
+
+  // Register fin-data-provider service for other plugins
+  if (datahubClient) {
+    api.registerService({
+      id: "fin-data-provider",
+      start: () => {},
+      instance: {
+        async getOHLCV(params: {
+          symbol: string;
+          market?: string;
+          timeframe?: string;
+          limit?: number;
+        }) {
+          const market = (params.market as MarketType) ?? guessMarket(params.symbol);
+          return datahubClient.getOHLCV({
+            symbol: params.symbol,
+            market,
+            limit: params.limit ?? 300,
+          });
+        },
+        async getTicker(symbol: string, market?: string) {
+          const m = (market as MarketType) ?? guessMarket(symbol);
+          return datahubClient.getTicker(symbol, m);
+        },
+      },
+    } as Parameters<typeof api.registerService>[0]);
+  }
+
+  // ── fin_price — Price Lookup ──
+  api.registerTool(
+    {
+      name: "fin_price",
+      label: "Price Lookup",
+      description:
+        "Get the current/latest price for any asset — stocks (A/HK/US), crypto, index. " +
+        "Returns latest close, volume, and date. The simplest way to answer 'XX 现在什么价格'.",
+      parameters: Type.Object({
+        symbol: Type.String({
+          description:
+            "Asset symbol. Crypto: BTC/USDT, ETH/USDT; A-share: 600519.SH; HK: 00700.HK; US: AAPL; Index: 000300.SH",
+        }),
+        market: Type.Optional(
+          Type.Unsafe<"crypto" | "equity">({
+            type: "string",
+            enum: ["crypto", "equity"],
+            description:
+              "Market type. Auto-detected if omitted: symbols with .SH/.SZ/.HK or pure letters → equity; contains '/' → crypto.",
+          }),
+        ),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const symbol = String(params.symbol);
+          const market = (params.market as MarketType) ?? guessMarket(symbol);
+          const ticker = await datahubClient.getTicker(symbol, market);
+          return json({
+            symbol: ticker.symbol,
+            market: ticker.market,
+            price: ticker.last,
+            volume24h: ticker.volume24h,
+            timestamp: new Date(ticker.timestamp).toISOString(),
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_price"] },
+  );
+
+  // ── fin_kline — K-Line / OHLCV ──
+  api.registerTool(
+    {
+      name: "fin_kline",
+      label: "K-Line / OHLCV",
+      description:
+        "Fetch historical OHLCV (candlestick) data for any asset. " +
+        "Use for price history, charting, and trend analysis.",
+      parameters: Type.Object({
+        symbol: Type.String({
+          description: "Asset symbol (BTC/USDT, 600519.SH, AAPL, etc.)",
+        }),
+        market: Type.Optional(
+          Type.Unsafe<"crypto" | "equity">({
+            type: "string",
+            enum: ["crypto", "equity"],
+            description: "Market type (auto-detected if omitted)",
+          }),
+        ),
+        limit: Type.Optional(
+          Type.Number({ description: "Number of bars to return (default: 30)" }),
+        ),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const symbol = String(params.symbol);
+          const market = (params.market as MarketType) ?? guessMarket(symbol);
+          const limit = (params.limit as number) ?? 30;
+          const ohlcv = await datahubClient.getOHLCV({ symbol, market, limit });
+          return json({
+            symbol,
+            market,
+            count: ohlcv.length,
+            bars: ohlcv.map((b) => ({
+              date: new Date(b.timestamp).toISOString().slice(0, 10),
+              open: b.open,
+              high: b.high,
+              low: b.low,
+              close: b.close,
+              volume: b.volume,
+            })),
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_kline"] },
+  );
+
+  // ── fin_crypto — Crypto & DeFi ──
+  api.registerTool(
+    {
+      name: "fin_crypto",
+      label: "Crypto & DeFi",
+      description:
+        "Crypto market data (ticker/orderbook/trades/funding_rate) via CEX, " +
+        "DeFi (protocols/TVL/yields/stablecoins/fees/dex_volumes) via DefiLlama, " +
+        "market metrics (coin/market/info/categories/trending/global_stats) via CoinGecko.",
+      parameters: Type.Object({
+        endpoint: Type.Unsafe<string>({
+          type: "string",
+          enum: [
+            "market/ticker",
+            "market/tickers",
+            "market/orderbook",
+            "market/trades",
+            "market/funding_rate",
+            "coin/market",
+            "coin/historical",
+            "coin/info",
+            "coin/categories",
+            "coin/trending",
+            "coin/global_stats",
+            "defi/protocols",
+            "defi/tvl_historical",
+            "defi/protocol_tvl",
+            "defi/chains",
+            "defi/yields",
+            "defi/stablecoins",
+            "defi/fees",
+            "defi/dex_volumes",
+            "defi/bridges",
+            "defi/coin_prices",
+            "price/historical",
+            "search",
+          ],
+          description: "DataHub crypto endpoint path",
+        }),
+        symbol: Type.Optional(
+          Type.String({ description: "Coin ID, trading pair, or protocol slug" }),
+        ),
+        start_date: Type.Optional(Type.String({ description: "Start date (YYYY-MM-DD)" })),
+        end_date: Type.Optional(Type.String({ description: "End date (YYYY-MM-DD)" })),
+        limit: Type.Optional(Type.Number({ description: "Max results (default: 20)" })),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const endpoint = String(params.endpoint ?? "coin/market");
+          const qp = pick(params, "symbol", "start_date", "end_date", "limit");
+          if (!qp.limit) qp.limit = "20";
+          if (qp.symbol) {
+            const coinIdEndpoints = ["coin/historical", "coin/info"];
+            if (coinIdEndpoints.includes(endpoint)) {
+              qp.coin_id = qp.symbol;
+              delete qp.symbol;
+            } else if (endpoint === "defi/protocol_tvl") {
+              qp.protocol = qp.symbol;
+              delete qp.symbol;
+            } else if (endpoint === "defi/coin_prices") {
+              qp.coins = qp.symbol;
+              delete qp.symbol;
+            }
+          }
+          const results = await datahubClient.crypto(endpoint, qp);
+          return json({
+            success: true,
+            endpoint: `crypto/${endpoint}`,
+            count: results.length,
+            results,
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_crypto"] },
+  );
+
+  // ── fin_compare — Price Compare ──
+  api.registerTool(
+    {
+      name: "fin_compare",
+      label: "Price Compare",
+      description:
+        "Compare prices of 2-5 assets side by side. Returns latest price and recent change for each. " +
+        "Use for cross-asset comparison questions like 'BTC vs ETH vs 黄金'.",
+      parameters: Type.Object({
+        symbols: Type.String({
+          description: "Comma-separated symbols (2-5). Example: BTC/USDT,ETH/USDT,600519.SH",
+        }),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const raw = String(params.symbols);
+          const symbols = raw
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+            .slice(0, 5);
+          if (symbols.length < 2)
+            return json({ error: "Need at least 2 symbols, comma-separated" });
+
+          const results = await Promise.allSettled(
+            symbols.map(async (sym) => {
+              const market = guessMarket(sym);
+              const ticker = await datahubClient!.getTicker(sym, market);
+              const bars = await datahubClient!.getOHLCV({ symbol: sym, market, limit: 7 });
+              const weekAgo = bars.length > 0 ? bars[0]!.close : ticker.last;
+              const weekChange = weekAgo > 0 ? ((ticker.last - weekAgo) / weekAgo) * 100 : 0;
+              return {
+                symbol: sym,
+                market,
+                price: ticker.last,
+                weekChange: Math.round(weekChange * 100) / 100,
+              };
+            }),
+          );
+
+          return json({
+            comparison: results.map((r, i) =>
+              r.status === "fulfilled"
+                ? r.value
+                : { symbol: symbols[i], error: (r.reason as Error).message },
+            ),
+          });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_compare"] },
+  );
+
+  // ── fin_slim_search — Symbol Search ──
+  api.registerTool(
+    {
+      name: "fin_slim_search",
+      label: "Symbol Search",
+      description:
+        "Search for stock/crypto symbols by name or keyword. " +
+        "Use when user mentions a company/coin name but not the exact symbol.",
+      parameters: Type.Object({
+        query: Type.String({ description: "Search keyword (e.g. '茅台', 'bitcoin', 'Tesla')" }),
+        market: Type.Optional(
+          Type.Unsafe<"crypto" | "equity">({
+            type: "string",
+            enum: ["crypto", "equity"],
+            description: "Limit search to market type",
+          }),
+        ),
+      }),
+      async execute(_id: string, params: Record<string, unknown>) {
+        try {
+          if (!datahubClient) return json({ error: NO_KEY });
+          const q = String(params.query);
+          const market = params.market as string | undefined;
+
+          const results: unknown[] = [];
+
+          if (!market || market === "crypto") {
+            try {
+              const crypto = await datahubClient!.crypto("search", { query: q, limit: "5" });
+              results.push(...crypto.map((r) => ({ ...(r as object), market: "crypto" })));
+            } catch {
+              /* ignore */
+            }
+          }
+
+          if (!market || market === "equity") {
+            try {
+              const equity = await datahubClient!.equity("search", { query: q, limit: "5" });
+              results.push(...equity.map((r) => ({ ...(r as object), market: "equity" })));
+            } catch {
+              /* ignore */
+            }
+          }
+
+          return json({ query: q, count: results.length, results });
+        } catch (err) {
+          return json({ error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    },
+    { names: ["fin_slim_search"] },
+  );
+}

package/src/strategy/client.ts

@@ -0,0 +1,44 @@
+/**
+ * Hub API client for strategy operations.
+ * Handles HTTP requests to hub.openfinclaw.ai
+ */
+import type { UnifiedPluginConfig } from "../types.js";
+
+/**
+ * HTTP request helper for Hub API.
+ */
+export async function hubApiRequest(
+  config: UnifiedPluginConfig,
+  method: "GET" | "POST",
+  pathSegments: string,
+  options?: { body?: Record<string, unknown>; searchParams?: Record<string, string> },
+): Promise<{ status: number; data: unknown }> {
+  const url = new URL(`${config.hubApiUrl}/api/v1${pathSegments}`);
+  if (options?.searchParams) {
+    for (const [k, v] of Object.entries(options.searchParams)) {
+      url.searchParams.set(k, v);
+    }
+  }
+
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+
+  const response = await fetch(url.toString(), {
+    method,
+    headers,
+    body: options?.body ? JSON.stringify(options.body) : undefined,
+    signal: AbortSignal.timeout(config.requestTimeoutMs),
+  });
+
+  const rawText = await response.text();
+  let data: unknown = rawText;
+  if (rawText && rawText.trim().startsWith("{")) {
+    try {
+      data = JSON.parse(rawText);
+    } catch {
+      data = { raw: rawText };
+    }
+  }
+
+  return { status: response.status, data };
+}

package/src/{fork.ts → strategy/fork.ts}

@@ -4,6 +4,14 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import type {
+  UnifiedPluginConfig,
+  ForkOptions,
+  ForkResult,
+  HubPublicEntry,
+  ForkAndDownloadResponse,
+} from "../types.js";
+import type { ForkMeta } from "../types.js";
 import {
   getStrategiesRoot,
   createDateDir,
@@ -11,15 +19,7 @@ import {
   writeForkMeta,
   parseStrategyId,
   formatDate,
-} from "./strategy-storage.js";
-import type {
-  UnifiedPluginConfig,
-  ForkOptions,
-  ForkResult,
-  HubPublicEntry,
-  ForkAndDownloadResponse,
-} from "./types.js";
-import type { ForkMeta } from "./types.js";
+} from "./storage.js";
 
 const HUB_BASE_URL = "https://hub.openfinclaw.ai";
 
@@ -91,7 +91,8 @@ export async function forkAndDownloadFromHub(
   if (!config.apiKey) {
     return {
       success: false,
-      error: "API key is required for fork operation. Set OPENFINCLAW_API_KEY environment variable.",
+      error:
+        "API key is required for fork operation. Set OPENFINCLAW_API_KEY environment variable.",
     };
   }
 

package/src/{strategy-storage.ts → strategy/storage.ts}

@@ -1,7 +1,11 @@
+/**
+ * Local strategy storage management.
+ * Handles reading/writing strategy metadata and listing local strategies.
+ */
 import fs from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-import type { ForkMeta, CreatedMeta, LocalStrategy, StrategyPerformance } from "./types.js";
+import type { ForkMeta, CreatedMeta, LocalStrategy } from "../types.js";
 
 const WORKSPACE_DIRNAME = "workspace";
 const STRATEGIES_DIRNAME = "strategies";
@@ -30,10 +34,6 @@ export function getStrategiesRoot(): string {
 
 /**
  * Generate a slugified directory name from strategy name.
- * - Lowercase
- * - Spaces/underscores to hyphens
- * - Remove special characters
- * - Max 40 characters
  */
 export function slugifyName(name: string): string {
   return name
@@ -73,7 +73,6 @@ export function generateCreatedDirName(name: string): string {
 
 /**
  * Create date directory under strategies root.
- * Returns the full path to the date directory.
  */
 export function createDateDir(baseDir: string, date?: string): string {
   const dateStr = date ?? formatDate(new Date());