Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
//! `ai-memory audit-contamination` — structural cross-project contamination audit.
//!
//! Thin HTTP client. Calls `GET /admin/audit-contamination` on the configured
//! server and renders the report as human text or JSON. Read-only — the server
//! only reports, never mutates; remediation is a separate operator step.
use anyhow::{Result, bail};
use serde::{Deserialize, Serialize};
use crate::cli::AuditContaminationArgs;
use crate::config::Config;
use crate::http_client::{ServerEndpoint, get_json};
/// Server-shaped response. Mirrors `ai_memory_store::ContaminationReport`.
#[derive(Debug, Default, Deserialize, Serialize)]
struct Report {
#[serde(default)]
summary: Summary,
#[serde(default)]
findings: Vec<Finding>,
}
#[derive(Debug, Default, Deserialize, Serialize)]
struct Summary {
#[serde(default)]
sessions_misbucketed: usize,
#[serde(default)]
project_name_collisions: usize,
}
#[derive(Debug, Deserialize, Serialize)]
struct Finding {
check: String,
confidence: String,
entity_kind: String,
entity_id: String,
landed_workspace: String,
landed_project: String,
#[serde(default)]
expected_project: Option<String>,
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
peer_projects: Option<String>,
#[serde(default)]
pages: Option<u64>,
#[serde(default)]
sessions: Option<u64>,
#[serde(default)]
collision_kind: Option<String>,
#[serde(default)]
last_activity_us: Option<i64>,
}
/// Run the `audit-contamination` subcommand.
///
/// # Errors
/// Returns an error if the server is unreachable, returns non-2xx, or the
/// response can't be parsed.
pub async fn run(config: &Config, args: AuditContaminationArgs) -> Result<()> {
let ep = ServerEndpoint::from_config_resolving_auth(config).await;
let query = scope_query(&args)?;
let report: Report = get_json(&ep, "/admin/audit-contamination", &query).await?;
if args.json {
println!("{}", serde_json::to_string_pretty(&report)?);
return Ok(());
}
if report.findings.is_empty() {
println!(
"No structural contamination found (no session mis-bucketed by cwd, no project \
name collisions)."
);
return Ok(());
}
println!(
"Contamination audit: {} session(s) mis-bucketed, {} project(s) with a colliding name.",
report.summary.sessions_misbucketed, report.summary.project_name_collisions
);
for f in &report.findings {
let expected = f.expected_project.as_deref().unwrap_or("?");
match f.check.as_str() {
"session_wrong_bucket" => println!(
" [{}] session {} landed in {}/{} but its cwd ({}) resolves to project {}",
f.confidence,
f.entity_id,
f.landed_workspace,
f.landed_project,
f.cwd.as_deref().unwrap_or("?"),
expected,
),
"project_name_collision" => println!(
" [{}] project {} ({}/{}): {} page(s), {} session(s), last activity {}; \
collides by {} with {}. Add a `.ai-memory.toml` marker or run `merge-project`.",
f.confidence,
f.entity_id,
f.landed_workspace,
f.landed_project,
f.pages.unwrap_or(0),
f.sessions.unwrap_or(0),
f.last_activity_us
.map_or_else(|| "unknown".into(), |value| value.to_string()),
f.collision_kind.as_deref().unwrap_or("spelling"),
f.peer_projects.as_deref().unwrap_or("?"),
),
other => println!(
" [{}] {} {} in {}/{}",
f.confidence, other, f.entity_id, f.landed_workspace, f.landed_project
),
}
}
Ok(())
}
fn scope_query(args: &AuditContaminationArgs) -> Result<Vec<(&str, &str)>> {
match (args.workspace.as_deref(), args.project.as_deref()) {
(Some(ws), Some(proj)) => Ok(vec![("workspace", ws), ("project", proj)]),
(None, None) => Ok(Vec::new()),
_ => bail!("--workspace and --project must be provided together"),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn args(workspace: Option<&str>, project: Option<&str>) -> AuditContaminationArgs {
AuditContaminationArgs {
workspace: workspace.map(str::to_string),
project: project.map(str::to_string),
json: false,
}
}
#[test]
fn scope_query_rejects_partial_scope() {
assert!(scope_query(&args(Some("default"), None)).is_err());
assert!(scope_query(&args(None, Some("ai-memory"))).is_err());
}
#[test]
fn scope_query_accepts_global_or_complete_scope() {
assert!(scope_query(&args(None, None)).unwrap().is_empty());
assert_eq!(
scope_query(&args(Some("default"), Some("ai-memory"))).unwrap(),
vec![("workspace", "default"), ("project", "ai-memory")]
);
}
}