thrum 0.0.6

A terminal email client
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

# CLAUDE.md

## Project Overview

Thrum is a terminal email client (TUI) written in Rust (edition 2024). It uses [ratatui](https://ratatui.rs/) for terminal UI components.

## Version Control

This project uses **jj** (Jujutsu) as the version control CLI with a git backend. Use `jj` commands instead of `git` for all VCS operations:

- `jj status` instead of `git status`
- `jj diff` instead of `git diff`
- `jj new` instead of `git commit` (jj auto-commits working copy changes)
- `jj describe -m "message"` to set the change description
- `jj log` instead of `git log`
- `jj bookmark` for branch-like workflows

## Build & Run

```sh
just build           # debug build
just check           # type-check without building
just test            # run all tests
just clippy          # lint
just fmt             # format
```

## Development Environment

The project uses a Nix flake (`flake.nix`) with direnv (`.envrc`) to provide the development toolchain (rustc, cargo, clippy, rustfmt, rust-analyzer, cargo-info, cargo-udeps, just).

## Project Structure

```
src/
  main.rs            # entrypoint
  <module>/
    mod.rs           # module implementation
    test.rs          # tests for that module
```

## Testing

Tests live in separate `test.rs` files alongside the module they test, not inline with `#[cfg(test)]` blocks in the implementation file. Each module should include its test file conditionally:

```rust
// in mod.rs
#[cfg(test)]
mod test;
```

And the corresponding `test.rs`:

```rust
use super::*;

#[test]
fn it_works() {
    // ...
}
```

## Tracing

Use the `tracing` crate with `tracing::instrument` for instrumentation. Default instrument level is `tracing::Level::TRACE`.

Tracing is gated behind a cargo feature flag called `tracing` so that logs are only included when explicitly enabled at build time:

```toml
[features]
tracing = ["dep:tracing"]

[dependencies]
tracing = { version = "0.1", optional = true }
```

To build with tracing enabled:

```sh
cargo run --features tracing
```

When annotating functions:

```rust
#[cfg_attr(feature = "tracing", tracing::instrument(level = tracing::Level::TRACE))]
fn my_function() {
    // ...
}
```

## UI Framework

The TUI is built with [ratatui](https://ratatui.rs/). Use ratatui idioms and patterns for rendering, layout, and event handling.

## Configuration

When the config struct (`src/config/mod.rs`) is modified (fields added, removed, or renamed), update the example TOML snippets in `README.md` to match.

## Style Guidelines

- Keep code simple and focused; avoid over-engineering.
- Follow standard `cargo fmt` formatting.
- Use `cargo clippy` to catch common mistakes.