@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/antigravity/records.ts

@@ -0,0 +1,236 @@
+import { join } from "node:path"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+import { allBytes, asText, concat, decode, messageField, numberOf, textField, textOf, varintField, type Field } from "./proto.ts"
+
+// Antigravity (Google): where its conversations are and what their rows look like. Ported from the clean-room
+// format notes and reference adapter of session-migrate (MIT, xhluca: docs/antigravity-format.md,
+// src/session_migrate/formats/antigravity.py), which pin Antigravity CLI 1.1.16, and checked against the real
+// 1.1.16 capture in test/fixtures/native-corpus/antigravity.
+//
+// Every conversation is its own SQLite database, ~/.gemini/<store>/conversations/<uuid>.db, with seven tables:
+// trajectory_meta (the conversation's trajectory: type 4 cascade, source 17 for the CLI), steps (one row per
+// step, idx 0..n-1, each with its type and status both as columns and inside the serialised Step protobuf),
+// trajectory_metadata_blob (one "main" row), and four runtime tables. Beside the folder,
+// conversation_summaries.db is the picker's index: title, preview, workspace, times. The CLI keeps its store in
+// antigravity-cli; the IDE uses antigravity and antigravity-ide, the same layout, a wider summaries table, and
+// encrypted <uuid>.pb files that nothing here reads.
+//
+// A Step carries its type in field 1, its status in field 4 (3 done, 7 error), its metadata (times, the tool
+// call a result answers) in field 5, and its body in a field that depends on the type (PAYLOAD_FIELD). A user
+// input keeps the person's text in field 2; a planner response keeps the reply in field 1, a message id in
+// field 6 and its tool calls (id 1, name 2, JSON arguments 3) in repeated field 7, and private thinking in
+// fields 3, 4, 14 and 16; a generic tool step keeps the arguments as {key, JSON value} entries in repeated field
+// 1 and the result in field 2 (text in its field 1, {key, value} metadata in its repeated field 2).
+
+export const TOOL = "antigravity"
+export const LABEL = "Antigravity"
+/** Antigravity CLI versions whose store the writer was checked against (by session-migrate's live checks). */
+export const TESTED_VERSIONS = ["1.1.16"]
+
+/** The CLI's store, then the IDE's two. */
+export const STORES = ["antigravity-cli", "antigravity", "antigravity-ide"] as const
+export type Store = (typeof STORES)[number]
+export const CLI_STORE: Store = "antigravity-cli"
+
+export const storeDir = (home: string, store: Store) => join(home, ".gemini", store)
+export const conversationsDir = (home: string, store: Store) => join(storeDir(home, store), "conversations")
+export const summariesPath = (home: string, store: Store) => join(storeDir(home, store), "conversation_summaries.db")
+
+/** A conversation database's file name: its UUID and .db. */
+export const CONVERSATION_FILE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.db$/i
+
+export const STEP = {
+  viewFile: 8,
+  listDirectory: 9,
+  userInput: 14,
+  plannerResponse: 15,
+  runCommand: 21,
+  checkpoint: 23,
+  mcpTool: 38,
+  fileChange: 86,
+  conversationHistory: 98,
+  shellExec: 112,
+  writeBlob: 128,
+  generic: 132,
+} as const
+
+/** The Step field holding each type's body, as observed in 1.1.16. */
+export const PAYLOAD_FIELD: Record<number, number> = { 8: 14, 9: 15, 14: 19, 15: 20, 21: 28, 23: 30, 38: 47, 86: 98, 98: 111, 112: 127, 128: 142, 132: 140 }
+
+export const STATUS = { done: 3, error: 7 } as const
+export const TRAJECTORY = { cascade: 4, cli: 17 } as const
+/** The project the CLI files conversations under when it has no other. */
+export const PROJECT_ID = "default-cli-project"
+/** The generic result's metadata key linking it to its call (session-migrate's, kept for interoperability). */
+export const LINK_KEY = "session_migrate_call_id"
+
+/** Bounds on what a reader accepts from a store. */
+export const MAX_DB_BYTES = 256 * 1024 * 1024
+export const MAX_STEPS = 100_000
+
+/** The conversation database as the 1.1.16 CLI creates it (from the capture's sqlite_master). */
+export const SCHEMA = `
+CREATE TABLE \`trajectory_meta\` (\`trajectory_id\` text,\`cascade_id\` text,\`trajectory_type\` integer,\`source\` integer,PRIMARY KEY (\`trajectory_id\`));
+CREATE TABLE \`steps\` (\`idx\` integer,\`step_type\` integer NOT NULL DEFAULT 0,\`status\` integer NOT NULL DEFAULT 0,\`has_subtrajectory\` numeric NOT NULL DEFAULT false,\`metadata\` blob,\`error_details\` blob,\`permissions\` blob,\`task_details\` blob,\`render_info\` blob,\`step_payload\` blob,\`step_format\` integer NOT NULL DEFAULT 0,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`gen_metadata\` (\`idx\` integer,\`data\` blob,\`size\` integer NOT NULL DEFAULT 0,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`executor_metadata\` (\`idx\` integer,\`data\` blob,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`parent_references\` (\`idx\` integer,\`data\` blob,PRIMARY KEY (\`idx\`));
+CREATE TABLE \`trajectory_metadata_blob\` (\`id\` text DEFAULT "main",\`data\` blob,PRIMARY KEY (\`id\`));
+CREATE TABLE \`battle_mode_infos\` (\`idx\` integer,\`data\` blob,PRIMARY KEY (\`idx\`));
+CREATE INDEX \`idx_steps_status\` ON \`steps\`(\`status\`);
+CREATE INDEX \`idx_steps_step_type\` ON \`steps\`(\`step_type\`);
+`
+
+/** The picker index as 1.1.16 creates it. */
+export const SUMMARY_SCHEMA = `
+CREATE TABLE \`conversation_summaries\` (\`conversation_id\` text,\`title\` text NOT NULL DEFAULT "",\`preview\` text NOT NULL DEFAULT "",\`step_count\` integer NOT NULL DEFAULT 0,\`last_modified_time\` datetime NOT NULL,\`workspace_uris\` text NOT NULL,\`status\` text NOT NULL DEFAULT "",\`source\` text NOT NULL DEFAULT "",\`project_id\` text NOT NULL DEFAULT "",\`agent_name\` text NOT NULL DEFAULT "",\`parent_conversation_id\` text NOT NULL DEFAULT "",\`nesting_depth\` integer NOT NULL DEFAULT 0,\`battle_id\` text NOT NULL DEFAULT "",\`winning_conversation_id\` text NOT NULL DEFAULT "",\`not_fully_idle\` numeric NOT NULL DEFAULT false,\`killed\` numeric NOT NULL DEFAULT false,\`last_user_input_time\` datetime NOT NULL,\`last_user_input_step_index\` integer NOT NULL DEFAULT -1,\`app_data_dir\` text NOT NULL DEFAULT "",PRIMARY KEY (\`conversation_id\`));
+CREATE INDEX \`idx_conversation_summaries_last_user_input_time\` ON \`conversation_summaries\`(\`last_user_input_time\`);
+CREATE INDEX \`idx_conversation_summaries_last_modified_time\` ON \`conversation_summaries\`(\`last_modified_time\`);
+`
+
+/** The summary columns 1.1.16 has, all of which the writer fills. Newer builds and the IDE add more. */
+export const SUMMARY_COLUMNS = [
+  "conversation_id",
+  "title",
+  "preview",
+  "step_count",
+  "last_modified_time",
+  "workspace_uris",
+  "status",
+  "source",
+  "project_id",
+  "agent_name",
+  "parent_conversation_id",
+  "nesting_depth",
+  "battle_id",
+  "winning_conversation_id",
+  "not_fully_idle",
+  "killed",
+  "last_user_input_time",
+  "last_user_input_step_index",
+  "app_data_dir",
+] as const
+
+/** A google.protobuf.Timestamp ({1: seconds, 2: nanos}) as ISO time. */
+export function timestampOf(fields: Field[] | undefined): string | undefined {
+  const seconds = fields && numberOf(fields, 1)
+  if (!seconds || seconds <= 0) return undefined
+  const nanos = numberOf(fields!, 2) ?? 0
+  const ms = seconds * 1000 + Math.floor(nanos / 1e6)
+  return Number.isFinite(ms) && ms < 8.64e15 ? new Date(ms).toISOString() : undefined
+}
+
+/** A summaries datetime ("2026-09-01 00:08:05.04913412+00:00", as Go writes it) as ISO time; Go's zero time is none. */
+export function sqlTime(v: unknown): string | undefined {
+  if (typeof v !== "string") return undefined
+  const m = /^(\d{4}-\d\d-\d\d)[ T](\d\d:\d\d:\d\d)(?:\.(\d+))?\s*(Z|[+-]\d\d:?\d\d)?$/.exec(v.trim())
+  if (!m || m[1]!.startsWith("0001-")) return undefined
+  const frac = (m[3] ?? "").slice(0, 3).padEnd(3, "0")
+  const t = Date.parse(`${m[1]}T${m[2]}.${frac}${m[4] ?? "Z"}`)
+  return Number.isFinite(t) ? new Date(t).toISOString() : undefined
+}
+
+/** A time as the summaries table stores it. */
+export const toSqlTime = (d: Date) => `${d.toISOString().slice(0, 10)} ${d.toISOString().slice(11, 23)}+00:00`
+
+/** A tool call as a planner response stores it. */
+export interface NativeCall {
+  id: string
+  name: string
+  /** The arguments JSON as stored. */
+  args: string
+}
+
+export function decodeCall(b: Uint8Array): NativeCall | undefined {
+  const f = decode(b)
+  const id = textOf(f, 1)
+  const name = textOf(f, 2)
+  if (!id || !name) return undefined
+  return { id, name, args: textOf(f, 3) ?? "" }
+}
+
+/** Whether a planner response holds private thinking (visible or raw thinking, a signature, or the thinking flag). */
+export const hasThinking = (planner: Field[]) => [3, 4, 14, 16].some((n) => allBytes(planner, n).length > 0) || numberOf(planner, 5) === 1
+
+/** The {key, value} entries of a repeated map field. */
+export function entriesOf(fields: Field[], no: number): Array<[string, string]> {
+  const out: Array<[string, string]> = []
+  for (const e of allBytes(fields, no)) {
+    try {
+      const f = decode(e)
+      const k = textOf(f, 1)
+      if (k !== undefined) out.push([k, textOf(f, 2) ?? ""])
+    } catch {
+      // An entry that is not a {key, value} message is skipped.
+    }
+  }
+  return out
+}
+
+/** What Antigravity's own tools do; other names go through the shared guess. */
+const KINDS: Record<string, ToolKind> = {
+  view_file: "read",
+  view_file_outline: "read",
+  view_code_item: "read",
+  list_dir: "list",
+  find_by_name: "search",
+  grep_search: "search",
+  codebase_search: "search",
+  run_command: "shell",
+  command_status: "shell",
+  send_command_input: "shell",
+  shell_exec: "shell",
+  write_to_file: "write",
+  replace_file_content: "edit",
+  multi_replace_file_content: "edit",
+  read_url_content: "web",
+  search_web: "web",
+}
+export const antigravityToolKind = (name: string): ToolKind => KINDS[name] ?? toolKindOf(name)
+
+// Encoding the four messages the writer emits.
+
+const uuidText = (no: number, id: string) => textField(no, id)
+
+/** A whole Step: type, status, and the body in its type's field. */
+export function stepBytes(type: number, status: number, body: Uint8Array): Uint8Array {
+  const field = PAYLOAD_FIELD[type]
+  if (field === undefined) throw new Error(`no payload field is known for Antigravity step type ${type}`)
+  return concat([varintField(1, type), varintField(4, status), messageField(field, [body])])
+}
+
+export const userInputBody = (text: string) => textField(2, text)
+
+export function plannerBody(o: { text?: string; messageId: string; calls?: NativeCall[] }): Uint8Array {
+  return concat([
+    ...(o.text ? [textField(1, o.text)] : []),
+    uuidText(6, o.messageId),
+    ...(o.calls ?? []).map((c) => messageField(7, [textField(1, c.id), textField(2, c.name), textField(3, c.args)])),
+  ])
+}
+
+export function genericBody(o: { args: Array<[string, string]>; result: string; callId: string }): Uint8Array {
+  return concat([
+    ...o.args.map(([k, v]) => messageField(1, [textField(1, k), textField(2, v)])),
+    messageField(2, [textField(1, o.result), messageField(2, [textField(1, LINK_KEY), textField(2, o.callId)])]),
+  ])
+}
+
+/** The minimal "main" trajectory metadata: creation time, root conversation id, project. */
+export const trajectoryMetadata = (seconds: number, conversationId: string) =>
+  concat([messageField(2, [varintField(1, seconds)]), textField(6, conversationId), textField(18, PROJECT_ID)])
+
+/** The first workspace folder in trajectory metadata (field 1's folder URI, else field 7). */
+export function workspaceOf(meta: Field[]): string | undefined {
+  for (const w of allBytes(meta, 1)) {
+    try {
+      const uri = textOf(decode(w), 1)
+      if (uri) return uri
+    } catch {
+      // not a workspace message
+    }
+  }
+  const first = allBytes(meta, 7)[0]
+  return first ? asText(first) : undefined
+}