use anyhow::{Context, Result};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use crate::paths;
use crate::store::Store;
use crate::types::Task;
use super::show_output_extract::collect_messages;
pub fn output_text_for_task(store: &Store, task_id: &str, full: bool) -> Result<String> {
let task = load_task_for_output(task_id, store)?;
render_task_output(&task, task_id, full, 200)
}
fn load_task_for_output(task_id: &str, store: &Store) -> Result<Task> {
store
.get_task(task_id)?
.ok_or_else(|| anyhow::anyhow!("Task '{task_id}' not found"))
}
pub fn output_text(store: &Arc<Store>, task_id: &str) -> Result<String> {
let task = super::super::load_task(store, task_id)?;
render_task_output(&task, task_id, true, 200)
}
pub fn output_text_brief(store: &Arc<Store>, task_id: &str) -> Result<String> {
let task = super::super::load_task(store, task_id)?;
render_task_output(&task, task_id, false, 50)
}
#[allow(dead_code)]
pub fn output_text_full(store: &Arc<Store>, task_id: &str) -> Result<String> {
let task = super::super::load_task(store, task_id)?;
if let Ok(content) = read_task_output(&task) {
return Ok(content);
}
if let Some(content) = extract_messages_for_task(&task, task_id, true) {
return Ok(content);
}
let path = task_log_path(&task, task_id);
Ok(read_tail(&path, 200, "No output or log available"))
}
fn render_task_output(task: &Task, task_id: &str, full: bool, tail_lines: usize) -> Result<String> {
if let Ok(content) = read_task_output(task) {
return Ok(content);
}
if !full && is_research_task(task) {
let path = task_log_path(task, task_id);
if let Some(content) = extract_messages_research(&path) {
return Ok(content);
}
}
if let Some(content) = extract_messages_for_task(task, task_id, full) {
return Ok(content);
}
let path = task_log_path(task, task_id);
Ok(read_tail(&path, tail_lines, "No output or log available"))
}
fn task_log_path(task: &Task, task_id: &str) -> PathBuf {
task.log_path
.as_ref()
.map(PathBuf::from)
.unwrap_or_else(|| paths::log_path(task_id))
}
fn is_research_task(task: &Task) -> bool {
task.worktree_path.is_none() && task.worktree_branch.is_none()
}
fn extract_messages_for_task(task: &Task, task_id: &str, full: bool) -> Option<String> {
extract_messages_from_log(&task_log_path(task, task_id), full)
}
pub(crate) fn extract_messages_from_log(log_path: &Path, full: bool) -> Option<String> {
const MAX_MESSAGE_CHARS: usize = 1_000;
const MAX_OUTPUT_CHARS: usize = 8_000;
const HEAD_MESSAGE_COUNT: usize = 3;
const TAIL_MESSAGE_COUNT: usize = 7;
let content = std::fs::read_to_string(log_path).ok()?;
let mut messages = collect_messages(&content);
if messages.is_empty() {
return None;
}
if !full {
truncate_messages(&mut messages, MAX_MESSAGE_CHARS);
messages = cap_message_count(messages, HEAD_MESSAGE_COUNT, TAIL_MESSAGE_COUNT);
}
Some(join_messages(messages, full, MAX_OUTPUT_CHARS))
}
pub(crate) fn extract_messages_research(log_path: &Path) -> Option<String> {
const MAX_MESSAGE_CHARS: usize = 4_000;
const MAX_OUTPUT_CHARS: usize = 20_000;
let content = std::fs::read_to_string(log_path).ok()?;
let mut messages = collect_messages(&content);
if messages.is_empty() {
return None;
}
truncate_messages(&mut messages, MAX_MESSAGE_CHARS);
Some(join_messages(messages, false, MAX_OUTPUT_CHARS))
}
fn truncate_messages(messages: &mut [String], max_chars: usize) {
for message in messages {
if message.len() > max_chars {
message.truncate(message.floor_char_boundary(max_chars.saturating_sub(3)));
message.push_str("...");
}
}
}
fn cap_message_count(messages: Vec<String>, head: usize, tail: usize) -> Vec<String> {
if messages.len() <= head + tail {
return messages;
}
let omitted = messages.len() - head - tail;
let mut capped = Vec::with_capacity(head + tail + 1);
capped.extend(messages[..head].iter().cloned());
capped.push(format!("[... {omitted} messages omitted ...]"));
capped.extend(messages[messages.len() - tail..].iter().cloned());
capped
}
fn join_messages(messages: Vec<String>, full: bool, max_output_chars: usize) -> String {
let mut output = messages.join("\n---\n");
if !full && output.len() > max_output_chars {
output.truncate(output.floor_char_boundary(max_output_chars.saturating_sub(3)));
output.push_str("...");
}
output
}
pub fn read_task_output(task: &Task) -> Result<String> {
if let Some(path) = task.output_path.as_deref() {
return std::fs::read_to_string(path)
.with_context(|| format!("Failed to read output file {path}"));
}
let persisted = paths::task_dir(task.id.as_str()).join("result.md");
if persisted.exists() {
return std::fs::read_to_string(&persisted)
.with_context(|| format!("Failed to read result file {}", persisted.display()));
}
Err(anyhow::anyhow!("Task has no output file"))
}
pub fn log_text(task_id: &str) -> Result<String> {
let path = paths::log_path(task_id);
std::fs::read_to_string(&path)
.with_context(|| format!("Failed to read log file {}", path.display()))
}
pub(crate) fn read_tail(path: &Path, limit: usize, unavailable: &str) -> String {
let Ok(bytes) = std::fs::read(path) else {
return unavailable.to_string();
};
let content = String::from_utf8_lossy(&bytes);
let tail = tail_lines(&content, limit);
if tail.is_empty() {
unavailable.to_string()
} else {
tail
}
}
pub(crate) fn tail_lines(content: &str, limit: usize) -> String {
content
.lines()
.rev()
.take(limit)
.collect::<Vec<_>>()
.into_iter()
.rev()
.collect::<Vec<_>>()
.join("\n")
}