session_activity/
adapters.rs1use std::collections::HashMap;
2use std::fs;
3use std::io::{BufRead, BufReader};
4use std::path::Path;
5
6use anyhow::{Result, ensure};
7use serde_json::Value;
8use time::{OffsetDateTime, format_description::well_known::Rfc3339};
9
10use crate::{Agent, FileEvent, Operation, Outcome, SessionKey, Source, resolve_path};
11
12pub fn hook_events(agent: Agent, input: &Value, timestamp: i64) -> Result<Vec<FileEvent>> {
15 let session = SessionKey { agent, session_id: input["session_id"].as_str().unwrap_or_default().into() };
16 session.validate()?;
17 let cwd = Path::new(input["cwd"].as_str().unwrap_or_default());
18 ensure!(cwd.is_absolute(), "hook cwd must be absolute");
19 let failed = agent == Agent::Claude && input["hook_event_name"] == "PostToolUseFailure";
20 if input["hook_event_name"] != "PostToolUse" && !failed {
21 return Ok(Vec::new());
22 }
23 let mut events = tool_events(
24 &session,
25 cwd,
26 input["tool_name"].as_str().unwrap_or_default(),
27 &input["tool_input"],
28 timestamp,
29 Source::Hook,
30 );
31 for event in &mut events {
32 event.tool_call_id = input["tool_use_id"].as_str().map(str::to_owned);
33 event.outcome = if failed { Outcome::Failed } else { outcome(&input["tool_response"]) };
34 }
35 Ok(events)
36}
37
38fn outcome(response: &Value) -> Outcome {
39 let flags = [
40 response["is_error"].as_bool().map(|v| !v),
41 response["isError"].as_bool().map(|v| !v),
42 response["success"].as_bool(),
43 ];
44 if flags.contains(&Some(false)) {
45 return Outcome::Failed;
46 }
47 if flags.contains(&Some(true)) {
48 return Outcome::Succeeded;
49 }
50 Outcome::Unknown
53}
54
55fn tool_events(session: &SessionKey, cwd: &Path, tool: &str, input: &Value, at: i64, source: Source) -> Vec<FileEvent> {
56 if session.agent == Agent::Codex && tool == "apply_patch" {
57 return patch_events(session, cwd, input["command"].as_str().unwrap_or_default(), at, source);
58 }
59 if session.agent != Agent::Claude {
60 return Vec::new();
61 }
62 let operation = match tool {
63 "Read" => Operation::Read,
64 "Write" => Operation::Write, "Edit" | "MultiEdit" => Operation::Modify,
66 _ => return Vec::new(),
67 };
68 input["file_path"]
69 .as_str()
70 .filter(|p| !p.is_empty())
71 .map(|p| vec![FileEvent::new(session, cwd, Path::new(p), at, operation, source)])
72 .unwrap_or_default()
73}
74
75fn patch_events(session: &SessionKey, cwd: &Path, patch: &str, at: i64, source: Source) -> Vec<FileEvent> {
76 let lines: Vec<_> = patch.trim().lines().collect();
77 if lines.first() != Some(&"*** Begin Patch") || lines.last() != Some(&"*** End Patch") {
78 return Vec::new();
79 }
80 let mut events: Vec<FileEvent> = Vec::new();
81 for line in lines {
82 if let Some(path) = line.strip_prefix("*** Move to: ") {
83 if let Some(previous) = events.last_mut().filter(|e| e.operation == Operation::Modify && !path.is_empty()) {
84 previous.previous_path = Some(previous.path.clone());
85 previous.path = resolve_path(cwd, Path::new(path));
86 previous.operation = Operation::Rename;
87 }
88 continue;
89 }
90 for (prefix, operation) in [
91 ("*** Add File: ", Operation::Create),
92 ("*** Update File: ", Operation::Modify),
93 ("*** Delete File: ", Operation::Delete),
94 ] {
95 if let Some(path) = line.strip_prefix(prefix).filter(|p| !p.is_empty()) {
96 events.push(FileEvent::new(session, cwd, Path::new(path), at, operation, source));
97 }
98 }
99 }
100 events
101}
102
103pub fn transcript_events(session: &SessionKey, cwd: &Path, transcript: &Path) -> Vec<FileEvent> {
106 if session.agent != Agent::Claude {
107 return Vec::new();
108 }
109 let Ok(file) = fs::File::open(transcript) else {
110 return Vec::new();
111 };
112 let mut events = Vec::new();
113 let mut results = HashMap::new();
114 for line in BufReader::new(file).lines().map_while(Result::ok) {
115 if !line.contains("\"tool_use\"") && !line.contains("\"tool_result\"") {
116 continue;
117 }
118 let Ok(record) = serde_json::from_str::<Value>(&line) else {
119 continue;
120 };
121 if record["type"] == "user" {
122 if let Some(content) = record["message"]["content"].as_array() {
123 for item in content.iter().filter(|item| item["type"] == "tool_result") {
124 if let Some(id) = item["tool_use_id"].as_str() {
125 let result = match item.get("is_error") {
126 Some(Value::Bool(true)) => Outcome::Failed,
127 Some(Value::Bool(false)) | None => Outcome::Succeeded,
128 _ => Outcome::Unknown,
129 };
130 results
131 .entry(id.to_owned())
132 .and_modify(|old| {
133 if *old != result {
134 *old = Outcome::Unknown;
135 }
136 })
137 .or_insert(result);
138 }
139 }
140 }
141 continue;
142 }
143 if record["type"] != "assistant" {
144 continue;
145 }
146 let at = record["timestamp"]
147 .as_str()
148 .and_then(|ts| OffsetDateTime::parse(ts, &Rfc3339).ok())
149 .map(|t| t.unix_timestamp())
150 .unwrap_or(0);
151 let Some(content) = record["message"]["content"].as_array() else {
152 continue;
153 };
154 let cwd = record["cwd"].as_str().map(Path::new).filter(|p| p.is_absolute()).unwrap_or(cwd);
155 for item in content.iter().filter(|item| item["type"] == "tool_use") {
156 let mut found = tool_events(
157 session,
158 cwd,
159 item["name"].as_str().unwrap_or_default(),
160 &item["input"],
161 at,
162 Source::Transcript,
163 );
164 for event in &mut found {
165 event.tool_call_id = item["id"].as_str().map(str::to_owned);
166 }
167 events.extend(found);
168 }
169 }
170 for event in &mut events {
171 if let Some(result) = event.tool_call_id.as_ref().and_then(|id| results.get(id)) {
172 event.outcome = *result;
173 }
174 }
175 events
176}