use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
fn truncate_on_char_boundary(s: &str, max_bytes: usize) -> &str {
if s.len() <= max_bytes {
return s;
}
let mut end = max_bytes;
while end > 0 && !s.is_char_boundary(end) {
end -= 1;
}
&s[..end]
}
fn extraction_watermark_path() -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
PathBuf::from(home)
.join(".ctxone")
.join("extraction-watermarks.json")
}
fn load_watermarks_at(p: &Path) -> BTreeMap<String, usize> {
std::fs::read(p)
.ok()
.and_then(|b| serde_json::from_slice(&b).ok())
.unwrap_or_default()
}
fn set_watermark_at(p: &Path, session_id: &str, count: usize) {
if let Some(dir) = p.parent() {
let _ = std::fs::create_dir_all(dir);
}
let mut map = load_watermarks_at(p);
let entry = map.entry(session_id.to_string()).or_insert(0);
if count <= *entry {
return; }
*entry = count;
if let Ok(bytes) = serde_json::to_vec(&map) {
let tmp = p.with_extension("json.tmp");
if std::fs::write(&tmp, &bytes).is_ok() {
let _ = std::fs::rename(&tmp, p);
}
}
}
pub fn extraction_watermark(session_id: &str) -> usize {
load_watermarks_at(&extraction_watermark_path())
.get(session_id)
.copied()
.unwrap_or(0)
}
pub fn set_extraction_watermark(session_id: &str, count: usize) {
set_watermark_at(&extraction_watermark_path(), session_id, count);
}
#[derive(Debug, Default, Serialize)]
pub struct TurnTokens {
pub input: u64,
pub output: u64,
pub cache_read: u64,
pub cache_creation: u64,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub extra: BTreeMap<String, u64>,
}
impl TurnTokens {
pub fn is_empty(&self) -> bool {
self.input == 0 && self.output == 0 && self.extra.is_empty()
}
pub fn add(&mut self, other: &TurnTokens) {
self.input += other.input;
self.output += other.output;
self.cache_read += other.cache_read;
self.cache_creation += other.cache_creation;
for (k, v) in &other.extra {
*self.extra.entry(k.clone()).or_insert(0) += *v;
}
}
}
#[derive(Debug)]
pub struct Turn {
pub user_text: String,
pub assistant_text: String,
pub tool_calls: Vec<String>,
pub tool_calls_raw: Vec<Value>,
pub tokens: TurnTokens,
pub model: String,
pub timestamp: String,
pub cwd: Option<String>,
pub git_branches: Vec<String>,
pub git_commit: Option<String>,
}
impl Turn {
pub fn is_substantial(&self) -> bool {
self.assistant_text.len() > 100 || !self.tool_calls.is_empty()
}
pub fn to_exchange_text(&self) -> String {
let mut out = String::new();
out.push_str("USER:\n");
out.push_str(&self.user_text);
out.push_str("\n\nASSISTANT:\n");
let text = if self.assistant_text.len() > 8000 {
format!(
"{}…[truncated]",
truncate_on_char_boundary(&self.assistant_text, 8000)
)
} else {
self.assistant_text.clone()
};
out.push_str(&text);
if !self.tool_calls.is_empty() {
out.push_str("\n\nTOOLS USED:\n");
for t in &self.tool_calls {
out.push_str("- ");
out.push_str(t);
out.push('\n');
}
}
out
}
}
pub fn parse_turns(path: &Path) -> Vec<Turn> {
let content = match std::fs::read_to_string(path) {
Ok(c) => c,
Err(e) => {
eprintln!(" warn: could not read {}: {}", path.display(), e);
return vec![];
}
};
let entries: Vec<Value> = content
.lines()
.filter(|l| !l.trim().is_empty())
.filter_map(|l| serde_json::from_str(l).ok())
.collect();
let mut turns: Vec<Turn> = vec![];
let mut current_user: Option<String> = None;
let mut current_ts: String = String::new();
let mut current_cwd: Option<String> = None;
let mut current_branch: Option<String> = None;
for entry in &entries {
let typ = entry.get("type").and_then(|v| v.as_str()).unwrap_or("");
match typ {
"user" => {
let raw = extract_text_content(entry.get("message"));
if !raw.trim().is_empty() {
current_user = Some(strip_synthetic_blocks(&raw));
current_ts = entry
.get("timestamp")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string();
current_cwd = str_field(entry, "cwd");
current_branch = str_field(entry, "gitBranch");
} else {
let branch = str_field(entry, "gitBranch");
match turns.last_mut() {
Some(last) => push_unique(&mut last.git_branches, branch),
None => push_unique_opt(&mut current_branch, branch),
}
}
}
"assistant" => {
let Some(ref user_text) = current_user else {
continue;
};
let msg = match entry.get("message") {
Some(m) => m,
None => continue,
};
let assistant_text = extract_text_content(Some(msg));
let tool_calls = extract_tool_calls(msg);
let tool_calls_raw = extract_tool_calls_raw(msg);
let tokens = extract_tokens(msg);
let model = msg
.get("model")
.and_then(|v| v.as_str())
.unwrap_or("unknown")
.to_string();
if let Some(last) = turns.last_mut() {
if last.user_text == *user_text {
last.assistant_text.push('\n');
last.assistant_text.push_str(&assistant_text);
last.tool_calls.extend(tool_calls);
last.tool_calls_raw.extend(tool_calls_raw);
last.tokens.add(&tokens);
if !model.is_empty() && model != "unknown" {
last.model = model;
}
if last.cwd.is_none() {
last.cwd = str_field(entry, "cwd");
}
push_unique(&mut last.git_branches, str_field(entry, "gitBranch"));
continue;
}
}
turns.push(Turn {
user_text: user_text.clone(),
assistant_text,
tool_calls,
tool_calls_raw,
tokens,
model,
timestamp: current_ts.clone(),
cwd: str_field(entry, "cwd").or_else(|| current_cwd.clone()),
git_branches: {
let mut b = Vec::new();
push_unique(&mut b, current_branch.clone());
push_unique(&mut b, str_field(entry, "gitBranch"));
b
},
git_commit: None, });
}
_ => {}
}
}
turns
}
fn push_unique_opt(slot: &mut Option<String>, v: Option<String>) {
if slot.is_none() {
*slot = v;
}
}
fn push_unique(list: &mut Vec<String>, v: Option<String>) {
if let Some(v) = v
&& !list.iter().any(|x| *x == v)
{
list.push(v);
}
}
fn str_field(v: &Value, key: &str) -> Option<String> {
v.get(key)
.and_then(|x| x.as_str())
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_string)
}
const SYNTHETIC_TAGS: &[&str] = &[
"system-reminder",
"task-notification",
"local-command-caveat",
"local-command-stdout",
"local-command-message",
"local-command-name",
"local-command-args",
];
fn strip_synthetic_blocks(text: &str) -> String {
let mut s = text.to_string();
for tag in SYNTHETIC_TAGS {
let open = format!("<{tag}>");
let close = format!("</{tag}>");
loop {
let Some(start) = s.find(&open) else { break };
match s[start + open.len()..].find(&close) {
Some(rel) => {
let end = start + open.len() + rel + close.len();
s.replace_range(start..end, "");
}
None => {
s.truncate(start);
break;
}
}
}
}
let trimmed = s.trim_start();
if trimmed.starts_with("[SYSTEM NOTIFICATION") {
if let Some(nl) = trimmed.find("\n\n") {
return trimmed[nl..].trim().to_string();
}
}
s.trim().to_string()
}
fn extract_text_content(msg: Option<&Value>) -> String {
let msg = match msg {
Some(m) => m,
None => return String::new(),
};
match msg.get("content") {
Some(Value::String(s)) => s.clone(),
Some(Value::Array(blocks)) => {
let mut out = String::new();
for block in blocks {
let btype = block.get("type").and_then(|v| v.as_str()).unwrap_or("");
match btype {
"text" => {
if let Some(t) = block.get("text").and_then(|v| v.as_str()) {
if !out.is_empty() {
out.push('\n');
}
out.push_str(t);
}
}
_ => {}
}
}
out
}
_ => String::new(),
}
}
fn extract_tool_calls(msg: &Value) -> Vec<String> {
let blocks = match msg.get("content").and_then(|v| v.as_array()) {
Some(b) => b,
None => return vec![],
};
let mut calls = vec![];
for block in blocks {
if block.get("type").and_then(|v| v.as_str()) != Some("tool_use") {
continue;
}
let name = block
.get("name")
.and_then(|v| v.as_str())
.unwrap_or("Unknown");
let input = block.get("input").cloned().unwrap_or(Value::Null);
let summary = match name {
"Bash" => input
.get("command")
.and_then(|v| v.as_str())
.map(|c| {
let c = c.trim();
if c.len() > 120 {
format!("{}…", truncate_on_char_boundary(c, 120))
} else {
c.to_string()
}
})
.unwrap_or_default(),
"Write" | "Read" | "Edit" | "Glob" | "Grep" => input
.get("file_path")
.or_else(|| input.get("path"))
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string(),
"Agent" => input
.get("description")
.and_then(|v| v.as_str())
.unwrap_or("sub-agent")
.to_string(),
_ => String::new(),
};
if summary.is_empty() {
calls.push(name.to_string());
} else {
calls.push(format!("{}: {}", name, summary));
}
}
calls
}
fn extract_tool_calls_raw(msg: &Value) -> Vec<Value> {
let blocks = match msg.get("content").and_then(|v| v.as_array()) {
Some(b) => b,
None => return vec![],
};
let mut out = vec![];
for block in blocks {
if block.get("type").and_then(|v| v.as_str()) != Some("tool_use") {
continue;
}
let name = block.get("name").cloned().unwrap_or(Value::Null);
let input = block.get("input").cloned().unwrap_or(Value::Null);
let id = block.get("id").cloned().unwrap_or(Value::Null);
out.push(serde_json::json!({ "id": id, "name": name, "input": input }));
}
out
}
fn extract_tokens(msg: &Value) -> TurnTokens {
let usage = match msg.get("usage") {
Some(u) => u,
None => return TurnTokens::default(),
};
TurnTokens {
input: usage
.get("input_tokens")
.and_then(|v| v.as_u64())
.unwrap_or(0),
output: usage
.get("output_tokens")
.and_then(|v| v.as_u64())
.unwrap_or(0),
cache_read: usage
.get("cache_read_input_tokens")
.and_then(|v| v.as_u64())
.unwrap_or(0),
cache_creation: usage
.get("cache_creation_input_tokens")
.and_then(|v| v.as_u64())
.unwrap_or(0),
extra: BTreeMap::new(),
}
}
const EXTRACTION_SYSTEM: &str = r#"You extract structured facts from AI coding conversations.
Given a conversation exchange, return a JSON array of memory objects.
Each object:
{
"path": "/category/subcategory/slug",
"title": "Short descriptive title (under 80 chars)",
"body": "The fact plus reasoning. Include why if a decision was made (1-3 sentences).",
"importance": "high|medium|low",
"context": "topic-tag"
}
Path categories:
/decisions/ — architectural or design choices and their rationale
/problems/ — issues encountered and how they were solved
/preferences/ — user preferences revealed through corrections or feedback
/conventions/ — coding, naming, or process conventions established
/constraints/ — technical or business limitations discovered
/progress/ — significant milestones or completions
/next-steps/ — what was explicitly deferred or planned next
Rules:
- Include options that were REJECTED and why — this is as valuable as what was chosen
- Capture user corrections ("no, do X instead") as /preferences/
- Only extract facts that will be useful to a future agent on this project
- Skip: routine file reads, search results, compilation output unless something important was revealed
- Return ONLY a valid JSON array. No markdown fences, no explanation."#;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ExtractionProvider {
Anthropic,
OpenAi,
Gemini,
OpenAiCompatible,
}
impl ExtractionProvider {
fn parse(s: &str) -> Option<Self> {
match s.trim().to_ascii_lowercase().as_str() {
"anthropic" | "claude" => Some(Self::Anthropic),
"openai" => Some(Self::OpenAi),
"gemini" | "google" => Some(Self::Gemini),
"openai-compatible" | "openai_compatible" | "compatible" => {
Some(Self::OpenAiCompatible)
}
_ => None,
}
}
fn key_env(self) -> &'static str {
match self {
Self::Anthropic => "ANTHROPIC_API_KEY",
Self::OpenAi | Self::OpenAiCompatible => "OPENAI_API_KEY",
Self::Gemini => "GEMINI_API_KEY",
}
}
pub fn key_slug(self) -> &'static str {
match self {
Self::Anthropic => "anthropic",
Self::OpenAi => "openai",
Self::Gemini => "gemini",
Self::OpenAiCompatible => "openai-compatible",
}
}
}
pub async fn hub_analyzed_through(hub: &str, session: &str, client: &reqwest::Client) -> usize {
let url = format!("{}/api/sessions/{}/analysis", hub, urlencode(session));
let Ok(resp) = client
.get(&url)
.header("X-CTXone-Session", session)
.send()
.await
else {
return 0;
};
if !resp.status().is_success() {
return 0;
}
let v: Value = resp.json().await.unwrap_or(Value::Null);
v.get("analyzed_through")
.and_then(|x| x.as_u64())
.unwrap_or(0) as usize
}
pub async fn put_analysis(hub: &str, session: &str, body: &Value, client: &reqwest::Client) {
let url = format!("{}/api/sessions/{}/analysis", hub, urlencode(session));
let _ = client
.put(&url)
.header("X-CTXone-Session", session)
.json(body)
.send()
.await;
}
const SESSION_ANALYSIS_SYSTEM: &str = r#"You analyze an AI coding-agent session.
You are given a compact, turn-indexed transcript (one line per turn, "T<i> [branch] U: <user> | A: <assistant>").
Return ONLY a JSON object, no markdown fences:
{
"summary": "2-4 sentence summary of the whole session",
"topics": [
{"start": <first turn index>, "end": <last turn index>, "label": "short topic label", "summary": "1-2 sentence summary of this topic"}
]
}
A "topic" is a contiguous run of turns on one subject. A topic SHIFT (the work moves to a different subject) starts a new topic — these topic arcs act as pseudo-branches for clients that do not branch natively. Cover every turn; topics must be contiguous and non-overlapping, in order."#;
#[derive(Serialize, Deserialize, Debug)]
pub struct TopicArc {
pub start: usize,
pub end: usize,
pub label: String,
#[serde(default)]
pub summary: String,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SessionAnalysis {
#[serde(default)]
pub summary: String,
#[serde(default)]
pub topics: Vec<TopicArc>,
}
fn first_line(s: &str, max: usize) -> String {
let line = s
.lines()
.find(|l| !l.trim().is_empty())
.unwrap_or("")
.trim();
truncate_on_char_boundary(line, max).replace('\n', " ")
}
fn condensed_transcript(turns: &[Turn]) -> String {
let mut out = String::new();
for (i, t) in turns.iter().enumerate() {
let branch = t.git_branches.first().map(|s| s.as_str()).unwrap_or("");
out.push_str(&format!(
"T{i} [{branch}] U: {} | A: {}\n",
first_line(&t.user_text, 160),
first_line(&t.assistant_text, 200),
));
}
out
}
pub async fn analyze_session(
turns: &[Turn],
cfg: &ExtractionConfig,
client: &reqwest::Client,
) -> Option<SessionAnalysis> {
if turns.is_empty() {
return None;
}
let transcript = condensed_transcript(turns);
let transcript = truncate_on_char_boundary(&transcript, 24_000).to_string();
let raw = call_extraction_llm(cfg, SESSION_ANALYSIS_SYSTEM, &transcript, client).await?;
let json_str = raw
.trim()
.trim_start_matches("```json")
.trim_start_matches("```")
.trim_end_matches("```")
.trim();
match serde_json::from_str::<SessionAnalysis>(json_str) {
Ok(a) => Some(a),
Err(e) => {
eprintln!(" warn: could not parse session analysis: {e}");
None
}
}
}
fn urlencode(s: &str) -> String {
s.chars()
.map(|c| match c {
'a'..='z' | 'A'..='Z' | '0'..='9' | '-' | '_' | '.' | '~' => c.to_string(),
_ => format!("%{:02X}", c as u32),
})
.collect()
}
pub struct ExtractionConfig {
pub provider: ExtractionProvider,
pub model: String,
pub base_url: Option<String>,
pub api_key: String,
}
#[derive(Deserialize, Default)]
struct ExtractionToml {
enabled: Option<bool>,
provider: Option<String>,
model: Option<String>,
base_url: Option<String>,
key_file: Option<String>,
}
fn ctxone_home() -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
PathBuf::from(home).join(".ctxone")
}
fn read_key_file(path: &Path) -> Option<String> {
let k = std::fs::read_to_string(path).ok()?.trim().to_string();
(!k.is_empty()).then_some(k)
}
pub fn resolve_extraction_config() -> Option<ExtractionConfig> {
let cfg: ExtractionToml = std::fs::read_to_string(ctxone_home().join("extraction.toml"))
.ok()
.and_then(|s| toml::from_str(&s).ok())
.unwrap_or_default();
if cfg.enabled == Some(false) {
return None;
}
let provider = cfg
.provider
.as_deref()
.and_then(ExtractionProvider::parse)
.unwrap_or(ExtractionProvider::Anthropic);
let model = cfg.model.unwrap_or_else(|| match provider {
ExtractionProvider::Anthropic => "claude-haiku-4-5-20251001".to_string(),
ExtractionProvider::OpenAi | ExtractionProvider::OpenAiCompatible => {
"gpt-5-mini".to_string()
}
ExtractionProvider::Gemini => "gemini-3-flash".to_string(),
});
let api_key = cfg
.key_file
.as_deref()
.and_then(|p| read_key_file(Path::new(&shellexpand_home(p))))
.or_else(|| {
std::env::var(provider.key_env())
.ok()
.filter(|s| !s.is_empty())
})
.or_else(|| read_key_file(&ctxone_home().join("keys").join(provider.key_slug())))?;
Some(ExtractionConfig {
provider,
model,
base_url: cfg.base_url,
api_key,
})
}
fn shellexpand_home(p: &str) -> String {
if let Some(rest) = p.strip_prefix("~/") {
let home = std::env::var("HOME").unwrap_or_default();
format!("{home}/{rest}")
} else {
p.to_string()
}
}
#[derive(Serialize)]
struct AnthropicRequest {
model: String,
max_tokens: u32,
system: String,
messages: Vec<AnthropicMessage>,
}
#[derive(Serialize)]
struct AnthropicMessage {
role: String,
content: String,
}
#[derive(Deserialize)]
struct AnthropicResponse {
content: Vec<AnthropicContent>,
}
#[derive(Deserialize)]
struct AnthropicContent {
#[serde(rename = "type")]
content_type: String,
text: Option<String>,
}
#[derive(Deserialize, Debug)]
pub struct ExtractedMemory {
pub path: String,
pub title: String,
pub body: String,
pub importance: String,
pub context: String,
}
pub async fn extract_memories(
turn: &Turn,
cfg: &ExtractionConfig,
client: &reqwest::Client,
) -> Vec<ExtractedMemory> {
let exchange = turn.to_exchange_text();
let raw = match call_extraction_llm(cfg, EXTRACTION_SYSTEM, &exchange, client).await {
Some(r) => r,
None => return vec![],
};
let json_str = raw
.trim()
.trim_start_matches("```json")
.trim_start_matches("```")
.trim_end_matches("```")
.trim();
match serde_json::from_str::<Vec<ExtractedMemory>>(json_str) {
Ok(memories) => memories,
Err(e) => {
eprintln!(" warn: could not parse extracted memories: {}", e);
eprintln!(" raw: {}", truncate_on_char_boundary(json_str, 300));
vec![]
}
}
}
async fn call_extraction_llm(
cfg: &ExtractionConfig,
system: &str,
user: &str,
client: &reqwest::Client,
) -> Option<String> {
match cfg.provider {
ExtractionProvider::Anthropic => call_anthropic(cfg, system, user, client).await,
ExtractionProvider::OpenAi | ExtractionProvider::OpenAiCompatible => {
call_openai(cfg, system, user, client).await
}
ExtractionProvider::Gemini => call_gemini(cfg, system, user, client).await,
}
}
async fn warn_bad_response(who: &str, resp: reqwest::Response) -> Option<String> {
let status = resp.status();
let body = resp.text().await.unwrap_or_default();
eprintln!(
" warn: {who} returned {status}: {}",
truncate_on_char_boundary(&body, 200)
);
None
}
async fn call_anthropic(
cfg: &ExtractionConfig,
system: &str,
user: &str,
client: &reqwest::Client,
) -> Option<String> {
let req = AnthropicRequest {
model: cfg.model.clone(),
max_tokens: 4096,
system: system.to_string(),
messages: vec![AnthropicMessage {
role: "user".to_string(),
content: user.to_string(),
}],
};
let resp = client
.post("https://api.anthropic.com/v1/messages")
.header("x-api-key", &cfg.api_key)
.header("anthropic-version", "2023-06-01")
.header("content-type", "application/json")
.json(&req)
.send()
.await
.map_err(|e| eprintln!(" warn: Anthropic call failed: {e}"))
.ok()?;
if !resp.status().is_success() {
return warn_bad_response("Anthropic", resp).await;
}
let ar: AnthropicResponse = resp
.json()
.await
.map_err(|e| eprintln!(" warn: parse Anthropic response: {e}"))
.ok()?;
Some(
ar.content
.iter()
.filter(|c| c.content_type == "text")
.filter_map(|c| c.text.as_deref())
.collect::<Vec<_>>()
.join(""),
)
}
async fn call_openai(
cfg: &ExtractionConfig,
system: &str,
user: &str,
client: &reqwest::Client,
) -> Option<String> {
let base = cfg
.base_url
.as_deref()
.unwrap_or("https://api.openai.com")
.trim_end_matches('/');
let req = OpenAiRequest {
model: cfg.model.clone(),
messages: vec![
OpenAiMessage {
role: "system",
content: system.to_string(),
},
OpenAiMessage {
role: "user",
content: user.to_string(),
},
],
};
let resp = client
.post(format!("{base}/v1/chat/completions"))
.bearer_auth(&cfg.api_key)
.json(&req)
.send()
.await
.map_err(|e| eprintln!(" warn: OpenAI call failed: {e}"))
.ok()?;
if !resp.status().is_success() {
return warn_bad_response("OpenAI", resp).await;
}
let or: OpenAiResponse = resp
.json()
.await
.map_err(|e| eprintln!(" warn: parse OpenAI response: {e}"))
.ok()?;
or.choices.into_iter().next().map(|c| c.message.content)
}
async fn call_gemini(
cfg: &ExtractionConfig,
system: &str,
user: &str,
client: &reqwest::Client,
) -> Option<String> {
let url = format!(
"https://generativelanguage.googleapis.com/v1beta/models/{}:generateContent",
cfg.model
);
let req = GeminiRequest {
system_instruction: GeminiContent {
role: None,
parts: vec![GeminiPart {
text: system.to_string(),
}],
},
contents: vec![GeminiContent {
role: Some("user".to_string()),
parts: vec![GeminiPart {
text: user.to_string(),
}],
}],
};
let resp = client
.post(&url)
.header("x-goog-api-key", &cfg.api_key)
.json(&req)
.send()
.await
.map_err(|e| eprintln!(" warn: Gemini call failed: {e}"))
.ok()?;
if !resp.status().is_success() {
return warn_bad_response("Gemini", resp).await;
}
let gr: GeminiResponse = resp
.json()
.await
.map_err(|e| eprintln!(" warn: parse Gemini response: {e}"))
.ok()?;
let cand = gr.candidates.into_iter().next()?;
Some(
cand.content
.parts
.into_iter()
.map(|p| p.text)
.collect::<Vec<_>>()
.join(""),
)
}
#[derive(Serialize)]
struct OpenAiRequest {
model: String,
messages: Vec<OpenAiMessage>,
}
#[derive(Serialize)]
struct OpenAiMessage {
role: &'static str,
content: String,
}
#[derive(Deserialize)]
struct OpenAiResponse {
choices: Vec<OpenAiChoice>,
}
#[derive(Deserialize)]
struct OpenAiChoice {
message: OpenAiRespMessage,
}
#[derive(Deserialize)]
struct OpenAiRespMessage {
#[serde(default)]
content: String,
}
#[derive(Serialize)]
struct GeminiRequest {
system_instruction: GeminiContent,
contents: Vec<GeminiContent>,
}
#[derive(Serialize, Deserialize)]
struct GeminiContent {
#[serde(skip_serializing_if = "Option::is_none")]
role: Option<String>,
parts: Vec<GeminiPart>,
}
#[derive(Serialize, Deserialize)]
struct GeminiPart {
text: String,
}
#[derive(Deserialize)]
struct GeminiResponse {
#[serde(default)]
candidates: Vec<GeminiCandidate>,
}
#[derive(Deserialize)]
struct GeminiCandidate {
content: GeminiContent,
}
pub fn provider_for_model(model: &str) -> &'static str {
let m = model.to_ascii_lowercase();
if m.starts_with("claude") {
"anthropic"
} else if m.starts_with("gpt") || m.starts_with("o1") || m.starts_with("o3") {
"openai"
} else if m.starts_with("gemini") {
"google"
} else {
"unknown"
}
}
pub async fn record_turn_tokens(
tokens: &TurnTokens,
model: &str,
provider: &str,
hub: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
if tokens.is_empty() {
return;
}
let body = serde_json::json!({
"input_tokens": tokens.input,
"output_tokens": tokens.output,
"cache_read_tokens": tokens.cache_read,
"cache_creation_tokens": tokens.cache_creation,
"extra_tokens": tokens.extra,
"model": model,
"provider": provider,
});
let mut req = client
.post(format!("{}/api/stats/llm_usage", hub))
.json(&body);
if let Some(sid) = session {
req = req.header("X-CTXone-Session", sid);
}
let _ = req.send().await;
}
pub async fn trigger_session_by_model_backfill(
hub: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
let Some(sid) = session else {
return;
};
let url = format!(
"{}/api/stats/backfill_by_model?session={}",
hub,
crate::urlencoding(sid)
);
let _ = client
.post(url)
.header("X-CTXone-Session", sid)
.send()
.await;
}
pub fn turn_snapshot(turn: &Turn, idx: usize, sid: &str, source_file: &str) -> Value {
serde_json::json!({
"session": sid,
"turn_index": idx,
"timestamp": turn.timestamp,
"model": turn.model,
"source_file": source_file,
"user_text": turn.user_text,
"assistant_text": turn.assistant_text,
"tool_calls": turn.tool_calls,
"tool_calls_raw": turn.tool_calls_raw,
"tokens": turn.tokens,
"cwd": turn.cwd,
"git_branches": turn.git_branches,
"git_commit": turn.git_commit,
})
}
pub fn hub_is_local(hub: &str) -> bool {
let Ok(url) = reqwest::Url::parse(hub) else {
return false;
};
let Some(host) = url.host_str() else {
return false;
};
let host = host.trim_start_matches('[').trim_end_matches(']');
let lower = host.to_ascii_lowercase();
if lower == "localhost" || lower.ends_with(".localhost") {
return true;
}
match host.parse::<std::net::IpAddr>() {
Ok(std::net::IpAddr::V6(v6)) => {
v6.is_loopback()
|| v6.is_unspecified()
|| v6.to_ipv4_mapped().is_some_and(|v4| v4.is_loopback())
}
Ok(ip) => ip.is_loopback() || ip.is_unspecified(),
Err(_) => false,
}
}
pub fn hub_origin(hub: &str) -> String {
reqwest::Url::parse(hub)
.map(|u| u.origin().ascii_serialization())
.unwrap_or_else(|_| "the configured hub".to_string())
}
pub async fn store_full_turn(
turn: &Turn,
idx: usize,
source_file: &str,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
let sid = session.unwrap_or("default");
let snapshot = turn_snapshot(turn, idx, sid, source_file);
let url = format!(
"{}/api/sessions/{}/turns/{}?ref={}",
hub,
crate::urlencoding(sid),
idx,
crate::urlencoding(branch),
);
let mut req = client.post(url).json(&snapshot);
if let Some(s) = session {
req = req.header("X-CTXone-Session", s);
}
let _ = req.send().await;
}
pub async fn store_turns_bulk(
turns: &[Turn],
source_file: &str,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) -> usize {
let sid = session.unwrap_or("default");
let mut map = serde_json::Map::with_capacity(turns.len());
for (idx, turn) in turns.iter().enumerate() {
map.insert(
format!("t{idx:04}"),
turn_snapshot(turn, idx, sid, source_file),
);
}
let url = format!(
"{}/api/sessions/{}/turns?ref={}",
hub,
crate::urlencoding(sid),
crate::urlencoding(branch),
);
let mut req = client.put(url).json(&serde_json::Value::Object(map));
if let Some(s) = session {
req = req.header("X-CTXone-Session", s);
}
match req.send().await {
Ok(r) if r.status().is_success() => turns.len(),
Ok(r) => {
let st = r.status();
let b = r.text().await.unwrap_or_default();
eprintln!(
" bulk turn write for {sid} failed: {st} {}",
b.lines().next().unwrap_or("").trim()
);
0
}
Err(e) => {
eprintln!(" bulk turn write for {sid} errored: {e}");
0
}
}
}
const TITLE_MAX_CHARS: usize = 70;
fn is_substantive_user_text(text: &str) -> bool {
let t = text.trim();
if t.is_empty() {
return false;
}
if t.starts_with('/') {
return false;
}
if t.starts_with('<') {
return false;
}
if t.starts_with("Caveat:") {
return false;
}
t.chars().any(|c| c.is_alphanumeric())
}
pub fn derive_session_title(turns: &[Turn]) -> Option<String> {
let raw = turns
.iter()
.map(|t| t.user_text.as_str())
.find(|txt| is_substantive_user_text(txt))?;
let collapsed = raw.split_whitespace().collect::<Vec<_>>().join(" ");
Some(truncate_title(&collapsed))
}
pub fn truncate_title(s: &str) -> String {
if s.chars().count() <= TITLE_MAX_CHARS {
return s.to_string();
}
let truncated: String = s.chars().take(TITLE_MAX_CHARS).collect();
format!("{}…", truncated.trim_end())
}
pub async fn store_session_title(
title: &str,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
if title.trim().is_empty() {
return;
}
let sid = session.unwrap_or("default");
let url = format!(
"{}/api/sessions/{}/title?ref={}",
hub,
crate::urlencoding(sid),
crate::urlencoding(branch),
);
let mut req = client.put(url).json(&serde_json::json!(title));
if let Some(s) = session {
req = req.header("X-CTXone-Session", s);
}
let _ = req.send().await;
}
#[allow(clippy::too_many_arguments)]
pub async fn store_session_meta(
source: &str,
started_at: &str,
updated_at: &str,
models_used: &[String],
fingerprint: Option<&str>,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
if source.is_empty() && started_at.is_empty() && updated_at.is_empty() && models_used.is_empty()
{
return;
}
let sid = session.unwrap_or("default");
let url = format!(
"{}/api/sessions/{}/meta?ref={}",
hub,
crate::urlencoding(sid),
crate::urlencoding(branch),
);
let mut meta = serde_json::Map::new();
if !source.is_empty() {
meta.insert("source".into(), serde_json::json!(source));
}
if !started_at.is_empty() {
meta.insert("started_at".into(), serde_json::json!(started_at));
}
if !updated_at.is_empty() {
meta.insert("updated_at".into(), serde_json::json!(updated_at));
}
if !models_used.is_empty() {
meta.insert("models_used".into(), serde_json::json!(models_used));
}
if let Some(fp) = fingerprint {
meta.insert("fp".into(), serde_json::json!(fp));
}
let mut req = client.put(url).json(&serde_json::Value::Object(meta));
if let Some(s) = session {
req = req.header("X-CTXone-Session", s);
}
let _ = req.send().await;
}
pub async fn fetch_stored_fingerprint(
hub: &str,
branch: &str,
session: &str,
client: &reqwest::Client,
) -> Option<String> {
let url = format!(
"{}/api/state/{}?path=/sessions/{}/meta",
hub,
crate::urlencoding(branch),
crate::urlencoding(session),
);
let resp = client.get(url).send().await.ok()?;
if !resp.status().is_success() {
return None;
}
let v: Value = resp.json().await.ok()?;
v.get("fp").and_then(|f| f.as_str()).map(str::to_string)
}
pub fn build_provenance(turns: &[Turn]) -> Option<serde_json::Value> {
let mut cwds: Vec<String> = Vec::new();
let mut branches: Vec<(String, u64, String, String, Option<String>)> = Vec::new();
for t in turns {
if let Some(c) = &t.cwd
&& !cwds.iter().any(|x| x == c)
{
cwds.push(c.clone());
}
for b in &t.git_branches {
match branches.iter_mut().find(|(name, ..)| name == b) {
Some((_, count, first, last, commit)) => {
*count += 1;
if !t.timestamp.is_empty() {
if first.is_empty() || t.timestamp < *first {
*first = t.timestamp.clone();
}
if t.timestamp > *last {
*last = t.timestamp.clone();
}
}
if commit.is_none() {
*commit = t.git_commit.clone();
}
}
None => branches.push((
b.clone(),
1,
t.timestamp.clone(),
t.timestamp.clone(),
t.git_commit.clone(),
)),
}
}
}
if cwds.is_empty() && branches.is_empty() {
return None;
}
branches.sort_by(|a, b| b.1.cmp(&a.1));
let branches: Vec<serde_json::Value> = branches
.into_iter()
.map(|(branch, turns, first_ts, last_ts, commit_hash)| {
let mut o = serde_json::Map::new();
o.insert("branch".into(), serde_json::json!(branch));
o.insert("turns".into(), serde_json::json!(turns));
if !first_ts.is_empty() {
o.insert("first_ts".into(), serde_json::json!(first_ts));
}
if !last_ts.is_empty() {
o.insert("last_ts".into(), serde_json::json!(last_ts));
}
if let Some(c) = commit_hash {
o.insert("commit_hash".into(), serde_json::json!(c));
}
serde_json::Value::Object(o)
})
.collect();
let mut out = serde_json::Map::new();
if !cwds.is_empty() {
out.insert("cwds".into(), serde_json::json!(cwds));
}
if !branches.is_empty() {
out.insert("branches".into(), serde_json::json!(branches));
}
Some(serde_json::Value::Object(out))
}
#[allow(clippy::too_many_arguments)]
pub async fn store_session_provenance(
provenance: &serde_json::Value,
namespace: Option<&str>,
project_id: Option<&str>,
source_file: &str,
archived: bool,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
let sid = session.unwrap_or("default");
let url = format!(
"{}/api/sessions/{}/provenance?ref={}",
hub,
crate::urlencoding(sid),
crate::urlencoding(branch),
);
let mut body = provenance.as_object().cloned().unwrap_or_default();
if let Some(ns) = namespace {
body.insert("namespace".into(), serde_json::json!(ns));
}
if let Some(p) = project_id {
body.insert("project_id".into(), serde_json::json!(p));
}
if !source_file.is_empty() {
body.insert("source_file".into(), serde_json::json!(source_file));
}
if archived {
body.insert("archived".into(), serde_json::json!(true));
}
if let Some(device) = crate::device::device_id() {
body.insert("device".into(), serde_json::json!(device));
}
let mut req = client.put(url).json(&serde_json::Value::Object(body));
if let Some(s) = session {
req = req.header("X-CTXone-Session", s);
}
let _ = req.send().await;
}
pub async fn store_session_burn(
burn: &serde_json::Value,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
let sid = session.unwrap_or("default");
let url = format!(
"{}/api/sessions/{}/burn?ref={}",
hub,
crate::urlencoding(sid),
crate::urlencoding(branch),
);
let mut req = client.put(url).json(burn);
if let Some(s) = session {
req = req.header("X-CTXone-Session", s);
}
let _ = req.send().await;
}
fn is_openai_family(model: &str) -> bool {
let m = model.to_ascii_lowercase();
m.starts_with("gpt-")
|| m.starts_with("codex")
|| m.starts_with("o1")
|| m.starts_with("o3")
|| m.starts_with("o4")
}
pub fn session_usage(turns: &[Turn]) -> Value {
let mut by_model: BTreeMap<String, Value> = BTreeMap::new();
let mut last_model = None;
for turn in turns {
let model = turn.model.as_str();
if model.is_empty() || model == "unknown" || model.starts_with('<') {
continue;
}
let t = &turn.tokens;
let input = if is_openai_family(model) {
t.input.saturating_sub(t.cache_read)
} else {
t.input
};
let entry = by_model.entry(model.to_string()).or_insert_with(|| {
serde_json::json!({
"input_tokens": 0u64,
"output_tokens": 0u64,
"cache_read_tokens": 0u64,
"cache_create_tokens": 0u64,
"call_count": 0u64,
})
});
for (field, n) in [
("input_tokens", input),
("output_tokens", t.output),
("cache_read_tokens", t.cache_read),
("cache_create_tokens", t.cache_creation),
("call_count", 1),
] {
let sum = entry[field].as_u64().unwrap_or(0) + n;
entry[field] = sum.into();
}
last_model = Some(model.to_string());
}
serde_json::json!({ "by_model": by_model, "last_model": last_model })
}
#[derive(Debug, PartialEq)]
pub enum UsageStored {
Stored,
NotSupported,
Failed,
}
pub async fn store_session_usage(
usage: &Value,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) -> UsageStored {
let sid = session.unwrap_or("default");
let url = format!(
"{}/api/sessions/{}/usage?ref={}",
hub,
crate::urlencoding(sid),
crate::urlencoding(branch),
);
let mut req = client.put(url).json(usage);
if let Some(s) = session {
req = req.header("X-CTXone-Session", s);
}
match req.send().await {
Ok(r) if r.status().is_success() => UsageStored::Stored,
Ok(r) if matches!(r.status().as_u16(), 404 | 405) => UsageStored::NotSupported,
_ => UsageStored::Failed,
}
}
pub async fn store_memory(
mem: &ExtractedMemory,
hub: &str,
branch: &str,
session: Option<&str>,
client: &reqwest::Client,
) {
let body = serde_json::json!({
"fact": mem.body,
"path": mem.path,
"importance": mem.importance,
"context": mem.context,
"ref": branch,
"source": "ingest",
});
let mut req = client
.post(format!("{}/api/memory/remember", hub))
.json(&body);
if let Some(sid) = session {
req = req.header("X-CTXone-Session", sid);
}
let _ = req.send().await;
}
pub fn find_session_files(project_dir: &Path) -> Vec<PathBuf> {
use crate::sources::SessionSource;
crate::sources::ClaudeCode
.discover_for_project(project_dir)
.into_iter()
.map(|r| r.path)
.collect()
}
pub fn latest_session_file(project_dir: &Path) -> Option<PathBuf> {
find_session_files(project_dir).into_iter().last()
}
pub fn find_all_session_files() -> Vec<(String, Vec<PathBuf>)> {
use crate::sources::SessionSource;
crate::sources::group_by_label(crate::sources::ClaudeCode.discover_all())
}
pub fn last_turns(path: &Path, n: usize) -> Vec<Turn> {
let all = parse_turns(path);
let skip = all.len().saturating_sub(n);
all.into_iter().skip(skip).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hubs_on_this_machine_are_local() {
for hub in [
"http://localhost:3001",
"http://LOCALHOST:3001/",
"http://ctx.localhost:3001",
"http://127.0.0.1:3001",
"http://127.1.2.3",
"http://[::1]:3001",
"http://[::ffff:127.0.0.1]:3001",
"http://0.0.0.0:3001",
"http://[::]:3001",
"https://user:secret@127.0.0.1:3001/base",
] {
assert!(hub_is_local(hub), "{hub} should be local");
}
}
#[test]
fn every_other_hub_is_remote() {
for hub in [
"https://alice.ctxone.example/",
"http://192.168.1.20:3001",
"http://10.0.0.5:3001",
"http://[2001:db8::1]:3001",
"http://localhost.example.com:3001",
"http://notlocalhost:3001",
"not a url",
"",
] {
assert!(!hub_is_local(hub), "{hub:?} should be remote");
}
}
#[test]
fn hub_origin_drops_credentials_and_path() {
assert_eq!(
hub_origin("https://user:secret@hub.example:8443/base?x=1"),
"https://hub.example:8443"
);
assert_eq!(hub_origin("not a url"), "the configured hub");
}
#[test]
fn session_analysis_parses_summary_and_topics() {
let json = r#"{"summary":"did X then Y",
"topics":[{"start":0,"end":3,"label":"setup","summary":"set up repo"},
{"start":4,"end":9,"label":"bugfix","summary":"fixed panic"}]}"#;
let a: SessionAnalysis = serde_json::from_str(json).unwrap();
assert_eq!(a.summary, "did X then Y");
assert_eq!(a.topics.len(), 2);
assert_eq!(a.topics[1].label, "bugfix");
assert_eq!(a.topics[1].start, 4);
let a2: SessionAnalysis =
serde_json::from_str(r#"{"summary":"s","topics":[{"start":0,"end":1,"label":"x"}]}"#)
.unwrap();
assert_eq!(a2.topics[0].summary, "");
}
#[test]
fn first_line_takes_first_nonblank_trimmed() {
assert_eq!(
first_line("\n\n hello world \nsecond", 100),
"hello world"
);
assert_eq!(first_line("verylongword", 4), "very");
assert_eq!(first_line("", 10), "");
}
#[test]
fn extraction_provider_parse_accepts_aliases() {
use ExtractionProvider::*;
assert_eq!(ExtractionProvider::parse("anthropic"), Some(Anthropic));
assert_eq!(ExtractionProvider::parse("Claude"), Some(Anthropic));
assert_eq!(ExtractionProvider::parse("openai"), Some(OpenAi));
assert_eq!(ExtractionProvider::parse("gemini"), Some(Gemini));
assert_eq!(ExtractionProvider::parse("google"), Some(Gemini));
assert_eq!(
ExtractionProvider::parse("openai-compatible"),
Some(OpenAiCompatible)
);
assert_eq!(ExtractionProvider::parse("nope"), None);
}
#[test]
fn provider_key_env_and_slug() {
assert_eq!(ExtractionProvider::Anthropic.key_env(), "ANTHROPIC_API_KEY");
assert_eq!(ExtractionProvider::OpenAi.key_env(), "OPENAI_API_KEY");
assert_eq!(
ExtractionProvider::OpenAiCompatible.key_env(),
"OPENAI_API_KEY"
);
assert_eq!(ExtractionProvider::Gemini.key_slug(), "gemini");
}
#[test]
fn shellexpand_home_expands_leading_tilde() {
assert_eq!(shellexpand_home("/abs/path"), "/abs/path");
assert!(shellexpand_home("~/.ctxone/k").ends_with("/.ctxone/k"));
}
#[test]
fn extraction_watermark_is_monotonic_and_per_session() {
let dir = std::env::temp_dir().join(format!("ctx-wm-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let p = dir.join("watermarks.json");
assert_eq!(load_watermarks_at(&p).get("s1").copied().unwrap_or(0), 0);
set_watermark_at(&p, "s1", 3);
assert_eq!(load_watermarks_at(&p)["s1"], 3);
set_watermark_at(&p, "s1", 2);
assert_eq!(load_watermarks_at(&p)["s1"], 3);
set_watermark_at(&p, "s1", 5);
assert_eq!(load_watermarks_at(&p)["s1"], 5);
set_watermark_at(&p, "codex:abc", 1);
assert_eq!(load_watermarks_at(&p)["codex:abc"], 1);
assert_eq!(load_watermarks_at(&p)["s1"], 5);
let _ = std::fs::remove_dir_all(&dir);
}
fn turn_on(branches: &[&str], ts: &str) -> Turn {
Turn {
user_text: "u".into(),
assistant_text: "a".into(),
tool_calls: vec![],
tool_calls_raw: vec![],
tokens: TurnTokens::default(),
model: "m".into(),
timestamp: ts.into(),
cwd: Some("/repo".into()),
git_branches: branches.iter().map(|s| s.to_string()).collect(),
git_commit: None,
}
}
fn turn_using(model: &str, input: u64, output: u64, cache_read: u64) -> Turn {
let mut t = turn_on(&["main"], "2026-05-01T00:00:00Z");
t.model = model.into();
t.tokens = TurnTokens {
input,
output,
cache_read,
cache_creation: 2,
extra: BTreeMap::new(),
};
t
}
#[test]
fn session_usage_sums_each_model_and_skips_placeholders() {
let turns = vec![
turn_using("claude-opus-4-8", 100, 10, 50),
turn_using("<synthetic>", 999, 999, 999),
turn_using("claude-opus-4-8", 200, 20, 60),
turn_using("", 999, 999, 999),
turn_using("unknown", 999, 999, 999),
turn_using("gpt-5.5", 1000, 30, 400),
];
let u = session_usage(&turns);
let opus = &u["by_model"]["claude-opus-4-8"];
assert_eq!(opus["input_tokens"], 300);
assert_eq!(opus["output_tokens"], 30);
assert_eq!(opus["cache_read_tokens"], 110);
assert_eq!(opus["cache_create_tokens"], 4);
assert_eq!(opus["call_count"], 2);
assert_eq!(u["by_model"]["gpt-5.5"]["input_tokens"], 600);
assert_eq!(u["by_model"]["gpt-5.5"]["cache_read_tokens"], 400);
assert_eq!(u["by_model"].as_object().unwrap().len(), 2);
assert_eq!(u["last_model"], "gpt-5.5");
}
#[test]
fn session_usage_of_no_turns_is_empty() {
let u = session_usage(&[]);
assert_eq!(u["by_model"], serde_json::json!({}));
assert!(u["last_model"].is_null());
}
#[test]
fn provenance_lists_every_branch_not_just_the_dominant_one() {
let turns = vec![
turn_on(&["main"], "2026-05-01T00:00:00Z"),
turn_on(&["feature"], "2026-05-02T00:00:00Z"),
turn_on(&["feature"], "2026-05-03T00:00:00Z"),
];
let p = build_provenance(&turns).expect("has provenance");
let branches = p["branches"].as_array().unwrap();
assert_eq!(branches.len(), 2);
assert_eq!(branches[0]["branch"], "feature");
assert_eq!(branches[0]["turns"], 2);
assert_eq!(branches[1]["branch"], "main");
assert_eq!(branches[0]["first_ts"], "2026-05-02T00:00:00Z");
assert_eq!(branches[0]["last_ts"], "2026-05-03T00:00:00Z");
}
#[test]
fn provenance_counts_a_turn_that_touched_two_branches_under_both() {
let turns = vec![turn_on(&["old", "new"], "2026-05-01T00:00:00Z")];
let p = build_provenance(&turns).unwrap();
let names: Vec<&str> = p["branches"]
.as_array()
.unwrap()
.iter()
.map(|b| b["branch"].as_str().unwrap())
.collect();
assert!(names.contains(&"old") && names.contains(&"new"));
}
#[test]
fn provenance_keeps_head_verbatim() {
let p = build_provenance(&[turn_on(&["HEAD"], "2026-05-01T00:00:00Z")]).unwrap();
assert_eq!(p["branches"][0]["branch"], "HEAD");
}
#[test]
fn provenance_is_none_when_nothing_was_recorded() {
let mut t = turn_on(&[], "2026-05-01T00:00:00Z");
t.cwd = None;
assert!(build_provenance(&[t]).is_none());
}
#[test]
fn strip_synthetic_removes_task_notification() {
let raw = "<task-notification>\n<task-id>abc</task-id>\n<summary>Agent finished</summary>\n</task-notification>";
assert_eq!(strip_synthetic_blocks(raw), "");
}
#[test]
fn strip_synthetic_keeps_genuine_and_drops_reminder() {
let raw = "Do the thing.\n<system-reminder>internal context</system-reminder>";
assert_eq!(strip_synthetic_blocks(raw), "Do the thing.");
}
#[test]
fn strip_synthetic_removes_local_command_blocks() {
let raw = "<local-command-caveat>Caveat: …</local-command-caveat>\n<local-command-stdout>Set model to x</local-command-stdout>";
assert_eq!(strip_synthetic_blocks(raw), "");
}
#[test]
fn strip_synthetic_leaves_plain_user_text_untouched() {
let raw = "Just a normal message with < and > but no synthetic tags.";
assert_eq!(strip_synthetic_blocks(raw), raw);
}
#[test]
fn truncate_shorter_than_limit_is_unchanged() {
assert_eq!(truncate_on_char_boundary("hello", 120), "hello");
}
#[test]
fn truncate_backs_up_off_a_multibyte_boundary() {
let s = format!("{}—tail", "x".repeat(118)); assert!(!s.is_char_boundary(120));
let out = truncate_on_char_boundary(&s, 120);
assert_eq!(out.len(), 118);
assert_eq!(out, "x".repeat(118));
}
#[test]
fn truncate_on_exact_boundary_keeps_full_bytes() {
let s = "abcdef";
assert_eq!(truncate_on_char_boundary(s, 6), "abcdef");
assert_eq!(truncate_on_char_boundary(s, 3), "abc");
}
#[test]
fn extract_tool_calls_survives_long_unicode_bash_command() {
let cmd = format!("echo {}—done", "a".repeat(130));
let msg = serde_json::json!({
"content": [
{ "type": "tool_use", "name": "Bash", "input": { "command": cmd } }
]
});
let calls = extract_tool_calls(&msg);
assert_eq!(calls.len(), 1);
assert!(calls[0].starts_with("Bash: echo "));
}
}