agent-finance-cli 0.1.0

package/src/research/tests.rs

@@ -0,0 +1,42 @@
+use super::*;
+use serde_json::json;
+
+#[test]
+fn fundamentals_highlights_extract_raw_and_fmt_values() {
+    let payload = json!({
+        "quoteSummary": {
+            "result": [{
+                "price": {
+                    "longName": "Credo Technology Group Holding Ltd",
+                    "marketCap": {"raw": 41704132608_i64, "fmt": "41.7B"}
+                },
+                "summaryProfile": {"industry": "Semiconductors"},
+                "financialData": {
+                    "revenueGrowth": {"raw": 2.015, "fmt": "201.5%"},
+                    "freeCashflow": {"raw": 172241120_i64}
+                }
+            }]
+        }
+    });
+    let highlights = fundamentals_highlights(quote_summary_root(&payload));
+    assert!(
+        highlights
+            .iter()
+            .any(|row| row.label == "Company" && row.value == "Credo Technology Group Holding Ltd")
+    );
+    assert!(
+        highlights
+            .iter()
+            .any(|row| row.label == "Market cap" && row.value == "41.7B")
+    );
+    assert!(
+        highlights
+            .iter()
+            .any(|row| row.label == "Revenue growth" && row.value == "201.5%")
+    );
+    assert!(
+        highlights
+            .iter()
+            .any(|row| row.label == "Free cash flow" && row.value == "172241120")
+    );
+}

package/src/skills.rs

@@ -0,0 +1,58 @@
+pub struct BuiltinSkill {
+    pub name: &'static str,
+    pub description: &'static str,
+}
+
+const SKILLS: &[BuiltinSkill] = &[
+    BuiltinSkill {
+        name: "core",
+        description: "Entry guide for price, sessions, history, research, providers, proxy data, and safe source handling.",
+    },
+    BuiltinSkill {
+        name: "price",
+        description: "Fetch current price summaries, regular-market basis, pre/post/overnight sessions, streams, and proxy prices.",
+    },
+    BuiltinSkill {
+        name: "research-data",
+        description: "Fetch no-key Yahoo/SEC EDGAR/Robinhood/CNBC research data and read URL text with fallback readers.",
+    },
+    BuiltinSkill {
+        name: "providers",
+        description: "Understand Yahoo, SEC EDGAR, CNBC, Robinhood, Stooq, Binance futures, and proxy quote capabilities.",
+    },
+    BuiltinSkill {
+        name: "history-indicators",
+        description: "Fetch OHLCV, understand intervals, adjustments, repair, actions, and local technical indicators.",
+    },
+    BuiltinSkill {
+        name: "futures",
+        description: "Use Binance USD-M futures / TradFi perps for proxy price, funding, open interest, and mark price.",
+    },
+];
+
+pub fn print_list() {
+    for skill in SKILLS {
+        println!("{:<20} {}", skill.name, skill.description);
+    }
+}
+
+pub fn get(name: &str, full: bool) -> Option<&'static str> {
+    match (name, full) {
+        ("core", false) => Some(CORE),
+        ("core", true) => Some(CORE_FULL),
+        ("price", _) => Some(PRICE),
+        ("research-data", _) => Some(RESEARCH_DATA),
+        ("providers", _) => Some(PROVIDERS),
+        ("history-indicators", _) => Some(HISTORY_INDICATORS),
+        ("futures", _) => Some(FUTURES),
+        _ => None,
+    }
+}
+
+const CORE: &str = include_str!("../skills/core.md");
+const CORE_FULL: &str = include_str!("../skills/core-full.md");
+const PRICE: &str = include_str!("../skills/price.md");
+const RESEARCH_DATA: &str = include_str!("../skills/research-data.md");
+const PROVIDERS: &str = include_str!("../skills/providers.md");
+const HISTORY_INDICATORS: &str = include_str!("../skills/history-indicators.md");
+const FUTURES: &str = include_str!("../skills/futures.md");

package/src/stream.rs

@@ -0,0 +1,356 @@
+use std::time::Duration;
+
+use anyhow::{Context, Result, anyhow};
+use base64::{Engine as _, engine::general_purpose};
+use futures_util::{SinkExt, StreamExt};
+use prost::Message as _;
+use serde::Serialize;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
+use tokio_tungstenite::client_async_tls_with_config;
+use tokio_tungstenite::connect_async;
+use tokio_tungstenite::tungstenite::Message;
+use tokio_tungstenite::tungstenite::client::IntoClientRequest;
+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+use url::Url;
+
+use crate::http::selected_proxy;
+use crate::http::timestamp_ms_to_utc;
+use crate::model::StreamQuote;
+use crate::time::utc_to_local;
+
+#[derive(Serialize)]
+struct SubscribeMessage {
+    subscribe: Vec<String>,
+}
+
+pub async fn stream_quotes(options: StreamOptions<'_>) -> Result<Vec<StreamQuote>> {
+    let mut updates = Vec::new();
+    stream_quotes_each(options, |quote| {
+        updates.push(quote);
+        Ok(())
+    })
+    .await?;
+    Ok(updates)
+}
+
+#[derive(Debug)]
+pub struct StreamOptions<'a> {
+    pub url: &'a str,
+    pub symbols: Vec<String>,
+    pub message_limit: usize,
+    pub read_timeout: Duration,
+    pub timezone: &'a str,
+    pub proxy: Option<&'a str>,
+    pub no_proxy: bool,
+}
+
+pub async fn stream_quotes_each<F>(options: StreamOptions<'_>, mut on_quote: F) -> Result<()>
+where
+    F: FnMut(StreamQuote) -> Result<()>,
+{
+    let _ = rustls::crypto::ring::default_provider().install_default();
+    let symbols = options
+        .symbols
+        .into_iter()
+        .map(|symbol| symbol.trim().to_uppercase())
+        .filter(|symbol| !symbol.is_empty())
+        .collect::<Vec<_>>();
+    if symbols.is_empty() {
+        return Err(anyhow!("at least one symbol is required"));
+    }
+
+    let mut request = options
+        .url
+        .into_client_request()
+        .with_context(|| format!("invalid websocket URL: {}", options.url))?;
+    request.headers_mut().insert(
+        "Origin",
+        "https://finance.yahoo.com"
+            .parse()
+            .context("invalid websocket Origin header")?,
+    );
+    request.headers_mut().insert(
+        "User-Agent",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36"
+            .parse()
+            .context("invalid websocket User-Agent header")?,
+    );
+
+    let proxy = selected_proxy(options.proxy, options.no_proxy);
+    let (socket, _) = connect_websocket(request, proxy.as_deref())
+        .await
+        .context("Yahoo websocket connect failed")?;
+    let (mut write, mut read) = socket.split();
+    write
+        .send(Message::Text(
+            serde_json::to_string(&SubscribeMessage { subscribe: symbols })?.into(),
+        ))
+        .await
+        .context("Yahoo websocket subscribe failed")?;
+
+    let mut seen = 0usize;
+    while options.message_limit == 0 || seen < options.message_limit {
+        let Some(message) = tokio::time::timeout(options.read_timeout, read.next())
+            .await
+            .context("Yahoo websocket read timed out")?
+        else {
+            break;
+        };
+        let message = message.context("Yahoo websocket frame failed")?;
+        match message {
+            Message::Text(text) => {
+                if let Ok(update) = decode_text_message(&text, options.timezone) {
+                    on_quote(update)?;
+                    seen += 1;
+                }
+            }
+            Message::Binary(bytes) => {
+                if let Ok(text) = std::str::from_utf8(&bytes)
+                    && let Ok(update) = decode_text_message(text, options.timezone)
+                {
+                    on_quote(update)?;
+                    seen += 1;
+                    continue;
+                }
+                if let Ok(update) = decode_pricing_data(&bytes, options.timezone) {
+                    on_quote(update)?;
+                    seen += 1;
+                }
+            }
+            Message::Ping(_) | Message::Pong(_) => {}
+            Message::Close(_) => break,
+            _ => {}
+        }
+    }
+
+    if seen == 0 {
+        return Err(anyhow!(
+            "Yahoo websocket returned no pricing updates before timeout"
+        ));
+    }
+    Ok(())
+}
+
+async fn connect_websocket(
+    request: tokio_tungstenite::tungstenite::handshake::client::Request,
+    proxy: Option<&str>,
+) -> Result<(
+    WebSocketStream<MaybeTlsStream<TcpStream>>,
+    tokio_tungstenite::tungstenite::handshake::client::Response,
+)> {
+    let Some(proxy) = proxy else {
+        return connect_async(request)
+            .await
+            .context("direct websocket connect failed");
+    };
+    let proxy =
+        Url::parse(proxy).with_context(|| format!("invalid websocket proxy URL: {proxy}"))?;
+    if proxy.scheme() != "http" {
+        return Err(anyhow!(
+            "websocket stream currently supports http proxy only; got {}",
+            proxy.scheme()
+        ));
+    }
+    let proxy_host = proxy
+        .host_str()
+        .ok_or_else(|| anyhow!("websocket proxy URL missing host"))?;
+    let proxy_port = proxy
+        .port_or_known_default()
+        .ok_or_else(|| anyhow!("websocket proxy URL missing port"))?;
+    let target_host = request
+        .uri()
+        .host()
+        .ok_or_else(|| anyhow!("websocket target URL missing host"))?
+        .to_string();
+    let target_port = request
+        .uri()
+        .port_u16()
+        .or_else(|| match request.uri().scheme_str() {
+            Some("wss") => Some(443),
+            Some("ws") => Some(80),
+            _ => None,
+        })
+        .ok_or_else(|| anyhow!("websocket target URL missing port"))?;
+    let target = format!("{target_host}:{target_port}");
+    let mut stream = TcpStream::connect((proxy_host, proxy_port))
+        .await
+        .with_context(|| format!("failed to connect websocket proxy {proxy_host}:{proxy_port}"))?;
+    let connect = format!("CONNECT {target} HTTP/1.1\r\nHost: {target}\r\n\r\n");
+    stream
+        .write_all(connect.as_bytes())
+        .await
+        .context("failed to write websocket proxy CONNECT")?;
+    let mut response = Vec::new();
+    let mut buffer = [0_u8; 1024];
+    loop {
+        let read = stream
+            .read(&mut buffer)
+            .await
+            .context("failed to read websocket proxy CONNECT response")?;
+        if read == 0 {
+            return Err(anyhow!("websocket proxy closed before CONNECT completed"));
+        }
+        response.extend_from_slice(&buffer[..read]);
+        if response.windows(4).any(|window| window == b"\r\n\r\n") {
+            break;
+        }
+        if response.len() > 8192 {
+            return Err(anyhow!("websocket proxy CONNECT response was too large"));
+        }
+    }
+    let response_text = String::from_utf8_lossy(&response);
+    if !(response_text.starts_with("HTTP/1.1 200") || response_text.starts_with("HTTP/1.0 200")) {
+        return Err(anyhow!(
+            "websocket proxy CONNECT failed: {}",
+            response_text.lines().next().unwrap_or("<empty>")
+        ));
+    }
+    client_async_tls_with_config(request, stream, None, None)
+        .await
+        .context("websocket TLS handshake through proxy failed")
+}
+
+pub fn decode_text_message(text: &str, timezone: &str) -> Result<StreamQuote> {
+    let text = text.trim();
+    let message = if text.starts_with('{') {
+        serde_json::from_str::<serde_json::Value>(text)?
+            .get("message")
+            .and_then(|value| value.as_str())
+            .ok_or_else(|| anyhow!("websocket JSON frame missing message field"))?
+            .to_string()
+    } else {
+        text.to_string()
+    };
+    let bytes = general_purpose::STANDARD
+        .decode(message.as_bytes())
+        .context("websocket base64 decode failed")?;
+    decode_pricing_data(&bytes, timezone)
+}
+
+fn decode_pricing_data(bytes: &[u8], timezone: &str) -> Result<StreamQuote> {
+    let data = PricingData::decode(bytes).context("websocket protobuf decode failed")?;
+    let time_utc = (data.time > 0)
+        .then_some(data.time)
+        .and_then(timestamp_ms_to_utc);
+    Ok(StreamQuote {
+        symbol: data.id,
+        price: data.price as f64,
+        time_local: utc_to_local(time_utc.as_deref(), timezone),
+        time_utc,
+        currency: non_empty(data.currency),
+        exchange: non_empty(data.exchange),
+        quote_type: Some(data.quote_type).filter(|value| *value != 0),
+        market_hours: Some(data.market_hours).filter(|value| *value != 0),
+        change_pct: non_zero_f32(data.change_percent),
+        day_volume: Some(data.day_volume).filter(|value| *value != 0),
+        day_high: non_zero_f32(data.day_high),
+        day_low: non_zero_f32(data.day_low),
+        change: non_zero_f32(data.change),
+        short_name: non_empty(data.short_name),
+        open: non_zero_f32(data.open_price),
+        previous_close: non_zero_f32(data.previous_close),
+        provider: "yahoo-websocket".to_string(),
+    })
+}
+
+fn non_empty(value: String) -> Option<String> {
+    (!value.is_empty()).then_some(value)
+}
+
+fn non_zero_f32(value: f32) -> Option<f64> {
+    (value != 0.0).then_some(value as f64)
+}
+
+#[derive(Clone, PartialEq, ::prost::Message)]
+struct PricingData {
+    #[prost(string, tag = "1")]
+    id: String,
+    #[prost(float, tag = "2")]
+    price: f32,
+    #[prost(sint64, tag = "3")]
+    time: i64,
+    #[prost(string, tag = "4")]
+    currency: String,
+    #[prost(string, tag = "5")]
+    exchange: String,
+    #[prost(int32, tag = "6")]
+    quote_type: i32,
+    #[prost(int32, tag = "7")]
+    market_hours: i32,
+    #[prost(float, tag = "8")]
+    change_percent: f32,
+    #[prost(sint64, tag = "9")]
+    day_volume: i64,
+    #[prost(float, tag = "10")]
+    day_high: f32,
+    #[prost(float, tag = "11")]
+    day_low: f32,
+    #[prost(float, tag = "12")]
+    change: f32,
+    #[prost(string, tag = "13")]
+    short_name: String,
+    #[prost(sint64, tag = "14")]
+    expire_date: i64,
+    #[prost(float, tag = "15")]
+    open_price: f32,
+    #[prost(float, tag = "16")]
+    previous_close: f32,
+    #[prost(float, tag = "17")]
+    strike_price: f32,
+    #[prost(string, tag = "18")]
+    underlying_symbol: String,
+    #[prost(sint64, tag = "19")]
+    open_interest: i64,
+    #[prost(sint64, tag = "20")]
+    options_type: i64,
+    #[prost(sint64, tag = "21")]
+    mini_option: i64,
+    #[prost(sint64, tag = "22")]
+    last_size: i64,
+    #[prost(float, tag = "23")]
+    bid: f32,
+    #[prost(sint64, tag = "24")]
+    bid_size: i64,
+    #[prost(float, tag = "25")]
+    ask: f32,
+    #[prost(sint64, tag = "26")]
+    ask_size: i64,
+    #[prost(sint64, tag = "27")]
+    price_hint: i64,
+    #[prost(sint64, tag = "28")]
+    vol_24hr: i64,
+    #[prost(sint64, tag = "29")]
+    vol_all_currencies: i64,
+    #[prost(string, tag = "30")]
+    from_currency: String,
+    #[prost(string, tag = "31")]
+    last_market: String,
+    #[prost(double, tag = "32")]
+    circulating_supply: f64,
+    #[prost(double, tag = "33")]
+    market_cap: f64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn decodes_yahoo_json_wrapped_base64_pricing_frame() {
+        let frame = r#"{"message":"CgRDUkRPFQCATkMYgLaO8tBnIgNVU0QqCE5hc2RhcUdTMAg4AkVcjwrBSPa4ggFVwzVzQ109il9DZc3MnMFqEENyZWRvIFRlY2hub2xvZ3l9mhluQ4UBrgdsQw=="}"#;
+        let quote = decode_text_message(frame, "Asia/Singapore").unwrap();
+        assert_eq!(quote.symbol, "CRDO");
+        assert_eq!(quote.price, 206.5);
+        assert_eq!(quote.currency.as_deref(), Some("USD"));
+        assert_eq!(quote.exchange.as_deref(), Some("NasdaqGS"));
+        assert_eq!(quote.market_hours, Some(2));
+        assert_eq!(quote.day_volume, Some(1_068_603));
+        assert_eq!(quote.short_name.as_deref(), Some("Credo Technology"));
+        assert_eq!(quote.time_utc.as_deref(), Some("2026-06-02T07:00:00Z"));
+        assert_eq!(
+            quote.time_local.as_deref(),
+            Some("2026-06-02T15:00:00+08:00")
+        );
+    }
+}

package/src/time.rs

@@ -0,0 +1,21 @@
+use chrono::{DateTime, SecondsFormat, Utc};
+use chrono_tz::Tz;
+
+pub const DEFAULT_TIMEZONE: &str = "Asia/Singapore";
+
+pub fn utc_to_local(value: Option<&str>, timezone: &str) -> Option<String> {
+    let value = value?;
+    let datetime = DateTime::parse_from_rfc3339(value).ok()?;
+    Some(format_local(datetime.with_timezone(&Utc), timezone))
+}
+
+pub fn now_local(timezone: &str) -> String {
+    format_local(Utc::now(), timezone)
+}
+
+pub fn format_local(datetime: DateTime<Utc>, timezone: &str) -> String {
+    let timezone = timezone.parse::<Tz>().unwrap_or(chrono_tz::Asia::Singapore);
+    datetime
+        .with_timezone(&timezone)
+        .to_rfc3339_opts(SecondsFormat::Secs, true)
+}