memd 1.9.0

Local memory CLI for AI agents with hybrid retrieval
Documentation
use std::io::Write;
use std::process::{Command, Stdio};

use serde_json::Value;

fn memd_bin() -> &'static str {
    env!("CARGO_BIN_EXE_memd")
}

fn write_project_scope(project_dir: &std::path::Path) {
    std::fs::create_dir_all(project_dir.join(".memd")).unwrap();
    std::fs::write(
        project_dir.join(".memd/project_scope.json"),
        serde_json::to_vec(&serde_json::json!({
            "tenant_id": "scoped_tenant",
            "project_id": "scoped_project",
            "interface": "cli",
            "cli_command": "memd",
            "agent_context_output": ".memd/context.md",
            "project_dir": project_dir,
        }))
        .unwrap(),
    )
    .unwrap();
}

#[test]
fn supported_cli_help_surfaces_resolve() {
    let commands = [
        vec!["--help"],
        vec!["add", "--help"],
        vec!["search", "--help"],
        vec!["agent-context", "--help"],
        vec!["memory-md", "--help"],
        vec!["eval-memory-md", "--help"],
        vec!["eval-retrieval", "--help"],
        vec!["eval-write-quality", "--help"],
        vec!["eval-outcome-ranking", "--help"],
        vec!["audit", "--help"],
        vec!["cleanup-plan", "--help"],
        vec!["purge", "--help"],
        vec!["purge-archive", "--help"],
        vec!["outcome", "--help"],
        vec!["call", "--help"],
        vec!["batch", "--help"],
        vec!["warm", "--help"],
    ];

    for args in commands {
        let output = Command::new(memd_bin())
            .args(&args)
            .output()
            .expect("run memd help");
        assert!(
            output.status.success(),
            "memd {args:?} failed: {}",
            String::from_utf8_lossy(&output.stderr)
        );
        let stdout = String::from_utf8_lossy(&output.stdout);
        assert!(
            stdout.contains("Usage:"),
            "missing usage in {args:?}: {stdout}"
        );
        if args.as_slice() == ["--help"] {
            assert!(
                !stdout.contains("--mode"),
                "top-level help must not expose removed server --mode flag"
            );
        }
        assert!(
            !stdout.contains("mcp"),
            "supported help must not advertise removed MCP startup in {args:?}"
        );
    }
}

#[test]
fn mode_mcp_is_rejected_by_current_cli() {
    let output = Command::new(memd_bin())
        .args(["--mode", "mcp"])
        .output()
        .expect("run memd --mode mcp");

    assert!(
        !output.status.success(),
        "--mode mcp unexpectedly succeeded"
    );
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("--mode") || stderr.contains("unexpected argument"),
        "unexpected rejection message: {stderr}"
    );
}

#[test]
fn batch_cli_preserves_operation_response_shapes() {
    let jsonl = r#"{"tool":"memory.add","arguments":{"tenant_id":"cli_contract","project_id":"p","text":"contract alpha memory","type":"doc","tags":["contract"]}}
{"tool":"memory.search","arguments":{"tenant_id":"cli_contract","project_id":"p","query":"contract alpha","k":1,"compact":true,"include_text":true}}
{"tool":"task.start","arguments":{"tenant_id":"cli_contract","project_id":"p","agent_id":"agent","session_id":"session","goal":"contract task"}}
{"tool":"artifact.create","arguments":{"tenant_id":"cli_contract","project_id":"p","task_id":"contract-task","artifact_kind":"evidence","summary":"contract evidence","confidence":0.9}}
not-json
"#;

    let mut child = Command::new(memd_bin())
        .args([
            "--in-memory",
            "batch",
            "--jsonl",
            "-",
            "--continue-on-error",
        ])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("spawn memd batch");
    child
        .stdin
        .as_mut()
        .expect("stdin")
        .write_all(jsonl.as_bytes())
        .expect("write jsonl");
    let output = child.wait_with_output().expect("wait for memd batch");

    assert!(
        output.status.success(),
        "batch failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    let rows = String::from_utf8(output.stdout).expect("utf8 stdout");
    let rows = rows
        .lines()
        .map(|line| serde_json::from_str::<Value>(line).expect("jsonl row"))
        .collect::<Vec<_>>();

    assert_eq!(rows.len(), 5, "unexpected batch rows: {rows:#?}");
    assert_eq!(rows[0]["tool"], "memory.add");
    assert_eq!(rows[0]["ok"], true);
    assert!(rows[0]["result"]["chunk_id"].is_string());

    assert_eq!(rows[1]["tool"], "memory.search");
    assert_eq!(rows[1]["ok"], true);
    assert!(rows[1]["result"]["results"].is_array());
    assert!(rows[1]["result"]["results"][0]["chunk_id"].is_string());

    assert_eq!(rows[2]["tool"], "task.start");
    assert_eq!(rows[2]["ok"], true);
    assert!(rows[2]["result"]["task_id"].is_string());

    assert_eq!(rows[3]["tool"], "artifact.create");
    assert_eq!(rows[3]["ok"], true);
    assert!(rows[3]["result"]["artifact_id"].is_string());

    assert_eq!(rows[4]["ok"], false);
    assert!(rows[4]["error"]
        .as_str()
        .expect("error")
        .contains("invalid JSONL request"));
}

#[test]
fn call_inherits_repository_scope_for_structured_writes() {
    let temp = tempfile::tempdir().unwrap();
    let project_dir = temp.path().join("project");
    let data_dir = temp.path().join("data");
    write_project_scope(&project_dir);

    let added = Command::new(memd_bin())
        .current_dir(&project_dir)
        .arg("--data-dir")
        .arg(&data_dir)
        .args([
            "--search-variant",
            "bm25-only",
            "call",
            "memory.add",
            "--json",
            r#"{"text":"scoped call memory","type":"doc"}"#,
            "--warm",
            "off",
        ])
        .output()
        .expect("run scoped memd call");
    assert!(
        added.status.success(),
        "call failed: {}",
        String::from_utf8_lossy(&added.stderr)
    );
    let added: Value = serde_json::from_slice(&added.stdout).unwrap();
    let chunk_id = added["chunk_id"].as_str().expect("chunk id");

    let fetched = Command::new(memd_bin())
        .current_dir(&project_dir)
        .arg("--data-dir")
        .arg(&data_dir)
        .args(["--search-variant", "bm25-only", "get", "--chunk-id"])
        .arg(chunk_id)
        .output()
        .expect("get scoped call write");
    assert!(
        fetched.status.success(),
        "get failed: {}",
        String::from_utf8_lossy(&fetched.stderr)
    );
    let fetched: Value = serde_json::from_slice(&fetched.stdout).unwrap();
    assert_eq!(fetched["tenant_id"], "scoped_tenant");
    assert_eq!(fetched["project_id"], "scoped_project");
}

#[test]
fn batch_inherits_repository_scope_for_structured_operations() {
    let temp = tempfile::tempdir().unwrap();
    let project_dir = temp.path().join("project");
    write_project_scope(&project_dir);
    let jsonl = r#"{"tool":"memory.add","arguments":{"text":"scoped batch memory","type":"doc"}}
{"tool":"memory.search","arguments":{"query":"scoped batch","k":1}}
"#;

    let mut child = Command::new(memd_bin())
        .current_dir(&project_dir)
        .args(["--in-memory", "batch", "--jsonl", "-", "--warm", "off"])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("spawn scoped memd batch");
    child
        .stdin
        .as_mut()
        .expect("stdin")
        .write_all(jsonl.as_bytes())
        .expect("write scoped jsonl");
    let output = child.wait_with_output().expect("wait for scoped batch");
    assert!(
        output.status.success(),
        "batch failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    let rows = String::from_utf8(output.stdout)
        .unwrap()
        .lines()
        .map(|line| serde_json::from_str::<Value>(line).unwrap())
        .collect::<Vec<_>>();
    assert_eq!(rows.len(), 2);
    assert_eq!(rows[0]["ok"], true);
    assert_eq!(rows[1]["ok"], true);
    assert_eq!(
        rows[1]["result"]["results"][0]["tenant_id"],
        "scoped_tenant"
    );
    assert_eq!(
        rows[1]["result"]["results"][0]["project_id"],
        "scoped_project"
    );
}

#[test]
fn batch_continue_on_error_keeps_receipts_after_scope_failure() {
    let temp = tempfile::tempdir().unwrap();
    let project_dir = temp.path().join("project");
    std::fs::create_dir_all(project_dir.join(".memd")).unwrap();
    std::fs::write(
        project_dir.join(".memd/project_scope.json"),
        "{ malformed scope",
    )
    .unwrap();
    let jsonl = r#"{"tool":"memory.add","arguments":{"tenant_id":"explicit_tenant","text":"receipt survives scope error","type":"doc"}}
{"tool":"memory.add","arguments":{"text":"must not be written","type":"doc"}}
{"tool":"memory.search","arguments":{"tenant_id":"explicit_tenant","query":"receipt survives","k":1}}
"#;

    let mut child = Command::new(memd_bin())
        .current_dir(&project_dir)
        .args([
            "--in-memory",
            "batch",
            "--jsonl",
            "-",
            "--continue-on-error",
            "--warm",
            "off",
        ])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("spawn batch with malformed scope");
    child
        .stdin
        .as_mut()
        .expect("stdin")
        .write_all(jsonl.as_bytes())
        .expect("write malformed-scope jsonl");
    let output = child.wait_with_output().expect("wait for batch");
    assert!(
        output.status.success(),
        "batch failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    let rows = String::from_utf8(output.stdout)
        .unwrap()
        .lines()
        .map(|line| serde_json::from_str::<Value>(line).unwrap())
        .collect::<Vec<_>>();
    assert_eq!(rows.len(), 3);
    assert_eq!(rows[0]["ok"], true);
    assert_eq!(rows[1]["ok"], false);
    let scope_error = rows[1]["error"].as_str().unwrap();
    assert!(scope_error.contains("malformed"), "{scope_error}");
    assert!(
        scope_error.contains(".memd/project_scope.json"),
        "{scope_error}"
    );
    assert_eq!(rows[2]["ok"], true);
    assert_eq!(
        rows[2]["result"]["results"][0]["text"],
        "receipt survives scope error"
    );
}