agent-finance-cli 0.1.0

package/src/history.rs

@@ -0,0 +1,150 @@
+use crate::cli::HistoryAdjustment;
+use crate::model::OhlcBar;
+
+pub fn apply_history_adjustment_and_repair(
+    bars: &mut [OhlcBar],
+    adjustment: HistoryAdjustment,
+    repair: bool,
+) -> bool {
+    let repair_applied = if repair {
+        repair_obvious_100x_errors(bars)
+    } else {
+        false
+    };
+    apply_adjustment(bars, adjustment);
+    repair_applied
+}
+
+fn apply_adjustment(bars: &mut [OhlcBar], adjustment: HistoryAdjustment) {
+    if adjustment == HistoryAdjustment::Raw {
+        return;
+    }
+    for bar in bars {
+        let Some(adj_close) = bar.adj_close else {
+            continue;
+        };
+        if bar.close == 0.0 {
+            continue;
+        }
+        let ratio = adj_close / bar.close;
+        bar.open = bar.open.map(|value| value * ratio);
+        bar.high = bar.high.map(|value| value * ratio);
+        bar.low = bar.low.map(|value| value * ratio);
+        if adjustment == HistoryAdjustment::Auto {
+            bar.close = adj_close;
+        }
+    }
+}
+
+fn repair_obvious_100x_errors(bars: &mut [OhlcBar]) -> bool {
+    let closes = bars.iter().map(|bar| bar.close).collect::<Vec<_>>();
+    let mut repaired = false;
+    for (index, bar) in bars.iter_mut().enumerate() {
+        let Some(reference) = neighbor_reference(&closes, index) else {
+            continue;
+        };
+        if reference <= 0.0 {
+            continue;
+        }
+        let close = bar.close;
+        let factor = if within(close / 100.0, reference) {
+            Some(0.01)
+        } else if within(close * 100.0, reference) {
+            Some(100.0)
+        } else {
+            None
+        };
+        let Some(factor) = factor else {
+            continue;
+        };
+        scale_bar(bar, factor);
+        bar.repaired = true;
+        repaired = true;
+    }
+    repaired
+}
+
+fn neighbor_reference(closes: &[f64], index: usize) -> Option<f64> {
+    let previous = (index > 0)
+        .then(|| closes[index - 1])
+        .filter(|value| *value > 0.0);
+    let next = closes.get(index + 1).copied().filter(|value| *value > 0.0);
+    match (previous, next) {
+        (Some(previous), Some(next)) => Some((previous + next) / 2.0),
+        (Some(previous), None) => Some(previous),
+        (None, Some(next)) => Some(next),
+        (None, None) => None,
+    }
+}
+
+fn within(value: f64, reference: f64) -> bool {
+    value >= reference * 0.8 && value <= reference * 1.2
+}
+
+fn scale_bar(bar: &mut OhlcBar, factor: f64) {
+    bar.open = bar.open.map(|value| value * factor);
+    bar.high = bar.high.map(|value| value * factor);
+    bar.low = bar.low.map(|value| value * factor);
+    bar.close *= factor;
+    bar.adj_close = bar.adj_close.map(|value| value * factor);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn bar(open: f64, high: f64, low: f64, close: f64, adj_close: Option<f64>) -> OhlcBar {
+        OhlcBar {
+            symbol: "TST".to_string(),
+            provider: "fixture".to_string(),
+            open_time: "2026-01-01T00:00:00Z".to_string(),
+            close_time: None,
+            open: Some(open),
+            high: Some(high),
+            low: Some(low),
+            close,
+            adj_close,
+            volume: Some(100.0),
+            quote_volume: None,
+            trades: None,
+            dividend: None,
+            stock_split: None,
+            capital_gain: None,
+            repaired: false,
+        }
+    }
+
+    #[test]
+    fn auto_adjust_replaces_close_and_scales_ohl() {
+        let mut bars = vec![bar(100.0, 110.0, 90.0, 100.0, Some(50.0))];
+        let repaired =
+            apply_history_adjustment_and_repair(&mut bars, HistoryAdjustment::Auto, false);
+        assert!(!repaired);
+        assert_eq!(bars[0].open, Some(50.0));
+        assert_eq!(bars[0].high, Some(55.0));
+        assert_eq!(bars[0].low, Some(45.0));
+        assert_eq!(bars[0].close, 50.0);
+    }
+
+    #[test]
+    fn back_adjust_scales_ohl_but_keeps_raw_close() {
+        let mut bars = vec![bar(100.0, 110.0, 90.0, 100.0, Some(50.0))];
+        apply_history_adjustment_and_repair(&mut bars, HistoryAdjustment::Back, false);
+        assert_eq!(bars[0].open, Some(50.0));
+        assert_eq!(bars[0].close, 100.0);
+    }
+
+    #[test]
+    fn repair_marks_and_scales_isolated_100x_error() {
+        let mut bars = vec![
+            bar(100.0, 102.0, 98.0, 100.0, Some(100.0)),
+            bar(10100.0, 10200.0, 9800.0, 10100.0, Some(10100.0)),
+            bar(102.0, 103.0, 99.0, 102.0, Some(102.0)),
+        ];
+        let repaired = apply_history_adjustment_and_repair(&mut bars, HistoryAdjustment::Raw, true);
+        assert!(repaired);
+        assert!(bars[1].repaired);
+        assert_eq!(bars[1].close, 101.0);
+        assert_eq!(bars[1].high, Some(102.0));
+    }
+}

package/src/http.rs

@@ -0,0 +1,76 @@
+use std::time::Duration;
+
+use anyhow::{Context, Result};
+use chrono::{SecondsFormat, TimeZone, Utc};
+use wreq::{Client, Proxy};
+use wreq_util::Emulation;
+
+pub fn http_client(timeout_seconds: u64, proxy: Option<&str>, no_proxy: bool) -> Result<Client> {
+    let mut builder = Client::builder()
+        .emulation(Emulation::Chrome137)
+        .timeout(Duration::from_secs(timeout_seconds))
+        .cookie_store(true);
+
+    if let Some(proxy) = selected_proxy(proxy, no_proxy) {
+        builder = builder
+            .proxy(Proxy::all(&proxy).with_context(|| format!("invalid proxy URL: {proxy}"))?);
+    } else if no_proxy {
+        builder = builder.no_proxy();
+    }
+
+    builder.build().context("failed to build HTTP client")
+}
+
+pub fn selected_proxy(proxy: Option<&str>, no_proxy: bool) -> Option<String> {
+    if no_proxy {
+        return None;
+    }
+    proxy
+        .map(str::to_string)
+        .or_else(|| std::env::var("AGENT_FINANCE_PROXY").ok())
+        .or_else(|| std::env::var("ALL_PROXY").ok())
+        .or_else(|| std::env::var("HTTPS_PROXY").ok())
+        .or_else(|| std::env::var("HTTP_PROXY").ok())
+}
+
+pub fn utc_now() -> String {
+    Utc::now().to_rfc3339_opts(SecondsFormat::Secs, true)
+}
+
+pub fn timestamp_ms_to_utc(timestamp: i64) -> Option<String> {
+    Utc.timestamp_millis_opt(timestamp)
+        .single()
+        .map(|datetime| datetime.to_rfc3339_opts(SecondsFormat::Secs, true))
+}
+
+pub fn timestamp_sec_to_utc(timestamp: i64) -> Option<String> {
+    Utc.timestamp_opt(timestamp, 0)
+        .single()
+        .map(|datetime| datetime.to_rfc3339_opts(SecondsFormat::Secs, true))
+}
+
+pub fn change_pct(price: f64, previous_close: Option<f64>) -> Option<f64> {
+    let previous_close = previous_close?;
+    if previous_close == 0.0 {
+        None
+    } else {
+        Some((price - previous_close) / previous_close * 100.0)
+    }
+}
+
+pub fn parse_optional_f64(value: Option<&str>) -> Option<f64> {
+    let value = clean_text(value)?;
+    value.parse::<f64>().ok()
+}
+
+pub fn parse_optional_u64(value: Option<&str>) -> Option<u64> {
+    let value = clean_text(value)?;
+    value.parse::<f64>().ok().map(|number| number as u64)
+}
+
+pub fn clean_text(value: Option<&str>) -> Option<&str> {
+    match value.map(str::trim) {
+        Some("") | Some("N/D") | None => None,
+        Some(value) => Some(value),
+    }
+}

package/src/indicators.rs

@@ -0,0 +1,82 @@
+use crate::model::{DerivedIndicator, HistoryBatch, OhlcBar};
+
+pub fn compute_indicator(history: &HistoryBatch) -> DerivedIndicator {
+    let bars = &history.bars;
+    DerivedIndicator {
+        symbol: history.symbol.clone(),
+        provider: history.provider.clone(),
+        latest_close: bars.last().map(|bar| bar.close),
+        latest_time: bars.last().map(|bar| bar.open_time.clone()),
+        return_1_bar_pct: return_pct(bars, 1),
+        return_5_bar_pct: return_pct(bars, 5),
+        return_20_bar_pct: return_pct(bars, 20),
+        sma_20: sma(bars, 20),
+        sma_50: sma(bars, 50),
+        high_20: rolling_high(bars, 20),
+        low_20: rolling_low(bars, 20),
+        realized_vol_20_annualized_pct: realized_vol_annualized_pct(bars, 20),
+    }
+}
+
+fn return_pct(bars: &[OhlcBar], lookback: usize) -> Option<f64> {
+    if bars.len() <= lookback {
+        return None;
+    }
+    let latest = bars.last()?.close;
+    let base = bars.get(bars.len() - 1 - lookback)?.close;
+    if base == 0.0 {
+        None
+    } else {
+        Some((latest - base) / base * 100.0)
+    }
+}
+
+fn sma(bars: &[OhlcBar], lookback: usize) -> Option<f64> {
+    if bars.len() < lookback {
+        return None;
+    }
+    let values = bars.iter().rev().take(lookback).map(|bar| bar.close);
+    Some(values.sum::<f64>() / lookback as f64)
+}
+
+fn rolling_high(bars: &[OhlcBar], lookback: usize) -> Option<f64> {
+    bars.iter()
+        .rev()
+        .take(lookback)
+        .filter_map(|bar| bar.high.or(Some(bar.close)))
+        .reduce(f64::max)
+}
+
+fn rolling_low(bars: &[OhlcBar], lookback: usize) -> Option<f64> {
+    bars.iter()
+        .rev()
+        .take(lookback)
+        .filter_map(|bar| bar.low.or(Some(bar.close)))
+        .reduce(f64::min)
+}
+
+fn realized_vol_annualized_pct(bars: &[OhlcBar], lookback: usize) -> Option<f64> {
+    if bars.len() <= lookback {
+        return None;
+    }
+    let returns = bars
+        .windows(2)
+        .rev()
+        .take(lookback)
+        .filter_map(|window| {
+            let previous = window.first()?.close;
+            let latest = window.last()?.close;
+            (previous > 0.0).then(|| (latest / previous).ln())
+        })
+        .collect::<Vec<_>>();
+    if returns.len() < 2 {
+        return None;
+    }
+    let mean = returns.iter().sum::<f64>() / returns.len() as f64;
+    let variance = returns
+        .iter()
+        .map(|value| (value - mean).powi(2))
+        .sum::<f64>()
+        / (returns.len() - 1) as f64;
+    Some(variance.sqrt() * 252.0_f64.sqrt() * 100.0)
+}

package/src/lib.rs

@@ -0,0 +1,15 @@
+pub mod app;
+mod cache;
+mod cli;
+mod history;
+mod http;
+mod indicators;
+mod model;
+mod output;
+mod page_read;
+mod price;
+mod providers;
+mod research;
+mod skills;
+mod stream;
+mod time;

package/src/main.rs

@@ -0,0 +1,4 @@
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    agent_finance_cli::app::run().await
+}

package/src/model.rs

@@ -0,0 +1,347 @@
+use std::collections::BTreeMap;
+
+use serde::Serialize;
+use serde_json::Value;
+
+pub const SESSION_REGULAR: &str = "regular";
+pub const SESSION_PRE: &str = "pre";
+pub const SESSION_POST: &str = "post";
+pub const SESSION_EXTENDED: &str = "extended";
+pub const SESSION_OVERNIGHT: &str = "overnight";
+pub const SESSION_24H_PROXY: &str = "24h_proxy";
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Quote {
+    pub symbol: String,
+    pub price: f64,
+    pub currency: Option<String>,
+    pub provider: String,
+    pub session: Option<String>,
+    pub fetched_at_utc: String,
+    pub market_time: Option<String>,
+    pub previous_close: Option<f64>,
+    pub open: Option<f64>,
+    pub high: Option<f64>,
+    pub low: Option<f64>,
+    pub volume: Option<u64>,
+    pub exchange: Option<String>,
+    pub provider_symbol: Option<String>,
+    pub change_pct: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct OhlcBar {
+    pub symbol: String,
+    pub provider: String,
+    pub open_time: String,
+    pub close_time: Option<String>,
+    pub open: Option<f64>,
+    pub high: Option<f64>,
+    pub low: Option<f64>,
+    pub close: f64,
+    pub adj_close: Option<f64>,
+    pub volume: Option<f64>,
+    pub quote_volume: Option<f64>,
+    pub trades: Option<u64>,
+    pub dividend: Option<f64>,
+    pub stock_split: Option<f64>,
+    pub capital_gain: Option<f64>,
+    pub repaired: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub struct HistoryBatch {
+    pub symbol: String,
+    pub provider: String,
+    pub interval: String,
+    pub adjustment: String,
+    pub actions_included: bool,
+    pub repair_requested: bool,
+    pub repair_applied: bool,
+    pub bars: Vec<OhlcBar>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct DerivedIndicator {
+    pub symbol: String,
+    pub provider: String,
+    pub latest_close: Option<f64>,
+    pub latest_time: Option<String>,
+    pub return_1_bar_pct: Option<f64>,
+    pub return_5_bar_pct: Option<f64>,
+    pub return_20_bar_pct: Option<f64>,
+    pub sma_20: Option<f64>,
+    pub sma_50: Option<f64>,
+    pub high_20: Option<f64>,
+    pub low_20: Option<f64>,
+    pub realized_vol_20_annualized_pct: Option<f64>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct FuturesStats {
+    pub symbol: String,
+    pub provider: String,
+    pub fetched_at_utc: String,
+    pub ticker_24h: Option<FuturesTicker24h>,
+    pub mark_price: Option<FuturesMarkPrice>,
+    pub open_interest: Option<FuturesOpenInterest>,
+    pub funding_rates: Vec<FuturesFundingRate>,
+    pub errors: BTreeMap<String, String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct FuturesTicker24h {
+    pub last_price: Option<f64>,
+    pub price_change: Option<f64>,
+    pub price_change_pct: Option<f64>,
+    pub weighted_avg_price: Option<f64>,
+    pub open_price: Option<f64>,
+    pub high_price: Option<f64>,
+    pub low_price: Option<f64>,
+    pub volume: Option<f64>,
+    pub quote_volume: Option<f64>,
+    pub count: Option<u64>,
+    pub open_time: Option<String>,
+    pub close_time: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct FuturesMarkPrice {
+    pub mark_price: Option<f64>,
+    pub index_price: Option<f64>,
+    pub estimated_settle_price: Option<f64>,
+    pub last_funding_rate: Option<f64>,
+    pub interest_rate: Option<f64>,
+    pub next_funding_time: Option<String>,
+    pub time: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct FuturesOpenInterest {
+    pub open_interest: Option<f64>,
+    pub time: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct FuturesFundingRate {
+    pub funding_rate: Option<f64>,
+    pub funding_time: Option<String>,
+    pub mark_price: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct PricePoint {
+    pub label: String,
+    pub symbol: String,
+    pub price: Option<f64>,
+    pub currency: Option<String>,
+    pub provider: String,
+    pub session: Option<String>,
+    pub market_time_utc: Option<String>,
+    pub market_time_local: Option<String>,
+    pub change_pct: Option<f64>,
+    pub previous_close: Option<f64>,
+    pub open: Option<f64>,
+    pub high: Option<f64>,
+    pub low: Option<f64>,
+    pub volume: Option<u64>,
+    pub exchange: Option<String>,
+    pub note: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct RegularBasis {
+    pub previous_close: Option<f64>,
+    pub open: Option<f64>,
+    pub high: Option<f64>,
+    pub low: Option<f64>,
+    pub volume: Option<u64>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct PriceSummary {
+    pub symbol: String,
+    pub timezone: String,
+    pub fetched_at_utc: String,
+    pub fetched_at_local: String,
+    pub current: Option<PricePoint>,
+    pub regular_basis: RegularBasis,
+    pub sessions: Vec<PricePoint>,
+    pub proxy: Option<PricePoint>,
+    pub errors: BTreeMap<String, String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ResearchReport {
+    pub symbol: String,
+    pub category: String,
+    pub fetched_at_utc: String,
+    pub fetched_at_local: String,
+    pub sources: Vec<ResearchSource>,
+    pub modules: Vec<ResearchModule>,
+    pub coverage_gaps: Vec<ResearchCoverageGap>,
+    pub highlights: Vec<ResearchHighlight>,
+    pub payload: Value,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ResearchSource {
+    pub provider: String,
+    pub cache_status: String,
+    pub fetched_at_utc: String,
+    pub fetched_at_local: String,
+    pub note: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ResearchModule {
+    pub name: String,
+    pub provider: String,
+    pub status: String,
+    pub note: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ResearchCoverageGap {
+    pub module: String,
+    pub reason: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ResearchHighlight {
+    pub label: String,
+    pub value: String,
+    pub provider: String,
+    pub module: String,
+}
+
+impl ResearchHighlight {
+    pub fn new(label: &str, value: impl Into<String>, provider: &str, module: &str) -> Self {
+        Self {
+            label: label.to_string(),
+            value: value.into(),
+            provider: provider.to_string(),
+            module: module.to_string(),
+        }
+    }
+
+    pub fn from_path(
+        root: Option<&Value>,
+        label: &str,
+        path: &str,
+        provider: &str,
+        module: &str,
+    ) -> Option<Self> {
+        let value = research_value_string(root?.pointer(path))?;
+        Some(Self::new(label, value, provider, module))
+    }
+}
+
+pub fn research_value_string(value: Option<&Value>) -> Option<String> {
+    match value? {
+        Value::Null => None,
+        Value::String(value) => Some(value.clone()),
+        Value::Number(value) => Some(value.to_string()),
+        Value::Bool(value) => Some(value.to_string()),
+        Value::Array(values) => Some(
+            values
+                .iter()
+                .filter_map(|value| research_value_string(Some(value)))
+                .collect::<Vec<_>>()
+                .join(", "),
+        ),
+        Value::Object(map) => map
+            .get("fmt")
+            .and_then(|value| value.as_str().map(ToString::to_string))
+            .or_else(|| {
+                map.get("raw")
+                    .and_then(|value| research_value_string(Some(value)))
+            }),
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ProviderProfile {
+    pub provider: String,
+    pub requires_api_key: bool,
+    pub official_status: String,
+    pub stability: String,
+    pub best_for: String,
+    pub large_download: bool,
+    pub capabilities: Vec<ProviderCapability>,
+    pub limitations: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ProviderCapability {
+    pub module: String,
+    pub status: String,
+    pub note: String,
+    pub implemented: bool,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct StooqCatalog {
+    pub fetched_at_utc: String,
+    pub source_url: String,
+    pub entries: Vec<StooqCatalogEntry>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct StooqCatalogEntry {
+    pub frequency: String,
+    pub market: String,
+    pub asset: String,
+    pub label: String,
+    pub approx_size_mb: Option<f64>,
+    pub listing_url: String,
+    pub direct_download_requires_captcha: bool,
+    pub cache_key: String,
+    pub cached_zip_path: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct StooqSyncReport {
+    pub provider: String,
+    pub frequency: String,
+    pub market: String,
+    pub asset: String,
+    pub cache_key: String,
+    pub zip_path: String,
+    pub bytes: u64,
+    pub imported_at_utc: String,
+    pub source: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct SearchReport {
+    pub category: String,
+    pub query: String,
+    pub provider: String,
+    pub fetched_at_utc: String,
+    pub fetched_at_local: String,
+    pub cache_status: String,
+    pub highlights: Vec<ResearchHighlight>,
+    pub payload: Value,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct StreamQuote {
+    pub symbol: String,
+    pub price: f64,
+    pub time_utc: Option<String>,
+    pub time_local: Option<String>,
+    pub currency: Option<String>,
+    pub exchange: Option<String>,
+    pub quote_type: Option<i32>,
+    pub market_hours: Option<i32>,
+    pub change_pct: Option<f64>,
+    pub day_volume: Option<i64>,
+    pub day_high: Option<f64>,
+    pub day_low: Option<f64>,
+    pub change: Option<f64>,
+    pub short_name: Option<String>,
+    pub open: Option<f64>,
+    pub previous_close: Option<f64>,
+    pub provider: String,
+}