csift 0.10.0

ripgrep for Claude Code session transcripts: fast regex list/search over ~/.claude/projects/**/*.jsonl
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

//! File-op extraction from structured tool_use blocks and their result carriers.

use super::*;

// ── File-mutation extraction (FileOp / FileMutation / Record helpers) ──

#[test]
fn file_op_label_all_variants() {
    assert_eq!(FileOp::Write.label(), "write");
    assert_eq!(FileOp::Edit.label(), "edit");
    assert_eq!(FileOp::NotebookEdit.label(), "notebook-edit");
    assert_eq!(FileOp::MultiEdit.label(), "multi-edit");
    assert_eq!(FileOp::BashMutation.label(), "bash");
}

#[test]
fn file_op_json_key_uses_underscores_for_multiword() {
    // The on-wire JSON spelling is UNDERSCORE-delimited so the timeline `op` field
    // matches the grouped per-op COUNT keys; single-word ops coincide with `label`.
    assert_eq!(FileOp::Write.json_key(), "write");
    assert_eq!(FileOp::Edit.json_key(), "edit");
    assert_eq!(FileOp::NotebookEdit.json_key(), "notebook_edit");
    assert_eq!(FileOp::MultiEdit.json_key(), "multi_edit");
    assert_eq!(FileOp::BashMutation.json_key(), "bash");
    // The two multi-word ops are the only ones that DIFFER from `label` (hyphen vs `_`).
    assert_ne!(
        FileOp::NotebookEdit.json_key(),
        FileOp::NotebookEdit.label()
    );
    assert_ne!(FileOp::MultiEdit.json_key(), FileOp::MultiEdit.label());
}

#[test]
fn file_op_is_heuristic_only_for_bash() {
    assert!(FileOp::BashMutation.is_heuristic());
    assert!(!FileOp::Write.is_heuristic());
    assert!(!FileOp::Edit.is_heuristic());
    assert!(!FileOp::NotebookEdit.is_heuristic());
    assert!(!FileOp::MultiEdit.is_heuristic());
}

#[test]
fn structured_tool_mutations_write_edit_multiedit() {
    let r = parse(
        r#"{"type":"assistant","timestamp":"2026-06-07T05:00:00.000Z","message":{"role":"assistant","content":[
                {"type":"tool_use","id":"t1","name":"Write","input":{"file_path":"/tmp/a.md","content":"x"}},
                {"type":"tool_use","id":"t2","name":"Edit","input":{"file_path":"/p/spec/gaps.md","old_string":"a","new_string":"b","replace_all":false}},
                {"type":"tool_use","id":"t3","name":"MultiEdit","input":{"file_path":"/p/multi.rs","edits":[]}}
            ]}}"#,
    );
    let muts = r.structured_tool_mutations();
    assert_eq!(muts.len(), 3);
    assert_eq!(muts[0].op, FileOp::Write);
    assert_eq!(muts[0].path, "/tmp/a.md");
    assert_eq!(
        muts[0].timestamp_utc.as_deref(),
        Some("2026-06-07T05:00:00.000Z")
    );
    assert!(!muts[0].is_create, "no carrier on tool_use → unknown=false");
    assert_eq!(muts[1].op, FileOp::Edit);
    assert_eq!(muts[1].path, "/p/spec/gaps.md");
    assert_eq!(muts[2].op, FileOp::MultiEdit);
    assert_eq!(muts[2].path, "/p/multi.rs");
}

#[test]
fn structured_tool_mutations_notebook_uses_notebook_path() {
    let r = parse(
        r#"{"type":"assistant","message":{"role":"assistant","content":[
                {"type":"tool_use","id":"t1","name":"NotebookEdit","input":{"notebook_path":"/p/nb.ipynb","new_source":"code"}}
            ]}}"#,
    );
    let muts = r.structured_tool_mutations();
    assert_eq!(muts.len(), 1);
    assert_eq!(muts[0].op, FileOp::NotebookEdit);
    assert_eq!(muts[0].path, "/p/nb.ipynb");
}

#[test]
fn structured_tool_mutations_reads_create_from_own_carrier() {
    // The rare case where the tool_use record ALSO carries the toolUseResult with
    // type:"create" (the `self_is_create` true arm).
    let r = parse(
        r#"{"type":"assistant","toolUseResult":{"type":"create","filePath":"/tmp/new.md"},"message":{"role":"assistant","content":[
                {"type":"tool_use","id":"t1","name":"Write","input":{"file_path":"/tmp/new.md","content":"x"}}
            ]}}"#,
    );
    let muts = r.structured_tool_mutations();
    assert_eq!(muts.len(), 1);
    assert!(
        muts[0].is_create,
        "own carrier type:create → is_create true"
    );
}

#[test]
fn structured_tool_mutations_skips_missing_and_empty_path() {
    // A Write with NO file_path and an Edit with an EMPTY file_path → both skipped
    // (the defensive `path.is_empty()` arm). A non-mutating tool is ignored too.
    let r = parse(
        r#"{"type":"assistant","message":{"role":"assistant","content":[
                {"type":"tool_use","id":"t1","name":"Write","input":{"content":"x"}},
                {"type":"tool_use","id":"t2","name":"Edit","input":{"file_path":"","old_string":"a"}},
                {"type":"tool_use","id":"t3","name":"Read","input":{"file_path":"/p/read.rs"}}
            ]}}"#,
    );
    assert!(r.structured_tool_mutations().is_empty());
}

#[test]
fn structured_tool_mutations_skips_tool_use_with_no_name() {
    // A tool_use block missing its `name` → the `name.as_deref()` None arm.
    let r = parse(
        r#"{"type":"assistant","message":{"role":"assistant","content":[
                {"type":"tool_use","id":"t1","input":{"file_path":"/p/x.md"}}
            ]}}"#,
    );
    assert!(r.structured_tool_mutations().is_empty());
}

#[test]
fn structured_tool_mutations_none_for_string_content() {
    // A record with string content → blocks() None → empty (the early-return arm).
    let r = parse(r#"{"type":"user","message":{"role":"user","content":"plain"}}"#);
    assert!(r.structured_tool_mutations().is_empty());
}

#[test]
fn carrier_create_paths_create_update_and_missing() {
    // type:"create" → is_create true, joined to the tool_result block's id.
    let create = parse(
        r#"{"type":"user","toolUseResult":{"type":"create","filePath":"/tmp/new.md"},"message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"ok"}]}}"#,
    );
    assert_eq!(
        create.carrier_create_paths(),
        vec![("t1".to_string(), "/tmp/new.md".to_string(), true)]
    );
    // type:"update" → is_create false.
    let update = parse(
        r#"{"type":"user","toolUseResult":{"type":"update","filePath":"/p/gaps.md"},"message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t2","content":"ok"}]}}"#,
    );
    assert_eq!(
        update.carrier_create_paths(),
        vec![("t2".to_string(), "/p/gaps.md".to_string(), false)]
    );
    // No toolUseResult at all → empty (the `let Some(tur) else` arm).
    let none = parse(
        r#"{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t3","content":"ok"}]}}"#,
    );
    assert!(none.carrier_create_paths().is_empty());
}

#[test]
fn carrier_create_paths_file_unchanged_is_not_create() {
    // type:"file_unchanged" (the edit-touched-but-no-change case) → is_create false.
    let r = parse(
        r#"{"type":"user","toolUseResult":{"type":"file_unchanged","filePath":"/p/same.md"},"message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"ok"}]}}"#,
    );
    assert_eq!(
        r.carrier_create_paths(),
        vec![("t1".to_string(), "/p/same.md".to_string(), false)]
    );
}

#[test]
fn carrier_create_paths_no_file_path_or_not_object() {
    // toolUseResult present but NO filePath → empty (the filePath None arm).
    let no_fp = parse(
        r#"{"type":"user","toolUseResult":{"type":"text","stdout":"x"},"message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"x"}]}}"#,
    );
    assert!(no_fp.carrier_create_paths().is_empty());
    // toolUseResult is NOT an object (a bare string) → `.get("filePath")` is None.
    let not_obj = parse(
        r#"{"type":"user","toolUseResult":"just a string","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"x"}]}}"#,
    );
    assert!(not_obj.carrier_create_paths().is_empty());
    // filePath present but EMPTY → empty (the `file_path.is_empty()` arm).
    let empty_fp = parse(
        r#"{"type":"user","toolUseResult":{"type":"create","filePath":""},"message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"x"}]}}"#,
    );
    assert!(empty_fp.carrier_create_paths().is_empty());
}

#[test]
fn carrier_create_paths_skips_non_tool_result_blocks_and_no_id() {
    // A carrier with a filePath but whose only block is NOT a tool_result, OR a
    // tool_result with no tool_use_id → no joinable id, so empty.
    let no_id = parse(
        r#"{"type":"user","toolUseResult":{"type":"create","filePath":"/tmp/x.md"},"message":{"role":"user","content":[{"type":"text","text":"not a tool result"},{"type":"tool_result","content":"ok"}]}}"#,
    );
    assert!(no_id.carrier_create_paths().is_empty());
}

#[test]
fn carrier_create_paths_empty_when_no_blocks() {
    // filePath present but the record has string content (no blocks) → empty.
    let r = parse(
        r#"{"type":"user","toolUseResult":{"type":"create","filePath":"/tmp/x.md"},"message":{"role":"user","content":"string body"}}"#,
    );
    assert!(r.carrier_create_paths().is_empty());
}