sqlite-graphrag 1.0.78

Persistent GraphRAG memory for Claude Code, Codex, Cursor, and 24+ AI agents in a single 6 MB Rust binary. LLM-only and one-shot in v1.0.78: every `remember` / `ingest` spawns a headless claude code or codex subprocess (OAuth, no MCP, no hooks). No daemon. No ONNX runtime. No model download. Graph-native retrieval with FTS5 + cosine + multi-hop traversal. OAuth-only enforcement: API keys ABORT the spawn.
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

//! Tests for the G22 VersionAdapter trait and concrete adapters.

use sqlite_graphrag::spawn::{
    claude_adapter::ClaudeAdapter, codex_adapter::CodexAdapter, compat_matrix,
    executor_version::ExecutorVersion, opencode_adapter::OpencodeAdapter, CompatMode,
    VersionAdapter,
};

#[tokio::test]
async fn codex_137_caps_removed_old_flag() {
    let v = ExecutorVersion::parse("0.137.0").unwrap();
    let caps = compat_matrix::codex_capabilities(&v);
    assert!(!caps.supports_ask_for_approval_flag);
    assert!(caps
        .removed_flags
        .contains(&"--ask-for-approval".to_string()));
}

#[tokio::test]
async fn codex_130_caps_keep_old_flag() {
    let v = ExecutorVersion::parse("0.130.0").unwrap();
    let caps = compat_matrix::codex_capabilities(&v);
    assert!(caps.supports_ask_for_approval_flag);
}

#[tokio::test]
async fn codex_adapter_name() {
    let adapter = CodexAdapter;
    assert_eq!(adapter.name(), "codex");
}

#[tokio::test]
async fn codex_adapter_capabilities_match_matrix() {
    let adapter = CodexAdapter;
    let v = ExecutorVersion::parse("0.137.0").unwrap();
    let caps = adapter.capabilities_for(&v);
    assert!(!caps.supports_ask_for_approval_flag);
}

#[tokio::test]
async fn codex_adapter_build_args_include_exec() {
    let adapter = CodexAdapter;
    let v = ExecutorVersion::parse("0.137.0").unwrap();
    let caps = adapter.capabilities_for(&v);
    let args = adapter.build_args("hello world", &caps, CompatMode::Auto);
    assert!(args.contains(&"exec".to_string()));
    assert!(args.contains(&"hello world".to_string()));
}

#[tokio::test]
async fn codex_adapter_parse_jsonl() {
    let adapter = CodexAdapter;
    let raw = r#"{"type":"message","content":"hello"}
{"type":"tool","name":"foo"}"#;
    let parsed = adapter.parse_output(raw, "", 0);
    assert_eq!(parsed.items.len(), 2);
    assert_eq!(parsed.exit_code, 0);
}

#[tokio::test]
async fn claude_adapter_name() {
    let adapter = ClaudeAdapter;
    assert_eq!(adapter.name(), "claude");
}

#[tokio::test]
async fn claude_adapter_capabilities_for_v2() {
    let adapter = ClaudeAdapter;
    let v = ExecutorVersion::parse("2.1.0").unwrap();
    let caps = adapter.capabilities_for(&v);
    assert!(caps.supports_ask_for_approval_flag);
    assert!(caps.supports_mcp_map);
}

#[tokio::test]
async fn claude_adapter_build_args_uses_dash_p() {
    let adapter = ClaudeAdapter;
    let v = ExecutorVersion::parse("2.1.0").unwrap();
    let caps = adapter.capabilities_for(&v);
    let args = adapter.build_args("test prompt", &caps, CompatMode::Auto);
    assert!(args.contains(&"-p".to_string()));
    assert!(args.contains(&"test prompt".to_string()));
}

#[tokio::test]
async fn opencode_adapter_name() {
    let adapter = OpencodeAdapter;
    assert_eq!(adapter.name(), "opencode");
}

#[tokio::test]
async fn opencode_adapter_capabilities() {
    let adapter = OpencodeAdapter;
    let v = ExecutorVersion::parse("0.5.0").unwrap();
    let caps = adapter.capabilities_for(&v);
    assert!(caps.supports_mcp_map);
    assert!(!caps.supports_strict_schema);
}

#[tokio::test]
async fn opencode_adapter_build_args() {
    let adapter = OpencodeAdapter;
    let v = ExecutorVersion::parse("0.5.0").unwrap();
    let caps = adapter.capabilities_for(&v);
    let args = adapter.build_args("hello", &caps, CompatMode::Auto);
    assert!(args.contains(&"headless".to_string()));
    assert!(args.contains(&"hello".to_string()));
}

#[test]
fn compat_mode_parse() {
    assert_eq!(CompatMode::parse("strict"), CompatMode::Strict);
    assert_eq!(CompatMode::parse("LENIENT"), CompatMode::Lenient);
    assert_eq!(CompatMode::parse("auto"), CompatMode::Auto);
    assert_eq!(CompatMode::parse("random"), CompatMode::Auto);
}