@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/antigravity/writer.ts

@@ -0,0 +1,463 @@
+import { Database } from "bun:sqlite"
+import { randomBytes, randomUUID } from "node:crypto"
+import { linkSync, lstatSync, mkdirSync, statSync, unlinkSync, writeFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { pathToFileURL } from "node:url"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Session } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../claude-code/records.ts"
+import { continuedTitle, sh } from "../opencode/writer.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { readConversation } from "./reader.ts"
+import {
+  CLI_STORE,
+  LABEL,
+  PROJECT_ID,
+  SCHEMA,
+  STATUS,
+  STEP,
+  SUMMARY_COLUMNS,
+  SUMMARY_SCHEMA,
+  TESTED_VERSIONS,
+  TOOL,
+  TRAJECTORY,
+  conversationsDir,
+  genericBody,
+  plannerBody,
+  stepBytes,
+  summariesPath,
+  toSqlTime,
+  trajectoryMetadata,
+  userInputBody,
+  type NativeCall,
+} from "./records.ts"
+
+// Continues a portable session in the Antigravity CLI as a new conversation of its own store, built the way
+// session-migrate's clean-room writer builds one for CLI 1.1.16 (docs/antigravity-format.md, "Conversion
+// policy"): a done user-input step per user turn, a done planner-response step per reply, the tool calls of one
+// response together in one planner step, and a generic tool step after it per result (done, or error when the
+// call failed), linked to its call by id. The tools keep their own names and JSON arguments: they are not
+// passed off as Antigravity's built-in tools. Private reasoning, compaction summaries, attachments and the
+// runtime tables are not written. The note saying where the session came from opens the first request.
+//
+// The new database is built in memory, read back with the reader, and only then published under
+// ~/.gemini/antigravity-cli/conversations/<uuid>.db with create-if-absent semantics (a hard link), while an
+// immediate transaction on conversation_summaries.db reserves the id and adds the picker's row; a failure
+// removes only the new file. An existing conversation is never overwritten or merged.
+
+const NO_RESULT = "No result was recorded for this call; the session moved before it finished."
+
+export interface PlannedStep {
+  type: number
+  status: number
+  payload: Uint8Array
+}
+
+export interface AntigravityPlan {
+  id: string
+  trajectoryId: string
+  steps: PlannedStep[]
+  title: string
+  preview: string
+  /** Index of the last user-input step. */
+  lastUserStep: number
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number; results: number }
+}
+
+const isObject = (v: unknown): v is Record<string, unknown> => !!v && typeof v === "object" && !Array.isArray(v)
+
+/** The steps of a new conversation `opts.id` continuing `session`. Pure: writes nothing. */
+export function planAntigravity(session: Session, opts: { id: string; trajectoryId?: string; now: Date }): AntigravityPlan {
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const steps: PlannedStep[] = []
+  const expect = { users: 0, assistants: 0, calls: 0, results: 0 }
+  const push = (type: number, status: number, body: Uint8Array) => steps.push({ type, status, payload: stepBytes(type, status, body) })
+
+  const note = continuedNote(toolLabel(session.header.tool), session.header.id, opts.now.toISOString().slice(0, 10))
+  let noted = false
+  const userStep = (text: string) => {
+    push(STEP.userInput, STATUS.done, userInputBody(noted ? text : text ? `${note}\n\n${text}` : note))
+    noted = true
+  }
+
+  // Calls of the response being built, and calls still waiting for a result (by the source's id, in order).
+  let open: NativeCall[] = []
+  const pending: Array<{ src: string; call: NativeCall; input: Record<string, unknown> }> = []
+  const used = new Set<string>()
+  let made = 0
+  const freshId = () => {
+    let id = ""
+    do id = `call_brain_${++made}`
+    while (used.has(id))
+    return id
+  }
+  const flushCalls = () => {
+    if (!open.length) return
+    if (!noted) userStep("")
+    push(STEP.plannerResponse, STATUS.done, plannerBody({ messageId: randomUUID(), calls: open }))
+    open = []
+  }
+  const resultStep = (call: NativeCall, input: Record<string, unknown>, ok: boolean, output: string) => {
+    const args = Object.entries(input)
+      .filter(([k]) => k)
+      .map(([k, v]): [string, string] => [k, JSON.stringify(v) ?? "null"])
+    push(STEP.generic, ok ? STATUS.done : STATUS.error, genericBody({ args, result: output, callId: call.id }))
+    expect.results++
+  }
+  // Calls still open when the person speaks again are closed as failed, so no call is left without a result.
+  const closeDangling = () => {
+    flushCalls()
+    for (const p of pending.splice(0)) {
+      resultStep(p.call, p.input, false, NO_RESULT)
+      drop("tool calls with no result, closed as failed")
+    }
+  }
+
+  let timed = 0
+  for (const t of session.turns) {
+    if (t.at) timed++
+    switch (t.kind) {
+      case "user": {
+        const n = t.attachments?.length ?? 0
+        const images = t.attachments?.filter((a) => a.kind === "image").length ?? 0
+        if (images) drop("images", images)
+        if (n - images) drop("attached files", n - images)
+        const text = t.text.trim() ? t.text : n ? `(${n} attachment${n > 1 ? "s" : ""} not carried over)` : ""
+        if (!text) break
+        closeDangling()
+        userStep(text)
+        expect.users++
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        flushCalls()
+        if (!noted) userStep("")
+        push(STEP.plannerResponse, STATUS.done, plannerBody({ text: t.text, messageId: randomUUID() }))
+        expect.assistants++
+        if (t.model || t.usage) drop("model names and token usage on replies")
+        break
+      }
+      case "tool_call": {
+        let id = t.id
+        if (!id || used.has(id)) {
+          id = freshId()
+          drop("missing or repeated tool call ids, replaced")
+        }
+        used.add(id)
+        let input: Record<string, unknown> = {}
+        if (isObject(t.input)) input = t.input
+        else if (t.input !== undefined && t.input !== null) {
+          input = { value: t.input }
+          drop("tool inputs that were not objects, wrapped")
+        }
+        let args = "{}"
+        try {
+          args = JSON.stringify(input)
+        } catch {
+          input = {}
+          drop("tool inputs that are not JSON")
+        }
+        const call: NativeCall = { id, name: t.name || "unknown_tool", args }
+        open.push(call)
+        pending.push({ src: t.id, call, input })
+        expect.calls++
+        break
+      }
+      case "tool_result": {
+        flushCalls()
+        const i = pending.findIndex((p) => p.src === t.callId)
+        let p = i >= 0 ? pending.splice(i, 1)[0]! : undefined
+        if (!p) {
+          // A result with no open call before it gets a call of its own: the store links every result to one.
+          const id = t.callId && !used.has(t.callId) ? t.callId : freshId()
+          used.add(id)
+          p = { src: t.callId, call: { id, name: "unknown_tool", args: "{}" }, input: {} }
+          if (!noted) userStep("")
+          push(STEP.plannerResponse, STATUS.done, plannerBody({ messageId: randomUUID(), calls: [p.call] }))
+          expect.calls++
+          drop("tool results without a call (given a placeholder call)")
+        }
+        resultStep(p.call, p.input, t.ok, t.output)
+        break
+      }
+      case "reasoning":
+        drop("reasoning")
+        break
+      case "compaction":
+        drop("compaction summaries")
+        break
+      case "file_edit":
+        if (!t.callId) drop("file edits not made by a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions (their call and result are kept)")
+        break
+    }
+  }
+  closeDangling()
+  // The store needs at least one user input; a session without one still gets the note.
+  if (!noted) userStep("")
+  if (timed) drop("turn times", timed)
+
+  let lastUserStep = -1
+  steps.forEach((s, i) => {
+    if (s.type === STEP.userInput) lastUserStep = i
+  })
+  const trajectoryId = opts.trajectoryId ?? randomUUID()
+  if (trajectoryId === opts.id) throw new Error("the Antigravity conversation and trajectory ids must differ")
+  return {
+    id: opts.id,
+    trajectoryId,
+    steps,
+    title: continuedTitle(session).slice(0, 4_096),
+    preview: (firstUserText(session) ?? "Imported conversation").slice(0, 16_384),
+    lastUserStep,
+    lost: [...drops].map(([what, n]) => `${what} (${n})`),
+    expect,
+  }
+}
+
+/** The conversation database's bytes, built in memory and read back before anything is written. */
+export function buildConversation(plan: AntigravityPlan, now: Date): Uint8Array {
+  const db = new Database(":memory:")
+  try {
+    db.exec(SCHEMA)
+    db.transaction(() => {
+      db.prepare("INSERT INTO trajectory_meta (trajectory_id, cascade_id, trajectory_type, source) VALUES (?, ?, ?, ?)").run(plan.trajectoryId, plan.id, TRAJECTORY.cascade, TRAJECTORY.cli)
+      const add = db.prepare("INSERT INTO steps (idx, step_type, status, has_subtrajectory, metadata, step_payload, step_format) VALUES (?, ?, ?, 0, NULL, ?, 0)")
+      plan.steps.forEach((s, i) => add.run(i, s.type, s.status, s.payload))
+      db.prepare("INSERT INTO trajectory_metadata_blob (id, data) VALUES ('main', ?)").run(trajectoryMetadata(Math.floor(now.getTime() / 1000), plan.id))
+    })()
+    const check = db.query("PRAGMA integrity_check").get() as { integrity_check?: string } | null
+    if (check?.integrity_check !== "ok") throw new Error("the new Antigravity conversation failed SQLite's integrity check")
+    const back = readConversation(db, plan.id, { path: `${plan.id}.db` })
+    const n = countTurns(back)
+    const pairs = unpaired(back)
+    const e = plan.expect
+    if (
+      n.user !== e.users ||
+      n.assistant !== e.assistants ||
+      n.tool_call !== e.calls ||
+      n.tool_result !== e.results ||
+      n.reasoning ||
+      pairs.calls.length ||
+      pairs.results.length ||
+      back.header.lost.length
+    )
+      throw new Error(
+        `the Antigravity conversation did not read back as written (users ${n.user}/${e.users}, replies ${n.assistant}/${e.assistants}, tool calls ${n.tool_call}/${e.calls}, results ${n.tool_result}/${e.results}, unpaired ${pairs.calls.length + pairs.results.length}, lost ${back.header.lost.join("; ") || "none"}); nothing was written`,
+      )
+    return db.serialize()
+  } finally {
+    db.close()
+  }
+}
+
+/** Summary columns the writer fills that a summaries table lacks. Extra columns are fine. */
+function missingColumns(d: Database): string[] {
+  const have = new Set((d.query("PRAGMA table_info(conversation_summaries)").all() as Array<{ name: string }>).map((c) => c.name))
+  return have.size ? SUMMARY_COLUMNS.filter((c) => !have.has(c)) : ["conversation_summaries (no such table)"]
+}
+
+const lexists = (p: string) => {
+  try {
+    lstatSync(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** The binary on PATH (an explicit PATH in the environment is the one searched). */
+export const agyBin = () => Bun.which("agy", { PATH: process.env.PATH ?? "" }) ?? undefined
+
+/**
+ * "1.1.16" from `agy --version`; undefined when it does not answer. Auto-update is turned off for the call:
+ * session-migrate found that even `agy --version` starts the 1.1.16 updater.
+ */
+export function agyVersion(bin: string): string | undefined {
+  try {
+    const p = Bun.spawnSync([bin, "--version"], {
+      env: { ...process.env, AGY_CLI_DISABLE_AUTO_UPDATE: "1" },
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      timeout: 15_000,
+    })
+    return p.exitCode === 0 ? p.stdout.toString().trim().split("\n")[0]?.match(/\d+\.\d+\.\d+/)?.[0] : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export interface InstallOptions extends WriteOptions {
+  /** The new conversation's id (a UUID); a fresh one when omitted. */
+  id?: string
+  trajectoryId?: string
+}
+
+/** Writes the session as a new CLI conversation (or, in a dry run, only checks it would). */
+export async function installConversation(session: Session, opts: InstallOptions): Promise<WriteResult> {
+  const cwd = resolve(opts.cwd)
+  const now = new Date()
+  const id = opts.id ?? randomUUID()
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(id)) throw new Error(`an Antigravity conversation id is a lowercase UUIDv4, not ${id}`)
+  const plan = planAntigravity(session, { id, now, ...(opts.trajectoryId ? { trajectoryId: opts.trajectoryId } : {}) })
+  const bytes = buildConversation(plan, now)
+  const dir = conversationsDir(opts.home, CLI_STORE)
+  const file = join(dir, `${id}.db`)
+  const sums = summariesPath(opts.home, CLI_STORE)
+  const taken = () => new Error(`Antigravity conversation ${id} already exists; brain never overwrites or merges a conversation`)
+
+  if (lexists(file)) throw taken()
+  if (exists(sums)) {
+    const { missing, row } = withSnapshot(sums, (d) => {
+      const missing = missingColumns(d)
+      return { missing, row: missing.length ? null : d.query("SELECT 1 FROM conversation_summaries WHERE conversation_id = ?").get(id) }
+    })
+    if (missing.length) throw new Error(`the Antigravity summaries database at ${sums} lacks ${missing.join(", ")}; it is not one this writer knows`)
+    if (row) throw taken()
+  }
+
+  if (!opts.dryRun) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 })
+    ensureSummaries(sums)
+    const summary = [
+      id,
+      plan.title,
+      plan.preview,
+      plan.steps.length,
+      toSqlTime(now),
+      JSON.stringify([pathToFileURL(cwd).href]),
+      "",
+      "antigravity-cli",
+      PROJECT_ID,
+      "",
+      "",
+      0,
+      "",
+      "",
+      0,
+      0,
+      toSqlTime(now),
+      plan.lastUserStep,
+      "antigravity-cli",
+    ]
+    publish(bytes, file, sums, id, summary, taken)
+  }
+  return {
+    tool: TOOL,
+    way: "native",
+    sessionId: id,
+    written: [file, sums],
+    open: `cd ${sh(cwd)} && agy --conversation ${id}`,
+    lost: plan.lost,
+    dryRun: !!opts.dryRun,
+  }
+}
+
+/** Creates the summaries database as 1.1.16 does when there is none; one made meanwhile by someone else is kept. */
+function ensureSummaries(path: string) {
+  if (lexists(path)) return
+  const mem = new Database(":memory:")
+  let bytes: Uint8Array
+  try {
+    mem.exec(SUMMARY_SCHEMA)
+    bytes = mem.serialize()
+  } finally {
+    mem.close()
+  }
+  const tmp = `${path}.brain-${randomBytes(6).toString("hex")}`
+  writeFileSync(tmp, bytes, { flag: "wx", mode: 0o600 })
+  try {
+    linkSync(tmp, path)
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code !== "EEXIST") throw e
+  } finally {
+    unlinkSync(tmp)
+  }
+}
+
+/**
+ * Publishes the conversation and its summary row together: the id is reserved in the summaries table with an
+ * immediate transaction, the database appears under its final name only if that name is free (a hard link
+ * from a private temporary file), and a failure before the commit removes only the file this call created.
+ */
+function publish(bytes: Uint8Array, file: string, sums: string, id: string, summary: unknown[], taken: () => Error) {
+  const tmp = join(resolve(file, ".."), `.${id}.db.brain-${randomBytes(6).toString("hex")}`)
+  writeFileSync(tmp, bytes, { flag: "wx", mode: 0o600 })
+  const ino = statSync(tmp).ino
+  const db = new Database(sums)
+  let linked = false
+  try {
+    db.exec("PRAGMA busy_timeout = 15000")
+    const missing = missingColumns(db)
+    if (missing.length) throw new Error(`the Antigravity summaries database at ${sums} lacks ${missing.join(", ")}`)
+    db.exec("BEGIN IMMEDIATE")
+    try {
+      if (db.query("SELECT 1 FROM conversation_summaries WHERE conversation_id = ?").get(id) || lexists(file)) throw taken()
+      try {
+        linkSync(tmp, file)
+      } catch (e) {
+        throw (e as NodeJS.ErrnoException).code === "EEXIST" ? taken() : e
+      }
+      linked = true
+      db.prepare(`INSERT INTO conversation_summaries (${SUMMARY_COLUMNS.join(", ")}) VALUES (${SUMMARY_COLUMNS.map(() => "?").join(", ")})`).run(...(summary as Array<string | number>))
+      db.exec("COMMIT")
+    } catch (e) {
+      db.exec("ROLLBACK")
+      if (linked)
+        try {
+          if (statSync(file).ino === ino) unlinkSync(file)
+        } catch {
+          // already gone
+        }
+      throw e
+    }
+  } finally {
+    db.close()
+    try {
+      unlinkSync(tmp)
+    } catch {
+      // already gone
+    }
+  }
+}
+
+export const antigravityWriter: Writer = {
+  tool: TOOL,
+  label: LABEL,
+  way: "native",
+
+  async ready(opts: WriteOptions): Promise<Readiness> {
+    const bin = agyBin()
+    if (!bin) return { ok: false, why: "the Antigravity CLI is not installed (no agy on PATH)" }
+    const v = agyVersion(bin)
+    if (!v) return { ok: false, why: `could not read the Antigravity CLI's version (${bin} --version failed)` }
+    if (!TESTED_VERSIONS.includes(v))
+      return { ok: false, why: `Antigravity CLI ${v} has not been tested; its private conversation store was checked on ${TESTED_VERSIONS.join(", ")} only` }
+    if (!isDir(opts.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${opts.cwd}` }
+    const sums = summariesPath(opts.home, CLI_STORE)
+    if (exists(sums)) {
+      let missing: string[]
+      try {
+        missing = withSnapshot(sums, missingColumns)
+      } catch (e) {
+        return { ok: false, why: `the Antigravity summaries database cannot be read: ${(e as Error).message}` }
+      }
+      if (missing.length) return { ok: false, why: `the Antigravity summaries database lacks ${missing.join(", ")}; it is not one this writer knows` }
+    }
+    return { ok: true }
+  },
+
+  write(session: Session, opts: WriteOptions): Promise<WriteResult> {
+    return installConversation(session, opts)
+  },
+}

package/src/adapters/auggie/index.ts

@@ -0,0 +1,36 @@
+import { randomUUID } from "node:crypto"
+import { join } from "node:path"
+import { piFamilyReader } from "../pi/reader.ts"
+import type { PiFlavor } from "../pi/records.ts"
+import { piFamilyWriter } from "../pi/writer.ts"
+import type { Reader, Writer } from "../types.ts"
+
+// Auggie CLI (Augment) 1.x: a rewrite built on Pi, so its sessions are Pi's format version 3 in its own
+// folder: ~/.augment/sessions-v2/--<cwd>--/<uuid>.jsonl (AUGGIE_CODING_AGENT_DIR / AUGMENT_CACHE_DIR move it,
+// which brain does not follow). Auggie adds a queue_state record, a compaction field (protectedHeadEntryId)
+// and two user-side roles (slash-command invocations, rule references); the Pi reader reads all of them.
+// Continues any session as a new native Auggie session, `auggie --session <id>`. Auggie 0.x keeps JSON
+// conversations in ~/.augment/sessions instead and is not written.
+
+/** Auggie versions whose session format this writer was checked against (1.x is published as daily prereleases). */
+export const AUGGIE_TESTED_VERSIONS = ["1.2.0-prerelease.202611061509"]
+
+export const auggieFlavor: PiFlavor = {
+  tool: "auggie",
+  label: "Auggie",
+  bin: "auggie",
+  sessionsRoot: (home) => join(home, ".augment", "sessions-v2"),
+  // <id>.jsonl: Auggie's SessionManager does not prefix the start time.
+  fileName: (id) => `${id}.jsonl`,
+  newId: () => randomUUID(),
+}
+
+/** Auggie 0.x stores another format; say so instead of only "untested". */
+const v0 = (v: string) =>
+  /^0\./.test(v) ? `Auggie ${v} keeps sessions as JSON in ~/.augment/sessions; this writer writes the 1.x format (install @augmentcode/auggie@prerelease)` : undefined
+
+export const auggieReader = piFamilyReader(auggieFlavor)
+export const auggieWriter = (version?: string) => piFamilyWriter(auggieFlavor, { tested: AUGGIE_TESTED_VERSIONS, why: v0, ...(version ? { version } : {}) })
+
+export const readers: Reader[] = [auggieReader]
+export const writers: Writer[] = [auggieWriter()]

package/src/adapters/claude-code/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { claudeCodeReader } from "./reader.ts"
+import { claudeCodeNativeWriter } from "./writer.ts"
+
+// Claude Code (CLI, Agent SDK, and Claude Desktop's Code sessions, which keep the same transcripts):
+// reads every session with its subagents, and continues any session as a new native Claude Code session.
+export const readers: Reader[] = [claudeCodeReader]
+export const writers: Writer[] = [claudeCodeNativeWriter]