opencandle 0.11.0 → 0.12.0

package/src/providers/finnhub.ts

@@ -1,125 +0,0 @@
-import { cache, STALE_LIMIT, TTL } from "../infra/cache.js";
-import { HttpError, httpGet } from "../infra/http-client.js";
-import { rateLimiter } from "../infra/rate-limiter.js";
-import { ProviderCredentialError } from "./provider-credential-error.js";
-
-const FINNHUB_BASE = "https://finnhub.io/api/v1";
-
-export interface FinnhubArticle {
-  headline: string;
-  summary: string;
-  source: string;
-  datetime: number;
-  url: string;
-  related: string;
-  id: number;
-  category: string;
-  image: string;
-}
-
-// Ticker → company name mapping for relevance filtering
-const TICKER_NAMES: Record<string, string> = {
-  AAPL: "apple",
-  MSFT: "microsoft",
-  GOOGL: "google",
-  GOOG: "google",
-  AMZN: "amazon",
-  META: "meta",
-  TSLA: "tesla",
-  NVDA: "nvidia",
-  TSM: "tsmc",
-  BABA: "alibaba",
-  NFLX: "netflix",
-  AMD: "amd",
-  INTC: "intel",
-  CRM: "salesforce",
-  ORCL: "oracle",
-};
-
-export function finnhubDateRange(freshness: "hours" | "day" | "week" | "month"): {
-  from: string;
-  to: string;
-} {
-  const now = new Date();
-  const to = formatDate(now);
-
-  switch (freshness) {
-    case "hours":
-      return { from: to, to };
-    case "day": {
-      const d = new Date(now);
-      d.setDate(d.getDate() - 1);
-      return { from: formatDate(d), to };
-    }
-    case "week": {
-      const d = new Date(now);
-      d.setDate(d.getDate() - 7);
-      return { from: formatDate(d), to };
-    }
-    case "month": {
-      const d = new Date(now);
-      d.setDate(d.getDate() - 30);
-      return { from: formatDate(d), to };
-    }
-  }
-}
-
-function formatDate(d: Date): string {
-  return d.toISOString().slice(0, 10);
-}
-
-function cacheKey(symbol: string, from: string, to: string): string {
-  return `finnhub:news:${symbol}:${from}:${to}`;
-}
-
-export function filterByRelevance(
-  articles: FinnhubArticle[],
-  symbol: string,
-  limit = 20,
-): FinnhubArticle[] {
-  const symLower = symbol.toLowerCase();
-  const companyName = TICKER_NAMES[symbol.toUpperCase()];
-
-  const filtered = articles.filter((a) => {
-    const hl = a.headline.toLowerCase();
-    const sm = a.summary.toLowerCase();
-    if (hl.includes(symLower) || sm.includes(symLower)) return true;
-    if (companyName && (hl.includes(companyName) || sm.includes(companyName))) return true;
-    return false;
-  });
-
-  // Most recent first, capped
-  return filtered.sort((a, b) => b.datetime - a.datetime).slice(0, limit);
-}
-
-export async function getCompanyNews(
-  symbol: string,
-  from: string,
-  to: string,
-  apiKey: string,
-): Promise<FinnhubArticle[]> {
-  const key = cacheKey(symbol, from, to);
-  const cached = cache.get<FinnhubArticle[]>(key);
-  if (cached) return cached;
-
-  try {
-    await rateLimiter.acquire("finnhub");
-
-    const url = `${FINNHUB_BASE}/company-news?symbol=${encodeURIComponent(symbol)}&from=${from}&to=${to}&token=${apiKey}`;
-    const data = await httpGet<FinnhubArticle[]>(url);
-
-    const articles = Array.isArray(data) ? data : [];
-    const filtered = filterByRelevance(articles, symbol);
-
-    cache.set(key, filtered, TTL.FINNHUB_NEWS);
-    return filtered;
-  } catch (error) {
-    if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
-      throw new ProviderCredentialError("finnhub", "stale", error.status);
-    }
-
-    const stale = cache.getStale<FinnhubArticle[]>(key, STALE_LIMIT.FINNHUB_NEWS);
-    if (stale) return stale.value;
-    throw error;
-  }
-}

package/src/providers/fred.ts

@@ -1,83 +0,0 @@
-import { cache, STALE_LIMIT, TTL } from "../infra/cache.js";
-import { HttpError, httpGet } from "../infra/http-client.js";
-import { rateLimiter } from "../infra/rate-limiter.js";
-import type { FredObservation, FredSeries } from "../types/macro.js";
-import { ProviderCredentialError } from "./provider-credential-error.js";
-
-const BASE_URL = "https://api.stlouisfed.org/fred";
-
-interface FredSeriesResponse {
-  seriess: Array<{
-    id: string;
-    title: string;
-    units: string;
-    frequency: string;
-    last_updated: string;
-  }>;
-}
-
-interface FredObservationsResponse {
-  observations: Array<{
-    date: string;
-    value: string;
-  }>;
-}
-
-export async function getSeries(
-  seriesId: string,
-  apiKey: string,
-  limit: number = 60,
-): Promise<FredSeries> {
-  const cacheKey = `fred:series:${seriesId}:${limit}`;
-  const cached = cache.get<FredSeries>(cacheKey);
-  if (cached) return cached;
-
-  try {
-    await rateLimiter.acquire("fred");
-
-    // Fetch series metadata and observations in parallel
-    const metaUrl = `${BASE_URL}/series?series_id=${seriesId}&api_key=${apiKey}&file_type=json`;
-    const obsUrl = `${BASE_URL}/series/observations?series_id=${seriesId}&api_key=${apiKey}&file_type=json&sort_order=desc&limit=${limit}`;
-
-    const [metaData, obsData] = await Promise.all([
-      httpGet<FredSeriesResponse>(metaUrl),
-      httpGet<FredObservationsResponse>(obsUrl),
-    ]);
-
-    const meta = metaData.seriess[0];
-    const observations: FredObservation[] = obsData.observations
-      .filter((o) => o.value !== ".")
-      .map((o) => ({
-        date: o.date,
-        value: parseFloat(o.value),
-      }))
-      .reverse(); // chronological order
-
-    const result: FredSeries = {
-      id: meta.id,
-      title: meta.title,
-      observations,
-      units: meta.units,
-      frequency: meta.frequency,
-      lastUpdated: meta.last_updated,
-    };
-
-    cache.set(cacheKey, result, TTL.MACRO);
-    return result;
-  } catch (error) {
-    // FRED historically returns 400 with a body like "Bad Request. The value
-    // for variable api_key is not registered..." when the key is invalid. A
-    // separate 400 can also indicate a bad series_id, which is NOT a credential
-    // problem. We only reclassify as credential-related on 401/403 here to
-    // avoid surfacing a `/connect` prompt when the user's real mistake is a
-    // typo in a series id. Bad-FRED-key users will still see the raw error
-    // message in v1; a body-string check can be added later if this becomes a
-    // reported friction.
-    if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
-      throw new ProviderCredentialError("fred", "stale", error.status);
-    }
-    const stale = cache.getStale<FredSeries>(cacheKey, STALE_LIMIT.MACRO);
-    if (stale) return stale.value;
-    throw error;
-  }
-}

package/src/providers/index.ts

@@ -1,17 +0,0 @@
-export { getEarnings, getFinancials, getOverview } from "./alpha-vantage.js";
-export { getCryptoHistory, getCryptoPrice } from "./coingecko.js";
-export { getFearGreedIndex } from "./fear-greed.js";
-export { getSeries } from "./fred.js";
-export { getSubredditPosts, scoreSentiment } from "./reddit.js";
-export { type SECFiling, searchFilings } from "./sec-edgar.js";
-export { getQuotes, screenStocks } from "./tradingview.js";
-export type { WebSearchOpts } from "./web-search.js";
-export { braveSearch, ddgSearch, normalizeFinancialQuery, searchWeb } from "./web-search.js";
-export {
-  clearCrumbCache,
-  computeTimeToExpiry,
-  getHistory,
-  getOptionsChain,
-  getQuote,
-  getYahooCrumb,
-} from "./yahoo-finance.js";

package/src/providers/provider-credential-error.ts

@@ -1,23 +0,0 @@
-// Typed error thrown by providers when they detect a missing or stale credential.
-//
-// Providers remain pure fetchers that throw on failure — this class is the
-// structured hand-off to the tool layer, where `withCredentialCheck` catches
-// the error and emits a tagged tool-result content string.
-//
-// Keep this module dependency-free (aside from the ProviderId type) so it can
-// be imported from anywhere without pulling in config loading or registry
-// side effects.
-
-import type { ProviderId } from "../onboarding/providers.js";
-
-export class ProviderCredentialError extends Error {
-  readonly name = "ProviderCredentialError";
-
-  constructor(
-    readonly provider: ProviderId,
-    readonly reason: "missing" | "stale",
-    readonly httpStatus?: number,
-  ) {
-    super(`credential_required:${provider}:${reason}`);
-  }
-}

package/src/providers/reddit-cli.ts

@@ -1,286 +0,0 @@
-import { type ExternalToolCommandResult, runExternalToolCommand } from "./external-tool-command.js";
-import { ExternalToolError, ExternalToolNotInstalled } from "./external-tool-error.js";
-import type { RedditComment } from "./reddit.js";
-
-const RDT_BINARY = "rdt";
-const RDT_INSTALL_CMD = "uv tool install rdt-cli";
-const COMMAND_TIMEOUT_MS = 20_000;
-const MAX_OUTPUT_CHARS = 2_000_000;
-
-interface RdtEnvelope<T> {
-  readonly ok: boolean;
-  readonly schema_version: string;
-  readonly data?: T;
-  readonly error?: {
-    readonly code?: string;
-    readonly message?: string;
-  };
-}
-
-export interface RdtPost {
-  readonly id: string;
-  readonly title: string;
-  readonly selftext: string;
-  readonly author: string;
-  readonly score: number;
-  readonly comments: number;
-  readonly subreddit?: string;
-  readonly url: string;
-  readonly permalink?: string;
-  readonly created: string;
-}
-
-interface RawRdtPost {
-  readonly id?: unknown;
-  readonly title?: unknown;
-  readonly selftext?: unknown;
-  readonly author?: unknown;
-  readonly score?: unknown;
-  readonly num_comments?: unknown;
-  readonly subreddit?: unknown;
-  readonly url?: unknown;
-  readonly permalink?: unknown;
-  readonly created_utc?: unknown;
-}
-
-interface RawRdtComment {
-  readonly id?: unknown;
-  readonly body?: unknown;
-  readonly author?: unknown;
-  readonly score?: unknown;
-  readonly permalink?: unknown;
-}
-
-interface RdtListingChild<T> {
-  readonly kind?: string;
-  readonly data?: T;
-}
-
-interface RdtListing<T> {
-  readonly data?: {
-    readonly children?: Array<RdtListingChild<T>>;
-  };
-}
-
-type RdtCommandRunner = (
-  command: string,
-  args: readonly string[],
-) => Promise<ExternalToolCommandResult>;
-
-let commandRunner: RdtCommandRunner = runCommand;
-
-export function setRdtCommandRunnerForTests(runner: RdtCommandRunner): void {
-  commandRunner = runner;
-}
-
-export function resetRdtCommandRunnerForTests(): void {
-  commandRunner = runCommand;
-}
-
-export async function searchRedditPosts(
-  query: string,
-  opts: { subreddit?: string; limit: number },
-): Promise<RdtPost[]> {
-  const args = ["search", query];
-  if (opts.subreddit) {
-    args.push("--subreddit", opts.subreddit);
-  }
-  args.push("--json", "--compact", "-n", String(opts.limit));
-  const data = await runRdt<RawRdtPost[]>(args);
-  if (!Array.isArray(data)) {
-    throw new ExternalToolError(RDT_BINARY, "rdt-cli returned invalid search data");
-  }
-  return data.map(adaptPost).filter((post) => post.id.length > 0);
-}
-
-export async function listSubredditPosts(
-  subreddit: string,
-  opts: { limit: number },
-): Promise<RdtPost[]> {
-  const data = await runRdt<RawRdtPost[]>([
-    "sub",
-    subreddit,
-    "--json",
-    "--compact",
-    "-n",
-    String(opts.limit),
-  ]);
-  if (!Array.isArray(data)) {
-    throw new ExternalToolError(RDT_BINARY, "rdt-cli returned invalid subreddit data");
-  }
-  return data.map((raw) => adaptPost({ ...raw, subreddit })).filter((post) => post.id.length > 0);
-}
-
-export async function readRedditPost(
-  postId: string,
-  opts: { limit: number },
-): Promise<{ post: RdtPost; comments: RedditComment[] }> {
-  const data = await runRdt<Array<RdtListing<RawRdtPost | RawRdtComment>>>([
-    "read",
-    postId,
-    "--json",
-    "-n",
-    String(opts.limit),
-  ]);
-  if (!Array.isArray(data)) {
-    throw new ExternalToolError(RDT_BINARY, "rdt-cli returned invalid read data");
-  }
-
-  const rawPost = data[0]?.data?.children?.find((child) => child.kind === "t3")?.data;
-  if (!rawPost) {
-    throw new ExternalToolError(RDT_BINARY, "rdt-cli read output did not include a post");
-  }
-
-  const post = adaptPost(rawPost as RawRdtPost);
-  const commentListing = data[1]?.data?.children ?? [];
-  const comments = commentListing
-    .filter((child): child is RdtListingChild<RawRdtComment> => child.kind === "t1")
-    .map((child) => adaptComment(child.data, post.permalink))
-    .filter((comment): comment is RedditComment => comment !== null)
-    .sort((a, b) => b.score - a.score)
-    .slice(0, opts.limit);
-
-  return { post, comments };
-}
-
-async function runRdt<T>(args: readonly string[]): Promise<T> {
-  let result: ExternalToolCommandResult;
-  try {
-    result = await commandRunner(RDT_BINARY, args);
-  } catch (err) {
-    const nodeError = err as NodeJS.ErrnoException;
-    if (nodeError.code === "ENOENT") {
-      throw new ExternalToolNotInstalled(RDT_BINARY, RDT_INSTALL_CMD);
-    }
-    throw new ExternalToolError(
-      RDT_BINARY,
-      redactSensitiveOutput(err instanceof Error ? err.message : String(err)),
-    );
-  }
-
-  if (result.code !== 0) {
-    const envelopeError = parseCliErrorEnvelope(result.stdout);
-    if (envelopeError) {
-      throw new ExternalToolError(
-        RDT_BINARY,
-        redactSensitiveOutput(envelopeError.message),
-        envelopeError.code,
-      );
-    }
-    throw new ExternalToolError(
-      RDT_BINARY,
-      redactSensitiveOutput(result.stderr.trim() || `rdt-cli exited with code ${result.code}`),
-    );
-  }
-
-  let envelope: RdtEnvelope<T>;
-  try {
-    envelope = JSON.parse(result.stdout) as RdtEnvelope<T>;
-  } catch {
-    throw new ExternalToolError(
-      RDT_BINARY,
-      `rdt-cli returned non-JSON output: ${redactSensitiveOutput(result.stdout.slice(0, 200))}`,
-    );
-  }
-
-  if (!envelope.ok) {
-    throw new ExternalToolError(
-      RDT_BINARY,
-      redactSensitiveOutput(envelope.error?.message ?? "rdt-cli returned an error"),
-      envelope.error?.code,
-    );
-  }
-  if (envelope.data === undefined) {
-    throw new ExternalToolError(RDT_BINARY, "rdt-cli returned no data");
-  }
-  return envelope.data;
-}
-
-function parseCliErrorEnvelope(stdout: string): { code?: string; message: string } | null {
-  try {
-    const parsed = JSON.parse(stdout) as {
-      ok?: unknown;
-      error?: { code?: unknown; message?: unknown };
-    };
-    if (parsed.ok !== false || typeof parsed.error?.message !== "string") return null;
-    return {
-      code: typeof parsed.error.code === "string" ? parsed.error.code : undefined,
-      message: parsed.error.message,
-    };
-  } catch {
-    return null;
-  }
-}
-
-function adaptPost(raw: RawRdtPost): RdtPost {
-  const permalink = stringValue(raw.permalink);
-  const url = stringValue(raw.url) || (permalink ? `https://reddit.com${permalink}` : "");
-  return {
-    id: stringValue(raw.id),
-    title: stringValue(raw.title),
-    selftext: stringValue(raw.selftext),
-    author: stringValue(raw.author) || "unknown",
-    score: numberValue(raw.score),
-    comments: numberValue(raw.num_comments),
-    subreddit: stringValue(raw.subreddit) || undefined,
-    url,
-    permalink: permalink || undefined,
-    created: normalizeCreatedAt(raw.created_utc),
-  };
-}
-
-function adaptComment(
-  raw: RawRdtComment | undefined,
-  postPermalink?: string,
-): RedditComment | null {
-  if (!raw || typeof raw.body !== "string" || raw.body.length === 0) return null;
-  const permalink = stringValue(raw.permalink) || postPermalink || "";
-  return {
-    id: stringValue(raw.id),
-    body: raw.body,
-    author: stringValue(raw.author) || "unknown",
-    score: numberValue(raw.score),
-    permalink: permalink ? `https://reddit.com${permalink}` : "",
-  };
-}
-
-function normalizeCreatedAt(value: unknown): string {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    const millis = value > 1_000_000_000_000 ? value : value * 1000;
-    return new Date(millis).toISOString();
-  }
-  if (typeof value === "string" && value.length > 0) {
-    const millis = Date.parse(value);
-    if (!Number.isNaN(millis)) return new Date(millis).toISOString();
-  }
-  return new Date(0).toISOString();
-}
-
-function stringValue(value: unknown): string {
-  return typeof value === "string" ? value : "";
-}
-
-function numberValue(value: unknown): number {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-
-export function redactSensitiveOutput(input: string): string {
-  return input
-    .slice(0, MAX_OUTPUT_CHARS)
-    .replace(
-      /\b([a-z0-9_]*(?:cookie|session|token)[a-z0-9_]*)\b\s*[:=]\s*[^;\s,)]+/gi,
-      "$1=[redacted]",
-    )
-    .replace(/\b([a-z0-9_]*(?:cookie|session|token)[a-z0-9_]*)=([^;\s,)]+)/gi, "$1=[redacted]")
-    .replace(
-      /(?:~|\/Users\/[^/\s]+|\/home\/[^/\s]+)?\/\.config\/rdt-cli\/credential\.json/g,
-      "[redacted-credential-path]",
-    );
-}
-
-function runCommand(command: string, args: readonly string[]): Promise<ExternalToolCommandResult> {
-  return runExternalToolCommand(command, args, {
-    timeoutMs: COMMAND_TIMEOUT_MS,
-    maxOutputChars: MAX_OUTPUT_CHARS,
-  });
-}

package/src/providers/reddit.ts

@@ -1,106 +0,0 @@
-import { cache, STALE_LIMIT, TTL } from "../infra/cache.js";
-import { rateLimiter } from "../infra/rate-limiter.js";
-import { BEARISH_TERMS, BULLISH_TERMS } from "../sentiment/keywords.js";
-import type { RedditSentimentResult } from "../types/sentiment.js";
-import { listSubredditPosts, readRedditPost, searchRedditPosts } from "./reddit-cli.js";
-
-export async function getSubredditPosts(
-  subreddit: string,
-  limit: number = 25,
-  query?: string,
-): Promise<RedditSentimentResult> {
-  const cacheKey = `reddit:${subreddit}:${query ?? "hot"}:${limit}`;
-  const cached = cache.get<RedditSentimentResult>(cacheKey);
-  if (cached) return cached;
-
-  try {
-    await rateLimiter.acquire("reddit");
-    const posts = query
-      ? await searchRedditPosts(query, { subreddit, limit })
-      : await listSubredditPosts(subreddit, { limit });
-
-    // Extract ticker-like mentions ($AAPL, $TSLA, etc.)
-    const tickerRegex = /\$([A-Z]{1,5})\b/g;
-    const mentionCounts = new Map<string, number>();
-    for (const post of posts) {
-      for (const match of post.title.matchAll(tickerRegex)) {
-        const ticker = match[1];
-        mentionCounts.set(ticker, (mentionCounts.get(ticker) ?? 0) + 1);
-      }
-    }
-    const topMentions = [...mentionCounts.entries()]
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 10)
-      .map(([ticker]) => ticker);
-
-    const sentiment = scoreSentiment(posts);
-
-    const result: RedditSentimentResult = {
-      subreddit,
-      postCount: posts.length,
-      posts,
-      topMentions,
-      sentimentScore: sentiment.score,
-      bullishCount: sentiment.bullish,
-      bearishCount: sentiment.bearish,
-      fetchedAt: new Date().toISOString(),
-    };
-
-    cache.set(cacheKey, result, TTL.SENTIMENT);
-    return result;
-  } catch (error) {
-    const stale = cache.getStale<RedditSentimentResult>(cacheKey, STALE_LIMIT.SENTIMENT);
-    if (stale) return stale.value;
-    throw error;
-  }
-}
-
-// ── Comment fetching ────────────────────────────────────
-
-export interface RedditComment {
-  id: string;
-  body: string;
-  author: string;
-  score: number;
-  permalink: string;
-}
-
-const COMMENT_TTL = 30 * 60 * 1000; // 30 minutes
-
-export async function getPostComments(
-  subreddit: string,
-  postId: string,
-  limit: number = 5,
-): Promise<RedditComment[]> {
-  const cacheKey = `reddit:comments:${subreddit}:${postId}:${limit}`;
-  const cached = cache.get<RedditComment[]>(cacheKey);
-  if (cached) return cached;
-
-  await rateLimiter.acquire("reddit_comments");
-  const { comments } = await readRedditPost(postId, { limit });
-
-  cache.set(cacheKey, comments, COMMENT_TTL);
-  return comments;
-}
-
-// ── Sentiment scoring ───────────────────────────────────
-
-export function scoreSentiment(posts: Array<{ title: string }>): {
-  score: number;
-  bullish: number;
-  bearish: number;
-} {
-  let bullish = 0;
-  let bearish = 0;
-  for (const post of posts) {
-    const lower = post.title.toLowerCase();
-    bullish += BULLISH_TERMS.filter((t) => lower.includes(t)).length;
-    bearish += BEARISH_TERMS.filter((t) => lower.includes(t)).length;
-  }
-  const total = bullish + bearish;
-  return {
-    score: total === 0 ? 0 : (bullish - bearish) / total,
-    bullish,
-    bearish,
-  };
-}