feat: add a stale time check so that we not reload the weather too often

Signed-off-by: Sven Kanoldt <sven@d34dl0ck.me>

Author: sassman

2026-Q2/core/src/lib.rs

@@ -1,18 +1,26 @@
 //! Crux core for the counter+weather PoC.
 //! Pure Rust, no FFI, no typegen — designed for an in-process Rust shell.
 
+use std::time::{Duration, SystemTime};
+
 use crux_core::capability::Operation;
 use crux_core::macros::effect;
 use crux_core::render::RenderOperation;
 use crux_core::{App, Command};
 
+/// Don't hammer the weather API: skip the fetch if the last reading is
+/// fresher than this.
+const WEATHER_REFRESH_AFTER: Duration = Duration::from_secs(10);
+
 // --- Domain types ---
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct WeatherSnapshot {
     pub temp_c: f32,
     pub condition: WeatherCondition,
-    pub fetched_at: String, // ISO local timestamp from API
+    /// Wall-clock time the shell received the response. The shell stamps
+    /// it; the core only compares it.
+    pub fetched_at: SystemTime,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -111,12 +119,17 @@ impl App for CounterApp {
     }
 }
 
-/// Re-rendered after every count change. If the new count is a multiple of 10
-/// and we're not already fetching, kick off a weather request.
+/// Re-rendered after every count change. If the new count is a non-zero
+/// multiple of 10, we're not already fetching, and the last reading is
+/// older than [`WEATHER_REFRESH_AFTER`], kick off a new weather request.
 fn after_count_change(model: &mut Model) -> Command<Effect, Event> {
     use crux_core::render::render;
     let render_cmd = render();
-    if model.count % 10 == 0 && !model.weather_in_flight {
+    let should_fetch = model.count != 0
+        && model.count % 10 == 0
+        && !model.weather_in_flight
+        && weather_is_stale(model.last_weather.as_ref());
+    if should_fetch {
         model.weather_in_flight = true;
         let fetch_cmd =
             Command::request_from_shell(FetchMunichWeather).then_send(Event::WeatherLoaded);
@@ -126,15 +139,32 @@ fn after_count_change(model: &mut Model) -> Command<Effect, Event> {
     }
 }
 
+/// `true` if we have no reading yet, or the existing one is older than the
+/// refresh interval. A backwards clock jump also counts as stale (safer).
+fn weather_is_stale(last: Option<&WeatherSnapshot>) -> bool {
+    match last {
+        None => true,
+        Some(snap) => SystemTime::now()
+            .duration_since(snap.fetched_at)
+            .map(|elapsed| elapsed >= WEATHER_REFRESH_AFTER)
+            .unwrap_or(true),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     fn snap(temp: f32) -> WeatherSnapshot {
+        snap_with_age(temp, Duration::ZERO)
+    }
+
+    /// `age` = how long ago the snapshot was taken (subtracted from `now`).
+    fn snap_with_age(temp: f32, age: Duration) -> WeatherSnapshot {
         WeatherSnapshot {
             temp_c: temp,
             condition: WeatherCondition::Clear,
-            fetched_at: "2026-05-06T12:00".into(),
+            fetched_at: SystemTime::now() - age,
         }
     }
 
@@ -212,6 +242,53 @@ mod tests {
         assert_eq!(model.last_weather.as_ref().map(|x| x.temp_c), Some(18.3));
     }
 
+    /// T5 — Throttle: a fresh snapshot suppresses the refetch even when we
+    ///       just crossed into a multiple of 10.
+    #[test]
+    fn fetch_is_suppressed_when_last_reading_is_fresh() {
+        let app = CounterApp;
+        let mut model = Model {
+            count: 9,
+            last_weather: Some(snap(18.3)),
+            ..Default::default()
+        };
+        let mut cmd = app.update(Event::Increment, &mut model);
+
+        let effects: Vec<Effect> = cmd.effects().collect();
+        assert!(
+            !effects
+                .iter()
+                .any(|e| matches!(e, Effect::FetchMunichWeather(_))),
+            "fresh reading should suppress refetch; got {} variants",
+            effects.len()
+        );
+    }
+
+    /// T6 — Throttle: once the snapshot is older than the refresh window,
+    ///       crossing a multiple of 10 fetches again.
+    #[test]
+    fn fetch_fires_after_refresh_window_elapsed() {
+        let app = CounterApp;
+        let mut model = Model {
+            count: 9,
+            last_weather: Some(snap_with_age(
+                18.3,
+                WEATHER_REFRESH_AFTER + Duration::from_secs(1),
+            )),
+            ..Default::default()
+        };
+        let mut cmd = app.update(Event::Increment, &mut model);
+
+        let effects: Vec<Effect> = cmd.effects().collect();
+        assert!(
+            effects
+                .iter()
+                .any(|e| matches!(e, Effect::FetchMunichWeather(_))),
+            "stale reading should trigger refetch; got {} variants",
+            effects.len()
+        );
+    }
+
     #[test]
     fn weather_loaded_error_clears_in_flight_only() {
         let app = CounterApp;

2026-Q2/shell-gpui/src/main.rs

@@ -77,7 +77,7 @@ impl Render for Shell {
                     div()
                         .text_xs()
                         .text_color(rgb(0x8a96a8))
-                        .child(format_pretty_datetime(&w.fetched_at)),
+                        .child(format_pretty_datetime(w.fetched_at)),
                 )
                 .into_any_element(),
             (None, false) => div()
@@ -153,24 +153,22 @@ fn emoji_for(c: app_core::WeatherCondition) -> &'static str {
     }
 }
 
-/// Reformat ISO-ish "2026-05-06T11:30" into "6 May 2026 · 11:30".
-/// Robust to truncations: if fields are missing, falls back to the raw string.
-fn format_pretty_datetime(iso: &str) -> String {
-    const MONTHS: [&str; 13] = [
-        "?", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
-    ];
-    let Some((date, time)) = iso.split_once('T') else {
-        return iso.to_string();
+/// Render the snapshot's wall-clock age as "12s ago" / "3m ago" / "2h ago".
+/// Relative time fits the "this is current weather" framing better than a
+/// formatted clock — and dodges the calendar math that would otherwise need
+/// a chrono/time dependency.
+fn format_pretty_datetime(t: std::time::SystemTime) -> String {
+    let Ok(elapsed) = std::time::SystemTime::now().duration_since(t) else {
+        return "just now".to_string();
     };
-    let mut parts = date.split('-');
-    let (Some(y), Some(m_str), Some(d_str)) = (parts.next(), parts.next(), parts.next()) else {
-        return iso.to_string();
-    };
-    let m: usize = m_str.parse().unwrap_or(0);
-    let d: u32 = d_str.parse().unwrap_or(0);
-    let month = MONTHS.get(m).copied().unwrap_or("?");
-    let hhmm = time.get(..5).unwrap_or(time);
-    format!("{d} {month} {y} · {hhmm}")
+    let secs = elapsed.as_secs();
+    if secs < 60 {
+        format!("{secs}s ago")
+    } else if secs < 3_600 {
+        format!("{}m ago", secs / 60)
+    } else {
+        format!("{}h ago", secs / 3_600)
+    }
 }
 
 fn button(

2026-Q2/shell-gpui/src/weather.rs

@@ -1,6 +1,8 @@
 //! Munich weather fetcher — blocking ureq + minimal JSON parse.
 //! Lives in the shell because Crux core is forbidden from doing I/O.
 
+use std::time::SystemTime;
+
 use app_core::{WeatherCondition, WeatherError, WeatherSnapshot};
 use serde::Deserialize;
 
@@ -16,7 +18,6 @@ struct OpenMeteoResponse {
 
 #[derive(Deserialize)]
 struct Current {
-    time: String,
     temperature_2m: f32,
     weather_code: u32,
 }
@@ -35,7 +36,7 @@ pub fn fetch_munich_weather_blocking() -> Result<WeatherSnapshot, WeatherError>
     Ok(WeatherSnapshot {
         temp_c: parsed.current.temperature_2m,
         condition: classify(parsed.current.weather_code),
-        fetched_at: parsed.current.time,
+        fetched_at: SystemTime::now(),
     })
 }