416 lines
15 KiB
Rust
416 lines
15 KiB
Rust
//! Only human text and session metadata enter the cache. Large tool/image/assistant
|
|
//! payloads are skipped by serde rather than materialized as JSON trees.
|
|
use std::{
|
|
collections::{HashMap, HashSet},
|
|
fs::File,
|
|
io::{self, BufRead, BufReader},
|
|
path::Path,
|
|
};
|
|
|
|
use serde::Deserialize;
|
|
use serde_json::{Value, value::RawValue};
|
|
|
|
use crate::session::{Agent, Session, compact};
|
|
|
|
#[derive(Default, Deserialize)]
|
|
#[serde(default, rename_all = "camelCase")]
|
|
struct Entry<'a> {
|
|
#[serde(rename = "type")]
|
|
kind: &'a str,
|
|
id: Option<String>,
|
|
uuid: Option<String>,
|
|
session_id: Option<String>,
|
|
cwd: Option<String>,
|
|
name: Option<String>,
|
|
title: Option<String>,
|
|
attribution: Option<String>,
|
|
#[serde(borrow)]
|
|
content: Option<&'a RawValue>,
|
|
custom_title: Option<String>,
|
|
ai_title: Option<String>,
|
|
summary: Option<String>,
|
|
is_meta: bool,
|
|
is_sidechain: bool,
|
|
#[serde(borrow)]
|
|
message: Option<&'a RawValue>,
|
|
#[serde(borrow)]
|
|
payload: Option<&'a RawValue>,
|
|
#[serde(borrow)]
|
|
origin: Option<&'a RawValue>,
|
|
}
|
|
|
|
#[derive(Default, Deserialize)]
|
|
#[serde(default)]
|
|
struct Payload<'a> {
|
|
#[serde(rename = "type")]
|
|
kind: &'a str,
|
|
role: &'a str,
|
|
attribution: Option<String>,
|
|
id: Option<String>,
|
|
session_id: Option<String>,
|
|
cwd: Option<String>,
|
|
thread_source: &'a str,
|
|
#[serde(borrow)]
|
|
source: Option<&'a RawValue>,
|
|
#[serde(borrow)]
|
|
content: Option<&'a RawValue>,
|
|
message: Option<String>,
|
|
}
|
|
|
|
pub fn parse_file(agent: Agent, path: &Path, modified: u64) -> io::Result<Option<Session>> {
|
|
parse(
|
|
agent,
|
|
path,
|
|
modified,
|
|
BufReader::with_capacity(128 * 1024, File::open(path)?),
|
|
)
|
|
}
|
|
|
|
fn parse(
|
|
agent: Agent,
|
|
path: &Path,
|
|
modified: u64,
|
|
mut reader: impl BufRead,
|
|
) -> io::Result<Option<Session>> {
|
|
let mut session = Session {
|
|
agent,
|
|
id: String::new(),
|
|
path: path.to_path_buf(),
|
|
cwd: Default::default(),
|
|
title: String::new(),
|
|
modified,
|
|
messages: vec![],
|
|
};
|
|
let mut seen = HashSet::new();
|
|
let mut events = vec![];
|
|
let mut custom_title = None;
|
|
let mut title_slot = None;
|
|
let mut ai_title = None;
|
|
let mut summary = None;
|
|
let mut line = String::new();
|
|
loop {
|
|
line.clear();
|
|
match reader.read_line(&mut line) {
|
|
Ok(0) => break,
|
|
Ok(_) => {}
|
|
Err(e) if e.kind() == io::ErrorKind::InvalidData => continue,
|
|
Err(e) => return Err(e),
|
|
}
|
|
// A live writer may leave a partial final record. It is retried next refresh.
|
|
let Ok(e) = serde_json::from_str::<Entry>(&line) else {
|
|
continue;
|
|
};
|
|
match agent {
|
|
Agent::Opencode => return Ok(None), // SQLite adapter; never JSONL.
|
|
Agent::Pi | Agent::Omp => match e.kind {
|
|
"session" if session.id.is_empty() => {
|
|
session.id = e.id.unwrap_or_default();
|
|
session.cwd = e.cwd.unwrap_or_default().into();
|
|
if agent == Agent::Omp {
|
|
custom_title = e.title;
|
|
}
|
|
}
|
|
"title" if agent == Agent::Omp => {
|
|
title_slot = e.title.filter(|t| !t.trim().is_empty())
|
|
}
|
|
"title_change" if agent == Agent::Omp => custom_title = e.title,
|
|
"custom_message"
|
|
if agent == Agent::Omp && e.attribution.as_deref() == Some("user") =>
|
|
{
|
|
push_text(&mut session.messages, e.content);
|
|
}
|
|
"session_info" => custom_title = e.name,
|
|
"message" => {
|
|
if let Some(raw) = e.message
|
|
&& let Ok(p) = serde_json::from_str::<Payload>(raw.get())
|
|
&& p.role == "user"
|
|
&& p.attribution.as_deref() != Some("agent")
|
|
{
|
|
push_text(&mut session.messages, p.content);
|
|
}
|
|
}
|
|
_ => {}
|
|
},
|
|
Agent::Claude => {
|
|
if e.is_sidechain {
|
|
continue;
|
|
}
|
|
if session.cwd.as_os_str().is_empty() {
|
|
session.cwd = e.cwd.unwrap_or_default().into();
|
|
}
|
|
if session.id.is_empty() {
|
|
session.id = e.session_id.unwrap_or_default();
|
|
}
|
|
match e.kind {
|
|
"custom-title" => custom_title = e.custom_title,
|
|
"ai-title" => ai_title = e.ai_title,
|
|
"summary" => summary = e.summary,
|
|
"user" if !e.is_meta => {
|
|
let nonhuman = e
|
|
.origin
|
|
.and_then(|r| serde_json::from_str::<Value>(r.get()).ok())
|
|
.and_then(|v| v["kind"].as_str().map(|k| k != "human"))
|
|
.unwrap_or(false);
|
|
if nonhuman || e.uuid.is_some_and(|id| !seen.insert(id)) {
|
|
continue;
|
|
}
|
|
if let Some(raw) = e.message
|
|
&& let Ok(p) = serde_json::from_str::<Payload>(raw.get())
|
|
&& p.role == "user"
|
|
{
|
|
push_text(&mut session.messages, p.content);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
Agent::Codex => {
|
|
if !matches!(e.kind, "session_meta" | "response_item" | "event_msg") {
|
|
continue;
|
|
}
|
|
let Some(raw) = e.payload else { continue };
|
|
let Ok(p) = serde_json::from_str::<Payload>(raw.get()) else {
|
|
continue;
|
|
};
|
|
match e.kind {
|
|
"session_meta" if session.id.is_empty() => {
|
|
// Fork logs can contain their parent's header later: first header wins.
|
|
let source = p
|
|
.source
|
|
.and_then(|r| serde_json::from_str::<Value>(r.get()).ok());
|
|
if p.thread_source == "subagent"
|
|
|| source.as_ref().is_some_and(|v| {
|
|
v.get("subagent").is_some() || v.as_str() == Some("subagent")
|
|
})
|
|
{
|
|
return Ok(None);
|
|
}
|
|
session.id = p.id.or(p.session_id).unwrap_or_default();
|
|
session.cwd = p.cwd.unwrap_or_default().into();
|
|
}
|
|
"event_msg" if p.kind == "user_message" => {
|
|
if let Some(text) = p.message {
|
|
push_human(&mut events, &text);
|
|
}
|
|
}
|
|
"response_item" if p.kind == "message" && p.role == "user" => {
|
|
if p.id.is_some_and(|id| !seen.insert(id)) {
|
|
continue;
|
|
}
|
|
push_text(&mut session.messages, p.content);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Older Codex records input twice. Keep events, plus response-only prompts
|
|
// from newer turns in logs that have been resumed across CLI versions.
|
|
if !events.is_empty() {
|
|
let mut mirrored = HashMap::<String, usize>::new();
|
|
for text in &events {
|
|
*mirrored.entry(text.clone()).or_default() += 1;
|
|
}
|
|
for text in session.messages {
|
|
let remaining = mirrored.entry(text.clone()).or_default();
|
|
if *remaining > 0 {
|
|
*remaining -= 1;
|
|
} else {
|
|
events.push(text);
|
|
}
|
|
}
|
|
session.messages = events;
|
|
}
|
|
session.title = title_slot
|
|
.or(custom_title)
|
|
.or(ai_title)
|
|
.or(summary)
|
|
.filter(|s| !s.trim().is_empty())
|
|
.map(|s| compact(&s, 200))
|
|
.or_else(|| session.messages.first().map(|s| compact(s, 160)))
|
|
.unwrap_or_else(|| "Untitled session".into());
|
|
if session.id.is_empty() || !session.cwd.is_absolute() {
|
|
return Ok(None);
|
|
}
|
|
Ok(Some(session))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct TextBlock {
|
|
#[serde(rename = "type")]
|
|
kind: String,
|
|
text: Option<String>,
|
|
}
|
|
|
|
fn push_text(messages: &mut Vec<String>, raw: Option<&RawValue>) {
|
|
let Some(raw) = raw else { return };
|
|
if raw.get().starts_with('"') {
|
|
if let Ok(text) = serde_json::from_str::<String>(raw.get()) {
|
|
push_human(messages, &text);
|
|
}
|
|
} else if let Ok(blocks) = serde_json::from_str::<Vec<TextBlock>>(raw.get()) {
|
|
// Ignore tool_result.content and image.data without allocating them.
|
|
let text = blocks
|
|
.iter()
|
|
.filter(|b| matches!(b.kind.as_str(), "text" | "input_text"))
|
|
.filter_map(|b| b.text.as_deref())
|
|
.filter(|s| is_human(s))
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
push_human(messages, &text);
|
|
}
|
|
}
|
|
|
|
pub(crate) fn push_human(messages: &mut Vec<String>, text: &str) {
|
|
if is_human(text) {
|
|
// Terminal escape/control sequences from stored content must never be emitted.
|
|
messages.push(
|
|
text.trim()
|
|
.chars()
|
|
.filter(|c| !c.is_control() || matches!(c, '\n' | '\t'))
|
|
.collect(),
|
|
);
|
|
}
|
|
}
|
|
|
|
fn is_human(text: &str) -> bool {
|
|
let text = text.trim();
|
|
!text.is_empty()
|
|
&& ![
|
|
"# AGENTS.md instructions",
|
|
"<environment_context>",
|
|
"<environment>",
|
|
"<permissions instructions>",
|
|
"<task-notification>",
|
|
"<subagent_notification>",
|
|
"<local-command-caveat>",
|
|
"<local-command-stdout>",
|
|
"<command-name>",
|
|
"[Request interrupted by user",
|
|
"This session is being continued from a previous conversation",
|
|
"<system-reminder>",
|
|
"<turn_aborted>",
|
|
]
|
|
.iter()
|
|
.any(|prefix| text.starts_with(prefix))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
fn fixture(agent: Agent, input: &str) -> Session {
|
|
parse(
|
|
agent,
|
|
Path::new("/tmp/session.jsonl"),
|
|
42,
|
|
io::Cursor::new(input),
|
|
)
|
|
.unwrap()
|
|
.unwrap()
|
|
}
|
|
#[test]
|
|
fn pi_latest_title_and_only_human_text() {
|
|
let s = fixture(
|
|
Agent::Pi,
|
|
r#"{"type":"session","id":"p","cwd":"/work"}
|
|
{"type":"session_info","name":"Old"}
|
|
{"type":"message","message":{"role":"user","content":[{"type":"text","text":"fix auth"},{"type":"image","data":"secret"}]}}
|
|
{"type":"message","message":{"role":"toolResult","content":"not searchable"}}
|
|
{"type":"message","message":{"role":"assistant","content":"not searchable"}}
|
|
{"type":"session_info","name":"New"}
|
|
not json
|
|
{"type":"message","message":
|
|
"#,
|
|
);
|
|
assert_eq!(s.title, "New");
|
|
assert_eq!(s.messages, ["fix auth"]);
|
|
}
|
|
#[test]
|
|
fn omp_title_slot_header_and_human_attribution() {
|
|
let s = fixture(
|
|
Agent::Omp,
|
|
r#"{"type":"title","title":"Current title"}
|
|
{"type":"session","id":"omp-id","cwd":"/work","title":"Legacy title"}
|
|
{"type":"message","message":{"role":"user","attribution":"user","content":[{"type":"text","text":"real request"}]}}
|
|
{"type":"message","message":{"role":"user","attribution":"agent","content":"injected request"}}
|
|
{"type":"custom_message","attribution":"user","content":"user skill request"}
|
|
{"type":"title_change","title":"Old title event"}
|
|
"#,
|
|
);
|
|
assert_eq!(s.agent, Agent::Omp);
|
|
assert_eq!(s.title, "Current title");
|
|
assert_eq!(s.messages, ["real request", "user skill request"]);
|
|
let s = fixture(
|
|
Agent::Omp,
|
|
r#"{"type":"session","id":"old","cwd":"/work","title":"Legacy title"}"#,
|
|
);
|
|
assert_eq!(s.title, "Legacy title");
|
|
let s = fixture(
|
|
Agent::Omp,
|
|
r#"{"type":"title","title":""}
|
|
{"type":"session","id":"old","cwd":"/work"}
|
|
{"type":"title_change","title":"Renamed"}
|
|
"#,
|
|
);
|
|
assert_eq!(s.title, "Renamed");
|
|
}
|
|
#[test]
|
|
fn claude_titles_dedup_and_generated_records() {
|
|
let s = fixture(
|
|
Agent::Claude,
|
|
r#"{"type":"user","uuid":"1","sessionId":"c","cwd":"/work","message":{"role":"user","content":"hello"}}
|
|
{"type":"user","uuid":"1","message":{"role":"user","content":"hello"}}
|
|
{"type":"user","isMeta":true,"message":{"role":"user","content":"injected"}}
|
|
{"type":"user","origin":{"kind":"agent"},"message":{"role":"user","content":"injected"}}
|
|
{"type":"user","message":{"role":"user","content":[{"type":"tool_result","content":"tool output"}]}}
|
|
{"type":"user","message":{"role":"user","content":"<task-notification>background"}}
|
|
{"type":"custom-title","customTitle":"Custom title"}
|
|
{"type":"ai-title","aiTitle":"Generated title"}
|
|
"#,
|
|
);
|
|
assert_eq!(s.title, "Custom title");
|
|
assert_eq!(s.messages, ["hello"]);
|
|
}
|
|
#[test]
|
|
fn codex_events_and_responses_are_not_double_counted() {
|
|
let s = fixture(
|
|
Agent::Codex,
|
|
r##"{"type":"session_meta","payload":{"id":"x","cwd":"/work","source":"cli"}}
|
|
{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"# AGENTS.md instructions for /work"}]}}
|
|
{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"real prompt"}]}}
|
|
{"type":"event_msg","payload":{"type":"user_message","message":"real prompt"}}
|
|
{"type":"session_meta","payload":{"id":"parent","cwd":"/wrong"}}
|
|
"##,
|
|
);
|
|
assert_eq!(s.id, "x");
|
|
assert_eq!(s.cwd, Path::new("/work"));
|
|
assert_eq!(s.messages, ["real prompt"]);
|
|
}
|
|
#[test]
|
|
fn codex_mixed_versions_keep_new_response_only_prompts() {
|
|
let s = fixture(
|
|
Agent::Codex,
|
|
r#"{"type":"session_meta","payload":{"id":"x","cwd":"/work"}}
|
|
{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"old prompt"}]}}
|
|
{"type":"event_msg","payload":{"type":"user_message","message":"old prompt"}}
|
|
{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"new prompt"}]}}
|
|
"#,
|
|
);
|
|
assert_eq!(s.messages, ["old prompt", "new prompt"]);
|
|
}
|
|
#[test]
|
|
fn modern_codex_response_fallback() {
|
|
let s = fixture(
|
|
Agent::Codex,
|
|
r#"{"type":"session_meta","payload":{"id":"x","cwd":"/work"}}
|
|
{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"<environment_context>injected"},{"type":"input_text","text":"日本語 request"}]}}
|
|
"#,
|
|
);
|
|
assert_eq!(s.messages, ["日本語 request"]);
|
|
}
|
|
#[test]
|
|
fn excludes_codex_subagents() {
|
|
let s = parse(Agent::Codex, Path::new("x"), 0, io::Cursor::new(r#"{"type":"session_meta","payload":{"id":"child","cwd":"/work","source":{"subagent":{}}}}"#)).unwrap();
|
|
assert!(s.is_none());
|
|
}
|
|
}
|