feat: add warning/critical thresholds to context window segment

[ekain-fr]

Summary

Extends threshold-based color and bold text support to the context window segment, matching the implementation from usage segments (5-hour/7-day). This provides visual feedback when context usage exceeds configurable warning and critical thresholds.

⚠️ Dependency

This PR depends on PR #41 and should not be merged until #41 is merged first.

• PR Fork enhancements: Usage segments with threshold styling and comprehensive improvements #41 introduces the color_utils module with serialize_ansi_color_to_json() helper
• This PR uses that helper function for threshold color serialization
• After Fork enhancements: Usage segments with threshold styling and comprehensive improvements #41 merges, this PR will need to be rebased onto master

Changes

Core Implementation

src/core/segments/context_window.rs:

• Add get_color_for_utilization() method
  • Checks utilization against warning_threshold (default 60%) and critical_threshold (default 80%)
  • Returns appropriate color override based on threshold level
• Add should_be_bold() method
  • Determines if text should be bold based on threshold configuration
  • Supports per-threshold bold flags (warning_bold, critical_bold)
• Integrate threshold logic into collect() method
  • Uses color_utils::serialize_ansi_color_to_json() from PR Fork enhancements: Usage segments with threshold styling and comprehensive improvements #41
  • Adds text_color_override and text_bold_override to metadata

TUI Integration

src/ui/app.rs, src/ui/components/settings.rs:

• Include ContextWindow in threshold segment checks
• Enables 6 threshold configuration fields in TUI:
  • Warning/Critical thresholds (percentage values)
  • Warning/Critical colors (16-color palette)
  • Warning/Critical bold flags (boolean)

Theme Configuration

All 9 theme files (theme_*.rs):

• Add threshold options to context_window_segment() functions
• Default configuration:
  • warning_threshold: 60%
  • critical_threshold: 80%
  • warning_color: c16=11 (bright yellow)
  • critical_color: c16=9 (bright red)
• Bold text behavior:
  • Cometix & Gruvbox themes: Both warning and critical use bold (warning_bold: true, critical_bold: true)
  • All other themes: Only critical uses bold (warning_bold: false, critical_bold: true)

Default Behavior

• Below 60%: Uses default segment colors (magenta/purple)
• 60-79% (Warning): Yellow text, normal weight (bold in Cometix/Gruvbox)
• 80%+ (Critical): Red text, bold weight

Testing

• ✅ Compiles successfully with cargo build --release
• ✅ All 9 themes updated consistently
• ✅ TUI configurator recognizes context window as threshold segment
• ✅ Threshold configuration fields appear in settings panel

Files Changed

12 files changed, 358 insertions(+), 13 deletions(-)

• src/core/segments/context_window.rs (+106 lines)
• src/ui/app.rs (1 line change)
• src/ui/components/settings.rs (1 line change)
• src/ui/themes/*.rs (9 files, +29 lines each for threshold configs)

Related

• Depends on: Fork enhancements: Usage segments with threshold styling and comprehensive improvements #41 (enhanced-usage-segments)
• Follows same pattern as Usage5Hour/Usage7Day threshold implementation

---

🤖 Generated with Claude Code

Co-Authored-By: Claude noreply@anthropic.com

Summary by Sourcery

Enable configurable warning and critical thresholds across context window and usage segments. This PR adds dynamic color and bold text overrides based on utilization, introduces dedicated 5-hour and 7-day usage segments sharing a unified API cache, centralizes color handling in a new utility module, and updates the TUI, theme presets, documentation, and status line rendering to support these features.

New Features:

• Add warning and critical utilization thresholds to ContextWindow segment for dynamic color and bold text overrides
• Introduce Usage5Hour and Usage7Day segments with shared API cache and threshold-based visual warnings
• Add color_utils module for ANSI color JSON serialization and ratatui color conversion

Enhancements:

• Extend TUI configurator to display and edit threshold options (warning/critical percentages, colors, bold flags) for usage and context window segments
• Update all built-in theme presets and segment configurations to include default warning/critical threshold settings
• Enhance preview component and status line generator to apply threshold-based color and bold overrides
• Add helper functions to format 5-hour and 7-day reset times and expose cache loading for usage segments

Documentation:

• Update README to document new usage segments and threshold-based color configuration
• Add CHANGELOG entry for version 1.0.9 detailing new segments and threshold features

[sourcery-ai]

Reviewer's Guide

This PR adds warning/critical threshold support across the context window and usage segments, integrating core evaluation methods, TUI controls, theme presets, new segment modules, shared color utilities, and updates to statusline, preview, configuration, and documentation.

Sequence diagram for TUI threshold configuration and preview update

sequenceDiagram
    actor User
    participant TUI_SettingsPanel
    participant App
    participant Config
    participant PreviewComponent
    User->>TUI_SettingsPanel: Select Usage5Hour/Usage7Day/ContextWindow segment
    TUI_SettingsPanel->>App: User changes threshold field (e.g., warning_threshold)
    App->>Config: Update segment.options with new threshold value
    App->>PreviewComponent: update_preview(&config)
    PreviewComponent->>Config: Read updated segment threshold options
    PreviewComponent->>PreviewComponent: get_threshold_color() for utilization
    PreviewComponent->>TUI_SettingsPanel: Display preview with color/bold override

Loading

Class diagram for new and updated usage segments with threshold logic

classDiagram
    class UsageSegment {
        +five_hour_utilization: f64
        +seven_day_utilization: f64
        +five_hour_resets_at: Option<String>
        +seven_day_resets_at: Option<String>
        +cached_at: String
        +get_circle_icon(utilization: f64) String
        +format_5hour_reset_time(reset_time_str: Option<&str>) String
        +format_7day_reset_time(reset_time_str: Option<&str>) String
        +load_usage_cache() Option<ApiUsageCache>
    }
    class Usage5HourSegment {
        +collect(input: &InputData) Option<SegmentData>
        +get_color_for_utilization(utilization: f64) Option<AnsiColor>
        +should_be_bold(utilization: f64) Option<bool>
    }
    class Usage7DaySegment {
        +collect(input: &InputData) Option<SegmentData>
        +get_color_for_utilization(utilization: f64) Option<AnsiColor>
        +should_be_bold(utilization: f64) Option<bool>
    }
    Usage5HourSegment ..> UsageSegment : uses cache and helpers
    Usage7DaySegment ..> UsageSegment : uses cache and helpers
    class ContextWindowSegment {
        +get_color_for_utilization(utilization: f64) Option<AnsiColor>
        +should_be_bold(utilization: f64) Option<bool>
        +collect(input: &InputData) Option<SegmentData>
    }
    class color_utils {
        +serialize_ansi_color_to_json(color: &AnsiColor) String
        +c16_to_ratatui_color(c16: u8) Color
        +ansi_color_to_ratatui(color: &AnsiColor) Color
    }
    Usage5HourSegment ..> color_utils : uses
    Usage7DaySegment ..> color_utils : uses
    ContextWindowSegment ..> color_utils : uses

Loading

File-Level Changes

Change	Details	Files
Threshold logic in context window segment	Add get_color_for_utilization and should_be_bold methods Inject text_color_override and text_bold_override in collect() via color_utils	src/core/segments/context_window.rs
TUI integration for threshold settings	Replace manual color mapping with ansi_color_to_ratatui helper Add threshold fields and bold flags in settings component Update app.rs navigation and event handlers for threshold, color and bold toggles Introduce new FieldSelection variants for thresholds	src/ui/components/settings.rs src/ui/app.rs src/ui/components/segment_list.rs
Theme presets and built-in themes updated	Extend context_window_segment options with threshold configs Add usage_5hour_segment and usage_7day_segment to all themes Update presets to include new usage segments	src/ui/themes/theme_*.rs src/ui/themes/presets.rs
New Usage5Hour and Usage7Day segment modules	Implement segments with shared cache load and threshold evaluation Expose time formatting and cache loader helpers in usage.rs	src/core/segments/usage_5hour.rs src/core/segments/usage_7day.rs src/core/segments/usage.rs
Color utilities module	Add serialize_ansi_color_to_json helper Add ansi_color_to_ratatui and c16_to_ratatui_color functions	src/core/segments/color_utils.rs
Statusline and preview apply threshold overrides	Parse and apply text_color_override/text_bold_override in statusline Add get_threshold_color and mock preview entries for new usage segments	src/core/statusline.rs src/ui/components/preview.rs
Configuration and documentation updates	Extend SegmentId enum and bump crate version Update README with usage segment and threshold docs Add 1.0.9 entry in CHANGELOG	Cargo.toml src/config/types.rs README.md CHANGELOG.md

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[sourcery-ai]

Hey there - I've reviewed your changes - here's some feedback:

• There’s significant duplication in the threshold logic across ContextWindowSegment, Usage5HourSegment, and Usage7DaySegment—consider extracting a shared helper or trait for get_color_for_utilization and should_be_bold to DRY up the code.
• You’re calling Config::load() on every threshold check, which could be expensive; think about caching the loaded config or injecting it into the segments so you don’t reload from disk on each call.

Prompt for AI Agents

Please address the comments from this code review:

## Overall Comments
- There’s significant duplication in the threshold logic across ContextWindowSegment, Usage5HourSegment, and Usage7DaySegment—consider extracting a shared helper or trait for get_color_for_utilization and should_be_bold to DRY up the code.
- You’re calling Config::load() on every threshold check, which could be expensive; think about caching the loaded config or injecting it into the segments so you don’t reload from disk on each call.

## Individual Comments

### Comment 1
<location> `src/core/segments/usage.rs:95` </location>
<code_context>
+    }
+
+    /// Format 7-day reset time as "Oct 9, 5am"
+    pub fn format_7day_reset_time(reset_time_str: Option<&str>) -> String {
+        if let Some(time_str) = reset_time_str {
+            if let Ok(dt) = DateTime::parse_from_rfc3339(time_str) {
</code_context>

<issue_to_address>
**suggestion:** Date formatting for 7-day reset time may produce ambiguous output.

Consider replacing the colon with a comma to avoid confusion, e.g., "Oct 9, 5am".

Suggested implementation:

```rust
                let hour = local_dt.hour();
                let (hour_12, period) = if hour == 0 {
                    (12, "am")
                } else if hour < 12 {
                    (hour, "am")

```

```rust
                // Format as "Oct 9, 5am"
                return format!(
                    "{} {}, {}{}",
                    local_dt.format("%b"),
                    local_dt.day(),
                    hour_12,
                    period
                );

```
</issue_to_address>

### Comment 2
<location> `src/core/segments/context_window.rs:22` </location>
<code_context>
         model_config.get_context_limit(model_id)
     }
+
+    fn get_color_for_utilization(&self, utilization: f64) -> Option<AnsiColor> {
+        // Load config to get threshold settings
+        let config = Config::load().ok()?;
</code_context>

<issue_to_address>
**suggestion:** get_color_for_utilization and should_be_bold duplicate logic found in usage_5hour and usage_7day.

Refactor the threshold logic into a shared helper to eliminate duplication and enhance maintainability.

Suggested implementation:

```rust
    /// Helper to get warning and critical thresholds for a segment
    fn get_thresholds_for_segment(segment_id: SegmentId) -> Option<(f64, f64)> {
        let config = Config::load().ok()?;
        let segment_config = config.segments.iter().find(|s| s.id == segment_id)?;
        let warning_threshold = segment_config
            .options
            .get("warning_threshold")
            .and_then(|v| v.as_u64())
            .unwrap_or(60) as f64;
        let critical_threshold = segment_config
            .options
            .get("critical_threshold")
            .and_then(|v| v.as_u64())
            .unwrap_or(80) as f64;
        Some((warning_threshold, critical_threshold))
    }

    fn get_color_for_utilization(&self, utilization: f64) -> Option<AnsiColor> {
        let (warning_threshold, critical_threshold) = Self::get_thresholds_for_segment(SegmentId::ContextWindow)?;

```

```rust
        if utilization >= critical_threshold {
            Some(AnsiColor::Red)
        } else if utilization >= warning_threshold {
            Some(AnsiColor::Yellow)
        } else {
            Some(AnsiColor::Green)
        }
    }

```

```rust
    fn should_be_bold(&self, utilization: f64) -> bool {
        let (_, critical_threshold) = Self::get_thresholds_for_segment(SegmentId::ContextWindow)?;
        utilization >= critical_threshold
    }

```

You will also need to refactor the threshold logic in `usage_5hour` and `usage_7day` to use the new `get_thresholds_for_segment` helper. Replace any duplicated config/threshold extraction with calls to this helper, passing the appropriate `SegmentId`.
</issue_to_address>

### Comment 3
<location> `src/ui/app.rs:471-472` </location>
<code_context>
+                    .map(|s| matches!(s.id, crate::config::SegmentId::Usage5Hour | crate::config::SegmentId::Usage7Day | crate::config::SegmentId::ContextWindow))
+                    .unwrap_or(false);
+
+                let field_count = if is_usage_segment {
+                    13 // Enabled, Icon, IconColor, TextColor, BackgroundColor, TextStyle, WarningThreshold, CriticalThreshold, WarningColor, CriticalColor, WarningBold, CriticalBold, Options
+                } else {
+                    7 // Enabled, Icon, IconColor, TextColor, BackgroundColor, TextStyle, Options
</code_context>

<issue_to_address>
**suggestion:** Field count for usage segments is hardcoded; consider using a constant or deriving from enum.

Using a hardcoded value increases the risk of errors if the enum changes. Please use a constant or derive the count directly from the FieldSelection enum to ensure consistency.

Suggested implementation:

```rust
                // Use constants for field counts to avoid hardcoding
                const USAGE_SEGMENT_FIELD_COUNT: usize = {
                    // If FieldSelection is an enum with EnumIter, filter for usage fields
                    use crate::config::FieldSelection;
                    FieldSelection::iter()
                        .filter(|f| matches!(
                            f,
                            FieldSelection::Enabled
                                | FieldSelection::Icon
                                | FieldSelection::IconColor
                                | FieldSelection::TextColor
                                | FieldSelection::BackgroundColor
                                | FieldSelection::TextStyle
                                | FieldSelection::WarningThreshold
                                | FieldSelection::CriticalThreshold
                                | FieldSelection::WarningColor
                                | FieldSelection::CriticalColor
                                | FieldSelection::WarningBold
                                | FieldSelection::CriticalBold
                                | FieldSelection::Options
                        ))
                        .count()
                };

                const DEFAULT_SEGMENT_FIELD_COUNT: usize = {
                    use crate::config::FieldSelection;
                    FieldSelection::iter()
                        .filter(|f| matches!(
                            f,
                            FieldSelection::Enabled
                                | FieldSelection::Icon
                                | FieldSelection::IconColor
                                | FieldSelection::TextColor
                                | FieldSelection::BackgroundColor
                                | FieldSelection::TextStyle
                                | FieldSelection::Options
                        ))
                        .count()
                };

                let field_count = if is_usage_segment {
                    USAGE_SEGMENT_FIELD_COUNT
                } else {
                    DEFAULT_SEGMENT_FIELD_COUNT
                };

```

1. This change assumes that `FieldSelection` is an enum and derives `EnumIter` from the `strum` crate. If not, you will need to add `#[derive(EnumIter)]` to the enum and add `strum = "0.24"` (or similar) to your Cargo.toml.
2. You may need to import `strum::IntoEnumIterator` and `crate::config::FieldSelection` at the top of the file.
3. If you do not want to use `strum`, you can define the constants manually, but this will not automatically update if the enum changes.
</issue_to_address>

### Comment 4
<location> `src/ui/app.rs:719-464` </location>
<code_context>
                 FieldSelection::IconColor => segment.colors.icon = Some(color),
                 FieldSelection::TextColor => segment.colors.text = Some(color),
                 FieldSelection::BackgroundColor => segment.colors.background = Some(color),
+                FieldSelection::WarningColor => {
+                    // Store warning color in options using shared helper
+                    let color_json: serde_json::Value = serde_json::from_str(&color_utils::serialize_ansi_color_to_json(&color)).unwrap();
+                    segment.options.insert("warning_color".to_string(), color_json);
+                }
+                FieldSelection::CriticalColor => {
+                    // Store critical color in options using shared helper
</code_context>

<issue_to_address>
**issue (bug_risk):** Color picker serialization/deserialization may panic if color_utils returns invalid JSON.

Using unwrap here may cause a panic if serialize_ansi_color_to_json ever returns invalid JSON. Consider handling the error or using from_value for safer deserialization.
</issue_to_address>

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}