opencandle 0.3.0 → 0.5.0

package/src/tools/interaction/twitter-login.ts

@@ -0,0 +1,93 @@
+import { mkdirSync } from "node:fs";
+import type { BrowserContext } from "playwright-core";
+import { Type } from "@sinclair/typebox";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+interface TwitterLoginResult {
+  success: boolean;
+  message: string;
+}
+
+export async function runTwitterLogin(notify: (msg: string) => void): Promise<TwitterLoginResult> {
+  const { getBrowserProfileDir } = await import("../../infra/opencandle-paths.js");
+  const { Camoufox } = await import("camoufox-js");
+
+  const profileDir = getBrowserProfileDir();
+  mkdirSync(profileDir, { recursive: true });
+
+  notify("Launching browser for Twitter login...");
+
+  const context = (await Camoufox({
+    headless: false,
+    user_data_dir: profileDir,
+    geoip: true,
+    humanize: true,
+    os: "macos",
+    block_webrtc: true,
+    window: [1440, 900],
+  })) as unknown as BrowserContext;
+
+  try {
+    const pages = context.pages();
+    const page = pages.length > 0 ? pages[0] : await context.newPage();
+
+    await page.goto("https://x.com/login", {
+      waitUntil: "domcontentloaded",
+      timeout: 30_000,
+    });
+
+    notify("Log in via the browser window. Waiting for auth cookies...");
+
+    const deadline = Date.now() + 300_000;
+    while (Date.now() < deadline) {
+      try {
+        const cookies = await context.cookies("https://x.com");
+        const authNames = ["auth_token", "ct0", "twid"];
+        const found = cookies.filter((c) => authNames.includes(c.name));
+        if (found.length >= 2) {
+          await page.waitForTimeout(3000);
+          await context.close();
+          return { success: true, message: `Twitter login successful! (${found.map((c) => c.name).join(", ")})` };
+        }
+      } catch {
+        return { success: false, message: "Twitter login cancelled (browser closed)." };
+      }
+      await page.waitForTimeout(2000);
+    }
+
+    await context.close();
+    return { success: false, message: "Twitter login timed out after 5 minutes." };
+  } catch (error) {
+    try { await context.close(); } catch { /* already closed */ }
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, message: `Twitter login failed: ${msg}` };
+  }
+}
+
+export function registerTwitterLoginTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "trigger_twitter_login",
+    label: "Twitter Login",
+    description:
+      "Open a browser window for the user to log in to Twitter/X. Call this when get_twitter_sentiment reports that login is needed and the user has confirmed they want to proceed. Returns success/failure. After success, retry get_twitter_sentiment.",
+    promptSnippet:
+      "trigger_twitter_login: Opens a browser for Twitter/X login. Use when Twitter sentiment is unavailable due to missing session.",
+    parameters: Type.Object({}),
+
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      if (!ctx?.hasUI) {
+        return {
+          content: [{ type: "text", text: "Cannot open browser in non-interactive mode. Twitter login requires a terminal session with UI." }],
+          details: { success: false },
+        };
+      }
+
+      const result = await runTwitterLogin((msg) => ctx.ui.notify(msg, "info"));
+
+      return {
+        content: [{ type: "text", text: result.message }],
+        details: { success: result.success },
+      };
+    },
+  });
+}

package/src/tools/macro/fear-greed.ts

@@ -0,0 +1,41 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getFearGreedIndex } from "../../providers/fear-greed.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import type { FearGreedData } from "../../types/sentiment.js";
+
+const params = Type.Object({});
+
+export const fearGreedTool: AgentTool<typeof params, FearGreedData> = {
+  name: "get_fear_greed",
+  label: "Fear & Greed Index",
+  description:
+    "Get the Crypto Fear & Greed Index (alternative.me) — a sentiment indicator from 0 (Extreme Fear) to 100 (Extreme Greed). Includes current value and previous close.",
+  parameters: params,
+  async execute(_toolCallId, _args) {
+    const result = await wrapProvider("feargreed", () => getFearGreedIndex());
+    if (result.status === "unavailable") {
+      return {
+        content: [{ type: "text", text: `⚠ Fear & Greed Index unavailable (${result.reason}).` }],
+        details: null as any,
+      };
+    }
+    const fg = result.data;
+
+    const gauge = buildGauge(fg.value);
+    const text = [
+      `**Fear & Greed Index: ${fg.value} — ${fg.label}**`,
+      gauge,
+      `Previous Close: ${fg.previousClose}${fg.weekAgo != null ? ` | Week Ago: ${fg.weekAgo}` : ""}${fg.monthAgo != null ? ` | Month Ago: ${fg.monthAgo}` : ""}`,
+    ].join("\n");
+
+    return { content: [{ type: "text", text }], details: fg };
+  },
+};
+
+function buildGauge(value: number): string {
+  const width = 20;
+  const pos = Math.round((value / 100) * width);
+  const bar = "█".repeat(pos) + "░".repeat(width - pos);
+  return `[${bar}] ${value}/100`;
+}

package/src/tools/macro/fred-data.ts

@@ -0,0 +1,80 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getSeries } from "../../providers/fred.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import { getConfig } from "../../config.js";
+import { withCredentialCheck } from "../../onboarding/tool-helpers.js";
+import { FRED_SERIES } from "../../types/macro.js";
+import type { FredSeries } from "../../types/macro.js";
+
+const params = Type.Object({
+  series_id: Type.String({
+    description: `FRED series ID. Common ones: ${Object.entries(FRED_SERIES).map(([k, v]) => `${v} (${k})`).join(", ")}`,
+  }),
+  limit: Type.Optional(
+    Type.Number({ description: "Number of observations to return. Default: 30" }),
+  ),
+});
+
+export const fredDataTool: AgentTool<typeof params, FredSeries | { credentialRequired: unknown }> = {
+  name: "get_economic_data",
+  label: "FRED Economic Data",
+  description:
+    "Get economic data from FRED (Federal Reserve Economic Data): interest rates, CPI, GDP, unemployment, yield curve, and more. Requires FRED.",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    return withCredentialCheck("fred", async () => {
+      const apiKey = getConfig().fredApiKey!;
+      const seriesId = args.series_id.toUpperCase();
+      const limit = normalizeLimit(seriesId, args.limit);
+      const result = await wrapProvider("fred", () => getSeries(seriesId, apiKey, limit));
+      if (result.status === "unavailable") {
+        return {
+          content: [{ type: "text", text: `⚠ FRED data unavailable for ${seriesId} (${result.reason}).` }],
+          details: null as any,
+        };
+      }
+      const series = result.data;
+
+      const latest = series.observations[series.observations.length - 1];
+      const header = `**${series.title}** (${series.id})`;
+      const meta = `Units: ${series.units} | Frequency: ${series.frequency} | Last updated: ${series.lastUpdated}`;
+      const current = latest ? `Latest: ${latest.value} (${latest.date})` : "No data";
+      const derived = formatDerivedChange(series);
+
+      // Show last 10 observations
+      const recent = series.observations.slice(-10);
+      const table = recent.map((o) => `${o.date}: ${o.value}`).join("\n");
+
+      const text = [header, meta, current, derived, "", "Recent observations:", table]
+        .filter(Boolean)
+        .join("\n");
+      const prefix = result.stale
+        ? `⚠ Using cached FRED data from ${result.timestamp} (FRED unavailable)\n`
+        : "";
+      return { content: [{ type: "text", text: prefix + text }], details: series };
+    });
+  },
+};
+
+function normalizeLimit(seriesId: string, requested: number | undefined): number {
+  const limit = requested ?? 30;
+  if (seriesId === FRED_SERIES.CPI && limit < 13) return 13;
+  return limit;
+}
+
+function formatDerivedChange(series: FredSeries): string | null {
+  const latest = series.observations.at(-1);
+  if (!latest) return null;
+  if (!/monthly/i.test(series.frequency) || !/\bindex\b/i.test(series.units)) return null;
+
+  const latestYear = Number(latest.date.slice(0, 4));
+  const monthDay = latest.date.slice(4);
+  const prior = series.observations.find((observation) =>
+    observation.date === `${latestYear - 1}${monthDay}`
+  );
+  if (!prior || prior.value === 0) return null;
+
+  const pct = ((latest.value / prior.value) - 1) * 100;
+  return `Derived YoY change: ${pct.toFixed(2)}% (${prior.date} to ${latest.date}).`;
+}

package/src/tools/market/crypto-history.ts

@@ -0,0 +1,67 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getCryptoHistory } from "../../providers/coingecko.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import type { OHLCV } from "../../types/market.js";
+import { computeRiskMetrics } from "../portfolio/risk-analysis.js";
+
+const params = Type.Object({
+  id: Type.String({
+    description: "CoinGecko coin ID (e.g. bitcoin, ethereum, solana)",
+  }),
+  days: Type.Optional(
+    Type.Number({
+      description: "Number of days of history: 1, 7, 14, 30, 90, 180, 365, max. Default: 180",
+    }),
+  ),
+});
+
+export const cryptoHistoryTool: AgentTool<typeof params, OHLCV[]> = {
+  name: "get_crypto_history",
+  label: "Crypto History",
+  description: "Get historical OHLC data for a cryptocurrency",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const id = args.id.toLowerCase();
+    const days = args.days ?? 180;
+    const result = await wrapProvider("coingecko", () => getCryptoHistory(id, days));
+    if (result.status === "unavailable") {
+      return {
+        content: [{ type: "text", text: `⚠ Crypto history unavailable for ${id} (${result.reason}).` }],
+        details: [],
+      };
+    }
+    const bars = result.data;
+
+    const summary = [
+      `${id} — ${bars.length} bars (${days} days)`,
+      `Period: ${bars[0]?.date} to ${bars[bars.length - 1]?.date}`,
+    ];
+
+    const recent = bars.slice(-10);
+    const table = recent
+      .map(
+        (b) =>
+          `${b.date} | O:${b.open.toFixed(2)} H:${b.high.toFixed(2)} L:${b.low.toFixed(2)} C:${b.close.toFixed(2)}`,
+      )
+      .join("\n");
+
+    const riskLines = buildRiskLines(id, bars);
+    const text = [...summary, ...riskLines, "", "Recent bars:", table].join("\n");
+    return { content: [{ type: "text", text }], details: bars };
+  },
+};
+
+function buildRiskLines(id: string, bars: OHLCV[]): string[] {
+  if (bars.length < 30) return [];
+  const metrics = computeRiskMetrics(id.toUpperCase(), bars.map((bar) => bar.close));
+  return [
+    "",
+    "Risk metrics from crypto history:",
+    `Annualized Return: ${(metrics.annualizedReturn * 100).toFixed(2)}%`,
+    `Annualized Volatility: ${(metrics.annualizedVolatility * 100).toFixed(2)}%`,
+    `Sharpe Ratio: ${metrics.sharpeRatio.toFixed(2)}`,
+    `Max Drawdown: ${(metrics.maxDrawdown * 100).toFixed(2)}%`,
+    `Value at Risk (95%, daily): ${(metrics.var95 * 100).toFixed(2)}%`,
+  ];
+}

package/src/tools/market/crypto-price.ts

@@ -0,0 +1,53 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getCryptoPrice } from "../../providers/coingecko.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import type { CryptoPrice } from "../../types/market.js";
+
+const params = Type.Object({
+  id: Type.String({
+    description:
+      "CoinGecko coin ID (e.g. bitcoin, ethereum, solana, dogecoin). Use lowercase.",
+  }),
+});
+
+export const cryptoPriceTool: AgentTool<typeof params, CryptoPrice> = {
+  name: "get_crypto_price",
+  label: "Crypto Price",
+  description:
+    "Get current crypto price, 24h change, market cap, volume, ATH, and supply data",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const result = await wrapProvider("coingecko", () => getCryptoPrice(args.id.toLowerCase()));
+    if (result.status === "unavailable") {
+      return {
+        content: [{ type: "text", text: `⚠ Crypto price unavailable for ${args.id} (${result.reason}).` }],
+        details: null as any,
+      };
+    }
+    const crypto = result.data;
+    const sign = crypto.changePercent24h >= 0 ? "+" : "";
+    const text = [
+      `${crypto.name} (${crypto.symbol.toUpperCase()}): $${formatPrice(crypto.price)} (${sign}${crypto.changePercent24h.toFixed(2)}%)`,
+      `24h High: $${formatPrice(crypto.high24h)} | 24h Low: $${formatPrice(crypto.low24h)}`,
+      `Market Cap: $${formatLargeNumber(crypto.marketCap)} | 24h Volume: $${formatLargeNumber(crypto.volume24h)}`,
+      `ATH: $${formatPrice(crypto.ath)} (${crypto.athDate.split("T")[0]})`,
+      `Circulating: ${formatLargeNumber(crypto.circulatingSupply)} ${crypto.symbol.toUpperCase()}`,
+    ].join("\n");
+
+    return { content: [{ type: "text", text }], details: crypto };
+  },
+};
+
+function formatPrice(n: number): string {
+  if (n >= 1) return n.toFixed(2);
+  if (n >= 0.01) return n.toFixed(4);
+  return n.toFixed(8);
+}
+
+function formatLargeNumber(n: number): string {
+  if (n >= 1e12) return `${(n / 1e12).toFixed(2)}T`;
+  if (n >= 1e9) return `${(n / 1e9).toFixed(2)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  return n.toLocaleString();
+}

package/src/tools/market/search-ticker.ts

@@ -0,0 +1,53 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { httpGet } from "../../infra/http-client.js";
+
+const params = Type.Object({
+  query: Type.String({
+    description: "Search query — company name, ticker symbol, or crypto name (e.g. 'apple', 'AAPL', 'ethereum', 'bitcoin')",
+  }),
+});
+
+interface YahooSearchResponse {
+  quotes: Array<{
+    symbol: string;
+    shortname?: string;
+    longname?: string;
+    quoteType: string;
+    exchange: string;
+    score: number;
+  }>;
+}
+
+export const searchTickerTool: AgentTool<typeof params> = {
+  name: "search_ticker",
+  label: "Search Ticker",
+  description:
+    "Search for any ticker symbol — stocks, crypto, ETFs, indices, forex. Returns matching symbols with names and exchange info. Use this when you don't know the exact ticker for an asset.",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const url = `https://query1.finance.yahoo.com/v1/finance/search?q=${encodeURIComponent(args.query)}&quotesCount=10&newsCount=0`;
+    const data = await httpGet<YahooSearchResponse>(url, {
+      headers: { "User-Agent": "OpenCandle/1.0" },
+    });
+
+    const quotes = data.quotes ?? [];
+    if (quotes.length === 0) {
+      return {
+        content: [{ type: "text", text: `No results found for "${args.query}"` }],
+        details: quotes,
+      };
+    }
+
+    const lines = [
+      `**Search results for "${args.query}"** — ${quotes.length} matches`,
+      "",
+      ...quotes.map(
+        (q) =>
+          `  ${q.symbol} — ${q.longname || q.shortname || "N/A"} (${q.quoteType}, ${q.exchange})`,
+      ),
+    ];
+
+    return { content: [{ type: "text", text: lines.join("\n") }], details: quotes };
+  },
+};

package/src/tools/market/stock-history.ts

@@ -0,0 +1,79 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getHistory } from "../../providers/yahoo-finance.js";
+import { getDailyHistory } from "../../providers/alpha-vantage.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import { withFallback } from "../../providers/with-fallback.js";
+import { getConfig } from "../../config.js";
+import type { OHLCV } from "../../types/market.js";
+import type { ProviderResult } from "../../runtime/evidence.js";
+
+const DAILY_INTERVALS = new Set(["1d", "1wk", "1mo"]);
+
+const params = Type.Object({
+  symbol: Type.String({ description: "Stock ticker symbol (e.g. AAPL, MSFT)" }),
+  range: Type.Optional(
+    Type.String({
+      description: "Time range: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, max. Default: 6mo",
+    }),
+  ),
+  interval: Type.Optional(
+    Type.String({
+      description: "Data interval: 1m, 5m, 15m, 1h, 1d, 1wk, 1mo. Default: 1d",
+    }),
+  ),
+});
+
+export const stockHistoryTool: AgentTool<typeof params, OHLCV[]> = {
+  name: "get_stock_history",
+  label: "Stock History",
+  description: "Get historical OHLCV (open, high, low, close, volume) data for a stock",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const symbol = args.symbol.toUpperCase();
+    const range = args.range ?? "6mo";
+    const interval = args.interval ?? "1d";
+    const apiKey = getConfig().alphaVantageApiKey;
+
+    let result: ProviderResult<OHLCV[]>;
+
+    if (DAILY_INTERVALS.has(interval) && apiKey) {
+      // Daily or above — can fall back to Alpha Vantage
+      result = await withFallback([
+        { provider: "yahoo", fn: () => getHistory(symbol, range, interval) },
+        { provider: "alphavantage", fn: () => getDailyHistory(symbol, apiKey, range) },
+      ]);
+    } else {
+      // Intraday — no cross-provider fallback
+      result = await wrapProvider("yahoo", () => getHistory(symbol, range, interval));
+    }
+
+    if (result.status === "unavailable") {
+      const intradayNote = !DAILY_INTERVALS.has(interval)
+        ? ` No alternate source for ${interval} data.`
+        : "";
+      return {
+        content: [{ type: "text", text: `⚠ Stock history unavailable for ${symbol} (${result.reason}).${intradayNote}` }],
+        details: [],
+      };
+    }
+    const bars = result.data;
+
+    const summary = [
+      `${symbol} — ${bars.length} bars (${range}, ${interval})`,
+      `Period: ${bars[0]?.date} to ${bars[bars.length - 1]?.date}`,
+    ];
+
+    // Include last 10 bars as sample
+    const recent = bars.slice(-10);
+    const table = recent
+      .map(
+        (b) =>
+          `${b.date} | O:${b.open.toFixed(2)} H:${b.high.toFixed(2)} L:${b.low.toFixed(2)} C:${b.close.toFixed(2)} V:${b.volume.toLocaleString()}`,
+      )
+      .join("\n");
+
+    const text = [...summary, "", "Recent bars:", table].join("\n");
+    return { content: [{ type: "text", text }], details: bars };
+  },
+};

package/src/tools/market/stock-quote.ts

@@ -0,0 +1,64 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getQuote } from "../../providers/yahoo-finance.js";
+import { getGlobalQuote } from "../../providers/alpha-vantage.js";
+import { withFallback } from "../../providers/with-fallback.js";
+import { getConfig } from "../../config.js";
+import type { StockQuote } from "../../types/market.js";
+
+const params = Type.Object({
+  symbol: Type.String({ description: "Stock ticker symbol (e.g. AAPL, MSFT, TSLA)" }),
+});
+
+export const stockQuoteTool: AgentTool<typeof params, StockQuote> = {
+  name: "get_stock_quote",
+  label: "Stock Quote",
+  description:
+    "Get real-time stock price, volume, market cap, and 52-week range for a ticker symbol",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const symbol = args.symbol.toUpperCase();
+    const apiKey = getConfig().alphaVantageApiKey;
+
+    const entries = [
+      { provider: "yahoo" as const, fn: () => getQuote(symbol) },
+      ...(apiKey
+        ? [{ provider: "alphavantage" as const, fn: () => getGlobalQuote(symbol, apiKey) }]
+        : []),
+    ];
+
+    const result = await withFallback(entries);
+    if (result.status === "unavailable") {
+      return {
+        content: [{ type: "text", text: `⚠ Stock quote unavailable for ${symbol} (${result.reason}).` }],
+        details: null as any,
+      };
+    }
+    const quote = result.data;
+    const sign = quote.changePercent >= 0 ? "+" : "";
+
+    const week52 = quote.week52High > 0 && quote.week52Low > 0
+      ? `$${quote.week52Low.toFixed(2)} - $${quote.week52High.toFixed(2)}`
+      : "N/A";
+    const marketCapStr = quote.marketCap > 0 ? `$${formatLargeNumber(quote.marketCap)}` : "N/A";
+
+    const text = [
+      `${quote.symbol}: $${quote.price.toFixed(2)} (${sign}${quote.changePercent.toFixed(2)}%)`,
+      `Open: $${quote.open.toFixed(2)} | High: $${quote.high.toFixed(2)} | Low: $${quote.low.toFixed(2)}`,
+      `Volume: ${quote.volume.toLocaleString()} | Market Cap: ${marketCapStr}`,
+      `52W Range: ${week52}`,
+    ].join("\n");
+
+    const prefix = result.stale
+      ? `⚠ Using cached quote from ${result.timestamp} (provider rate limited)\n`
+      : "";
+    return { content: [{ type: "text", text: prefix + text }], details: quote };
+  },
+};
+
+function formatLargeNumber(n: number): string {
+  if (n >= 1e12) return `${(n / 1e12).toFixed(2)}T`;
+  if (n >= 1e9) return `${(n / 1e9).toFixed(2)}B`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  return n.toLocaleString();
+}

package/src/tools/options/greeks.ts

@@ -0,0 +1,81 @@
+import type { Greeks } from "../../types/options.js";
+
+interface GreeksInput {
+  type: "call" | "put";
+  spot: number;       // underlying price
+  strike: number;     // strike price
+  timeYears: number;  // time to expiration in years
+  iv: number;         // implied volatility (e.g. 0.30 for 30%)
+  riskFreeRate: number; // risk-free rate (e.g. 0.05 for 5%)
+}
+
+/**
+ * Compute option Greeks using the Black-Scholes model.
+ */
+export function computeGreeks(input: GreeksInput): Greeks {
+  const { type, spot, strike, timeYears, iv, riskFreeRate: r } = input;
+
+  // At expiration: return intrinsic values
+  if (timeYears <= 0) {
+    const isCall = type === "call";
+    const itm = isCall ? spot >= strike : spot <= strike;
+    return {
+      delta: itm ? (isCall ? 1 : -1) : 0,
+      gamma: 0,
+      theta: 0,
+      vega: 0,
+      rho: 0,
+    };
+  }
+
+  const sqrtT = Math.sqrt(timeYears);
+  const d1 = (Math.log(spot / strike) + (r + (iv * iv) / 2) * timeYears) / (iv * sqrtT);
+  const d2 = d1 - iv * sqrtT;
+
+  const nd1 = cdf(d1);
+  const nd2 = cdf(d2);
+  const npd1 = pdf(d1);
+
+  const expRT = Math.exp(-r * timeYears);
+
+  if (type === "call") {
+    return {
+      delta: nd1,
+      gamma: npd1 / (spot * iv * sqrtT),
+      theta: (-(spot * npd1 * iv) / (2 * sqrtT) - r * strike * expRT * nd2) / 365,
+      vega: (spot * npd1 * sqrtT) / 100, // per 1% change in IV
+      rho: (strike * timeYears * expRT * nd2) / 100, // per 1% change in rate
+    };
+  } else {
+    const nMinusD2 = cdf(-d2);
+    return {
+      delta: nd1 - 1,
+      gamma: npd1 / (spot * iv * sqrtT),
+      theta: (-(spot * npd1 * iv) / (2 * sqrtT) + r * strike * expRT * nMinusD2) / 365,
+      vega: (spot * npd1 * sqrtT) / 100,
+      rho: -(strike * timeYears * expRT * nMinusD2) / 100,
+    };
+  }
+}
+
+/** Standard normal cumulative distribution function */
+function cdf(x: number): number {
+  // Abramowitz and Stegun approximation 26.2.17
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const t = 1 / (1 + p * absX);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX / 2);
+  return 0.5 * (1 + sign * y);
+}
+
+/** Standard normal probability density function */
+function pdf(x: number): number {
+  return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+}