opencandle 0.4.0 → 0.6.0

package/src/tools/portfolio/watchlist.ts

@@ -1,50 +1,53 @@
-import { Type } from "@sinclair/typebox";
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { getQuote } from "../../providers/yahoo-finance.js";
+import { Type } from "@sinclair/typebox";
+import { isZeroFilledQuote } from "../../market-state/resolve.js";
+import { resolveInstrumentForMutation } from "../../market-state/resolve-for-mutation.js";
+import { MarketStateService, type WatchlistItemRecord } from "../../market-state/service.js";
+import { initDefaultDatabase } from "../../memory/sqlite.js";
+import { getQuotes, type TradingViewQuote } from "../../providers/tradingview.js";
 import { wrapProvider } from "../../providers/wrap-provider.js";
-import { ensureParentDir, getWatchlistPath } from "../../infra/opencandle-paths.js";
-
-interface WatchlistItem {
-  symbol: string;
-  addedAt: string;
-  targetPrice?: number;
-  stopPrice?: number;
-  notes?: string;
-}
-
-function loadWatchlist(): WatchlistItem[] {
-  const watchlistPath = getWatchlistPath();
-  if (!existsSync(watchlistPath)) return [];
-  try {
-    return JSON.parse(readFileSync(watchlistPath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
+import { getQuote } from "../../providers/yahoo-finance.js";
 
-function saveWatchlist(items: WatchlistItem[]): void {
-  const watchlistPath = getWatchlistPath();
-  ensureParentDir(watchlistPath);
-  writeFileSync(watchlistPath, JSON.stringify(items, null, 2));
+interface WatchlistCheck extends WatchlistItemRecord {
+  currentPrice: number | null;
+  alerts: string[];
+  statuses: string[];
+  sourceProvider?: "tradingview" | "yahoo";
+  dataCaveat?: string;
 }
 
 const params = Type.Object({
   action: Type.Union(
-    [Type.Literal("add"), Type.Literal("remove"), Type.Literal("check")],
-    { description: "One of: 'add', 'remove', or 'check'" },
-  ),
-  symbol: Type.Optional(
-    Type.String({ description: "Ticker symbol (required for add/remove)" }),
+    [Type.Literal("add"), Type.Literal("update"), Type.Literal("remove"), Type.Literal("check")],
+    { description: "One of: 'add', 'update', 'remove', or 'check'" },
   ),
+  symbol: Type.Optional(Type.String({ description: "Ticker symbol (required for add/remove)" })),
   target_price: Type.Optional(
-    Type.Number({ description: "Alert when price rises above this level" }),
+    Type.Union([
+      Type.Number({ description: "Alert when price rises above this level" }),
+      Type.Null({ description: "Clear the existing target price during update" }),
+    ]),
   ),
   stop_price: Type.Optional(
-    Type.Number({ description: "Alert when price falls below this level" }),
+    Type.Union([
+      Type.Number({ description: "Alert when price falls below this level" }),
+      Type.Null({ description: "Clear the existing stop price during update" }),
+    ]),
   ),
   notes: Type.Optional(
-    Type.String({ description: "Optional notes for why you're watching this" }),
+    Type.Union([
+      Type.String({ description: "Optional notes for why you're watching this" }),
+      Type.Null({ description: "Clear existing notes during update" }),
+    ]),
+  ),
+  thesis: Type.Optional(
+    Type.Union([
+      Type.String({ description: "Optional thesis for why you're watching this" }),
+      Type.Null({ description: "Clear the existing thesis during update" }),
+    ]),
+  ),
+  tags: Type.Optional(
+    Type.Array(Type.String(), { description: "Optional tags for organizing the watchlist item" }),
   ),
 });
 
@@ -52,102 +55,234 @@ export const watchlistTool: AgentTool<typeof params> = {
   name: "manage_watchlist",
   label: "Watchlist",
   description:
-    "Manage your watchlist of stocks and crypto. Add symbols with optional target and stop prices, remove symbols, or check current prices against your alert levels. Data persisted to ~/.opencandle/watchlist.json.",
+    "Manage your watchlist of stocks and crypto. Add symbols with optional target and stop prices, remove symbols, or check current prices against your watchlist levels.",
   parameters: params,
-  async execute(toolCallId, args) {
-    const items = loadWatchlist();
+  async execute(_toolCallId, args) {
+    const db = initDefaultDatabase();
+    const service = new MarketStateService(db);
 
-    if (args.action === "add") {
-      if (!args.symbol) {
-        throw new Error("symbol is required for add action.");
+    try {
+      if (args.action === "add") {
+        if (!args.symbol) {
+          throw new Error("symbol is required for add action.");
+        }
+        const instrument = await resolveInstrumentForMutation(args.symbol);
+        if (instrument.status === "needs_selection") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Could not verify ${instrument.query}. Choose one of the returned candidates before adding it to the watchlist.`,
+              },
+            ],
+            details: instrument,
+          };
+        }
+        const item = service.addWatchlistItem({
+          instrument: instrument.instrument,
+          targetPrice: args.target_price,
+          stopPrice: args.stop_price,
+          thesis: args.thesis,
+          notes: args.notes,
+          tags: args.tags,
+        });
+        const alerts = [];
+        if (args.target_price) alerts.push(`target: $${args.target_price}`);
+        if (args.stop_price) alerts.push(`stop: $${args.stop_price}`);
+        const alertStr = alerts.length > 0 ? ` (${alerts.join(", ")})` : "";
+        return {
+          content: [{ type: "text", text: `Added ${item.symbol} to watchlist${alertStr}` }],
+          details: item,
+        };
       }
-      const symbol = args.symbol.toUpperCase();
-      const existing = items.findIndex((i) => i.symbol === symbol);
-      const item: WatchlistItem = {
-        symbol,
-        addedAt: new Date().toISOString(),
-        ...(args.target_price != null && { targetPrice: args.target_price }),
-        ...(args.stop_price != null && { stopPrice: args.stop_price }),
-        ...(args.notes != null && { notes: args.notes }),
-      };
-      if (existing >= 0) {
-        items[existing] = item;
-      } else {
-        items.push(item);
+
+      if (args.action === "remove") {
+        if (!args.symbol) {
+          throw new Error("symbol is required for remove action.");
+        }
+        const symbol = args.symbol.toUpperCase();
+        if (!service.removeWatchlistItemBySymbol(symbol)) {
+          return {
+            content: [{ type: "text", text: `${symbol} not found in watchlist` }],
+            details: null,
+          };
+        }
+        return {
+          content: [{ type: "text", text: `Removed ${symbol} from watchlist` }],
+          details: null,
+        };
       }
-      saveWatchlist(items);
-      const alerts = [];
-      if (args.target_price) alerts.push(`target: $${args.target_price}`);
-      if (args.stop_price) alerts.push(`stop: $${args.stop_price}`);
-      const alertStr = alerts.length > 0 ? ` (${alerts.join(", ")})` : "";
-      return {
-        content: [{ type: "text", text: `Added ${symbol} to watchlist${alertStr}` }],
-        details: null,
-      };
-    }
 
-    if (args.action === "remove") {
-      if (!args.symbol) {
-        throw new Error("symbol is required for remove action.");
+      if (args.action === "update") {
+        if (!args.symbol) {
+          throw new Error("symbol is required for update action.");
+        }
+        const symbol = args.symbol.toUpperCase();
+        const item = service.updateWatchlistItemBySymbol(symbol, {
+          targetPrice: args.target_price,
+          stopPrice: args.stop_price,
+          notes: args.notes,
+          thesis: args.thesis,
+          tags: args.tags,
+        });
+        if (item == null) {
+          return {
+            content: [{ type: "text", text: `${symbol} not found in watchlist` }],
+            details: null,
+          };
+        }
+        return {
+          content: [{ type: "text", text: `Updated ${item.symbol} in watchlist` }],
+          details: item,
+        };
       }
-      const symbol = args.symbol.toUpperCase();
-      const idx = items.findIndex((i) => i.symbol === symbol);
-      if (idx === -1) {
+
+      const items = service.listWatchlistItems();
+      if (items.length === 0) {
         return {
-          content: [{ type: "text", text: `${symbol} not found in watchlist` }],
+          content: [{ type: "text", text: "Watchlist is empty. Use add action to add symbols." }],
           details: null,
         };
       }
-      items.splice(idx, 1);
-      saveWatchlist(items);
-      return {
-        content: [{ type: "text", text: `Removed ${symbol} from watchlist` }],
-        details: null,
-      };
-    }
 
-    // Check action
-    if (items.length === 0) {
+      const checks = await checkWatchlistPrices(items);
+      const alertItems = checks.filter((c) => c.alerts.length > 0);
+      const lines = [
+        `**Watchlist** — ${items.length} symbols${alertItems.length > 0 ? ` | ${alertItems.length} ALERT(S)` : ""}`,
+        "",
+      ];
+
+      const tradingViewCaveats = Array.from(
+        new Set(
+          checks
+            .filter((c) => c.sourceProvider === "tradingview")
+            .map(
+              (c) =>
+                c.dataCaveat ??
+                "TradingView scanner data may be delayed about 15 minutes and comes from an unofficial endpoint.",
+            ),
+        ),
+      );
+      if (tradingViewCaveats.length > 0) {
+        lines.push(...tradingViewCaveats.map((caveat) => `Data caveat: ${caveat}`), "");
+      }
+
+      for (const c of checks) {
+        const alertStr = c.alerts.length > 0 ? ` ** ${c.alerts.join(" | ")} **` : "";
+        const statusStr = c.statuses.length > 0 ? ` | ${c.statuses.join(" | ")}` : "";
+        const targetStr = c.targetPrice ? ` | Target: $${c.targetPrice}` : "";
+        const stopStr = c.stopPrice ? ` | Stop: $${c.stopPrice}` : "";
+        const sourceStr = c.sourceProvider
+          ? ` | Source: ${c.sourceProvider === "tradingview" ? "TradingView" : "Yahoo"}`
+          : "";
+        const priceStr =
+          typeof c.currentPrice === "number" ? `$${c.currentPrice.toFixed(2)}` : "Unavailable";
+        lines.push(
+          `  ${c.symbol}: ${priceStr}${targetStr}${stopStr}${sourceStr}${statusStr}${alertStr}`,
+        );
+      }
+
       return {
-        content: [{ type: "text", text: "Watchlist is empty. Use add action to add symbols." }],
-        details: null,
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: { items: checks },
       };
+    } finally {
+      db.close();
     }
+  },
+};
 
-    const checks = await Promise.all(
-      items.map(async (item) => {
-        const result = await wrapProvider("yahoo", () => getQuote(item.symbol));
-        if (result.status === "unavailable") {
-          return { ...item, currentPrice: 0, alerts: [`UNAVAILABLE: ${result.reason}`] };
-        }
-        const quote = result.data;
-        const alerts: string[] = [];
-        if (item.targetPrice && quote.price >= item.targetPrice) {
-          alerts.push(`TARGET HIT: $${quote.price.toFixed(2)} >= $${item.targetPrice}`);
-        }
-        if (item.stopPrice && quote.price <= item.stopPrice) {
-          alerts.push(`STOP ALERT: $${quote.price.toFixed(2)} fell below $${item.stopPrice}`);
-        }
-        return { ...item, currentPrice: quote.price, alerts };
-      }),
-    );
-
-    const alertItems = checks.filter((c) => c.alerts.length > 0);
-    const lines = [
-      `**Watchlist** — ${items.length} symbols${alertItems.length > 0 ? ` | ${alertItems.length} ALERT(S)` : ""}`,
-      "",
-    ];
-
-    for (const c of checks) {
-      const alertStr = c.alerts.length > 0 ? ` ** ${c.alerts.join(" | ")} **` : "";
-      const targetStr = c.targetPrice ? ` | Target: $${c.targetPrice}` : "";
-      const stopStr = c.stopPrice ? ` | Stop: $${c.stopPrice}` : "";
-      lines.push(`  ${c.symbol}: $${c.currentPrice.toFixed(2)}${targetStr}${stopStr}${alertStr}`);
+async function checkWatchlistPrices(items: WatchlistItemRecord[]): Promise<WatchlistCheck[]> {
+  const tradingViewSymbols = items
+    .map((item) => item.symbol)
+    .filter((symbol) => !shouldSkipTradingView(symbol));
+  const tradingViewQuotes = new Map<string, TradingViewQuote>();
+
+  if (tradingViewSymbols.length > 0) {
+    const result = await wrapProvider("tradingview", () => getQuotes(tradingViewSymbols));
+    if (result.status === "ok" && result.data.length > 0) {
+      for (const quote of result.data) {
+        tradingViewQuotes.set(quote.requestedSymbol.toUpperCase(), {
+          ...quote,
+          dataCaveat: result.stale
+            ? `cached TradingView data from ${result.timestamp}; ${quote.dataCaveat}`
+            : quote.dataCaveat,
+        });
+      }
     }
+  }
 
-    return {
-      content: [{ type: "text", text: lines.join("\n") }],
-      details: { items: checks },
-    };
-  },
-};
+  return Promise.all(
+    items.map(async (item) => {
+      const tradingViewQuote = tradingViewQuotes.get(item.symbol.toUpperCase());
+      if (tradingViewQuote) {
+        return buildCheckResult(
+          item,
+          tradingViewQuote.price,
+          "tradingview",
+          tradingViewQuote.dataCaveat,
+        );
+      }
+
+      const result = await wrapProvider("yahoo", () => getQuote(item.symbol));
+      if (result.status === "unavailable") {
+        return {
+          ...item,
+          currentPrice: null,
+          alerts: [`UNAVAILABLE: ${result.reason}`],
+          statuses: [],
+        };
+      }
+      if (result.stale) {
+        return {
+          ...item,
+          currentPrice: null,
+          alerts: ["UNAVAILABLE: provider returned stale market data"],
+          statuses: [],
+        };
+      }
+      const quote = result.data;
+      if (isZeroFilledQuote(quote)) {
+        return {
+          ...item,
+          currentPrice: null,
+          alerts: ["UNAVAILABLE: Yahoo returned no valid market data."],
+          statuses: [],
+        };
+      }
+      return buildCheckResult(item, quote.price, "yahoo");
+    }),
+  );
+}
+
+function buildCheckResult(
+  item: WatchlistItemRecord,
+  price: number,
+  sourceProvider: "tradingview" | "yahoo",
+  dataCaveat?: string,
+): WatchlistCheck {
+  const alerts: string[] = [];
+  const statuses: string[] = [];
+  if (item.targetPrice && price >= item.targetPrice) {
+    alerts.push(`TARGET HIT: $${price.toFixed(2)} >= $${item.targetPrice}`);
+  } else if (item.targetPrice) {
+    statuses.push(`Target pending: $${price.toFixed(2)} < $${item.targetPrice}`);
+  }
+  if (item.stopPrice && price <= item.stopPrice) {
+    alerts.push(`STOP ALERT: $${price.toFixed(2)} fell below $${item.stopPrice}`);
+  } else if (item.stopPrice) {
+    statuses.push(`Stop OK: $${price.toFixed(2)} > $${item.stopPrice}`);
+  }
+  return {
+    ...item,
+    currentPrice: price,
+    alerts,
+    statuses,
+    sourceProvider,
+    dataCaveat,
+  };
+}
+
+function shouldSkipTradingView(symbol: string): boolean {
+  return /(?:-USD|\.(?:TO|DE|T|L|HK))$/i.test(symbol.trim());
+}

package/src/tools/sentiment/reddit-sentiment.ts

@@ -1,11 +1,12 @@
-import { Type } from "@sinclair/typebox";
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { getSubredditPosts, getPostComments } from "../../providers/reddit.js";
+import { Type } from "@sinclair/typebox";
+import { getConfig } from "../../config.js";
+import { getPostComments, getSubredditPosts } from "../../providers/reddit.js";
 import { wrapProvider } from "../../providers/wrap-provider.js";
-import type { RedditSentimentResult } from "../../types/sentiment.js";
 import { RedditAdapter } from "../../sentiment/adapters/reddit.js";
 import { getSentimentPipeline } from "../../sentiment/index.js";
-import { getConfig } from "../../config.js";
+import type { RedditSentimentResult } from "../../types/sentiment.js";
+import { renderUntrustedText, untrustedContentHeader } from "./untrusted-text.js";
 
 const params = Type.Object({
   subreddit: Type.Optional(
@@ -36,7 +37,7 @@ export const redditSentimentTool: AgentTool<typeof params, RedditSentimentResult
   description:
     "Analyze sentiment from financial Reddit communities. Supports single subreddit, multi-subreddit, and topic filtering. Returns scored posts with comment analysis and trend context.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const limit = Math.min(args.limit ?? 25, 100);
     const config = getConfig();
 
@@ -47,7 +48,12 @@ export const redditSentimentTool: AgentTool<typeof params, RedditSentimentResult
     } else if (args.subreddit) {
       subreddits = [args.subreddit];
     } else {
-      subreddits = config.sentiment?.defaultSubreddits ?? ["wallstreetbets", "stocks", "investing", "options"];
+      subreddits = config.sentiment?.defaultSubreddits ?? [
+        "wallstreetbets",
+        "stocks",
+        "investing",
+        "options",
+      ];
     }
 
     // Fetch from all subreddits
@@ -64,21 +70,26 @@ export const redditSentimentTool: AgentTool<typeof params, RedditSentimentResult
 
     if (allResults.length === 0) {
       return {
-        content: [{ type: "text", text: `⚠ Reddit sentiment unavailable (${warnings.join("; ")}).` }],
+        content: [
+          { type: "text", text: `⚠ Reddit sentiment unavailable (${warnings.join("; ")}).` },
+        ],
         details: null as any,
       };
     }
 
     // Merge and filter by query if provided
     const adapter = new RedditAdapter();
-    let allRecords = allResults.flatMap((r) => adapter.mapPostsToRecords(r, args.query ?? subreddits.join("+")));
+    let allRecords = allResults.flatMap((r) =>
+      adapter.mapPostsToRecords(r, args.query ?? subreddits.join("+")),
+    );
 
     // Topic filtering
     if (args.query) {
       const queryLower = args.query.toLowerCase();
-      allRecords = allRecords.filter((r) =>
-        r.text.toLowerCase().includes(queryLower) ||
-        (r.title?.toLowerCase().includes(queryLower) ?? false),
+      allRecords = allRecords.filter(
+        (r) =>
+          r.text.toLowerCase().includes(queryLower) ||
+          (r.title?.toLowerCase().includes(queryLower) ?? false),
       );
     }
 
@@ -115,23 +126,33 @@ export const redditSentimentTool: AgentTool<typeof params, RedditSentimentResult
 
     // Process through pipeline
     const pipeline = getSentimentPipeline();
-    const pipelineResult = await pipeline.processRecords(allRecords, args.query ?? subreddits.join("+"));
+    const pipelineResult = await pipeline.processRecords(
+      allRecords,
+      args.query ?? subreddits.join("+"),
+    );
 
     // Build output using first result as base for backward compatibility
     const firstResult = allResults[0];
     const postRecords = pipelineResult.fresh.filter((r) => !r.metadata.isComment);
     const commentRecords = pipelineResult.fresh.filter((r) => r.metadata.isComment);
-    const avgScore = postRecords.length > 0
-      ? postRecords.reduce((s, r) => s + r.sentiment.score, 0) / postRecords.length
-      : 0;
+    const avgScore =
+      postRecords.length > 0
+        ? postRecords.reduce((s, r) => s + r.sentiment.score, 0) / postRecords.length
+        : 0;
 
     const sentimentLabel =
-      avgScore > 0.3 ? "Bullish" :
-      avgScore < -0.3 ? "Bearish" :
-      avgScore > 0 ? "Leaning Bullish" :
-      avgScore < 0 ? "Leaning Bearish" : "Neutral";
-
-    const subLabel = subreddits.length === 1 ? `r/${subreddits[0]}` : `${subreddits.length} subreddits`;
+      avgScore > 0.3
+        ? "Bullish"
+        : avgScore < -0.3
+          ? "Bearish"
+          : avgScore > 0
+            ? "Leaning Bullish"
+            : avgScore < 0
+              ? "Leaning Bearish"
+              : "Neutral";
+
+    const subLabel =
+      subreddits.length === 1 ? `r/${subreddits[0]}` : `${subreddits.length} subreddits`;
     const lines = [
       `**Reddit: ${args.query ?? subLabel}** — ${postRecords.length} posts, ${commentRecords.length} comments`,
       `Sentiment: ${avgScore.toFixed(2)} (${sentimentLabel})`,
@@ -142,16 +163,21 @@ export const redditSentimentTool: AgentTool<typeof params, RedditSentimentResult
     }
 
     lines.push("");
-    lines.push("Top posts:");
+    lines.push(untrustedContentHeader("Reddit posts"));
     for (const post of postRecords.slice(0, 10)) {
-      const scoreIndicator = post.sentiment.score > 0 ? "🟢" : post.sentiment.score < 0 ? "🔴" : "⚪";
-      lines.push(`  ${scoreIndicator} ⬆${post.engagement.score} 💬${post.engagement.replies ?? 0} — ${(post.title ?? post.text).slice(0, 100)}`);
+      const scoreIndicator =
+        post.sentiment.score > 0 ? "🟢" : post.sentiment.score < 0 ? "🔴" : "⚪";
+      lines.push(
+        `  ${scoreIndicator} ⬆${post.engagement.score} 💬${post.engagement.replies ?? 0} — ${renderUntrustedText(post.title ?? post.text, 100)}`,
+      );
     }
 
     if (pipelineResult.trend && pipelineResult.trend.length > 0) {
       const t = pipelineResult.trend[0];
       lines.push("");
-      lines.push(`Trend: ${t.sparkline} ${t.direction} (${t.delta >= 0 ? "+" : ""}${t.delta.toFixed(2)}, ${t.count} records)`);
+      lines.push(
+        `Trend: ${t.sparkline} ${t.direction} (${t.delta >= 0 ? "+" : ""}${t.delta.toFixed(2)}, ${t.count} records)`,
+      );
     }
 
     if (warnings.length > 0) {