1use std::io::{BufRead, BufReader, Read};
23
24use serde_json::Value;
25
26use crate::error::{MnemoError, Result};
27use crate::memory::ThreadTurn;
28
29#[derive(Debug, Clone, Copy, PartialEq, Eq)]
32pub enum TranscriptFormat {
33 JsonlGeneric,
35 ClaudeCodeJsonl,
38}
39
40impl TranscriptFormat {
41 pub fn parse(s: &str) -> Option<TranscriptFormat> {
44 match s.to_ascii_lowercase().as_str() {
45 "jsonl" => Some(TranscriptFormat::JsonlGeneric),
46 "claude-code-jsonl" | "claude_code_jsonl" => Some(TranscriptFormat::ClaudeCodeJsonl),
47 _ => None,
48 }
49 }
50}
51
52#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
54pub enum ToolResults {
55 #[default]
58 Full,
59 Omit,
63}
64
65#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
67pub struct TranscriptOptions {
68 pub tool_results: ToolResults,
70 pub lenient: bool,
74}
75
76pub fn read_transcript<R: Read>(reader: R, format: TranscriptFormat) -> Result<Vec<ThreadTurn>> {
80 read_transcript_with(reader, format, TranscriptOptions::default())
81}
82
83pub fn read_transcript_with<R: Read>(
85 reader: R,
86 format: TranscriptFormat,
87 opts: TranscriptOptions,
88) -> Result<Vec<ThreadTurn>> {
89 let mut out = Vec::new();
90 for (lineno, line) in BufReader::new(reader).lines().enumerate() {
91 let line = match line {
92 Ok(l) => l,
93 Err(e) if opts.lenient && e.kind() == std::io::ErrorKind::InvalidData => continue,
95 Err(e) => return Err(MnemoError::Io(e)),
96 };
97 let trimmed = line.trim();
98 if trimmed.is_empty() || trimmed.starts_with('#') {
99 continue;
100 }
101 let v: Value = match serde_json::from_str(trimmed) {
102 Ok(v) => v,
103 Err(_) if opts.lenient => continue,
104 Err(e) => {
105 return Err(MnemoError::Invalid(format!(
106 "transcript line {}: invalid JSON: {e}",
107 lineno + 1
108 )))
109 }
110 };
111 let turn = match format {
112 TranscriptFormat::JsonlGeneric => parse_generic_line(&v),
113 TranscriptFormat::ClaudeCodeJsonl => parse_claude_code_line(&v, opts.tool_results),
114 };
115 match turn {
116 Ok(Some(t)) => out.push(t),
117 Ok(None) => {}
118 Err(_) if opts.lenient => {}
119 Err(e) => return Err(e),
120 }
121 }
122 Ok(out)
123}
124
125fn parse_generic_line(v: &Value) -> Result<Option<ThreadTurn>> {
126 let obj = v.as_object().ok_or_else(|| {
127 MnemoError::Invalid("transcript: generic jsonl line must be a JSON object".into())
128 })?;
129 let turn_id = obj
130 .get("turn_id")
131 .and_then(|v| v.as_str())
132 .ok_or_else(|| {
133 MnemoError::Invalid("transcript: generic jsonl line missing 'turn_id' (string)".into())
134 })?
135 .to_string();
136 let role = obj
137 .get("role")
138 .and_then(|v| v.as_str())
139 .ok_or_else(|| {
140 MnemoError::Invalid("transcript: generic jsonl line missing 'role' (string)".into())
141 })?
142 .to_string();
143 let content = obj
144 .get("content")
145 .and_then(|v| v.as_str())
146 .ok_or_else(|| {
147 MnemoError::Invalid("transcript: generic jsonl line missing 'content' (string)".into())
148 })?
149 .to_string();
150 let timestamp = obj.get("timestamp").and_then(|v| v.as_i64());
151 Ok(Some(ThreadTurn {
152 turn_id,
153 role,
154 content,
155 timestamp,
156 }))
157}
158
159fn parse_claude_code_line(v: &Value, tool_results: ToolResults) -> Result<Option<ThreadTurn>> {
176 let obj = match v.as_object() {
177 Some(o) => o,
178 None => return Ok(None),
179 };
180 let type_tag = obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
181 if type_tag != "user" && type_tag != "assistant" {
182 return Ok(None);
184 }
185 let turn_id = obj
186 .get("uuid")
187 .and_then(|v| v.as_str())
188 .map(|s| s.to_string())
189 .ok_or_else(|| {
190 MnemoError::Invalid("transcript: claude-code-jsonl message missing 'uuid'".into())
191 })?;
192 let message = obj
193 .get("message")
194 .and_then(|v| v.as_object())
195 .ok_or_else(|| {
196 MnemoError::Invalid(
197 "transcript: claude-code-jsonl message missing 'message' object".into(),
198 )
199 })?;
200 let role = message
201 .get("role")
202 .and_then(|v| v.as_str())
203 .unwrap_or(type_tag)
204 .to_string();
205 let content = match message.get("content") {
206 Some(Value::String(s)) => s.clone(),
207 Some(Value::Array(blocks)) => flatten_blocks(blocks, tool_results),
208 _ => String::new(),
209 };
210 let timestamp = obj
215 .get("timestamp")
216 .and_then(|v| v.as_str())
217 .and_then(parse_iso8601_secs)
218 .or_else(|| {
219 message
220 .get("timestamp")
221 .and_then(|v| v.as_str())
222 .and_then(parse_iso8601_secs)
223 });
224 Ok(Some(ThreadTurn {
225 turn_id,
226 role,
227 content,
228 timestamp,
229 }))
230}
231
232fn flatten_blocks(blocks: &[Value], tool_results: ToolResults) -> String {
237 let mut out = String::new();
238 for b in blocks {
239 let Some(obj) = b.as_object() else {
240 continue;
241 };
242 let t = obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
243 match t {
244 "text" => {
245 if let Some(s) = obj.get("text").and_then(|v| v.as_str()) {
246 if !out.is_empty() {
247 out.push('\n');
248 }
249 out.push_str(s);
250 }
251 }
252 "tool_use" => {
253 let name = obj.get("name").and_then(|v| v.as_str()).unwrap_or("?");
254 if !out.is_empty() {
255 out.push('\n');
256 }
257 out.push_str(&format!("[tool_use name={name}]"));
258 }
259 "tool_result" => {
260 let is_error = obj
261 .get("is_error")
262 .and_then(|v| v.as_bool())
263 .unwrap_or(false);
264 let status = if is_error { "error" } else { "ok" };
265 let inner = obj.get("content").and_then(|c| match c {
266 Value::String(s) => Some(s.clone()),
267 Value::Array(nested) => Some(flatten_blocks(nested, tool_results)),
268 _ => None,
269 });
270 if !out.is_empty() {
271 out.push('\n');
272 }
273 match (inner, tool_results) {
274 (Some(body), ToolResults::Full) => {
275 out.push_str(&format!("[tool_result {status}] {body}"))
276 }
277 (inner, ToolResults::Omit) => out.push_str(&format!(
278 "[tool_result {status}, {} bytes]",
279 inner.map_or(0, |b| b.len())
280 )),
281 (None, ToolResults::Full) => out.push_str(&format!("[tool_result {status}]")),
282 }
283 }
284 "image" => {
285 if !out.is_empty() {
286 out.push('\n');
287 }
288 out.push_str("[image]");
289 }
290 other => {
291 if !out.is_empty() {
292 out.push('\n');
293 }
294 out.push_str(&format!("[{other}]"));
295 }
296 }
297 }
298 out
299}
300
301pub(crate) fn is_marker_only(content: &str) -> bool {
309 let mut any = false;
310 for line in content.lines() {
311 let l = line.trim();
312 if l.is_empty() {
313 continue;
314 }
315 if !is_marker(l) {
316 return false;
317 }
318 any = true;
319 }
320 any
321}
322
323fn is_marker(l: &str) -> bool {
324 let Some(inner) = l.strip_prefix('[').and_then(|r| r.strip_suffix(']')) else {
325 return false;
326 };
327 if let Some(name) = inner.strip_prefix("tool_use name=") {
328 return !name.is_empty() && !name.contains([']', '[', ' ']);
329 }
330 if let Some(rest) = inner.strip_prefix("tool_result ") {
331 let (status, size) = match rest.split_once(", ") {
332 Some((s, n)) => (s, Some(n)),
333 None => (rest, None),
334 };
335 return matches!(status, "ok" | "error")
336 && size.is_none_or(|n| {
337 n.strip_suffix(" bytes")
338 .is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))
339 });
340 }
341 !inner.is_empty() && inner.bytes().all(|b| b.is_ascii_lowercase() || b == b'_')
342}
343
344fn parse_iso8601_secs(s: &str) -> Option<i64> {
349 let bytes = s.as_bytes();
351 if bytes.len() < 19 || bytes[4] != b'-' || bytes[7] != b'-' || bytes[10] != b'T' {
352 return None;
353 }
354 let year: i64 = s.get(0..4)?.parse().ok()?;
355 let month: u32 = s.get(5..7)?.parse().ok()?;
356 let day: u32 = s.get(8..10)?.parse().ok()?;
357 let hour: u32 = s.get(11..13)?.parse().ok()?;
358 let minute: u32 = s.get(14..16)?.parse().ok()?;
359 let second: u32 = s.get(17..19)?.parse().ok()?;
360 Some(
361 days_from_civil(year, month, day) * 86_400
362 + hour as i64 * 3600
363 + minute as i64 * 60
364 + second as i64,
365 )
366}
367
368fn days_from_civil(y: i64, m: u32, d: u32) -> i64 {
372 let y = if m <= 2 { y - 1 } else { y };
373 let era = if y >= 0 { y } else { y - 399 } / 400;
374 let yoe = y - era * 400;
375 let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) as i64 + 2) / 5 + d as i64 - 1;
376 let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
377 era * 146_097 + doe - 719_468
378}
379
380#[cfg(test)]
381mod tests {
382 use super::*;
383
384 #[test]
386 fn marker_only_content() {
387 for yes in [
388 "[thinking]",
389 "[redacted_thinking]\n[tool_use name=Read]",
390 "[tool_use name=mcp__mnemo__remember]",
391 "[tool_result ok, 30 bytes]",
392 "[tool_result error]",
393 "\n[image]\n\n [tool_result ok, 0 bytes] \n",
394 ] {
395 assert!(is_marker_only(yes), "{yes:?}");
396 }
397 for no in [
398 "",
399 " \n",
400 "It deploys to staging-7.\n[tool_use name=Bash]",
401 "[tool_result ok] the whole body, kept in full",
402 "[tool_result maybe, 3 bytes]",
403 "[tool_result ok, many bytes]",
404 "[Thinking]",
405 "[see the docs]",
406 "[]",
407 "[tool_use name=]",
408 "a [thinking] b",
409 "[thinking] ok",
410 ] {
411 assert!(!is_marker_only(no), "{no:?}");
412 }
413 }
414
415 #[test]
416 fn jsonl_generic_round_trip() {
417 let src = r#"
418{"turn_id":"a","role":"user","content":"hi","timestamp":1700000000}
419{"turn_id":"b","role":"assistant","content":"hello"}
420"#;
421 let turns = read_transcript(src.as_bytes(), TranscriptFormat::JsonlGeneric).unwrap();
422 assert_eq!(turns.len(), 2);
423 assert_eq!(turns[0].turn_id, "a");
424 assert_eq!(turns[0].role, "user");
425 assert_eq!(turns[0].timestamp, Some(1_700_000_000));
426 assert_eq!(turns[1].timestamp, None);
427 }
428
429 #[test]
430 fn claude_code_jsonl_skips_non_message_types() {
431 let src = r#"{"type":"system","uuid":"sys-1","content":"init"}
432{"type":"user","uuid":"u-1","message":{"role":"user","content":"hi"}}
433{"type":"assistant","uuid":"a-1","message":{"role":"assistant","content":[{"type":"text","text":"hey"}]}}
434"#;
435 let turns = read_transcript(src.as_bytes(), TranscriptFormat::ClaudeCodeJsonl).unwrap();
436 assert_eq!(turns.len(), 2);
437 assert_eq!(turns[0].turn_id, "u-1");
438 assert_eq!(turns[1].content, "hey");
439 }
440
441 #[test]
442 fn claude_code_flattens_tool_use_and_tool_result() {
443 let src = r#"{"type":"assistant","uuid":"a","message":{"role":"assistant","content":[{"type":"text","text":"let me run:"},{"type":"tool_use","id":"t","name":"Bash","input":{}}]}}
444{"type":"user","uuid":"u","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t","content":"ok\n","is_error":false}]}}
445"#;
446 let turns = read_transcript(src.as_bytes(), TranscriptFormat::ClaudeCodeJsonl).unwrap();
447 assert_eq!(turns.len(), 2);
448 assert!(turns[0].content.contains("let me run:"));
449 assert!(turns[0].content.contains("[tool_use name=Bash]"));
450 assert!(turns[1].content.contains("[tool_result ok]"));
451 }
452}