refactor: apply PR #108 sub-field boilerplate refactor and remove unused HasThresholdStyle impls

- Merged CostSubfieldConfig and ContextWindowSubfieldConfig into a unified
  SubfieldConfig struct with #[cfg(test)] type aliases for backward compat.
- Added HasThresholdStyle trait and impl_has_threshold_style! macro to config.rs;
  only ContextWindowConfig gets an impl (the three unused CostConfig,
  ContextBarConfig, UsageLimitsConfig impls are intentionally absent per Story 3.1).
- Added render_styled_value() to format.rs with six unit tests covering all paths
  (format, threshold, invert_threshold, parent fallback, no-sub/no-parent).
- Replaced all inline threshold/style boilerplate in cost.rs (5 functions) and
  context_window.rs (8 functions) with render_styled_value() calls.
- cargo build, cargo test (65/65), and cargo clippy -- -D warnings all exit 0.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: stephenleo

src/config.rs

@@ -48,34 +48,18 @@ pub struct CostConfig {
     pub critical_style: Option<String>,
     pub format: Option<String>,
     // Sub-field per-display configs (map to [cship.cost.total_cost_usd] etc.)
-    pub total_cost_usd: Option<CostSubfieldConfig>,
-    pub total_duration_ms: Option<CostSubfieldConfig>,
-    pub total_api_duration_ms: Option<CostSubfieldConfig>,
-    pub total_lines_added: Option<CostSubfieldConfig>,
-    pub total_lines_removed: Option<CostSubfieldConfig>,
+    pub total_cost_usd: Option<SubfieldConfig>,
+    pub total_duration_ms: Option<SubfieldConfig>,
+    pub total_api_duration_ms: Option<SubfieldConfig>,
+    pub total_lines_added: Option<SubfieldConfig>,
+    pub total_lines_removed: Option<SubfieldConfig>,
 }
 
-/// Configuration for individual `[cship.cost.*]` sub-field modules.
+/// Unified configuration for individual sub-field modules
+/// (e.g. `[cship.cost.total_cost_usd]`, `[cship.context_window.used_percentage]`).
 #[derive(Debug, Deserialize, Default)]
-pub struct CostSubfieldConfig {
+pub struct SubfieldConfig {
     pub style: Option<String>,
-    /// Reserved — not yet rendered; included for config schema consistency.
-    pub symbol: Option<String>,
-    pub disabled: Option<bool>,
-    /// Reserved — not yet rendered; included for config schema consistency.
-    pub label: Option<String>,
-    pub warn_threshold: Option<f64>,
-    pub warn_style: Option<String>,
-    pub critical_threshold: Option<f64>,
-    pub critical_style: Option<String>,
-    pub format: Option<String>,
-}
-
-/// Configuration for individual `[cship.context_window.*]` sub-field modules.
-#[derive(Debug, Deserialize, Default)]
-pub struct ContextWindowSubfieldConfig {
-    pub style: Option<String>,
-    /// Used only in the format path (via `$symbol`); ignored in the default render path.
     pub symbol: Option<String>,
     pub disabled: Option<bool>,
     pub warn_threshold: Option<f64>,
@@ -97,6 +81,55 @@ pub struct ContextWindowSubfieldConfig {
     pub invert_threshold: Option<bool>,
 }
 
+/// Backwards-compatible type aliases (used by test code).
+#[cfg(test)]
+pub type CostSubfieldConfig = SubfieldConfig;
+#[cfg(test)]
+pub type ContextWindowSubfieldConfig = SubfieldConfig;
+
+/// Trait for uniform access to style/threshold fields shared by config types.
+/// Used by `render_styled_value()` to resolve sub-field → parent fallback.
+///
+/// `format_str()` and `symbol_str()` default to `None`. Only parent configs
+/// whose sub-fields should inherit format/symbol (i.e., `ContextWindowConfig`)
+/// override these.
+pub trait HasThresholdStyle {
+    fn style(&self) -> Option<&str>;
+    fn warn_threshold(&self) -> Option<f64>;
+    fn warn_style(&self) -> Option<&str>;
+    fn critical_threshold(&self) -> Option<f64>;
+    fn critical_style(&self) -> Option<&str>;
+    fn format_str(&self) -> Option<&str> {
+        None
+    }
+    fn symbol_str(&self) -> Option<&str> {
+        None
+    }
+}
+
+#[allow(unused_macros)]
+macro_rules! impl_has_threshold_style {
+    ($t:ty) => {
+        impl HasThresholdStyle for $t {
+            fn style(&self) -> Option<&str> {
+                self.style.as_deref()
+            }
+            fn warn_threshold(&self) -> Option<f64> {
+                self.warn_threshold
+            }
+            fn warn_style(&self) -> Option<&str> {
+                self.warn_style.as_deref()
+            }
+            fn critical_threshold(&self) -> Option<f64> {
+                self.critical_threshold
+            }
+            fn critical_style(&self) -> Option<&str> {
+                self.critical_style.as_deref()
+            }
+        }
+    };
+}
+
 /// Configuration for `[cship.context_bar]` — visual progress bar with thresholds.
 /// Implemented in Story 2.2. Defined here so all Epic 2 config is available.
 #[derive(Debug, Deserialize, Default)]
@@ -127,16 +160,40 @@ pub struct ContextWindowConfig {
     pub critical_style: Option<String>,
     pub format: Option<String>,
     // Per-sub-field configs (map to [cship.context_window.used_percentage] etc.)
-    pub used_percentage: Option<ContextWindowSubfieldConfig>,
-    pub remaining_percentage: Option<ContextWindowSubfieldConfig>,
-    pub size: Option<ContextWindowSubfieldConfig>,
-    pub total_input_tokens: Option<ContextWindowSubfieldConfig>,
-    pub total_output_tokens: Option<ContextWindowSubfieldConfig>,
-    pub current_usage_input_tokens: Option<ContextWindowSubfieldConfig>,
-    pub current_usage_output_tokens: Option<ContextWindowSubfieldConfig>,
-    pub current_usage_cache_creation_input_tokens: Option<ContextWindowSubfieldConfig>,
-    pub current_usage_cache_read_input_tokens: Option<ContextWindowSubfieldConfig>,
-    pub used_tokens: Option<ContextWindowSubfieldConfig>,
+    pub used_percentage: Option<SubfieldConfig>,
+    pub remaining_percentage: Option<SubfieldConfig>,
+    pub size: Option<SubfieldConfig>,
+    pub total_input_tokens: Option<SubfieldConfig>,
+    pub total_output_tokens: Option<SubfieldConfig>,
+    pub current_usage_input_tokens: Option<SubfieldConfig>,
+    pub current_usage_output_tokens: Option<SubfieldConfig>,
+    pub current_usage_cache_creation_input_tokens: Option<SubfieldConfig>,
+    pub current_usage_cache_read_input_tokens: Option<SubfieldConfig>,
+    pub used_tokens: Option<SubfieldConfig>,
+}
+
+impl HasThresholdStyle for ContextWindowConfig {
+    fn style(&self) -> Option<&str> {
+        self.style.as_deref()
+    }
+    fn warn_threshold(&self) -> Option<f64> {
+        self.warn_threshold
+    }
+    fn warn_style(&self) -> Option<&str> {
+        self.warn_style.as_deref()
+    }
+    fn critical_threshold(&self) -> Option<f64> {
+        self.critical_threshold
+    }
+    fn critical_style(&self) -> Option<&str> {
+        self.critical_style.as_deref()
+    }
+    fn format_str(&self) -> Option<&str> {
+        self.format.as_deref()
+    }
+    fn symbol_str(&self) -> Option<&str> {
+        self.symbol.as_deref()
+    }
 }
 
 /// Configuration for `[cship.vim]` — vim mode display.

src/format.rs

@@ -10,6 +10,76 @@
 //!
 //! Source: architecture.md#Core Architectural Decisions, epics.md#Story 2.5
 
+/// Centralized style/threshold/format rendering for sub-field render functions.
+///
+/// Resolves style, thresholds, and format strings using sub-field → parent fallback,
+/// handling `invert_threshold` for decreasing-health indicators (e.g. remaining_percentage).
+///
+/// # Arguments
+/// - `val_str`: Already-formatted display string (e.g. `"85"`, `"0.0123"`)
+/// - `threshold_val`: Numeric value for threshold comparison; `None` for non-threshold fields
+/// - `sub_cfg`: The sub-field's own `SubfieldConfig` (may be `None`)
+/// - `parent`: Parent config implementing `HasThresholdStyle` for fallback (may be `None`)
+///
+/// # Returns
+/// `None` when the format path renders empty (conditional group with absent `$value`).
+/// `Some(styled_string)` otherwise.
+pub fn render_styled_value(
+    val_str: &str,
+    threshold_val: Option<f64>,
+    sub_cfg: Option<&crate::config::SubfieldConfig>,
+    parent: Option<&dyn crate::config::HasThresholdStyle>,
+) -> Option<String> {
+    // Resolve all fields with sub → parent fallback
+    let style = sub_cfg
+        .and_then(|c| c.style.as_deref())
+        .or_else(|| parent.and_then(|p| p.style()));
+    let mut effective_val = threshold_val;
+    let mut warn_threshold = sub_cfg
+        .and_then(|c| c.warn_threshold)
+        .or_else(|| parent.and_then(|p| p.warn_threshold()));
+    let mut warn_style = sub_cfg
+        .and_then(|c| c.warn_style.as_deref())
+        .or_else(|| parent.and_then(|p| p.warn_style()));
+    let mut critical_threshold = sub_cfg
+        .and_then(|c| c.critical_threshold)
+        .or_else(|| parent.and_then(|p| p.critical_threshold()));
+    let mut critical_style = sub_cfg
+        .and_then(|c| c.critical_style.as_deref())
+        .or_else(|| parent.and_then(|p| p.critical_style()));
+
+    // Inverted thresholds: use sub-only values (negated) and negate the comparison value.
+    // Parent thresholds are in the non-inverted domain and must not be inherited.
+    if sub_cfg.and_then(|c| c.invert_threshold).unwrap_or(false) {
+        effective_val = threshold_val.map(|v| -v);
+        warn_threshold = sub_cfg.and_then(|c| c.warn_threshold).map(|t| -t);
+        warn_style = sub_cfg.and_then(|c| c.warn_style.as_deref());
+        critical_threshold = sub_cfg.and_then(|c| c.critical_threshold).map(|t| -t);
+        critical_style = sub_cfg.and_then(|c| c.critical_style.as_deref());
+    }
+
+    // Format path: resolve symbol, threshold style, then apply format
+    let fmt = sub_cfg
+        .and_then(|c| c.format.as_deref())
+        .or_else(|| parent.and_then(|p| p.format_str()));
+    if let Some(fmt) = fmt {
+        let symbol = sub_cfg
+            .and_then(|c| c.symbol.as_deref())
+            .or_else(|| parent.and_then(|p| p.symbol_str()));
+        let effective_style = crate::ansi::resolve_threshold_style(
+            effective_val, style, warn_threshold, warn_style,
+            critical_threshold, critical_style,
+        );
+        return apply_module_format(fmt, Some(val_str), symbol, effective_style);
+    }
+
+    // Default path: apply_style_with_threshold handles no-threshold gracefully
+    Some(crate::ansi::apply_style_with_threshold(
+        val_str, effective_val, style, warn_threshold, warn_style,
+        critical_threshold, critical_style,
+    ))
+}
+
 /// Apply a per-module format string.
 ///
 /// # Arguments
@@ -150,6 +220,91 @@ fn find_matching_close(s: &str, start: usize, open: char, close: char) -> Option
 mod tests {
     use super::*;
 
+    // --- render_styled_value tests ---
+
+    #[test]
+    fn test_render_styled_value_with_format_string() {
+        let sub = crate::config::SubfieldConfig {
+            format: Some("[$value]($style)".to_string()),
+            style: Some("bold green".to_string()),
+            ..Default::default()
+        };
+        let result = render_styled_value("85", Some(85.0), Some(&sub), None);
+        let s = result.unwrap();
+        assert!(s.contains("85"), "value present: {s:?}");
+        assert!(s.contains('\x1b'), "ANSI codes present: {s:?}");
+    }
+
+    #[test]
+    fn test_render_styled_value_no_format_threshold_above_warn() {
+        let sub = crate::config::SubfieldConfig {
+            warn_threshold: Some(50.0),
+            warn_style: Some("yellow".to_string()),
+            critical_threshold: Some(90.0),
+            critical_style: Some("bold red".to_string()),
+            ..Default::default()
+        };
+        let result = render_styled_value("75", Some(75.0), Some(&sub), None);
+        let s = result.unwrap();
+        assert!(s.contains("75"), "value present: {s:?}");
+        assert!(s.contains('\x1b'), "ANSI codes for warn style: {s:?}");
+    }
+
+    #[test]
+    fn test_render_styled_value_no_format_no_threshold() {
+        let sub = crate::config::SubfieldConfig {
+            style: Some("cyan".to_string()),
+            ..Default::default()
+        };
+        let result = render_styled_value("hello", None, Some(&sub), None);
+        let s = result.unwrap();
+        assert!(s.contains("hello"), "value present: {s:?}");
+        assert!(s.contains('\x1b'), "ANSI codes for base style: {s:?}");
+    }
+
+    #[test]
+    fn test_render_styled_value_invert_threshold() {
+        // invert_threshold: value 20 with warn_threshold 30 → inverted: -20 >= -30 → warn fires
+        let sub = crate::config::SubfieldConfig {
+            invert_threshold: Some(true),
+            warn_threshold: Some(30.0),
+            warn_style: Some("yellow".to_string()),
+            critical_threshold: Some(10.0),
+            critical_style: Some("bold red".to_string()),
+            ..Default::default()
+        };
+        let result = render_styled_value("20", Some(20.0), Some(&sub), None);
+        let s = result.unwrap();
+        assert!(s.contains("20"), "value present: {s:?}");
+        assert!(s.contains('\x1b'), "ANSI codes for inverted warn: {s:?}");
+    }
+
+    #[test]
+    fn test_render_styled_value_parent_fallback_style() {
+        let sub = crate::config::SubfieldConfig {
+            ..Default::default()
+        };
+        let parent = crate::config::ContextWindowConfig {
+            style: Some("bold magenta".to_string()),
+            ..Default::default()
+        };
+        let result = render_styled_value(
+            "42",
+            None,
+            Some(&sub),
+            Some(&parent as &dyn crate::config::HasThresholdStyle),
+        );
+        let s = result.unwrap();
+        assert!(s.contains("42"), "value present: {s:?}");
+        assert!(s.contains('\x1b'), "ANSI codes from parent style: {s:?}");
+    }
+
+    #[test]
+    fn test_render_styled_value_no_sub_no_parent() {
+        let result = render_styled_value("plain", None, None, None);
+        assert_eq!(result, Some("plain".to_string()));
+    }
+
     #[test]
     fn test_dollar_value_substituted() {
         let result = apply_module_format("$value", Some("35"), None, None);