Skip to content

Commit 1935e0e

Browse files
committed
feat(gemini): support Antigravity SQLite conversation database parsing
- Discover SQLite conversation databases under ~/.gemini/antigravity/conversations/*.db alongside existing JSON/JSONL logs - Decode Antigravity binary protobuf metadata from the gen_metadata table in read-only mode - Parse input, output, cached, and reasoning/thinking tokens with defensive varint decoding - Add fixture-based unit test covering SQLite database parsing and environment isolation - Update crate README with SQLite data source and dependencies
1 parent ee74244 commit 1935e0e

6 files changed

Lines changed: 225 additions & 6 deletions

File tree

‎rust/Cargo.lock‎

Lines changed: 1 addition & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎rust/adapters/gemini/Cargo.toml‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,8 @@ ccusage-core.workspace = true
1010
jiff.workspace = true
1111
serde.workspace = true
1212
serde_json.workspace = true
13+
sqlite.workspace = true
1314

1415
[dev-dependencies]
16+
ccusage-core = { workspace = true, features = ["fetch-litellm-pricing"] }
1517
ccusage-test-support.workspace = true

‎rust/adapters/gemini/README.md‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,8 +16,9 @@ Anything that is not specific to this source belongs in `ccusage-core` or
1616
## Data source
1717

1818
- `${GEMINI_DATA_DIR:-~/.gemini}/tmp/**/chats/*.{json,jsonl}`
19+
- `${GEMINI_DATA_DIR:-~/.gemini}/antigravity/conversations/*.db`
1920

20-
Reads plain files through `ccusage-adapter-common`, which handles walking, size-balanced
21+
Reads plain files and SQLite databases through `ccusage-adapter-common` and `sqlite`, which handles walking, size-balanced
2122
chunking, and ordered parallel reads.
2223

2324
## Public surface
@@ -34,6 +35,7 @@ chunking, and ordered parallel reads.
3435
- `jiff`
3536
- `serde`
3637
- `serde_json`
38+
- `sqlite`
3739

3840
## Build layer
3941

‎rust/adapters/gemini/src/loader.rs‎

Lines changed: 59 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@ use crate::{
33
};
44

55
use super::{
6-
parser::{event_to_loaded, parse_json_file, parse_jsonl_file},
6+
parser::{event_to_loaded, parse_json_file, parse_jsonl_file, parse_sqlite_file},
77
paths::discover_log_files,
88
};
99

@@ -21,10 +21,10 @@ fn load_entries_inner(shared: &SharedArgs, pricing: &PricingMap) -> Result<Vec<L
2121
// Read each log file in parallel; the events keep their original file order
2222
// before the stable sort, so output is identical to the sequential read.
2323
let loaded = read_files_parallel(&files, shared.single_thread, |file| {
24-
let parsed = if file.extension().and_then(|extension| extension.to_str()) == Some("jsonl") {
25-
parse_jsonl_file(file)
26-
} else {
27-
parse_json_file(file)
24+
let parsed = match file.extension().and_then(|extension| extension.to_str()) {
25+
Some("jsonl") => parse_jsonl_file(file),
26+
Some("db") => parse_sqlite_file(file),
27+
_ => parse_json_file(file),
2828
};
2929
parsed.unwrap_or_else(|error| {
3030
debug_log(
@@ -75,4 +75,58 @@ mod tests {
7575
);
7676
assert_eq!(entries[0].extra_total_tokens, 919);
7777
}
78+
79+
#[test]
80+
fn loads_sqlite_antigravity_metadata() {
81+
let fixture = ccusage_test_support::Fixture::new();
82+
let db_path = fixture.path("session-db.db");
83+
let connection = sqlite::open(&db_path).unwrap();
84+
connection
85+
.execute("CREATE TABLE gen_metadata (idx INTEGER PRIMARY KEY, data BLOB);")
86+
.unwrap();
87+
88+
// 1.4: tokens submessage (1.4.2 = 100, 1.4.3 = 50, 1.4.5 = 20, 1.4.9 = 10)
89+
let tokens_bytes = vec![
90+
0x10, 100, // 2: varint 100
91+
0x18, 50, // 3: varint 50
92+
0x28, 20, // 5: varint 20
93+
0x48, 10, // 9: varint 10
94+
];
95+
// 1.9.4.1 = 1779000000 (0x6A0BB9C0 -> varint: C0 B3 AF D0 06)
96+
let ts_inner = vec![0x08, 0xC0, 0xB3, 0xAF, 0xD0, 0x06];
97+
let ts_field9 = vec![0x22, ts_inner.len() as u8];
98+
let mut field1_payload = Vec::new();
99+
field1_payload.push(0x22); // tag for 1.4
100+
field1_payload.push(tokens_bytes.len() as u8);
101+
field1_payload.extend_from_slice(&tokens_bytes);
102+
field1_payload.push(0x4A); // tag for 1.9
103+
field1_payload.push((ts_field9.len() + ts_inner.len()) as u8);
104+
field1_payload.extend_from_slice(&ts_field9);
105+
field1_payload.extend_from_slice(&ts_inner);
106+
107+
let mut blob = Vec::new();
108+
blob.push(0x0A); // tag for 1
109+
blob.push(field1_payload.len() as u8);
110+
blob.extend_from_slice(&field1_payload);
111+
112+
let mut statement = connection
113+
.prepare("INSERT INTO gen_metadata (idx, data) VALUES (1, ?)")
114+
.unwrap();
115+
statement.bind((1, blob.as_slice())).unwrap();
116+
statement.next().unwrap();
117+
118+
let _env_guard = super::super::GeminiDataDirEnvGuard::set(fixture.root());
119+
let shared = SharedArgs {
120+
timezone: Some("UTC".to_string()),
121+
..SharedArgs::default()
122+
};
123+
let entries = load_entries(&shared, &PricingMap::load_embedded()).unwrap();
124+
125+
assert_eq!(entries.len(), 1);
126+
assert_eq!(entries[0].session_id.as_ref(), "session-db");
127+
assert_eq!(entries[0].data.message.usage.input_tokens, 100);
128+
assert_eq!(entries[0].data.message.usage.output_tokens, 50);
129+
assert_eq!(entries[0].data.message.usage.cache_read_input_tokens, 20);
130+
assert_eq!(entries[0].extra_total_tokens, 10);
131+
}
78132
}

‎rust/adapters/gemini/src/parser.rs‎

Lines changed: 152 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -218,6 +218,158 @@ pub(super) fn parse_jsonl_file(path: &Path) -> Result<Vec<GeminiUsageEvent>> {
218218
Ok(events)
219219
}
220220

221+
pub(super) fn parse_sqlite_file(path: &Path) -> Result<Vec<GeminiUsageEvent>> {
222+
let fallback_timestamp = file_modified_timestamp(path);
223+
let Ok(connection) =
224+
sqlite::Connection::open_with_flags(path, sqlite::OpenFlags::new().with_read_only())
225+
else {
226+
return Ok(Vec::new());
227+
};
228+
let Ok(mut statement) = connection.prepare("SELECT idx, data FROM gen_metadata") else {
229+
return Ok(Vec::new());
230+
};
231+
232+
let session_id = path
233+
.file_stem()
234+
.and_then(|stem| stem.to_str())
235+
.unwrap_or("unknown")
236+
.to_string();
237+
238+
let mut events = Vec::new();
239+
while let Ok(sqlite::State::Row) = statement.next() {
240+
let idx: i64 = statement.read(0).unwrap_or_default();
241+
let blob: Vec<u8> = statement.read(1).unwrap_or_default();
242+
if blob.is_empty() {
243+
continue;
244+
}
245+
let parsed = parse_antigravity_protobuf(&blob);
246+
let model = parsed
247+
.get("1.3")
248+
.map(|value| value.to_string())
249+
.unwrap_or_else(|| "gemini-internal-model".to_string());
250+
let input_tokens = parsed.get("1.4.2").copied().unwrap_or(0);
251+
let output_tokens = parsed.get("1.4.3").copied().unwrap_or(0);
252+
let cache_read_tokens = parsed.get("1.4.5").copied().unwrap_or(0);
253+
let reasoning_tokens = parsed.get("1.4.9").copied().unwrap_or(0);
254+
let visible_tokens = parsed.get("1.4.10").copied().unwrap_or(0);
255+
let timestamp = parsed
256+
.get("1.9.4.1")
257+
.copied()
258+
.and_then(|value| i64::try_from(value).ok())
259+
.and_then(|ms| {
260+
if ms > 0 {
261+
Some(TimestampMs::from_millis(ms * 1000))
262+
} else {
263+
None
264+
}
265+
})
266+
.unwrap_or(fallback_timestamp);
267+
if input_tokens == 0
268+
&& output_tokens == 0
269+
&& cache_read_tokens == 0
270+
&& reasoning_tokens == 0
271+
&& visible_tokens == 0
272+
{
273+
continue;
274+
}
275+
let event = build_event(
276+
Some(&model),
277+
&session_id,
278+
timestamp,
279+
GeminiTokens {
280+
input: input_tokens,
281+
output: output_tokens,
282+
cached: cache_read_tokens,
283+
thoughts: reasoning_tokens.max(visible_tokens.saturating_sub(output_tokens)),
284+
tool: 0,
285+
total: Some(input_tokens + output_tokens + cache_read_tokens + reasoning_tokens),
286+
},
287+
normalize_session_input,
288+
Some(format!("antigravity-gen-{idx}")),
289+
);
290+
if let Some(event) = event {
291+
events.push(event);
292+
}
293+
}
294+
Ok(events)
295+
}
296+
297+
fn parse_antigravity_protobuf(blob: &[u8]) -> HashMap<String, u64> {
298+
let mut out = HashMap::new();
299+
parse_antigravity_protobuf_fields(blob, &mut out, "");
300+
out
301+
}
302+
303+
fn parse_antigravity_protobuf_fields(blob: &[u8], out: &mut HashMap<String, u64>, prefix: &str) {
304+
let mut cursor = 0usize;
305+
while cursor < blob.len() {
306+
let Some((tag, next)) = read_varint(blob, cursor) else {
307+
break;
308+
};
309+
cursor = next;
310+
let field = tag >> 3;
311+
let wire = tag & 0x7;
312+
let path = if prefix.is_empty() {
313+
field.to_string()
314+
} else {
315+
format!("{prefix}.{field}")
316+
};
317+
match wire {
318+
0 => {
319+
let Some((value, next)) = read_varint(blob, cursor) else {
320+
break;
321+
};
322+
cursor = next;
323+
out.insert(path, value);
324+
}
325+
2 => {
326+
let Some((len, next)) = read_varint(blob, cursor) else {
327+
break;
328+
};
329+
cursor = next;
330+
let Some(end) = usize::try_from(len)
331+
.ok()
332+
.and_then(|len_usize| cursor.checked_add(len_usize))
333+
.filter(|&end| end <= blob.len())
334+
else {
335+
break;
336+
};
337+
let payload = &blob[cursor..end];
338+
let mut nested = HashMap::new();
339+
parse_antigravity_protobuf_fields(payload, &mut nested, &path);
340+
if nested.is_empty() {
341+
out.insert(path, 0);
342+
} else {
343+
for (nested_path, value) in nested {
344+
out.insert(nested_path, value);
345+
}
346+
}
347+
cursor = end;
348+
}
349+
1 => cursor += 8,
350+
5 => cursor += 4,
351+
_ => break,
352+
}
353+
}
354+
}
355+
356+
fn read_varint(blob: &[u8], mut offset: usize) -> Option<(u64, usize)> {
357+
let mut value = 0u64;
358+
let mut shift = 0u32;
359+
loop {
360+
if offset >= blob.len() || shift >= 64 {
361+
return None;
362+
}
363+
let byte = blob[offset];
364+
offset += 1;
365+
value |= u64::from(byte & 0x7F) << shift;
366+
if byte & 0x80 == 0 {
367+
return Some((value, offset));
368+
}
369+
shift += 7;
370+
}
371+
}
372+
221373
fn parse_direct_event(
222374
record: &Map<String, Value>,
223375
model_hint: Option<&str>,

‎rust/adapters/gemini/src/paths.rs‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,13 @@ fn paths() -> Result<Vec<PathBuf>> {
2626
if path.is_dir() && seen.insert(path.clone()) {
2727
paths.push(path);
2828
}
29+
let antigravity_dir = home
30+
.join(".gemini")
31+
.join("antigravity")
32+
.join("conversations");
33+
if antigravity_dir.is_dir() && seen.insert(antigravity_dir.clone()) {
34+
paths.push(antigravity_dir);
35+
}
2936
}
3037
Ok(paths)
3138
}
@@ -35,6 +42,7 @@ pub(super) fn discover_log_files() -> Result<Vec<PathBuf>> {
3542
for path in paths()? {
3643
collect_files_with_extension(&path, "json", &mut files);
3744
collect_files_with_extension(&path, "jsonl", &mut files);
45+
collect_files_with_extension(&path, "db", &mut files);
3846
}
3947
files.sort();
4048
files.dedup();

0 commit comments

Comments
 (0)