remem-ai 0.6.88

Local-first coding agent memory for Claude Code and OpenAI Codex
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use serde_json::Value;

#[test]
fn memory_run_schema_has_one_strict_suite_content_identity_definition() -> serde_json::Result<()> {
    let raw = include_str!("../../../../eval/public/schemas/memory-run.schema.json");
    assert_eq!(raw.matches("\"suite_content_identity\": {").count(), 1);

    let schema: Value = serde_json::from_str(raw)?;
    let definition = &schema["properties"]["suite_content_identity"];
    assert_eq!(definition["type"], "string");
    assert_eq!(definition["pattern"], "^sha256-raw-suite-v1:[0-9a-f]{64}$");
    Ok(())
}

#[test]
fn adversarial_policy_v2_schema_requires_provenance_and_artifact_hashes() -> serde_json::Result<()>
{
    let schema: Value = serde_json::from_str(include_str!(
        "../../../../eval/public/schemas/memory-run.schema.json"
    ))?;
    let required = schema["allOf"][0]["then"]["required"]
        .as_array()
        .expect("v2 conditional required fields");
    for field in ["artifact_sha256", "suite_content_identity"] {
        assert!(required.iter().any(|value| value == field), "{field}");
    }
    let required_artifacts = [
        "reader_input",
        "retrieved_evidence",
        "answer",
        "score",
        "diagnosis",
        "remem_db_snapshot",
    ];
    let artifacts = &schema["allOf"][0]["then"]["properties"]["artifacts"];
    let artifact_required = artifacts["required"]
        .as_array()
        .expect("v2 required artifact paths");
    let artifact_hashes = &schema["allOf"][0]["then"]["properties"]["artifact_sha256"];
    let artifact_hash_required = artifact_hashes["required"]
        .as_array()
        .expect("v2 required artifact hashes");
    assert_eq!(artifact_hashes["minProperties"], required_artifacts.len());
    for field in required_artifacts {
        assert!(
            artifact_required.iter().any(|value| value == field),
            "{field}"
        );
        assert!(
            artifact_hash_required.iter().any(|value| value == field),
            "{field} hash"
        );
        assert_eq!(artifacts["properties"][field]["type"], "string");
        assert_eq!(artifacts["properties"][field]["minLength"], 1);
    }
    let environment = &schema["allOf"][0]["then"]["properties"]["environment"];
    let environment_required = environment["required"]
        .as_array()
        .expect("v2 environment required fields");
    for field in ["os", "arch", "source_dirty", "production_input_tree_sha256"] {
        assert!(
            environment_required.iter().any(|value| value == field),
            "{field}"
        );
    }
    assert_eq!(environment["properties"]["source_dirty"]["const"], false);
    assert_eq!(
        environment["properties"]["production_input_tree_sha256"]["type"],
        "string"
    );
    assert_eq!(
        environment["properties"]["production_input_tree_sha256"]["pattern"],
        "^[0-9a-f]{64}$"
    );
    let diagnosis = &schema["properties"]["diagnosis"];
    let diagnosis_required = diagnosis["required"]
        .as_array()
        .expect("typed diagnosis required fields");
    for field in [
        "write_side_gap",
        "retrieval_side_gap",
        "reader_gap",
        "policy_abstention",
    ] {
        assert!(diagnosis_required.iter().any(|value| value == field));
        assert_eq!(diagnosis["properties"][field]["type"], "boolean");
    }
    Ok(())
}

#[test]
fn memory_report_schema_types_all_string_arrays() -> serde_json::Result<()> {
    let schema: Value = serde_json::from_str(include_str!(
        "../../../../eval/public/schemas/memory-report.schema.json"
    ))?;

    for field in ["conditions", "schema_refs", "run_artifacts"] {
        let items = &schema["properties"][field]["items"];
        assert_eq!(items["type"], "string", "{field}");
        assert_eq!(items["minLength"], 1, "{field}");
    }
    Ok(())
}

#[test]
fn duplicate_coding_claim_contract_is_removed_from_runtime() {
    let duplicate_name = ["coding-claim", "-contract-v1.json"].concat();
    assert!(!std::path::Path::new("eval/public/claims")
        .join(&duplicate_name)
        .exists());
    assert!(
        !include_str!("../../../../scripts/ci/check_public_claims.py").contains(&duplicate_name)
    );
}