use std::collections::{HashMap, HashSet};
use chrono::DateTime;
use khive_runtime::secret_gate;
use serde_json::{Map, Value};
fn mask_session_mirror(text: &str) -> std::borrow::Cow<'_, str> {
secret_gate::mask_for_redaction_surface(secret_gate::RedactionSurface::SessionMirror, text)
}
fn mask_session_mirror_bounded(text: &str, output_cap_chars: usize) -> String {
secret_gate::mask_bounded(
secret_gate::RedactionSurface::SessionMirror,
text,
secret_gate::MASK_WINDOW_CHARS,
output_cap_chars,
)
.text
}
#[derive(Debug, Clone, PartialEq)]
pub struct ParsedEvent {
pub uuid: String,
pub session_id: String,
pub parent_uuid: Option<String>,
pub is_sidechain: bool,
pub role: Option<String>,
pub msg_type: String,
pub text: Option<String>,
pub raw: String,
pub created_at_micros: i64,
pub cwd: Option<String>,
pub git_branch: Option<String>,
pub slug: Option<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub(crate) struct ParsedSession {
pub(crate) session_id: String,
pub(crate) created_at_micros: i64,
pub(crate) cwd: Option<String>,
pub(crate) git_branch: Option<String>,
pub(crate) slug: Option<String>,
}
#[derive(Debug, Clone, PartialEq)]
pub(crate) struct ParsedExport {
pub(crate) sessions: Vec<ParsedSession>,
pub(crate) events: Vec<ParsedEvent>,
}
pub fn parse_cc_line(line: &str) -> Option<ParsedEvent> {
let trimmed = line.trim();
if trimmed.is_empty() {
return None;
}
let obj: Value = serde_json::from_str(trimmed).ok()?;
let map = obj.as_object()?;
let uuid = map.get("uuid")?.as_str()?.to_string();
if uuid.is_empty() {
return None;
}
let session_id = map.get("sessionId")?.as_str()?.to_string();
if session_id.is_empty() {
return None;
}
let parent_uuid = map
.get("parentUuid")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map(str::to_string);
let is_sidechain = map
.get("isSidechain")
.and_then(|v| v.as_bool())
.unwrap_or(false);
let msg_type = map
.get("type")
.and_then(|v| v.as_str())
.unwrap_or("unknown")
.to_string();
let cwd = map
.get("cwd")
.and_then(|v| v.as_str())
.map(|s| mask_session_mirror(s).into_owned());
let git_branch = map
.get("gitBranch")
.and_then(|v| v.as_str())
.map(|s| mask_session_mirror(s).into_owned());
let slug = map
.get("slug")
.and_then(|v| v.as_str())
.map(|s| mask_session_mirror(s).into_owned());
let created_at_micros = map
.get("timestamp")
.and_then(|v| v.as_str())
.and_then(|ts| DateTime::parse_from_rfc3339(ts).ok())
.map(|dt| dt.timestamp_micros())
.unwrap_or(0);
let (role, text) = match map.get("message").and_then(|m| m.as_object()) {
None => (None, None),
Some(msg) => {
let role = msg.get("role").and_then(|v| v.as_str()).map(str::to_string);
let text = extract_text(msg.get("content"));
(role, text)
}
};
let raw = mask_session_mirror(trimmed).into_owned();
let text = text.map(|t| mask_session_mirror(&t).into_owned());
Some(ParsedEvent {
uuid,
session_id,
parent_uuid,
is_sidechain,
role,
msg_type,
text,
raw,
created_at_micros,
cwd,
git_branch,
slug,
})
}
pub fn parse_codex_line(line: &str, session_id: &str, abs_byte_offset: u64) -> Option<ParsedEvent> {
let trimmed = line.trim();
if trimmed.is_empty() {
return None;
}
let obj: Value = serde_json::from_str(trimmed).ok()?;
let map = obj.as_object()?;
let line_type = map.get("type")?.as_str()?;
if line_type == "event_msg" {
return None;
}
let created_at_micros = map
.get("timestamp")
.and_then(|v| v.as_str())
.and_then(|ts| DateTime::parse_from_rfc3339(ts).ok())
.map(|dt| dt.timestamp_micros())
.unwrap_or(0);
match line_type {
"session_meta" => {
let payload = map.get("payload").and_then(|v| v.as_object());
let cwd = payload
.and_then(|p| p.get("cwd"))
.and_then(|v| v.as_str())
.map(|s| mask_session_mirror(s).into_owned());
let git_branch = payload
.and_then(|p| p.get("git"))
.and_then(|g| g.as_object())
.and_then(|g| g.get("branch"))
.and_then(|v| v.as_str())
.map(|s| mask_session_mirror(s).into_owned());
let uuid = format!("{session_id}:{abs_byte_offset}");
let raw = mask_session_mirror(trimmed).into_owned();
Some(ParsedEvent {
uuid,
session_id: session_id.to_string(),
parent_uuid: None,
is_sidechain: false,
role: None,
msg_type: "session_meta".to_string(),
text: None,
raw,
created_at_micros,
cwd,
git_branch,
slug: None,
})
}
"response_item" => {
let payload = map.get("payload").and_then(|v| v.as_object())?;
if payload.get("type").and_then(|v| v.as_str()) != Some("message") {
return None;
}
let role = payload
.get("role")
.and_then(|v| v.as_str())
.map(str::to_string);
let text = extract_text(payload.get("content"));
let text = text.map(|t| mask_session_mirror_bounded(&t, 500));
let uuid = format!("{session_id}:{abs_byte_offset}");
let raw = mask_session_mirror(trimmed).into_owned();
Some(ParsedEvent {
uuid,
session_id: session_id.to_string(),
parent_uuid: None,
is_sidechain: false,
role,
msg_type: "response_item".to_string(),
text,
raw,
created_at_micros,
cwd: None,
git_branch: None,
slug: None,
})
}
_ => None,
}
}
pub fn parse_chatgpt_export(content: &str) -> Option<Vec<ParsedEvent>> {
let value: Value = serde_json::from_str(content).ok()?;
let conversations = value.as_array()?;
if conversations.iter().any(is_claude_ai_conversation) {
return None;
}
let mut events = Vec::new();
for conv in conversations {
parse_conversation(conv, &mut events);
}
Some(events)
}
pub fn parse_claude_ai_export(content: &str) -> Option<Vec<ParsedEvent>> {
parse_claude_ai_export_with_sessions(content).map(|parsed| parsed.events)
}
pub(crate) fn parse_claude_ai_export_with_sessions(content: &str) -> Option<ParsedExport> {
let value: Value = serde_json::from_str(content).ok()?;
let conversations = value.as_array()?;
if conversations.iter().any(is_chatgpt_conversation) {
return None;
}
let mut sessions = Vec::new();
let mut events = Vec::new();
for conversation in conversations {
if let Some(session) = parse_claude_ai_conversation(conversation, &mut events) {
sessions.push(session);
}
}
Some(ParsedExport { sessions, events })
}
fn is_chatgpt_conversation(conversation: &Value) -> bool {
conversation.as_object().is_some_and(|conversation| {
conversation
.get("id")
.and_then(Value::as_str)
.is_some_and(|id| !id.is_empty())
&& conversation.get("mapping").is_some_and(Value::is_object)
})
}
fn is_claude_ai_conversation(conversation: &Value) -> bool {
conversation.as_object().is_some_and(|conversation| {
conversation
.get("uuid")
.and_then(Value::as_str)
.is_some_and(|id| !id.is_empty())
&& conversation
.get("chat_messages")
.is_some_and(Value::is_array)
})
}
fn parse_claude_ai_conversation(
conversation: &Value,
out: &mut Vec<ParsedEvent>,
) -> Option<ParsedSession> {
let conversation = conversation.as_object()?;
let session_id = conversation
.get("uuid")
.and_then(Value::as_str)
.filter(|id| !id.is_empty())?;
let messages = conversation
.get("chat_messages")
.and_then(Value::as_array)?;
let slug = conversation
.get("name")
.and_then(Value::as_str)
.filter(|name| !name.is_empty())
.or_else(|| {
conversation
.get("summary")
.and_then(Value::as_str)
.filter(|summary| !summary.is_empty())
})
.map(|title| mask_session_mirror(title).into_owned());
let conversation_created_at_micros = conversation
.get("created_at")
.and_then(parse_rfc3339_micros)
.or_else(|| {
conversation
.get("updated_at")
.and_then(parse_rfc3339_micros)
})
.unwrap_or(0);
let mut parent_by_id: HashMap<String, Option<String>> = HashMap::new();
for message in messages {
let Some(message) = message.as_object() else {
continue;
};
let Some(uuid) = message
.get("uuid")
.and_then(Value::as_str)
.filter(|id| !id.is_empty())
else {
continue;
};
parent_by_id
.entry(uuid.to_string())
.or_insert_with(|| claude_ai_parent_uuid(message));
}
let current_path = claude_ai_current_path(conversation, &parent_by_id);
let mut order: Vec<usize> = (0..messages.len()).collect();
order.sort_by_key(|&position| {
let source_index = messages[position]
.as_object()
.and_then(|message| message.get("index"))
.and_then(Value::as_i64)
.unwrap_or(position as i64);
(source_index, position)
});
let mut emitted = HashSet::new();
let start = out.len();
for position in order {
let Some(message) = messages[position].as_object() else {
continue;
};
let Some(uuid) = message
.get("uuid")
.and_then(Value::as_str)
.filter(|id| !id.is_empty())
else {
continue;
};
if !emitted.insert(uuid.to_string()) {
continue;
}
if let Some(event) = build_claude_ai_event(
message,
session_id,
slug.as_deref(),
conversation_created_at_micros,
¤t_path,
) {
out.push(event);
}
}
let stored_ids: HashSet<String> = out[start..]
.iter()
.map(|event| event.uuid.clone())
.collect();
for event in &mut out[start..] {
if event
.parent_uuid
.as_ref()
.is_some_and(|parent| !stored_ids.contains(parent))
{
event.parent_uuid = None;
}
}
Some(ParsedSession {
session_id: session_id.to_string(),
created_at_micros: conversation_created_at_micros,
cwd: None,
git_branch: None,
slug,
})
}
fn claude_ai_current_path(
conversation: &Map<String, Value>,
parent_by_id: &HashMap<String, Option<String>>,
) -> HashSet<String> {
let Some(current_leaf) = conversation
.get("current_leaf_message_uuid")
.and_then(Value::as_str)
.filter(|id| parent_by_id.contains_key(*id))
else {
return parent_by_id.keys().cloned().collect();
};
let mut path = HashSet::new();
let mut cursor = Some(current_leaf.to_string());
while let Some(message_id) = cursor {
if !path.insert(message_id.clone()) {
break;
}
cursor = parent_by_id.get(&message_id).cloned().flatten();
}
path
}
fn build_claude_ai_event(
message: &Map<String, Value>,
session_id: &str,
slug: Option<&str>,
conversation_created_at_micros: i64,
current_path: &HashSet<String>,
) -> Option<ParsedEvent> {
let uuid = message
.get("uuid")
.and_then(Value::as_str)
.filter(|id| !id.is_empty())?
.to_string();
let role = message
.get("sender")
.or_else(|| message.get("role"))
.and_then(Value::as_str)
.filter(|sender| !sender.is_empty())
.map(|sender| match sender {
"human" | "user" => "user".to_string(),
other => other.to_string(),
});
let text = extract_claude_ai_text(message)?;
if text.trim().is_empty() {
return None;
}
let created_at_micros = message
.get("created_at")
.and_then(parse_rfc3339_micros)
.or_else(|| message.get("updated_at").and_then(parse_rfc3339_micros))
.unwrap_or(conversation_created_at_micros);
let parent_uuid = claude_ai_parent_uuid(message);
let raw_json = serde_json::to_string(message).unwrap_or_default();
Some(ParsedEvent {
uuid: uuid.clone(),
session_id: session_id.to_string(),
parent_uuid,
is_sidechain: !current_path.contains(&uuid),
role,
msg_type: "message".to_string(),
text: Some(mask_session_mirror(&text).into_owned()),
raw: mask_session_mirror(&raw_json).into_owned(),
created_at_micros,
cwd: None,
git_branch: None,
slug: slug.map(str::to_string),
})
}
fn claude_ai_parent_uuid(message: &Map<String, Value>) -> Option<String> {
message
.get("parent_message_uuid")
.and_then(Value::as_str)
.filter(|parent| !parent.is_empty() && *parent != "00000000-0000-4000-8000-000000000000")
.map(str::to_string)
}
fn extract_claude_ai_text(message: &Map<String, Value>) -> Option<String> {
let top_level_text = message
.get("text")
.and_then(Value::as_str)
.filter(|text| !text.trim().is_empty());
let mut parts = Vec::new();
match message.get("content") {
Some(Value::Array(blocks)) => {
for part in blocks
.iter()
.filter_map(extract_block)
.filter(|part| !part.trim().is_empty())
{
parts.push(part);
}
}
Some(Value::String(text)) if !text.trim().is_empty() => parts.push(text.clone()),
Some(_) | None => {}
}
if let Some(text) = top_level_text {
if !parts.iter().any(|part| part == text) {
parts.push(text.to_string());
}
}
(!parts.is_empty()).then(|| parts.join("\n"))
}
fn parse_rfc3339_micros(value: &Value) -> Option<i64> {
value
.as_str()
.and_then(|timestamp| DateTime::parse_from_rfc3339(timestamp).ok())
.map(|timestamp| timestamp.timestamp_micros())
}
fn extract_text(content: Option<&Value>) -> Option<String> {
match content? {
Value::String(s) => Some(s.clone()),
Value::Array(blocks) => {
let parts: Vec<String> = blocks.iter().filter_map(extract_block).collect();
if parts.is_empty() {
None
} else {
Some(parts.join("\n"))
}
}
_ => None,
}
}
fn extract_block(block: &Value) -> Option<String> {
let map = block.as_object()?;
match map.get("type")?.as_str()? {
"text" | "input_text" | "output_text" | "voice_note" => {
map.get("text").and_then(|v| v.as_str()).map(str::to_string)
}
"tool_use" => {
let name = map
.get("name")
.and_then(|v| v.as_str())
.unwrap_or("unknown");
let input = map.get("input").cloned().unwrap_or(Value::Null);
let input_json = serde_json::to_string(&input).unwrap_or_default();
let input_str = mask_session_mirror_bounded(&input_json, 500);
Some(format!("[tool_use: {name}] {input_str}"))
}
"tool_result" => {
let content_val = map.get("content").cloned().unwrap_or(Value::Null);
let content_str = match &content_val {
Value::String(s) => s.clone(),
other => serde_json::to_string(other).unwrap_or_default(),
};
Some(format!(
"[tool_result] {}",
mask_session_mirror_bounded(&content_str, 500)
))
}
_ => None,
}
}
struct ConvContext<'a> {
mapping: &'a Map<String, Value>,
current_path: &'a HashSet<String>,
session_id: &'a str,
conv_created_at_micros: i64,
slug: Option<&'a str>,
}
fn parse_conversation(conv: &Value, out: &mut Vec<ParsedEvent>) {
let Some(conv_obj) = conv.as_object() else {
return;
};
let Some(session_id) = conv_obj
.get("id")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
else {
return;
};
let Some(mapping) = conv_obj.get("mapping").and_then(|v| v.as_object()) else {
return;
};
let slug = conv_obj
.get("title")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map(|title| mask_session_mirror(title).into_owned());
let conv_created_at_micros = conv_obj
.get("create_time")
.and_then(|v| v.as_f64())
.map(|secs| (secs * 1_000_000.0) as i64)
.unwrap_or(0);
let mut current_path: HashSet<String> = HashSet::new();
if let Some(current_node) = conv_obj.get("current_node").and_then(|v| v.as_str()) {
let mut cursor = Some(current_node.to_string());
while let Some(node_id) = cursor {
if !current_path.insert(node_id.clone()) {
break; }
cursor = mapping
.get(&node_id)
.and_then(|n| n.as_object())
.and_then(|n| n.get("parent"))
.and_then(|v| v.as_str())
.map(str::to_string);
}
}
let root_id = mapping.iter().find_map(|(id, node)| {
let node_obj = node.as_object()?;
let parent_is_null = node_obj.get("parent").map(|v| v.is_null()).unwrap_or(true);
parent_is_null.then(|| id.clone())
});
let Some(root_id) = root_id else {
return;
};
let ctx = ConvContext {
mapping,
current_path: ¤t_path,
session_id,
conv_created_at_micros,
slug: slug.as_deref(),
};
let mut stack: Vec<String> = vec![root_id];
let mut visited: HashSet<String> = HashSet::new();
while let Some(node_id) = stack.pop() {
if !visited.insert(node_id.clone()) {
continue; }
let Some(node) = mapping.get(&node_id).and_then(|n| n.as_object()) else {
continue;
};
if let Some(message) = node.get("message").filter(|m| !m.is_null()) {
if let Some(message_obj) = message.as_object() {
if let Some(ev) = build_chatgpt_event(&node_id, node, message_obj, &ctx) {
out.push(ev);
}
}
}
if let Some(children) = node.get("children").and_then(|c| c.as_array()) {
for child in children.iter().rev() {
if let Some(child_id) = child.as_str() {
stack.push(child_id.to_string());
}
}
}
}
}
fn build_chatgpt_event(
node_id: &str,
node: &Map<String, Value>,
message: &Map<String, Value>,
ctx: &ConvContext,
) -> Option<ParsedEvent> {
let uuid = message
.get("id")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())?
.to_string();
let role = message
.get("author")
.and_then(|a| a.as_object())
.and_then(|a| a.get("role"))
.and_then(|v| v.as_str())
.map(str::to_string);
let content = message.get("content").and_then(|c| c.as_object());
let content_type = content
.and_then(|c| c.get("content_type"))
.and_then(|v| v.as_str())
.unwrap_or("unknown")
.to_string();
let text = extract_chatgpt_text(&content_type, content)?;
if text.trim().is_empty() {
return None;
}
let created_at_micros = message
.get("create_time")
.and_then(|v| v.as_f64())
.map(|secs| (secs * 1_000_000.0) as i64)
.unwrap_or(ctx.conv_created_at_micros);
let parent_uuid = node
.get("parent")
.and_then(|v| v.as_str())
.filter(|pid| {
ctx.mapping
.get(*pid)
.and_then(|p| p.as_object())
.and_then(|p| p.get("message"))
.map(|m| !m.is_null())
.unwrap_or(false)
})
.map(str::to_string);
let is_sidechain = !ctx.current_path.contains(node_id);
let raw_json = serde_json::to_string(node).unwrap_or_default();
let raw = mask_session_mirror(&raw_json).into_owned();
let text = mask_session_mirror(&text).into_owned();
Some(ParsedEvent {
uuid,
session_id: ctx.session_id.to_string(),
parent_uuid,
is_sidechain,
role,
msg_type: content_type,
text: Some(text),
raw,
created_at_micros,
cwd: None,
git_branch: None,
slug: ctx.slug.map(str::to_string),
})
}
fn extract_chatgpt_text(
content_type: &str,
content: Option<&Map<String, Value>>,
) -> Option<String> {
let content = content?;
if content_type == "text" {
let parts = content.get("parts")?.as_array()?;
let joined: Vec<String> = parts
.iter()
.filter_map(|p| p.as_str().map(str::to_string))
.collect();
return if joined.is_empty() {
None
} else {
Some(joined.join("\n"))
};
}
if let Some(text) = content.get("text").and_then(|v| v.as_str()) {
return Some(text.to_string());
}
let parts = content.get("parts")?.as_array()?;
let joined: Vec<String> = parts
.iter()
.filter_map(|p| p.as_str().map(str::to_string))
.collect();
if joined.is_empty() {
None
} else {
Some(joined.join("\n"))
}
}
#[cfg(test)]
#[path = "parse_tests.rs"]
mod tests;