feat: add --no-optional-locks flag to all git commands

[ekain-fr]

Summary

Fixes #46

Adds the --no-optional-locks flag to all git command invocations in the Git segment to prevent creation of .git/index.lock files during statusline operations. This eliminates potential conflicts with concurrent user git operations.

Changes

• Added --no-optional-locks to is_git_repository() - git rev-parse command
• Added --no-optional-locks to get_branch() - git branch and git symbolic-ref commands
• Added --no-optional-locks to get_status() - git status command (most critical)
• Added --no-optional-locks to get_commit_count() - git rev-list command
• Added --no-optional-locks to get_sha() - git rev-parse command

Benefits

• Prevents git from creating optional lock files during read-only operations
• Eliminates potential conflicts when users run git commands while statusline is updating
• No performance impact - these operations remain read-only
• Compatible with Git 2.15+ (widely available since 2017)

Test plan

• Built successfully with cargo build
• Test in active git repository with concurrent git operations
• Verify statusline continues to work correctly
• Verify no .git/index.lock files are created during statusline updates

🤖 Generated with Claude Code

Summary by Sourcery

Add --no-optional-locks to all Git invocations to prevent lock file creation and introduce two new focused usage segments with dynamic threshold‐based coloring and styling. Update TUI components, themes, and core utilities to support new Usage5Hour and Usage7Day segments, threshold configuration, Git segment options (show SHA and dirty count), and unified color conversion. Bump version to 1.0.9 and refresh documentation and changelog accordingly.

New Features:

• Add --no-optional-locks flag to all Git command calls to avoid creating .git/index.lock
• Introduce Usage5Hour and Usage7Day segments for specialized 5-hour and 7-day API usage monitoring
• Implement threshold-based warning and critical color and bold overrides for usage and context window segments
• Add Git segment options to toggle SHA and dirty-count display

Enhancements:

• Refactor TUI settings and app logic to display new segment fields and Git options
• Create color_utils and threshold_utils modules for consistent color conversion and threshold evaluation
• Extend credential loader to prefer CLAUDE_CONFIG_DIR and fallback to default credentials path
• Update all built-in theme presets to include new usage segments with default threshold options

Documentation:

• Bump version to 1.0.9
• Update README with instructions for new usage segments and forked rebuild process
• Refresh CHANGELOG with new features and segment changes

Chores:

• Add install.sh script for simplified build and installation

[sourcery-ai]

Reviewer's Guide

This pull request enhances Git segment stability by adding --no-optional-locks to all underlying Git invocations and introducing dirty-file counts, and expands usage monitoring with two new specialized segments (5-hour and 7-day) that share a common API cache and support threshold-based warning/critical coloring. It adds reusable threshold_utils and color_utils modules, updates the status-line renderer to honor metadata overrides, integrates the new options into the TUI, updates all built-in themes and presets, bumps the package version, and refreshes documentation and install scripts.

ER diagram for updated ApiUsageCache structure

erDiagram
    API_USAGE_CACHE {
        five_hour_utilization float
        seven_day_utilization float
        five_hour_resets_at varchar
        seven_day_resets_at varchar
        cached_at varchar
    }

Loading

Class diagram for new and updated Usage segments

classDiagram
    class UsageSegment {
        +load_usage_cache() Option<ApiUsageCache>
        +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
    }
    class Usage5HourSegment {
        +collect(input: &InputData) Option<SegmentData>
        +new() Usage5HourSegment
    }
    class Usage7DaySegment {
        +collect(input: &InputData) Option<SegmentData>
        +new() Usage7DaySegment
    }
    class ApiUsageCache {
        +five_hour_utilization: f64
        +seven_day_utilization: f64
        +five_hour_resets_at: Option<String>
        +seven_day_resets_at: Option<String>
        +cached_at: String
    }
    Usage5HourSegment ..> UsageSegment : uses
    Usage7DaySegment ..> UsageSegment : uses
    UsageSegment --> ApiUsageCache : cache
    Usage5HourSegment --> ApiUsageCache : reads
    Usage7DaySegment --> ApiUsageCache : reads

Loading

Class diagram for updated Git segment with dirty count

classDiagram
    class GitSegment {
        +show_sha: bool
        +show_dirty_count: bool
        +new() GitSegment
        +with_sha(show_sha: bool) GitSegment
        +with_dirty_count(show_dirty_count: bool) GitSegment
        +get_git_info(working_dir: &str) Option<GitInfo>
        +is_git_repository(working_dir: &str) bool
        +get_branch(working_dir: &str) Option<String>
        +get_status(working_dir: &str) (GitStatus, u32)
        +get_commit_count(working_dir: &str, range: &str) u32
        +get_sha(working_dir: &str) Option<String>
    }
    class GitInfo {
        +branch: String
        +status: GitStatus
        +ahead: u32
        +behind: u32
        +sha: Option<String>
        +dirty_count: u32
    }
    GitSegment --> GitInfo : returns

Loading

Class diagram for threshold_utils and color_utils modules

classDiagram
    class threshold_utils {
        +get_thresholds_for_segment(segment_id: SegmentId) Option<(f64, f64)>
        +get_color_for_utilization(segment_id: SegmentId, utilization: f64) Option<AnsiColor>
        +should_be_bold(segment_id: SegmentId, utilization: f64) Option<bool>
        +invalidate_config_cache()
    }
    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
    }

Loading

File-Level Changes

Change	Details	Files
Enhance GitSegment with no-locks support and dirty-file counts	Prepend --no-optional-locks to all Git command invocations Extend get_status to return and count dirty files Add dirty_count field and show_dirty_count option to GitSegment Propagate dirty count through GitInfo, metadata, and toggles	src/core/segments/git.rs src/config/types.rs src/core/statusline.rs
Restructure usage cache and add two new usage segments	Split cache into separate 5-hour and 7-day reset timestamps Expose load_usage_cache and format helpers for reset times Implement Usage5HourSegment and Usage7DaySegment using shared cache	src/core/segments/usage.rs src/core/segments/usage_5hour.rs src/core/segments/usage_7day.rs src/core/segments/mod.rs
Introduce threshold and color utilities for dynamic coloring	Add threshold_utils to load config thresholds and decide overrides Add color_utils to serialize and convert AnsiColor values Update ContextWindow and usage segments to insert color and bold overrides Modify status-line rendering to honor text_color_override and text_bold_override metadata	src/core/segments/threshold_utils.rs src/core/segments/color_utils.rs src/core/segments/context_window.rs src/core/statusline.rs
Extend TUI components for new segments and options	Add threshold fields (warning/critical thresholds, colors, bold) to settings view Support ShowSha and ShowDirtyCount toggles in segment list and navigation Integrate new segments into preview mock data and rendering	src/ui/components/settings.rs src/ui/app.rs src/ui/components/segment_list.rs src/ui/components/preview.rs
Update themes, presets, docs, version, and install scripts	Add usage_5hour and usage_7day presets to all built-in theme modules Bump version to 1.0.9 and update README.md and CHANGELOG.md Add install.sh script and enhance credentials lookup logic	src/ui/themes/ src/ui/themes/presets.rs Cargo.toml README.md CHANGELOG.md install.sh src/utils/credentials.rs

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#46	Prevent creation of .git/index.lock files during statusline operations by ensuring all git commands invoked by the Git segment use the --no-optional-locks flag.	✅

Possibly linked issues

• Problem with .git/index.lock in Claude Code #46: The PR adds the --no-optional-locks flag to various git commands to prevent the .git/index.lock file issue, directly resolving the problem described in the issue.

---

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 a lot of duplicated theme code for the new usage segments across all theme files—consider extracting a helper or macro so you don’t have to copy/paste the same logic nine times.
• The new threshold_utils reads and caches the on-disk config, which won’t reflect changes made in the interactive TUI’s in-memory Config; consider feeding the live config into your threshold logic instead of using a static file cache.
• Mapping every FieldSelection variant to hardcoded indices in App is getting brittle—think about driving that from a data structure or generating it so you avoid off-by-one errors as you add more options.

Prompt for AI Agents

Please address the comments from this code review:

## Overall Comments
- There’s a lot of duplicated theme code for the new usage segments across all theme files—consider extracting a helper or macro so you don’t have to copy/paste the same logic nine times.
- The new threshold_utils reads and caches the on-disk config, which won’t reflect changes made in the interactive TUI’s in-memory Config; consider feeding the live config into your threshold logic instead of using a static file cache.
- Mapping every FieldSelection variant to hardcoded indices in App is getting brittle—think about driving that from a data structure or generating it so you avoid off-by-one errors as you add more options.

## Individual Comments

### Comment 1
<location> `src/core/segments/color_utils.rs:5` </location>
<code_context>
+use ratatui::style::Color;
+
+/// Serializes an AnsiColor to a JSON string for metadata storage
+pub fn serialize_ansi_color_to_json(color: &AnsiColor) -> String {
+    match color {
+        AnsiColor::Color256 { c256 } => {
</code_context>

<issue_to_address>
**suggestion (performance):** Serializing color to JSON string may be less efficient than storing as Value.

If possible, store the color directly as a serde_json::Value in metadata to reduce parsing overhead and simplify the code.

Suggested implementation:

```rust
/// Serializes an AnsiColor to a serde_json::Value for metadata storage
pub fn serialize_ansi_color_to_json_value(color: &AnsiColor) -> serde_json::Value {
    match color {
        AnsiColor::Color256 { c256 } => {
            serde_json::json!({"c256": c256})
        }
        AnsiColor::Color16 { c16 } => {
            serde_json::json!({"c16": c16})
        }
        AnsiColor::Rgb { r, g, b } => {
            serde_json::json!({"r": r, "g": g, "b": b})
        }
    }
}

```

- You will need to update any code that calls `serialize_ansi_color_to_json` to use the new function name `serialize_ansi_color_to_json_value` and handle a `serde_json::Value` instead of a `String`.
- If you use this value in metadata, ensure the metadata field expects a `serde_json::Value`.
</issue_to_address>

### Comment 2
<location> `src/core/segments/git.rs:124` </location>
<code_context>
             Ok(output) if output.status.success() => {
                 let status_text = String::from_utf8(output.stdout).unwrap_or_default();

</code_context>

<issue_to_address>
**suggestion:** Parsing git status output may miss edge cases for dirty files.

Consider filtering lines by status code or using --untracked-files=normal to ensure only relevant dirty files are counted.

Suggested implementation:

```rust
        let output = Command::new("git")
            .args([
                "--no-optional-locks",
                "status",
                "--porcelain",
                "--untracked-files=normal",
            ])
            .current_dir(working_dir)
            .output();

```

```rust
                 let status_text = String::from_utf8(output.stdout).unwrap_or_default();

```

```rust
                 // Count dirty files by filtering lines with relevant status codes
                 let dirty_count = status_text
                     .lines()
                     .filter(|line| {
                         // Porcelain format: first two chars are status codes
                         // Untracked files: "??", others: any non-space in first or second char
                         line.len() >= 2 && (line.starts_with("??") || line[..2].chars().any(|c| c != ' '))
                     })
                     .count() as u32;

```

You will need to use `dirty_count` in place of any previous dirty file counting logic in the rest of the function. If the function currently returns a dirty count, update the return statement to use this new `dirty_count` variable.
</issue_to_address>

### Comment 3
<location> `src/core/segments/usage.rs:36` </location>
<code_context>
         Self
     }

-    fn get_circle_icon(utilization: f64) -> String {
+    pub fn get_circle_icon(utilization: f64) -> String {
         let percent = (utilization * 100.0) as u8;
</code_context>

<issue_to_address>
**nitpick:** get_circle_icon's percent calculation may round down for values near boundaries.

Using .round() before casting will improve accuracy for icon selection.
</issue_to_address>

### Comment 4
<location> `src/core/segments/usage_5hour.rs:20-27` </location>
<code_context>
+        let reset_time = UsageSegment::format_5hour_reset_time(cache.five_hour_resets_at.as_deref());
+
+        // Convert percentage (0-100) to normalized value (0-1) for get_circle_icon
+        let dynamic_icon = UsageSegment::get_circle_icon(five_hour_util / 100.0);
+
+        let five_hour_percent = five_hour_util.round() as u8;
</code_context>

<issue_to_address>
**suggestion:** Division by 100.0 assumes API always returns 0-100.

Clamping or validating the input before division will prevent incorrect icon selection if the API returns unexpected values.

```suggestion
        // Note: five_hour_utilization is a percentage (0-100) from the API
        let five_hour_util = cache.five_hour_utilization;
        let reset_time = UsageSegment::format_5hour_reset_time(cache.five_hour_resets_at.as_deref());

        // Clamp the value to [0.0, 100.0] to prevent incorrect icon selection
        let clamped_util = five_hour_util.clamp(0.0, 100.0);

        // Convert percentage (0-100) to normalized value (0-1) for get_circle_icon
        let dynamic_icon = UsageSegment::get_circle_icon(clamped_util / 100.0);

        let five_hour_percent = clamped_util.round() as u8;
```
</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.}

[sourcery-ai]

suggestion: Parsing git status output may miss edge cases for dirty files.

Consider filtering lines by status code or using --untracked-files=normal to ensure only relevant dirty files are counted.

Suggested implementation:

        let output = Command::new("git")
            .args([
                "--no-optional-locks",
                "status",
                "--porcelain",
                "--untracked-files=normal",
            ])
            .current_dir(working_dir)
            .output();

                 let status_text = String::from_utf8(output.stdout).unwrap_or_default();

                 // Count dirty files by filtering lines with relevant status codes
                 let dirty_count = status_text
                     .lines()
                     .filter(|line| {
                         // Porcelain format: first two chars are status codes
                         // Untracked files: "??", others: any non-space in first or second char
                         line.len() >= 2 && (line.starts_with("??") || line[..2].chars().any(|c| c != ' '))
                     })
                     .count() as u32;

You will need to use dirty_count in place of any previous dirty file counting logic in the rest of the function. If the function currently returns a dirty count, update the return statement to use this new dirty_count variable.

[sourcery-ai]

nitpick: get_circle_icon's percent calculation may round down for values near boundaries.

Using .round() before casting will improve accuracy for icon selection.