opencandle 0.11.1 → 0.12.0

package/src/tools/portfolio/tracker.ts

@@ -1,308 +0,0 @@
-import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { Type } from "@sinclair/typebox";
-import { isZeroFilledQuote } from "../../market-state/resolve.js";
-import { resolveInstrumentForMutation } from "../../market-state/resolve-for-mutation.js";
-import { MarketStateService } from "../../market-state/service.js";
-import { initDefaultDatabase } from "../../memory/sqlite.js";
-import { wrapProvider } from "../../providers/wrap-provider.js";
-import { getQuote } from "../../providers/yahoo-finance.js";
-import type { PortfolioSummary, Position } from "../../types/portfolio.js";
-
-async function getCurrentPrice(
-  symbol: string,
-): Promise<
-  | { status: "ok"; price: number; currency: string | null }
-  | { status: "unavailable"; reason: string }
-> {
-  const result = await wrapProvider("yahoo", () => getQuote(symbol));
-  if (result.status === "unavailable") return { status: "unavailable", reason: result.reason };
-  if (result.stale) return { status: "unavailable", reason: "provider returned stale market data" };
-  if (isZeroFilledQuote(result.data)) {
-    return { status: "unavailable", reason: "Yahoo returned no valid market data." };
-  }
-  return { status: "ok", price: result.data.price, currency: result.data.currency ?? null };
-}
-
-const params = Type.Object({
-  action: Type.Union(
-    [Type.Literal("add"), Type.Literal("update"), Type.Literal("remove"), Type.Literal("view")],
-    { description: "Action: add a position, update a lot, remove a position, or view portfolio" },
-  ),
-  lot_id: Type.Optional(
-    Type.Integer({
-      minimum: 1,
-      description: "Portfolio lot id for precise update or single-lot removal",
-    }),
-  ),
-  symbol: Type.Optional(
-    Type.String({
-      description:
-        "Ticker symbol — stocks (AAPL, MSFT) or crypto with -USD suffix (BTC-USD, ETH-USD, SOL-USD). Use search_ticker to find the right ticker.",
-    }),
-  ),
-  shares: Type.Optional(
-    Type.Number({ exclusiveMinimum: 0, description: "Number of shares/units (required for add)" }),
-  ),
-  avg_cost: Type.Optional(
-    Type.Number({
-      exclusiveMinimum: 0,
-      description: "Average cost per share/unit in the lot currency (required for add)",
-    }),
-  ),
-  currency: Type.Optional(
-    Type.String({
-      description:
-        "Lot currency, such as USD or CAD (defaults to the resolved instrument currency)",
-    }),
-  ),
-});
-
-export const portfolioTrackerTool: AgentTool<typeof params> = {
-  name: "track_portfolio",
-  label: "Portfolio Tracker",
-  description:
-    "Track your portfolio of stocks and crypto. Add/remove positions with cost basis, or view current holdings with live P&L. For stocks use standard tickers (AAPL, MSFT). For crypto use the -USD suffix (BTC-USD, ETH-USD, SOL-USD). Use search_ticker first if you're unsure of the exact ticker.",
-  parameters: params,
-  async execute(_toolCallId, args) {
-    const db = initDefaultDatabase();
-    const service = new MarketStateService(db);
-
-    try {
-      if (args.action === "add") {
-        if (!args.symbol || args.shares == null || args.avg_cost == null) {
-          throw new Error("symbol, shares, and avg_cost are required for add action.");
-        }
-        if (args.shares <= 0) throw new Error("shares must be greater than 0.");
-        if (args.avg_cost <= 0) throw new Error("avg_cost must be greater than 0.");
-        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 portfolio.`,
-              },
-            ],
-            details: instrument,
-          };
-        }
-        const resolvedCurrency = args.currency?.trim() || instrument.instrument.currency?.trim();
-        if (!resolvedCurrency) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Could not determine currency for ${instrument.instrument.symbol}. Supply currency explicitly before adding it to the portfolio.`,
-              },
-            ],
-            details: {
-              status: "needs_currency",
-              symbol: instrument.instrument.symbol,
-            },
-          };
-        }
-        const currency = resolvedCurrency.toUpperCase();
-        const lot = service.addPortfolioLot({
-          instrument: instrument.instrument,
-          quantity: args.shares,
-          avgCost: args.avg_cost,
-          currency,
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Added ${args.shares} shares of ${lot.symbol} at ${formatMoney(args.avg_cost, lot.currency)}`,
-            },
-          ],
-          details: lot,
-        };
-      }
-
-      if (args.action === "remove") {
-        if (args.lot_id != null) {
-          const removed = service.removePortfolioLot(args.lot_id);
-          if (removed == null) {
-            return {
-              content: [{ type: "text", text: `lot ${args.lot_id} not found in portfolio` }],
-              details: null,
-            };
-          }
-          return {
-            content: [
-              { type: "text", text: `Removed ${removed.symbol} portfolio lot ${removed.id}` },
-            ],
-            details: removed,
-          };
-        }
-        if (!args.symbol) {
-          throw new Error("lot_id or symbol is required for remove action.");
-        }
-        const symbol = args.symbol.toUpperCase();
-        const removedLots = service.listPortfolioLots().filter((lot) => lot.symbol === symbol);
-        if (!service.removePortfolioLotsBySymbol(symbol)) {
-          return {
-            content: [{ type: "text", text: `${symbol} not found in portfolio` }],
-            details: null,
-          };
-        }
-        return {
-          content: [{ type: "text", text: `Removed ${symbol} from portfolio` }],
-          details: {
-            symbol,
-            removedCount: removedLots.length,
-            removedLotIds: removedLots.map((lot) => lot.id),
-            instrumentIds: [...new Set(removedLots.map((lot) => lot.instrumentId))],
-          },
-        };
-      }
-
-      if (args.action === "update") {
-        if (args.lot_id == null) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "lot_id is required for update action. Use view to find the lot id before updating a holding.",
-              },
-            ],
-            details: {
-              status: "needs_lot_id",
-              symbol: args.symbol?.toUpperCase(),
-            },
-          };
-        }
-        const updateParams = {
-          quantity: args.shares,
-          avgCost: args.avg_cost,
-          currency: args.currency?.trim() || undefined,
-        };
-        if (updateParams.quantity != null && updateParams.quantity <= 0) {
-          throw new Error("shares must be greater than 0.");
-        }
-        if (updateParams.avgCost != null && updateParams.avgCost <= 0) {
-          throw new Error("avg_cost must be greater than 0.");
-        }
-        const updated = service.updatePortfolioLot(args.lot_id, updateParams);
-        if (updated == null) {
-          const target = args.lot_id ? `lot ${args.lot_id}` : args.symbol?.toUpperCase();
-          return {
-            content: [{ type: "text", text: `${target} not found in portfolio` }],
-            details: null,
-          };
-        }
-        return {
-          content: [
-            { type: "text", text: `Updated ${updated.symbol} portfolio lot ${updated.id}` },
-          ],
-          details: updated,
-        };
-      }
-
-      const lots = service.listPortfolioLots();
-      if (lots.length === 0) {
-        return {
-          content: [{ type: "text", text: "Portfolio is empty. Use add action to add positions." }],
-          details: null,
-        };
-      }
-
-      const portfolio = service.getDefaultPortfolio();
-      const baseCurrency = portfolio.baseCurrency ?? "USD";
-      const enriched = await Promise.all(
-        lots.map(async (p) => {
-          const quote = await getCurrentPrice(p.symbol);
-          const totalCost = p.avgCost * p.quantity;
-          const lotCurrency = p.currency || baseCurrency;
-          const quoteCurrency =
-            quote.status === "ok"
-              ? (quote.currency ?? p.instrumentCurrency ?? lotCurrency)
-              : (p.instrumentCurrency ?? lotCurrency);
-          const canValueRow = quote.status === "ok" && quoteCurrency === lotCurrency;
-          const currentPrice = canValueRow ? quote.price : null;
-          const marketValue = currentPrice == null ? null : currentPrice * p.quantity;
-          const canComputePnlPercent = totalCost > 0;
-          const includedInTotals = canValueRow && lotCurrency === baseCurrency;
-          const exclusionReason =
-            quote.status === "unavailable"
-              ? `Quote unavailable: ${quote.reason}`
-              : includedInTotals
-                ? undefined
-                : canValueRow
-                  ? `No FX conversion from ${lotCurrency} to ${baseCurrency}`
-                  : `No FX conversion from ${quoteCurrency} to ${lotCurrency}`;
-          const position: Position = {
-            symbol: p.symbol,
-            shares: p.quantity,
-            avgCost: p.avgCost,
-            currency: lotCurrency,
-            addedAt: p.createdAt,
-          };
-          return {
-            ...position,
-            currentPrice,
-            marketValue,
-            totalCost,
-            pnl: marketValue == null ? null : marketValue - totalCost,
-            pnlPercent:
-              marketValue == null || !canComputePnlPercent
-                ? null
-                : ((marketValue - totalCost) / totalCost) * 100,
-            includedInTotals,
-            quoteStatus: quote.status,
-            exclusionReason,
-          };
-        }),
-      );
-
-      const included = enriched.filter((p) => p.includedInTotals);
-      const excludedFromTotals = enriched
-        .filter((p) => !p.includedInTotals)
-        .map((p) => ({
-          symbol: p.symbol,
-          currency: p.currency,
-          reason: p.exclusionReason ?? `No FX conversion from ${p.currency} to ${baseCurrency}`,
-        }));
-      const totalValue = included.reduce((s, p) => s + (p.marketValue ?? 0), 0);
-      const totalCost = included.reduce((s, p) => s + p.totalCost, 0);
-
-      const summary: PortfolioSummary = {
-        positions: enriched,
-        baseCurrency,
-        totalValue,
-        totalCost,
-        totalPnl: totalValue - totalCost,
-        totalPnlPercent: totalCost > 0 ? ((totalValue - totalCost) / totalCost) * 100 : 0,
-        excludedFromTotals,
-      };
-
-      const header = `**Portfolio** — ${enriched.length} positions | Value: ${formatMoney(totalValue, baseCurrency)} | P&L: ${formatMoney(summary.totalPnl, baseCurrency)} (${summary.totalPnlPercent >= 0 ? "+" : ""}${summary.totalPnlPercent.toFixed(2)}%)`;
-      const rows = enriched.map((p) => {
-        const excluded = p.includedInTotals
-          ? ""
-          : ` [excluded from ${baseCurrency} totals: ${p.exclusionReason}]`;
-        if (p.currentPrice == null || p.pnl == null || p.pnlPercent == null) {
-          return `  ${p.symbol}: ${p.shares} @ ${formatMoney(p.avgCost, p.currency)} → unavailable | P&L: unavailable${excluded}`;
-        }
-        const sign = p.pnlPercent >= 0 ? "+" : "";
-        return `  ${p.symbol}: ${p.shares} @ ${formatMoney(p.avgCost, p.currency)} → ${formatMoney(p.currentPrice, p.currency)} | P&L: ${formatMoney(p.pnl, p.currency)} (${sign}${p.pnlPercent.toFixed(2)}%)${excluded}`;
-      });
-
-      const exclusions =
-        excludedFromTotals.length === 0
-          ? []
-          : [
-              `Excluded from ${baseCurrency} totals: ${excludedFromTotals.map((p) => `${p.symbol} (${p.currency})`).join(", ")}`,
-            ];
-      const text = [header, ...rows, ...exclusions].join("\n");
-      return { content: [{ type: "text", text }], details: summary };
-    } finally {
-      db.close();
-    }
-  },
-};
-
-function formatMoney(value: number, currency: string): string {
-  if (currency === "USD") return `$${value.toFixed(2)}`;
-  return `${currency} ${value.toFixed(2)}`;
-}

package/src/tools/portfolio/watchlist.ts

@@ -1,288 +0,0 @@
-import type { AgentTool } from "@earendil-works/pi-agent-core";
-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 { getQuote } from "../../providers/yahoo-finance.js";
-
-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("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.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.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.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" }),
-  ),
-});
-
-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 watchlist levels.",
-  parameters: params,
-  async execute(_toolCallId, args) {
-    const db = initDefaultDatabase();
-    const service = new MarketStateService(db);
-
-    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,
-        };
-      }
-
-      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,
-        };
-      }
-
-      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 items = service.listWatchlistItems();
-      if (items.length === 0) {
-        return {
-          content: [{ type: "text", text: "Watchlist is empty. Use add action to add symbols." }],
-          details: null,
-        };
-      }
-
-      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: lines.join("\n") }],
-        details: { items: checks },
-      };
-    } finally {
-      db.close();
-    }
-  },
-};
-
-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 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

@@ -1,50 +0,0 @@
-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)}`;
-}