agent-finance-cli 0.1.1 → 0.1.3

package/src/output.rs

@@ -3,10 +3,12 @@ use std::collections::BTreeMap;
 use anyhow::Result;
 
 use crate::model::{
-    DerivedIndicator, FuturesStats, HistoryBatch, PricePoint, PriceSummary, ProviderProfile,
+    DerivedIndicator, FuturesStats, HistoryBatch, PredictionMarketReport, PredictionMarketSummary,
+    PredictionOutcome, PredictionSearchReport, PricePoint, PriceSummary, ProviderProfile,
     ResearchReport, SearchReport, StreamQuote,
 };
 use crate::page_read::PageReadReport;
+use crate::time::utc_to_local;
 
 pub fn print_price_summary(summary: &PriceSummary, show_all: bool) {
     println!(
@@ -72,7 +74,7 @@ pub fn print_price_summary(summary: &PriceSummary, show_all: bool) {
     }
 }
 
-pub fn print_history_table(history: &HistoryBatch) {
+pub fn print_history_table(history: &HistoryBatch, timezone: &str) {
     println!(
         "{} history via {} interval={} adjustment={} actions={} repair_requested={} repair_applied={}",
         history.symbol,
@@ -101,7 +103,7 @@ pub fn print_history_table(history: &HistoryBatch) {
         .iter()
         .map(|bar| {
             vec![
-                bar.open_time.clone(),
+                local_or_original(&bar.open_time, timezone),
                 money_value(bar.open),
                 money_value(bar.high),
                 money_value(bar.low),
@@ -157,10 +159,12 @@ pub fn print_indicator_table(indicators: &[DerivedIndicator], errors: &BTreeMap<
     print_table(&headers, &rows);
 }
 
-pub fn print_futures_stats(stats: &FuturesStats) {
+pub fn print_futures_stats(stats: &FuturesStats, timezone: &str) {
     println!(
         "{} futures stats via {} fetched_at={}",
-        stats.symbol, stats.provider, stats.fetched_at_utc
+        stats.symbol,
+        stats.provider,
+        local_or_original(&stats.fetched_at_utc, timezone)
     );
     if let Some(ticker) = stats.ticker_24h.as_ref() {
         println!(
@@ -182,14 +186,14 @@ pub fn print_futures_stats(stats: &FuturesStats) {
             money_value(mark.mark_price),
             money_value(mark.index_price),
             pct_value(mark.last_funding_rate.map(|value| value * 100.0)),
-            mark.next_funding_time.as_deref().unwrap_or("-")
+            local_or_original_optional(mark.next_funding_time.as_deref(), timezone)
         );
     }
     if let Some(open_interest) = stats.open_interest.as_ref() {
         println!(
             "open_interest: {} time={}",
             number_value(open_interest.open_interest),
-            open_interest.time.as_deref().unwrap_or("-")
+            local_or_original_optional(open_interest.time.as_deref(), timezone)
         );
     }
     if !stats.funding_rates.is_empty() {
@@ -200,7 +204,7 @@ pub fn print_futures_stats(stats: &FuturesStats) {
             .iter()
             .map(|row| {
                 vec![
-                    row.funding_time.clone().unwrap_or_else(|| "-".to_string()),
+                    local_or_original_optional(row.funding_time.as_deref(), timezone),
                     pct_value(row.funding_rate.map(|value| value * 100.0)),
                     money_value(row.mark_price),
                 ]
@@ -328,6 +332,153 @@ pub fn print_search_report(report: &SearchReport, raw: bool) -> Result<()> {
     Ok(())
 }
 
+pub fn print_prediction_search_report(report: &PredictionSearchReport) {
+    println!(
+        "{} search '{}' fetched={} cache={}",
+        report.provider, report.query, report.fetched_at_local, report.cache_status
+    );
+    println!("{}", report.interpretation_note);
+    print_source_urls(&report.source_urls);
+    print_prediction_markets(&report.markets);
+}
+
+pub fn print_prediction_market_report(report: &PredictionMarketReport) {
+    println!(
+        "{} market '{}' fetched={} cache={} enrichment={} enrichment_fetched={}",
+        report.provider,
+        report.identifier,
+        report.fetched_at_local,
+        report.cache_status,
+        report.enrichment_status,
+        report.enrichment_fetched_at_local
+    );
+    println!("{}", report.interpretation_note);
+    print_source_urls(&report.source_urls);
+    print_prediction_markets(std::slice::from_ref(&report.market));
+    println!();
+    println!("Outcomes");
+    print_prediction_outcomes(&report.outcomes);
+    if !report.price_history.is_empty() {
+        println!();
+        println!("Price history");
+        let headers = ["time", "price"];
+        let rows = report
+            .price_history
+            .iter()
+            .rev()
+            .take(12)
+            .map(|point| {
+                vec![
+                    point
+                        .time_local
+                        .as_deref()
+                        .or(point.time_utc.as_deref())
+                        .unwrap_or("-")
+                        .to_string(),
+                    money_value(Some(point.price)),
+                ]
+            })
+            .collect::<Vec<_>>();
+        print_table(&headers, &rows);
+    }
+    if report.open_interest.is_some() || report.holder_preview_count.is_some() {
+        println!();
+        println!(
+            "Data API: open_interest={} holder_preview_rows={}",
+            number_value(report.open_interest),
+            report
+                .holder_preview_count
+                .map_or_else(|| "-".to_string(), |value| value.to_string())
+        );
+    }
+    if !report.data_errors.is_empty() {
+        println!();
+        println!("Partial data errors");
+        for (source, error) in &report.data_errors {
+            println!("{source}: {error}");
+        }
+    }
+}
+
+fn print_source_urls(urls: &[String]) {
+    if urls.is_empty() {
+        return;
+    }
+    println!("Sources:");
+    for url in urls {
+        println!("- {url}");
+    }
+}
+
+fn print_prediction_markets(markets: &[PredictionMarketSummary]) {
+    if markets.is_empty() {
+        println!("No markets matched after local filtering.");
+        return;
+    }
+    let headers = [
+        "market", "active", "closed", "prob", "bid", "ask", "spread", "vol24h", "liq", "end",
+    ];
+    let rows = markets
+        .iter()
+        .map(|market| {
+            vec![
+                market.title.clone(),
+                bool_text(market.active),
+                bool_text(market.closed),
+                market
+                    .outcomes
+                    .first()
+                    .and_then(|outcome| outcome.implied_probability)
+                    .map(pct_from_unit)
+                    .unwrap_or_else(|| "-".to_string()),
+                money_value(market.best_bid),
+                money_value(market.best_ask),
+                money_value(market.spread),
+                number_value(market.volume_24hr),
+                number_value(market.liquidity),
+                market
+                    .end_time_local
+                    .clone()
+                    .unwrap_or_else(|| "-".to_string()),
+            ]
+        })
+        .collect::<Vec<_>>();
+    print_table(&headers, &rows);
+}
+
+fn print_prediction_outcomes(outcomes: &[PredictionOutcome]) {
+    if outcomes.is_empty() {
+        println!("No outcomes found.");
+        return;
+    }
+    let headers = [
+        "outcome", "prob", "bid", "ask", "spread", "last", "bids", "asks", "token",
+    ];
+    let rows = outcomes
+        .iter()
+        .map(|outcome| {
+            vec![
+                outcome.label.clone(),
+                outcome
+                    .implied_probability
+                    .map(pct_from_unit)
+                    .unwrap_or_else(|| "-".to_string()),
+                money_value(outcome.best_bid),
+                money_value(outcome.best_ask),
+                money_value(outcome.spread),
+                money_value(outcome.last_trade_price),
+                outcome.bid_count.to_string(),
+                outcome.ask_count.to_string(),
+                outcome
+                    .clob_token_id
+                    .clone()
+                    .unwrap_or_else(|| "-".to_string()),
+            ]
+        })
+        .collect::<Vec<_>>();
+    print_table(&headers, &rows);
+}
+
 pub fn print_provider_profiles(profiles: &[ProviderProfile]) {
     let headers = [
         "provider",
@@ -512,6 +663,16 @@ where
         .join("  ")
 }
 
+fn local_or_original_optional(value: Option<&str>, timezone: &str) -> String {
+    value
+        .map(|value| local_or_original(value, timezone))
+        .unwrap_or_else(|| "-".to_string())
+}
+
+fn local_or_original(value: &str, timezone: &str) -> String {
+    utc_to_local(Some(value), timezone).unwrap_or_else(|| value.to_string())
+}
+
 fn money_value(value: Option<f64>) -> String {
     match value {
         Some(value) => format!("${value:.2}"),
@@ -536,6 +697,18 @@ fn number_value(value: Option<f64>) -> String {
     }
 }
 
+fn bool_text(value: Option<bool>) -> String {
+    match value {
+        Some(true) => "yes".to_string(),
+        Some(false) => "no".to_string(),
+        None => "-".to_string(),
+    }
+}
+
+fn pct_from_unit(value: f64) -> String {
+    format!("{:.2}%", value * 100.0)
+}
+
 fn pct_value(value: Option<f64>) -> String {
     match value {
         Some(value) => format!("{value:+.2}%"),

package/src/providers/capabilities.rs

@@ -211,6 +211,55 @@ pub fn profiles() -> Vec<ProviderProfile> {
             ],
             &["Use for extended-hours price checks."],
         ),
+        profile(
+            "polymarket",
+            false,
+            "official-sdk",
+            "official-public-api",
+            "Prediction-market sentiment, implied probability, orderbook, liquidity, open interest, holder previews, and probability history.",
+            &[
+                cap(
+                    "prediction search",
+                    "yes",
+                    "Gamma public relevance search for events and markets",
+                ),
+                cap(
+                    "market detail",
+                    "yes",
+                    "Gamma market metadata and outcome probabilities",
+                ),
+                cap(
+                    "orderbook",
+                    "yes",
+                    "CLOB public best bid/ask and depth by outcome token",
+                ),
+                cap(
+                    "probability history",
+                    "yes",
+                    "CLOB prices-history by outcome token",
+                ),
+                cap(
+                    "open interest",
+                    "yes",
+                    "Data API open interest by condition id",
+                ),
+                cap(
+                    "holders",
+                    "preview",
+                    "Data API top holder preview rows by condition id; not total holder count",
+                ),
+                cap("quote", "no", "Prediction prices are not equity quotes"),
+                cap(
+                    "fundamentals",
+                    "no",
+                    "Does not replace SEC, IR, or company filings",
+                ),
+            ],
+            &[
+                "Use as quantifiable sentiment and event-probability evidence only.",
+                "Default transport uses the official SDK; explicit --proxy/--no-proxy uses public REST fallback through the CLI HTTP stack.",
+            ],
+        ),
         profile(
             Provider::BinanceFutures.label(),
             false,

package/src/providers/mod.rs

@@ -7,6 +7,7 @@ use crate::model::{HistoryBatch, Quote};
 pub mod binance_futures;
 pub mod capabilities;
 pub mod cnbc;
+pub mod polymarket;
 pub mod robinhood;
 pub mod sec_edgar;
 pub mod stooq;