pub mod claude_haiku;
pub mod codex_spark;
pub mod journal;
pub mod prompt;
pub mod select;
pub mod service;
use std::process::Stdio;
use std::time::Duration;
use async_trait::async_trait;
use serde::Serialize;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::process::Command;
use crate::error::{MemdError, Result};
pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(60);
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ConsolidatorIdentity {
pub adapter: String,
pub command: Option<String>,
pub model: Option<String>,
pub version: Option<String>,
}
impl ConsolidatorIdentity {
pub fn internal(adapter: impl Into<String>) -> Self {
Self {
adapter: adapter.into(),
command: Some("internal".to_string()),
model: None,
version: Some(env!("CARGO_PKG_VERSION").to_string()),
}
}
}
#[async_trait]
pub trait Consolidator: Send + Sync {
async fn consolidate(&self, prompt: &str) -> Result<String>;
fn name(&self) -> &'static str;
async fn identity(&self) -> Result<ConsolidatorIdentity> {
Ok(ConsolidatorIdentity::internal(self.name()))
}
}
pub(crate) async fn cli_version(program: &str, timeout: Duration) -> Result<String> {
let mut command = Command::new(program);
command
.arg("--version")
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
let child = command.spawn().map_err(|error| {
MemdError::ProtocolError(format!("failed to spawn `{program}`: {error}"))
})?;
let output = tokio::time::timeout(timeout, child.wait_with_output())
.await
.map_err(|_| {
MemdError::ProtocolError(format!(
"`{program} --version` timed out after {}s",
timeout.as_secs()
))
})?
.map_err(|error| {
MemdError::ProtocolError(format!("`{program} --version` failed: {error}"))
})?;
if !output.status.success() {
return Err(MemdError::ProtocolError(format!(
"`{program} --version` exited with {}",
output.status
)));
}
let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
if version.is_empty() {
return Err(MemdError::ProtocolError(format!(
"`{program} --version` returned empty output"
)));
}
Ok(version.chars().take(256).collect())
}
pub(crate) async fn run_cli_capture(
program: &str,
args: &[&str],
stdin_data: &str,
timeout: Duration,
) -> Result<String> {
let mut child = Command::new(program)
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true)
.spawn()
.map_err(|e| MemdError::ProtocolError(format!("failed to spawn `{program}`: {e}")))?;
let stdin = child.stdin.take();
let stdout = child.stdout.take();
let stderr = child.stderr.take();
let data = stdin_data.to_string();
let write_task = tokio::spawn(async move {
if let Some(mut stdin) = stdin {
let _ = stdin.write_all(data.as_bytes()).await;
let _ = stdin.shutdown().await;
}
});
let out_task = tokio::spawn(async move {
let mut buf = Vec::new();
if let Some(mut stdout) = stdout {
let _ = stdout.read_to_end(&mut buf).await;
}
buf
});
let err_task = tokio::spawn(async move {
let mut buf = Vec::new();
if let Some(mut stderr) = stderr {
let _ = stderr.read_to_end(&mut buf).await;
}
buf
});
let status = match tokio::time::timeout(timeout, child.wait()).await {
Ok(Ok(status)) => status,
Ok(Err(e)) => {
write_task.abort();
out_task.abort();
err_task.abort();
return Err(MemdError::ProtocolError(format!(
"`{program}` did not complete: {e}"
)));
}
Err(_) => {
let _ = child.start_kill();
let _ = child.wait().await;
write_task.abort();
out_task.abort();
err_task.abort();
return Err(MemdError::ProtocolError(format!(
"`{program}` timed out after {}s",
timeout.as_secs()
)));
}
};
let _ = write_task.await;
let stdout_bytes = out_task.await.unwrap_or_default();
let stderr_bytes = err_task.await.unwrap_or_default();
if !status.success() {
let stderr = String::from_utf8_lossy(&stderr_bytes);
let truncated: String = stderr.chars().take(500).collect();
return Err(MemdError::ProtocolError(format!(
"`{program}` exited with {status}: {truncated}"
)));
}
String::from_utf8(stdout_bytes)
.map_err(|e| MemdError::ProtocolError(format!("`{program}` produced non-UTF8 output: {e}")))
}
pub const MOCK_RESPONSE_ENV: &str = "MEMD_CONSOLIDATOR_MOCK_RESPONSE";
pub struct MockEnvConsolidator;
#[async_trait]
impl Consolidator for MockEnvConsolidator {
async fn consolidate(&self, _prompt: &str) -> Result<String> {
std::env::var(MOCK_RESPONSE_ENV).map_err(|_| {
MemdError::ConfigError(format!(
"MEMD_CONSOLIDATOR=mock requires {MOCK_RESPONSE_ENV} to be set"
))
})
}
fn name(&self) -> &'static str {
"mock"
}
async fn identity(&self) -> Result<ConsolidatorIdentity> {
Ok(ConsolidatorIdentity {
adapter: self.name().to_string(),
command: Some("MEMD_CONSOLIDATOR_MOCK_RESPONSE".to_string()),
model: Some("deterministic-env".to_string()),
version: Some(env!("CARGO_PKG_VERSION").to_string()),
})
}
}