eazygit 0.2.0

A fast TUI for Git with staging, conflicts, rebase, and palette-first UX
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

# MM Status (Staged + Unstaged) Verification

## Git Status Output
From `git status --porcelain=v2`, we have **9 files with MM status** (both staged and unstaged):
1. `src/app/actions.rs`
2. `src/app/event_loop.rs`
3. `src/app/reducer.rs`
4. `src/app/reducers/status_reducer.rs`
5. `src/app/state.rs`
6. `src/components/manager/mod.rs`
7. `src/palette/command.rs`
8. `src/palette/handler.rs`
9. `src/palette/registry.rs`

## Verification Checklist

### ✅ 1. Parser (`src/git/parsers/status.rs`)
**Status: CORRECT**

The parser correctly extracts both staged and unstaged flags:
```rust
let x = parts[1].chars().nth(0).unwrap_or('.');  // First char: M = staged
let y = parts[1].chars().nth(1).unwrap_or('.');  // Second char: M = unstaged
entries.push(StatusEntry {
    staged: x != '.',    // 'M' != '.' → true
    unstaged: y != '.',  // 'M' != '.' → true
    ...
});
```

For `"1 MM N... ... src/app/actions.rs"`:
- `x = 'M'` → `staged = true` ✅
- `y = 'M'` → `unstaged = true` ✅

### ✅ 2. Renderer (`src/components/status/render.rs`)
**Status: CORRECT**

The renderer correctly displays both indicators:
```rust
let indicator = if entry.staged && entry.unstaged {
    "●○ "  // Both staged and unstaged
} else {
    prefix
};
```

For MM files:
- Shows `"●○ "` when both flags are true ✅
- Uses unstaged color (priority) for styling ✅

### ✅ 3. Reducer (`src/app/reducers/status_reducer.rs`)
**Status: CORRECT**

The reducer preserves both states correctly:

**StageSelectedFile:**
```rust
entry.staged = true;
// Don't set entry.unstaged = false here - preserve existing unstaged state
```
- Sets `staged = true` ✅
- Preserves `unstaged` state ✅

**UnstageSelectedFile:**
```rust
entry.staged = false;
// Don't set entry.unstaged = true here - preserve existing state
```
- Sets `staged = false` ✅
- Preserves `unstaged` state ✅

**StageAllFiles:**
```rust
if entry.unstaged || (!entry.staged && !entry.unstaged) {
    entry.staged = true;
    // Don't set entry.unstaged = false - preserve existing state
}
```
- Sets `staged = true` for unstaged/untracked files ✅
- Preserves `unstaged` state ✅

**UnstageAllFiles:**
```rust
if entry.staged {
    entry.staged = false;
    // Don't set entry.unstaged = true - preserve existing state
}
```
- Sets `staged = false` for staged files ✅
- Preserves `unstaged` state ✅

### ✅ 4. Commands (`src/commands/git.rs`)
**Status: CORRECT**

Both commands trigger status refresh after execution:

**StageFilesCommand:**
```rust
new_state = reducer(new_state, Action::SetRefreshing(true));
```
- Triggers refresh after staging ✅

**UnstageFilesCommand:**
```rust
new_state = reducer(new_state, Action::SetRefreshing(true));
```
- Triggers refresh after unstaging ✅

### ✅ 5. Complete Flow
**Status: CORRECT**

1. **Initial State**: Git status parsed → MM files have both flags set ✅
2. **User Stages**: Command executes → Reducer sets `staged = true` (preserves `unstaged`) → Refresh triggered → Git status re-parsed → Correct MM state restored ✅
3. **User Unstages**: Command executes → Reducer sets `staged = false` (preserves `unstaged`) → Refresh triggered → Git status re-parsed → Correct MM state restored ✅
4. **Display**: Renderer shows `"●○ "` for MM files ✅

## Conclusion

**All components are correctly handling MM status (staged + unstaged changes):**

1. ✅ Parser correctly extracts both flags from `git status --porcelain=v2`
2. ✅ Renderer correctly displays `"●○ "` indicator for MM files
3. ✅ Reducer correctly preserves both states during staging/unstaging operations
4. ✅ Commands correctly trigger status refresh after operations
5. ✅ Complete flow ensures accurate state representation

**No issues found. The implementation correctly handles files with both staged and unstaged changes.**