opencandle 0.5.0 → 0.7.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,108 +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();
+    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}`], statuses: [] };
-        }
-        const quote = result.data;
-        const alerts: string[] = [];
-        const statuses: string[] = [];
-        if (item.targetPrice && quote.price >= item.targetPrice) {
-          alerts.push(`TARGET HIT: $${quote.price.toFixed(2)} >= $${item.targetPrice}`);
-        } else if (item.targetPrice) {
-          statuses.push(`Target pending: $${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}`);
-        } else if (item.stopPrice) {
-          statuses.push(`Stop OK: $${quote.price.toFixed(2)} > $${item.stopPrice}`);
-        }
-        return { ...item, currentPrice: quote.price, alerts, statuses };
-      }),
-    );
-
-    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 statusStr = c.statuses.length > 0 ? ` | ${c.statuses.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}${statusStr}${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/insight-format.ts

@@ -0,0 +1,50 @@
+import type { SentimentInsight } from "../../types/sentiment.js";
+import { renderUntrustedText } from "./untrusted-text.js";
+
+export function formatInsightSection(insight: SentimentInsight): string[] {
+  const lines: string[] = [];
+  lines.push("");
+  lines.push("Findings:");
+  lines.push(
+    `- Overall: ${insight.label} (${formatSigned(insight.score)}) from ${insight.sampleSize} records; ${insight.scoredSampleSize} had keyword sentiment evidence.`,
+  );
+  lines.push(
+    `- Confidence: ${insight.confidence.level} (${insight.confidence.score.toFixed(2)})${
+      insight.confidence.reasons.length > 0 ? ` — ${insight.confidence.reasons.join("; ")}` : ""
+    }`,
+  );
+  appendDrivers(lines, "Positive drivers", insight.positiveDrivers);
+  appendDrivers(lines, "Negative drivers", insight.negativeDrivers);
+  appendDrivers(lines, "Mixed drivers", insight.mixedDrivers);
+  if (insight.caveats.length > 0) {
+    lines.push(`- Caveats: ${insight.caveats.join("; ")}`);
+  }
+  if (insight.notableClaims.length > 0) {
+    lines.push("- Notable source claims:");
+    for (const claim of insight.notableClaims.slice(0, 3)) {
+      lines.push(`  - ${renderUntrustedText(claim, 140)}`);
+    }
+  }
+  if (insight.representativeItems.length > 0) {
+    lines.push(
+      `- Representative evidence preview: ${insight.representativeItems.length} shown from ${insight.scoredSampleSize} scored records (${insight.sampleSize} total records).`,
+    );
+  }
+  return lines;
+}
+
+function appendDrivers(
+  lines: string[],
+  label: string,
+  drivers: SentimentInsight["positiveDrivers"],
+): void {
+  if (drivers.length === 0) return;
+  const rendered = drivers
+    .map((driver) => `${renderUntrustedText(driver.label, 60)} (${driver.count})`)
+    .join(", ");
+  lines.push(`- ${label}: ${rendered}`);
+}
+
+function formatSigned(value: number): string {
+  return `${value >= 0 ? "+" : ""}${value.toFixed(2)}`;
+}

package/src/tools/sentiment/query-match.ts

@@ -0,0 +1,117 @@
+import { extractEntities } from "../../routing/entity-extractor.js";
+import type { SentinelRecord } from "../../sentiment/types.js";
+
+const STOP_TERMS = new Set([
+  "about",
+  "around",
+  "are",
+  "from",
+  "how",
+  "is",
+  "latest",
+  "mood",
+  "now",
+  "on",
+  "or",
+  "people",
+  "reddit",
+  "retail",
+  "right",
+  "say",
+  "saying",
+  "says",
+  "sentiment",
+  "social",
+  "stock",
+  "stocks",
+  "talking",
+  "the",
+  "think",
+  "thinking",
+  "to",
+  "tweet",
+  "tweets",
+  "twitter",
+  "what",
+  "with",
+]);
+
+export function sentimentQueryTerms(query: string): string[] {
+  const hasSp500 = /\bs\s*&\s*p\s*500\b/i.test(query) || /\bspx\b/i.test(query);
+
+  const symbols = hasSp500
+    ? ["sp500"]
+    : extractEntities(query).symbols.map((symbol) => symbol.toLowerCase());
+  const punctuationTerms = [...query.toLowerCase().matchAll(/\b([a-z])\s*[&/]\s*([a-z])\b/g)].map(
+    (match) => `${match[1]}${match[2]}`,
+  );
+  const terms = query.toLowerCase().match(/[a-z0-9]{2,}/g);
+  if (!terms) {
+    if (punctuationTerms.length > 0) return [...new Set(punctuationTerms)];
+    const compact = query.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (compact.length >= 2) return [compact];
+    return query.trim().length > 0 ? [query.trim().toLowerCase()] : [];
+  }
+
+  const stopTerms = hasSp500 ? new Set([...STOP_TERMS, "sp", "spx", "500"]) : STOP_TERMS;
+  const filtered = [
+    ...new Set([...punctuationTerms, ...terms.filter((term) => !stopTerms.has(term))]),
+  ].slice(0, 6);
+  if (symbols.length > 0) {
+    return [
+      ...new Set([
+        ...symbols,
+        ...filtered.filter((term) => !symbols.some((symbol) => symbol.startsWith(term))),
+      ]),
+    ].slice(0, 6);
+  }
+  if (filtered.length > 0) return filtered;
+  return query.trim().length > 0 ? [query.trim().toLowerCase()] : [];
+}
+
+export function recordMatchesSentimentQuery(
+  record: SentinelRecord,
+  terms: readonly string[],
+): boolean {
+  if (terms.length === 0) return true;
+  const text = `${record.title ?? ""}\n${record.text}`.toLowerCase();
+  const textTokens = new Set(text.match(/[a-z0-9]+/g) ?? []);
+  const metadataTokens = new Set<string>();
+  const subreddit = record.metadata.subreddit;
+  if (typeof subreddit === "string") {
+    metadataTokens.add(subreddit.toLowerCase());
+    metadataTokens.add(subreddit.toLowerCase().replace(/^r\//, ""));
+  }
+  if (/\bs\s*&\s*p\s*500\b/i.test(text) || /\bspx\b/i.test(text)) textTokens.add("sp500");
+  for (const match of text.matchAll(/\b([a-z])\s*[&/]\s*([a-z])\b/g)) {
+    textTokens.add(`${match[1]}${match[2]}`);
+  }
+  for (const match of text.matchAll(/\b([a-z]{1,5})[.-]([a-z])\b/g)) {
+    textTokens.add(`${match[1]}${match[2]}`);
+  }
+  const tickerTokens = new Set<string>();
+  for (const ticker of record.sentiment.tickers) {
+    const normalized = ticker.toLowerCase();
+    tickerTokens.add(normalized);
+    tickerTokens.add(normalized.replace(/[^a-z0-9]/g, ""));
+  }
+  const matchedTerms = terms.filter(
+    (term) => tickerTokens.has(term) || textTokens.has(term) || metadataTokens.has(term),
+  );
+  for (const term of terms) {
+    if (matchedTerms.includes(term) || !term.includes(" ")) continue;
+    if (text.includes(term)) matchedTerms.push(term);
+  }
+  for (const term of terms) {
+    if (matchedTerms.includes(term) || term.length < 4) continue;
+    if (textTokens.has(`${term}s`)) {
+      matchedTerms.push(term);
+      continue;
+    }
+    if (term.endsWith("s") && textTokens.has(term.slice(0, -1))) {
+      matchedTerms.push(term);
+    }
+  }
+  const requiredMatches = terms.length > 1 ? 2 : 1;
+  return matchedTerms.length >= requiredMatches;
+}