use crate::context::ContextReader;
use crate::context::ir::{IrMessage, IrPart, build_tool_call, extract_text};
use crate::message::{
AssistantResponse, Context, ContextListing, ConversationMessage, Entry, MessageKind,
TextContent,
};
use anyhow::Context as _;
use rusqlite::Connection;
use serde_json::Value;
use std::collections::BTreeMap;
use std::path::PathBuf;
pub struct OpenCodeReader {
db_path: PathBuf,
}
impl OpenCodeReader {
pub fn new(db_path: PathBuf) -> Self {
Self { db_path }
}
}
impl ContextReader for OpenCodeReader {
fn list_contexts(&self) -> anyhow::Result<Vec<ContextListing>> {
let conn = Connection::open(&self.db_path)
.with_context(|| format!("failed to open opencode db at {}", self.db_path.display()))?;
let sql = "SELECT session_id, COUNT(*), MIN(time_created), MAX(time_created) \
FROM message GROUP BY session_id ORDER BY MAX(time_created) DESC";
let mut stmt = conn.prepare(sql)?;
let rows = stmt.query_map([], |row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, i64>(1)?,
row.get::<_, i64>(2)?,
row.get::<_, i64>(3)?,
))
})?;
let mut contexts = Vec::new();
for row in rows {
let (session_id, count, min_time, max_time) = row?;
let detail = format!(
"{} messages, {} to {}",
count,
format_time(min_time),
format_time(max_time)
);
contexts.push(ContextListing {
id: session_id,
detail,
path: Some(self.db_path.clone()),
});
}
Ok(contexts)
}
fn read_context(&self, context_id: &str) -> anyhow::Result<Context> {
let conn = Connection::open(&self.db_path)
.with_context(|| format!("failed to open opencode db at {}", self.db_path.display()))?;
let sql = "SELECT id, data FROM message WHERE session_id = ?1 ORDER BY time_created";
let mut stmt = conn.prepare(sql)?;
let rows = stmt.query_map(rusqlite::params![context_id], |row| {
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
})?;
let mut messages_data: Vec<(String, Value)> = Vec::new();
for row in rows {
let (id, data_str) = row?;
let data: Value = serde_json::from_str(&data_str)?;
messages_data.push((id, data));
}
let part_sql =
"SELECT message_id, data FROM part WHERE session_id = ?1 ORDER BY time_created";
let mut part_stmt = conn.prepare(part_sql)?;
let part_rows = part_stmt.query_map(rusqlite::params![context_id], |row| {
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
})?;
let mut parts: Vec<(String, Value)> = Vec::new();
for row in part_rows {
let (msg_id, data_str) = row?;
let data: Value = serde_json::from_str(&data_str)?;
parts.push((msg_id, data));
}
let mut entries = Vec::new();
let mut messages = Vec::new();
for (msg_id, msg_data) in &messages_data {
let role = msg_data["role"].as_str().unwrap_or("unknown");
let entry_id = msg_data["id"]
.as_str()
.map_or_else(|| msg_id.clone(), std::string::ToString::to_string);
let parent_id = msg_data["parentID"]
.as_str()
.map(std::string::ToString::to_string)
.unwrap_or_default();
let msg_parts: Vec<&Value> = parts
.iter()
.filter(|(mid, _)| mid == msg_id)
.map(|(_, d)| d)
.collect();
let (kind, role_metadata) = build_message_kind_with_metadata(role, &msg_parts);
let mut full_metadata = opencode_metadata(msg_data, &msg_parts);
full_metadata.extend(role_metadata);
let mut message = ConversationMessage::new(entry_id.clone(), kind);
message.metadata = full_metadata;
messages.push(message);
entries.push(Entry {
id: entry_id,
parent_id,
});
}
Ok(Context { entries, messages })
}
}
fn build_message_kind_with_metadata(
role: &str,
parts: &[&Value],
) -> (MessageKind, BTreeMap<String, Value>) {
let mut metadata = BTreeMap::new();
metadata.insert("role".to_string(), Value::String(role.to_string()));
let kind = match role {
"assistant" => {
let mut ir = IrMessage::new();
for part in parts {
match part["type"].as_str() {
Some("text") => {
ir.push(IrPart::text(part["text"].as_str().unwrap_or("")));
}
Some("reasoning") => {
if let Some(text) = part["text"].as_str() {
ir.push(IrPart::thinking(text));
}
}
Some("tool") => {
if let Some(name) = part["name"].as_str() {
ir.push(IrPart::tool_call(build_tool_call(
name,
part.get("arguments"),
)));
}
}
_ => {}
}
}
if ir.is_empty() {
return (
MessageKind::AssistantResponse(AssistantResponse {
thinking: Vec::new(),
tool_calls: Vec::new(),
text: String::new(),
}),
metadata,
);
}
MessageKind::AssistantResponse(AssistantResponse {
thinking: ir.thinking(),
tool_calls: ir.tool_calls(),
text: ir.text(),
})
}
_ => MessageKind::TextContent(TextContent {
role: role.to_string(),
text: extract_text_from_parts(parts),
}),
};
(kind, metadata)
}
fn extract_text_from_parts(parts: &[&Value]) -> String {
let value = Value::Array(parts.iter().map(|v| (*v).clone()).collect());
extract_text(Some(&value))
}
fn format_time(ts: i64) -> String {
if ts <= 0 {
return "unknown".to_string();
}
let Some(dt) = chrono::DateTime::from_timestamp(ts, 0) else {
return ts.to_string();
};
dt.format("%Y-%m-%d %H:%M").to_string()
}
fn opencode_metadata(msg_data: &Value, parts: &[&Value]) -> BTreeMap<String, Value> {
let mut metadata = BTreeMap::new();
if let Some(id) = msg_data["id"].as_str() {
metadata.insert("message_id".to_string(), Value::String(id.to_string()));
}
if let Some(parent) = msg_data["parentID"].as_str() {
metadata.insert("parent_id".to_string(), Value::String(parent.to_string()));
}
if let Some(ts) = msg_data["time_created"].as_i64() {
metadata.insert("time_created".to_string(), Value::Number(ts.into()));
}
if let Some(part) = parts.first() {
if let Some(part_type) = part["type"].as_str() {
metadata.insert(
"part_type".to_string(),
Value::String(part_type.to_string()),
);
}
}
metadata
}