opencandle 0.4.0 → 0.6.0

package/src/tools/portfolio/risk-analysis.ts

@@ -1,13 +1,20 @@
-import { Type } from "@sinclair/typebox";
 import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { getHistory } from "../../providers/yahoo-finance.js";
+import { Type } from "@sinclair/typebox";
 import { wrapProvider } from "../../providers/wrap-provider.js";
+import { getHistory } from "../../providers/yahoo-finance.js";
 import type { RiskMetrics } from "../../types/portfolio.js";
 
+const RISK_PERIODS = ["6mo", "1y", "2y"] as const;
+
 const params = Type.Object({
   symbol: Type.String({ description: "Stock ticker symbol (e.g. AAPL, MSFT, SPY)" }),
   period: Type.Optional(
-    Type.String({ description: "Historical period for analysis: 6mo, 1y, 2y. Default: 1y" }),
+    Type.Union(
+      RISK_PERIODS.map((period) => Type.Literal(period)),
+      {
+        description: "Historical period for analysis: 6mo, 1y, 2y. Default: 1y",
+      },
+    ),
   ),
 });
 
@@ -17,13 +24,15 @@ export const riskAnalysisTool: AgentTool<typeof params, RiskMetrics> = {
   description:
     "Compute risk metrics for a stock: annualized return, volatility, Sharpe ratio, max drawdown, and Value at Risk (95%). All computed locally from historical data.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const symbol = args.symbol.toUpperCase();
     const period = args.period ?? "1y";
     const result = await wrapProvider("yahoo", () => getHistory(symbol, period, "1d"));
     if (result.status === "unavailable") {
       return {
-        content: [{ type: "text", text: `⚠ Risk analysis unavailable for ${symbol} (${result.reason}).` }],
+        content: [
+          { type: "text", text: `⚠ Risk analysis unavailable for ${symbol} (${result.reason}).` },
+        ],
         details: null as any,
       };
     }
@@ -32,12 +41,33 @@ export const riskAnalysisTool: AgentTool<typeof params, RiskMetrics> = {
 
     if (closes.length < 30) {
       return {
-        content: [{ type: "text", text: `Insufficient data for risk analysis (need 30+ days, got ${closes.length})` }],
+        content: [
+          {
+            type: "text",
+            text: `Insufficient data for risk analysis (need 30+ days, got ${closes.length})`,
+          },
+        ],
         details: null as any,
       };
     }
 
-    const metrics = computeRiskMetrics(symbol, closes);
+    let metrics: RiskMetrics;
+    try {
+      metrics = computeRiskMetrics(symbol, closes);
+    } catch (error) {
+      if (error instanceof Error && error.message === "insufficient usable price history") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Insufficient data for risk analysis (no usable price returns after filtering invalid closes)`,
+            },
+          ],
+          details: null as any,
+        };
+      }
+      throw error;
+    }
 
     const text = [
       `**${symbol} Risk Analysis** (${bars[0].date} to ${bars[bars.length - 1].date}, ${closes.length} days)`,
@@ -57,6 +87,9 @@ export const riskAnalysisTool: AgentTool<typeof params, RiskMetrics> = {
 
 export function computeRiskMetrics(symbol: string, closes: number[]): RiskMetrics {
   const dailyReturns = computeDailyReturns(closes);
+  if (dailyReturns.length === 0) {
+    throw new Error("insufficient usable price history");
+  }
   const avgDailyReturn = mean(dailyReturns);
   const dailyVol = stddev(dailyReturns);
 
@@ -84,16 +117,19 @@ export function computeRiskMetrics(symbol: string, closes: number[]): RiskMetric
 export function computeDailyReturns(prices: number[]): number[] {
   const returns: number[] = [];
   for (let i = 1; i < prices.length; i++) {
+    if (prices[i - 1] <= 0) continue;
     returns.push((prices[i] - prices[i - 1]) / prices[i - 1]);
   }
   return returns;
 }
 
 export function computeMaxDrawdown(prices: number[]): number {
-  let peak = prices[0];
+  let peak = 0;
   let maxDd = 0;
   for (const price of prices) {
+    if (price <= 0 && peak <= 0) continue;
     if (price > peak) peak = price;
+    if (peak <= 0) continue;
     const dd = (peak - price) / peak;
     if (dd > maxDd) maxDd = dd;
   }
@@ -101,6 +137,9 @@ export function computeMaxDrawdown(prices: number[]): number {
 }
 
 export function computeVaR(returns: number[], confidence: number): number {
+  if (returns.length === 0) {
+    throw new Error("insufficient usable price history");
+  }
   const sorted = [...returns].sort((a, b) => a - b);
   const idx = Math.floor(sorted.length * confidence);
   return Math.abs(sorted[idx]);

package/src/tools/portfolio/tracker.ts

@@ -1,147 +1,308 @@
-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 } from "../../market-state/service.js";
+import { initDefaultDatabase } from "../../memory/sqlite.js";
 import { wrapProvider } from "../../providers/wrap-provider.js";
-import type { Position, PortfolioSummary } from "../../types/portfolio.js";
-import { ensureParentDir, getPortfolioPath } from "../../infra/opencandle-paths.js";
-
-function loadPortfolio(): Position[] {
-  const portfolioPath = getPortfolioPath();
-  if (!existsSync(portfolioPath)) return [];
-  try {
-    return JSON.parse(readFileSync(portfolioPath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-
-function savePortfolio(positions: Position[]): void {
-  const portfolioPath = getPortfolioPath();
-  ensureParentDir(portfolioPath);
-  writeFileSync(portfolioPath, JSON.stringify(positions, null, 2));
-}
+import { getQuote } from "../../providers/yahoo-finance.js";
+import type { PortfolioSummary, Position } from "../../types/portfolio.js";
 
-async function getCurrentPrice(symbol: string): Promise<number | null> {
+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 null;
-  return result.data.price;
+  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("remove"),
-    Type.Literal("view"),
-  ], { description: "Action: add a position, remove a position, or view portfolio" }),
+  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." }),
+    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({ description: "Number of shares/units (required for add)" }),
+    Type.Number({ exclusiveMinimum: 0, description: "Number of shares/units (required for add)" }),
   ),
   avg_cost: Type.Optional(
-    Type.Number({ description: "Average cost per share/unit in USD (required for add)" }),
+    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, PortfolioSummary | null> = {
+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. Data persisted to ~/.opencandle/portfolio.json.",
+    "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 positions = loadPortfolio();
+  async execute(_toolCallId, args) {
+    const db = initDefaultDatabase();
+    const service = new MarketStateService(db);
 
-    if (args.action === "add") {
-      if (!args.symbol || !args.shares || !args.avg_cost) {
-        throw new Error("symbol, shares, and avg_cost are required for add action.");
-      }
-      const symbol = args.symbol.toUpperCase();
-      const existing = positions.find((p) => p.symbol === symbol);
-      if (existing) {
-        const totalShares = existing.shares + args.shares;
-        existing.avgCost =
-          (existing.avgCost * existing.shares + args.avg_cost * args.shares) / totalShares;
-        existing.shares = totalShares;
-      } else {
-        positions.push({
-          symbol,
-          shares: args.shares,
+    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,
-          addedAt: new Date().toISOString(),
+          currency,
         });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Added ${args.shares} shares of ${lot.symbol} at ${formatMoney(args.avg_cost, lot.currency)}`,
+            },
+          ],
+          details: lot,
+        };
       }
-      savePortfolio(positions);
-      return {
-        content: [{ type: "text", text: `Added ${args.shares} shares of ${symbol} at $${args.avg_cost.toFixed(2)}` }],
-        details: null,
-      };
-    }
 
-    if (args.action === "remove") {
-      if (!args.symbol) {
-        throw new Error("symbol is required for remove action.");
-      }
-      const symbol = args.symbol.toUpperCase();
-      const idx = positions.findIndex((p) => p.symbol === symbol);
-      if (idx === -1) {
+      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: `${symbol} not found in portfolio` }],
-          details: null,
+          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))],
+          },
         };
       }
-      positions.splice(idx, 1);
-      savePortfolio(positions);
-      return {
-        content: [{ type: "text", text: `Removed ${symbol} from portfolio` }],
-        details: null,
-      };
-    }
 
-    // View portfolio
-    if (positions.length === 0) {
-      return {
-        content: [{ type: "text", text: "Portfolio is empty. Use add action to add positions." }],
-        details: null,
-      };
-    }
+      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 enriched = await Promise.all(
-      positions.map(async (p) => {
-        const currentPrice = await getCurrentPrice(p.symbol) ?? p.avgCost;
-        const marketValue = currentPrice * p.shares;
-        const totalCost = p.avgCost * p.shares;
+      const lots = service.listPortfolioLots();
+      if (lots.length === 0) {
         return {
-          ...p,
-          currentPrice,
-          marketValue,
-          totalCost,
-          pnl: marketValue - totalCost,
-          pnlPercent: ((marketValue - totalCost) / totalCost) * 100,
+          content: [{ type: "text", text: "Portfolio is empty. Use add action to add positions." }],
+          details: null,
         };
-      }),
-    );
+      }
 
-    const totalValue = enriched.reduce((s, p) => s + p.marketValue, 0);
-    const totalCost = enriched.reduce((s, p) => s + p.totalCost, 0);
+      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 summary: PortfolioSummary = {
-      positions: enriched,
-      totalValue,
-      totalCost,
-      totalPnl: totalValue - totalCost,
-      totalPnlPercent: totalCost > 0 ? ((totalValue - totalCost) / totalCost) * 100 : 0,
-    };
+      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 header = `**Portfolio** — ${enriched.length} positions | Value: $${totalValue.toFixed(2)} | P&L: $${summary.totalPnl.toFixed(2)} (${summary.totalPnlPercent >= 0 ? "+" : ""}${summary.totalPnlPercent.toFixed(2)}%)`;
-    const rows = enriched.map((p) => {
-      const sign = p.pnlPercent >= 0 ? "+" : "";
-      return `  ${p.symbol}: ${p.shares} @ $${p.avgCost.toFixed(2)} → $${p.currentPrice.toFixed(2)} | P&L: $${p.pnl.toFixed(2)} (${sign}${p.pnlPercent.toFixed(2)}%)`;
-    });
+      const summary: PortfolioSummary = {
+        positions: enriched,
+        baseCurrency,
+        totalValue,
+        totalCost,
+        totalPnl: totalValue - totalCost,
+        totalPnlPercent: totalCost > 0 ? ((totalValue - totalCost) / totalCost) * 100 : 0,
+        excludedFromTotals,
+      };
 
-    const text = [header, ...rows].join("\n");
-    return { content: [{ type: "text", text }], details: summary };
+      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)}`;
+}