agentstategraph 1.4.1

AI-native versioned state store for intent-based systems
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! `--from`/merge RefSpec resolution: branch names, full commit hashes, and
//! unique `sg_`/hex commit-id prefixes, with distinct error variants.

use agentstategraph::{CommitOptions, RepoError, Repository};
use agentstategraph_core::{IntentCategory, Object};
use agentstategraph_storage::SqliteStorage;

fn repo() -> Repository {
    let r = Repository::new(Box::new(
        SqliteStorage::in_memory().expect("in-memory sqlite"),
    ));
    r.init().unwrap();
    r
}

fn opts(desc: &str) -> CommitOptions {
    CommitOptions::new("agent/test", IntentCategory::Checkpoint, desc)
}

/// Advance main and return its head commit id.
fn commit(r: &Repository, path: &str, v: i64, desc: &str) -> agentstategraph_core::ObjectId {
    r.set("main", path, &Object::int(v), opts(desc)).unwrap()
}

#[test]
fn branch_from_full_commit_hash() {
    let r = repo();
    let c = commit(&r, "/x", 1, "c1");
    commit(&r, "/y", 2, "c2"); // main moves on; c is now historical

    // sg_-prefixed full hash
    r.branch("recovery", &format!("{c}")).unwrap();
    assert_eq!(r.get("recovery", "/x").unwrap(), Object::int(1));
    // recovery is pinned at c, so /y must NOT be present
    assert!(r.get("recovery", "/y").is_err());
}

#[test]
fn branch_from_unique_prefix() {
    let r = repo();
    let c = commit(&r, "/x", 1, "c1");
    commit(&r, "/y", 2, "c2");

    let short = c.short(); // "sg_<12 hex>"
    r.branch("recovery", &short).unwrap();
    assert_eq!(r.get("recovery", "/x").unwrap(), Object::int(1));

    // Raw hex prefix (no sg_) must also resolve.
    let raw = &c.to_hex()[..10];
    r.branch("recovery2", raw).unwrap();
    assert_eq!(r.get("recovery2", "/x").unwrap(), Object::int(1));
}

#[test]
fn branch_from_orphaned_commit() {
    // A commit whose branch was deleted must still be resolvable by id.
    let r = repo();
    r.branch("temp", "main").unwrap();
    let c = r
        .set("temp", "/orphan", &Object::int(9), opts("on temp"))
        .unwrap();
    assert!(r.delete_branch("temp").unwrap());

    r.branch("recovery", &format!("{c}")).unwrap();
    assert_eq!(r.get("recovery", "/orphan").unwrap(), Object::int(9));
}

#[test]
fn unknown_branch_name_is_branch_not_found() {
    let r = repo();
    let err = r.branch("feat", "definitely-not-a-ref").unwrap_err();
    assert!(matches!(err, RepoError::BranchNotFound(_)), "got {err:?}");
}

#[test]
fn hex_shaped_miss_is_commit_not_found() {
    let r = repo();
    // Well-formed but nonexistent prefix.
    let err = r.branch("feat", "sg_deadbeef").unwrap_err();
    assert!(matches!(err, RepoError::CommitNotFound(_)), "got {err:?}");
}

#[test]
fn ambiguous_prefix_errors() {
    let r = repo();
    // With more than 16 commits, pigeonhole guarantees at least two commit ids
    // share the same first hex digit, so some 1-hex-digit prefix is ambiguous.
    for i in 0..24 {
        commit(&r, &format!("/k{i}"), i, "c");
    }

    let mut saw_ambiguous = false;
    for digit in "0123456789abcdef".chars() {
        if let Err(RepoError::AmbiguousCommitPrefix { count, .. }) =
            r.branch(&format!("b_{digit}"), &digit.to_string())
        {
            assert!(count >= 2);
            saw_ambiguous = true;
            break;
        }
    }
    assert!(
        saw_ambiguous,
        "expected some 1-hex-digit prefix to be ambiguous"
    );
}

/// A repository limited to branch names refuses commit ids and prefixes,
/// which resolve over every namespace's commits, and its forks keep the
/// limit. Branch names still resolve, including one that looks like hex.
#[test]
fn branch_refs_only_refuses_commit_ids() {
    let r = repo().with_branch_refs_only();
    let c = commit(&r, "/x", 1, "c1");
    let hex = c.to_hex();
    for spec in [hex.clone(), format!("sg_{hex}"), hex[..10].to_string()] {
        match r.get_json(&spec, "/x") {
            Err(RepoError::CommitRefNotAllowed(s)) => assert_eq!(s, spec),
            other => panic!("{spec}: {other:?}"),
        }
    }
    assert!(matches!(
        r.get_json("no-such-branch", "/x"),
        Err(RepoError::BranchNotFound(_))
    ));
    assert_eq!(r.get_json("main", "/x").unwrap(), serde_json::json!(1));
    r.branch("abc123", "main").unwrap();
    assert_eq!(r.get_json("abc123", "/x").unwrap(), serde_json::json!(1));

    let fork = r.fork_namespace(agentstategraph_core::Namespace::default_ns());
    assert!(matches!(
        fork.get_json(&hex, "/x"),
        Err(RepoError::CommitRefNotAllowed(_))
    ));
    // Without the limit, the same id resolves.
    let open = repo();
    let c = commit(&open, "/x", 1, "c1");
    assert_eq!(
        open.get_json(&c.to_hex(), "/x").unwrap(),
        serde_json::json!(1)
    );
}