sqlite-graphrag 1.1.5

Persistent GraphRAG memory for Claude Code, Codex, Cursor, and 24+ AI agents — one self-contained ~19 MiB Rust binary, zero daemon. Never re-explain your codebase again. Hybrid retrieval (FTS5 BM25 + cosine similarity + multi-hop graph traversal) surfaces the right memory in milliseconds. Embedding and entity enrichment run as parallel REST calls against your cloud LLM — no fragile headless subprocesses, no ONNX runtime, no model downloads. Soft-delete with full version history, transactional atomic writes, BLAKE3-tracked mutations. OAuth-only: raw 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(&"run".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);
}