@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/amazon-q-ide/reader.ts

@@ -0,0 +1,131 @@
+import { join } from "node:path"
+import { ls, readJson } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { asText, clip, header, iso, lossCounter, toolKindOf } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUED_NOTE, DUMMY_ANSWER, LABEL, SUMMARY_PREFIX, TOOL, historyDir, qKind } from "./records.ts"
+
+// Reads Amazon Q's IDE chat history: one LokiJS file per workspace, each tab (conversation) a document
+// in its "tabs" collection. Messages alternate prompt / answer; an answer's toolUses are answered by the
+// next prompt's userInputMessageContext.toolResults (a prompt with an empty body carries only results).
+// Prompts and answers Amazon Q hides (shouldDisplayMessage false) are its own: placeholder answers,
+// retries, generated instructions.
+
+type Row = Record<string, any>
+
+export interface LokiDb {
+  collections: Array<{ name: string; data: Row[]; maxId?: number; idIndex?: number[] | null; binaryIndices?: Record<string, { name: string; dirty: boolean; values: number[] }> }>
+  [k: string]: unknown
+}
+
+export const tabsOf = (db: LokiDb | undefined): Row[] => db?.collections?.find((c) => c.name === "tabs")?.data ?? []
+
+/** A tool result's content blocks as text: text blocks as they are, JSON blocks ({output} or {error}) unwrapped. */
+function resultText(content: unknown): string {
+  const parts: string[] = []
+  for (const b of Array.isArray(content) ? (content as Row[]) : []) {
+    if (typeof b?.text === "string") parts.push(b.text)
+    else if (b?.json !== undefined) {
+      const j = b.json
+      parts.push(j && typeof j === "object" && !Array.isArray(j) && Object.keys(j).length === 1 && ("output" in j || "error" in j) ? asText(j.output ?? j.error) : asText(j))
+    }
+  }
+  return parts.join("\n")
+}
+
+function readTab(file: string, tab: Row): Session {
+  const messages = (Array.isArray(tab.conversations) ? (tab.conversations as Row[]) : []).flatMap((c) => (Array.isArray(c?.messages) ? (c.messages as Row[]) : []))
+  let cwd: string | undefined
+  for (const m of messages) {
+    const folders = m?.userInputMessageContext?.editorState?.workspaceFolders
+    if (Array.isArray(folders) && typeof folders[0] === "string") {
+      cwd = folders[0]
+      break
+    }
+  }
+  const stamps = messages.map((m) => iso(m?.timestamp)).filter((t): t is string => !!t)
+  const h = header(TOOL, String(tab.historyId), {
+    sourcePath: file,
+    ...(typeof tab.title === "string" && tab.title.trim() ? { title: tab.title } : {}),
+    project: cwd ? { cwd } : {},
+    ...(stamps[0] ? { startedAt: stamps[0] } : {}),
+    ...(iso(tab.updatedAt) ?? stamps[stamps.length - 1] ? { updatedAt: iso(tab.updatedAt) ?? stamps[stamps.length - 1] } : {}),
+  })
+  if (typeof tab.modelId === "string") h.models.push(tab.modelId)
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const calls = new Map<string, string>()
+  for (const m of messages) {
+    const at = iso(m?.timestamp)
+    const body = typeof m?.body === "string" ? m.body : ""
+    if (m?.type === "prompt") {
+      for (const r of (m.userInputMessageContext?.toolResults as Row[] | undefined) ?? []) {
+        if (typeof r?.toolUseId !== "string") continue
+        const { text, truncated } = clip(resultText(r.content))
+        turns.push({ kind: "tool_result", ...(at ? { at } : {}), callId: r.toolUseId, ok: r.status !== "error", output: text, ...(truncated ? { truncated } : {}) })
+      }
+      if (Array.isArray(m.images) && m.images.length) lost.add("images", m.images.length)
+      if (!body.trim()) continue
+      // A summary a continued session starts from (shown, as Amazon Q shows its own compaction summary).
+      if (body.startsWith(SUMMARY_PREFIX)) {
+        turns.push({ kind: "compaction", ...(at ? { at } : {}), summary: body.replace(/^\[[^\]]*\]\s*/, "") })
+        continue
+      }
+      if (m.shouldDisplayMessage === false) {
+        const from = body.match(CONTINUED_NOTE)
+        if (from) h.parent = { id: from[1]!, kind: "continued" }
+        else lost.add("Amazon Q's hidden prompts (not carried)")
+        continue
+      }
+      turns.push({ kind: "user", ...(at ? { at } : {}), text: body })
+    } else if (m?.type === "answer") {
+      if (m.shouldDisplayMessage === false && body === DUMMY_ANSWER) continue
+      if (body.trim()) turns.push({ kind: "assistant", ...(at ? { at } : {}), text: body })
+      for (const u of (m.toolUses as Row[] | undefined) ?? []) {
+        if (typeof u?.toolUseId !== "string" || typeof u?.name !== "string" || calls.has(u.toolUseId)) continue
+        calls.set(u.toolUseId, u.name)
+        turns.push({ kind: "tool_call", ...(at ? { at } : {}), id: u.toolUseId, name: u.name, toolKind: qKind(u.name) ?? toolKindOf(u.name), input: u.input ?? {} })
+      }
+    } else lost.add(`unknown message types: ${String(m?.type)}`)
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+export const amazonQReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const refs: SessionRef[] = []
+    const dir = historyDir(home)
+    for (const name of ls(dir)) {
+      if (!/^chat-history-.+\.json$/.test(name)) continue
+      const file = join(dir, name)
+      for (const tab of tabsOf(readJson<LokiDb>(file))) {
+        if (typeof tab.historyId !== "string") continue
+        const hasMessages = (tab.conversations as Row[] | undefined)?.some((c) => Array.isArray(c?.messages) && c.messages.length)
+        if (!hasMessages) continue
+        const updatedAt = iso(tab.updatedAt)
+        const folders = (tab.conversations as Row[]).flatMap((c) => c.messages as Row[]).map((m) => m?.userInputMessageContext?.editorState?.workspaceFolders).find((f) => Array.isArray(f) && typeof f[0] === "string")
+        refs.push({
+          tool: TOOL,
+          sourceId: tab.historyId,
+          path: file,
+          ...(typeof tab.title === "string" ? { title: tab.title } : {}),
+          ...(folders ? { cwd: folders[0] as string } : {}),
+          ...(updatedAt ? { updatedAt } : {}),
+        })
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef): Promise<Session> {
+    const db = readJson<LokiDb>(ref.path)
+    if (!db) throw new Error(`${ref.path} is not a readable Amazon Q history file`)
+    const tab = tabsOf(db).find((t) => t.historyId === ref.sourceId)
+    if (!tab) throw new Error(`conversation ${ref.sourceId} is not in ${ref.path}`)
+    return readTab(ref.path, tab)
+  },
+}

package/src/adapters/amazon-q-ide/records.ts

@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto"
+import { join } from "node:path"
+import { isDir, ls } from "../../fsutil.ts"
+import type { ToolKind } from "../../session/types.ts"
+
+// What Amazon Q Developer's IDE chat (the VS Code extension, and JetBrains, through the same language
+// server) keeps on disk, as far as this adapter relies on it. Checked against aws/language-servers at
+// ba9d3b1 (2026-11-06: agenticChat/tools/chatDb/chatDb.ts, util.ts, tabBarController.ts,
+// agenticChatController.ts), the language server 1.85.0 bundle installed here, LokiJS 1.5.12, and the
+// history files on the author's Mac (structure and counts only).
+//
+// Each workspace has one LokiJS database, ~/.aws/amazonq/history/chat-history-<id>.json, holding every
+// conversation ("tab") of that workspace: <id> is the MD5 of the workspace folder's URI path (several
+// folders: their sorted paths joined by |; a saved .code-workspace file: SHA-256 of its path). A tab's
+// messages are both what the History panel restores and what the agent sends as conversation history
+// (fixAndGetHistory reads them from the database on every request; conversation ids are client-made).
+
+export const TOOL = "amazon-q-ide"
+export const LABEL = "Amazon Q (IDE)"
+
+/** Language server versions the writer's records were checked against. */
+export const TESTED_SERVERS = ["1.85.0"]
+
+export const historyDir = (home: string) => join(home, ".aws", "amazonq", "history")
+export const dbName = (workspaceId: string) => `chat-history-${workspaceId}.json`
+
+/**
+ * The path part of the folder's URI as VS Code sends it (vscode-uri encodes everything outside RFC 3986's
+ * unreserved set except '/'), which the server MD5s (`new URL(uri).pathname`).
+ */
+export function uriPath(folder: string): string {
+  return folder
+    .split("/")
+    .map((seg) => encodeURIComponent(seg).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`))
+    .join("/")
+}
+
+/** The database id of a single-folder workspace. */
+export const workspaceId = (folder: string) => createHash("md5").update(uriPath(folder)).digest("hex")
+
+/** The newest Amazon Q language server downloaded to this home, e.g. "1.85.0". */
+export function serverVersion(home: string): string | undefined {
+  const dir = join(home, "Library", "Caches", "aws", "toolkits", "language-servers", "AmazonQ")
+  const versions = ls(dir).filter((v) => /^\d+\.\d+\.\d+$/.test(v) && isDir(join(dir, v)))
+  const num = (v: string) => v.split(".").map(Number)
+  versions.sort((a, b) => {
+    const x = num(a)
+    const y = num(b)
+    for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i]! - y[i]!
+    return 0
+  })
+  return versions[versions.length - 1]
+}
+
+/** The editors with the Amazon Q extension installed here, as the command that opens a folder in them. */
+export function editors(home: string): string[] {
+  const out: string[] = []
+  for (const [dir, cmd] of [[".vscode", "code"], [".cursor", "cursor"], [".windsurf", "windsurf"], [".kiro", "kiro"]] as const)
+    if (ls(join(home, dir, "extensions")).some((e) => e.startsWith("amazonwebservices.amazon-q-vscode-"))) out.push(cmd)
+  return out
+}
+
+/** Whether Amazon Q's language server is running: it keeps the database in memory and saves it every second. */
+export function serverRunning(): boolean {
+  const p = Bun.spawnSync(["pgrep", "-f", "aws-lsp-codewhisperer"], { stdout: "pipe", stderr: "pipe" })
+  return p.exitCode === 0
+}
+
+/** Amazon Q's tools, by what they do (toolConstants.ts). */
+const KIND_OF: Record<string, ToolKind> = {
+  fsRead: "read",
+  fsWrite: "write",
+  fsReplace: "edit",
+  listDirectory: "list",
+  grepSearch: "search",
+  fileSearch: "search",
+  executeBash: "shell",
+  codeReview: "other",
+}
+export const qKind = (name: string): ToolKind | undefined => KIND_OF[name]
+
+const pick = (o: Record<string, unknown>, keys: string[]): unknown => {
+  for (const k of keys) if (o[k] !== undefined && o[k] !== null && o[k] !== "") return o[k]
+  return undefined
+}
+const str = (v: unknown) => (typeof v === "string" ? v : Array.isArray(v) && v.every((x) => typeof x === "string") ? v.join(" ") : undefined)
+
+/**
+ * A call from another tool as the Amazon Q tool that does the same thing, with Q's input shape, so the
+ * history panel renders it like its own (toolUseToToolChatMessage) and the model sees calls it knows.
+ * Calls whose input does not map cleanly keep their own name and input.
+ */
+export function asQCall(kind: ToolKind, name: string, input: unknown): { name: string; input: Record<string, unknown> } {
+  const obj = input && typeof input === "object" && !Array.isArray(input) ? (input as Record<string, unknown>) : { input: input ?? null }
+  if (KIND_OF[name]) return { name, input: obj }
+  const path = str(pick(obj, ["file_path", "target_file", "path", "filePath", "absolute_path", "filename"]))
+  switch (kind) {
+    case "read":
+      if (path) return { name: "fsRead", input: { paths: [path] } }
+      break
+    case "write": {
+      const text = pick(obj, ["content", "contents", "file_text", "fileText", "text"])
+      if (path && typeof text === "string") return { name: "fsWrite", input: { command: "create", path, fileText: text } }
+      break
+    }
+    case "edit": {
+      const oldStr = str(pick(obj, ["old_string", "old_str", "oldText", "old_text"]))
+      const newStr = pick(obj, ["new_string", "new_str", "newText", "new_text"])
+      if (path && oldStr !== undefined && typeof newStr === "string") return { name: "fsReplace", input: { path, diffs: [{ oldStr, newStr }] } }
+      break
+    }
+    case "list": {
+      const dir = str(pick(obj, ["path", "target_directory", "dir_path", "directory", "relative_workspace_path"]))
+      if (dir) return { name: "listDirectory", input: { path: dir } }
+      break
+    }
+    case "shell": {
+      const command = str(pick(obj, ["command", "cmd", "commandLine"]))
+      if (command) return { name: "executeBash", input: { command } }
+      break
+    }
+    case "search": {
+      const query = str(pick(obj, ["pattern", "regex", "query"]))
+      if (/grep|ripgrep|search_files/i.test(name) && query) return { name: "grepSearch", input: { query, ...(path ? { path } : {}) } }
+      break
+    }
+    default:
+      break
+  }
+  return { name, input: obj }
+}
+
+/** The placeholder answer Amazon Q itself stores to keep prompts and answers alternating; never shown. */
+export const DUMMY_ANSWER = "Working..."
+
+/** The note the writer puts first; the reader recognises it and records where the session came from. */
+export const continuedNote = (label: string, id: string, when: string) =>
+  `[This conversation continues ${label} session ${id}, carried over by brain session on ${when}. The messages after this note are its history; reasoning and anything listed as lost did not carry over. Check files before relying on details, since they may have changed.]`
+export const CONTINUED_NOTE = /^\[This conversation continues .+? session (\S+), carried over by brain session/
+
+export const SUMMARY_PREFIX = "[Summary of the earlier conversation"

package/src/adapters/amazon-q-ide/writer.ts

@@ -0,0 +1,325 @@
+import { randomBytes, randomUUID } from "node:crypto"
+import { copyFileSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
+import { basename, join, resolve } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { type LokiDb, amazonQReader, tabsOf } from "./reader.ts"
+import {
+  DUMMY_ANSWER, LABEL, SUMMARY_PREFIX, TESTED_SERVERS, TOOL,
+  asQCall, continuedNote, dbName, editors, historyDir, serverRunning, serverVersion, workspaceId,
+} from "./records.ts"
+
+// Continues a portable session in Amazon Q's IDE chat as a new conversation (tab) in the workspace's
+// history database, the document ChatDatabase.addMessage builds: prompts and answers alternating, each
+// answer's toolUses answered by the next prompt's toolResults, ids in Q's style. The tab is marked open,
+// so Amazon Q restores it when the editor next opens the folder (tabBarController.loadChats); it is also
+// in Amazon Q's History list. Its messages are the conversation history the agent sends with the next
+// request, so the model has the whole conversation.
+//
+// The database holds the workspace's other conversations too, so the writer only adds a document and
+// never changes another, refuses while Amazon Q's language server runs (it keeps the database in memory
+// and saves it every second), and copies the file to ~/.brain/backups/amazon-q-ide/<time>/ first.
+//
+// Amazon Q's own conventions decide the rest: the note saying where the session came from is a prompt
+// the panel does not show (shouldDisplayMessage false) followed by Q's hidden "Working..." answer, the
+// pair Q itself stores to keep prompts and answers alternating; a compaction starts the conversation from
+// its summary, as Q's replaceWithSummary does. Reasoning has no place in Q's history and is dropped.
+
+type Row = Record<string, unknown>
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Result = Extract<Turn, { kind: "tool_result" }>
+
+interface QMessage {
+  body: string
+  type: "prompt" | "answer"
+  timestamp: string
+  shouldDisplayMessage: boolean
+  origin?: "IDE"
+  userInputMessageContext?: { toolResults?: Row[] }
+  images?: unknown[]
+  toolUses?: Array<{ toolUseId: string; name: string; input: Record<string, unknown> }>
+}
+
+const ALNUM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+/** Amazon Q's tool use ids: tooluse_ and 22 characters. */
+const toolUseId = () => `tooluse_${[...randomBytes(22)].map((b) => ALNUM[b % ALNUM.length]).join("")}`
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+export interface QPlan {
+  tab: Row
+  lost: string[]
+  expect: { users: number; calls: number }
+}
+
+/** The tab document of a new Amazon Q conversation continuing `session` (without $loki and meta). Pure. */
+export function planTab(session: Session, opts: { historyId: string; conversationId: string; now: Date }): QPlan {
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const label = toolLabel(session.header.tool)
+  const turns = session.turns
+  const lastCompaction = turns.map((t) => t.kind).lastIndexOf("compaction")
+  if (lastCompaction > 0) drop("turns before the last compaction (Amazon Q keeps only the summary)", turns.slice(0, lastCompaction).filter((t) => t.kind === "user" || t.kind === "assistant").length)
+
+  const results = new Map<string, Result>()
+  const callIds = new Set<string>()
+  for (const t of turns) {
+    if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+    if (t.kind === "tool_call") callIds.add(t.id)
+  }
+  const ids = new Map<string, string>()
+  const qId = (id: string) => {
+    let v = ids.get(id)
+    if (!v) ids.set(id, (v = toolUseId()))
+    return v
+  }
+
+  const known = turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let clock = (known ?? opts.now.getTime()) - 1
+  const stamp = (at?: string) => {
+    const t = at ? Date.parse(at) : Number.NaN
+    clock = Number.isFinite(t) && t > clock ? t : clock + 1
+    return new Date(clock).toISOString()
+  }
+
+  const msgs: QMessage[] = []
+  const prompt = (body: string, shown: boolean, at?: string, toolResults?: Row[]): QMessage => ({
+    body,
+    type: "prompt",
+    origin: "IDE",
+    userInputMessageContext: toolResults ? { toolResults } : {},
+    shouldDisplayMessage: shown,
+    timestamp: stamp(at),
+    images: [],
+  })
+  const dummy = (): QMessage => ({ body: DUMMY_ANSWER, type: "answer", shouldDisplayMessage: false, timestamp: stamp() })
+  /** Appends keeping Q's invariant: prompts and answers alternate, starting with a prompt. */
+  const push = (m: QMessage) => {
+    const last = msgs[msgs.length - 1]
+    if (last?.type === "prompt" && m.type === "prompt") {
+      // A request typed right after tool results travels with them, as Q sends it; otherwise Q's hidden placeholder answer goes between.
+      if (!last.body && last.userInputMessageContext?.toolResults && !m.userInputMessageContext?.toolResults && m.shouldDisplayMessage) {
+        last.body = m.body
+        return
+      }
+      msgs.push(dummy())
+    } else if (last?.type === "answer" && m.type === "answer" && !last.toolUses?.length) {
+      last.body = [last.body, m.body].filter((b) => b.trim()).join("\n\n")
+      last.toolUses = m.toolUses ?? []
+      return
+    }
+    msgs.push(m)
+  }
+
+  push(prompt(continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)), false))
+
+  let cur: { text: string; at?: string; calls: Call[] } | undefined
+  const flush = () => {
+    if (!cur) return
+    const a = cur
+    cur = undefined
+    if (!a.text.trim() && !a.calls.length) return
+    push({
+      body: a.text,
+      type: "answer",
+      toolUses: a.calls.map((c) => {
+        const q = asQCall(c.toolKind, c.name, c.input)
+        return { toolUseId: qId(c.id), name: q.name, input: q.input }
+      }),
+      shouldDisplayMessage: true,
+      timestamp: stamp(a.at),
+    })
+    if (!a.calls.length) return
+    const toolResults = a.calls.map((c) => {
+      const r = results.get(c.id)
+      if (!r) drop("tool calls without a result (closed as errors)")
+      const text = r ? r.output + (r.fullPath ? `\n\n[Full output: ${r.fullPath}]` : "") : "No result was recorded for this call."
+      return { toolUseId: qId(c.id), status: r?.ok ? "success" : "error", content: [{ text: text || "(no output)" }] }
+    })
+    push(prompt("", true, results.get(a.calls[a.calls.length - 1]!.id)?.at, toolResults))
+  }
+
+  const expect = { users: 0, calls: 0 }
+  const seen = new Set<string>()
+  for (const [i, t] of turns.entries()) {
+    if (i < lastCompaction) continue
+    switch (t.kind) {
+      case "compaction":
+        push(prompt(`${SUMMARY_PREFIX} in ${label}, which replaced the turns before it]\n\n${t.summary}`, true, t.at))
+        break
+      case "user":
+        if (t.attachments?.length) drop("attachments", t.attachments.length)
+        if (!t.text.trim()) break
+        flush()
+        push(prompt(t.text, true, t.at))
+        expect.users++
+        break
+      case "assistant":
+        if (!t.text.trim()) break
+        // Text after a call is a new answer: it was written after the call's result came back.
+        if (cur?.calls.length) flush()
+        cur ??= { text: "", ...(t.at ? { at: t.at } : {}), calls: [] }
+        cur.text = cur.text ? `${cur.text}\n\n${t.text}` : t.text
+        break
+      case "tool_call":
+        if (seen.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        seen.add(t.id)
+        cur ??= { text: "", ...(t.at ? { at: t.at } : {}), calls: [] }
+        cur.calls.push(t)
+        expect.calls++
+        break
+      case "tool_result":
+        if (!callIds.has(t.callId)) drop("tool results without a call")
+        // A result closes the answer it belongs to, so a call made after it starts a new answer.
+        else if (cur?.calls.some((c) => c.id === t.callId)) flush()
+        break
+      case "reasoning":
+        drop("reasoning")
+        break
+      case "file_edit":
+        if (!t.callId || !callIds.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions")
+        break
+    }
+  }
+  flush()
+  // Q ends a stored conversation on an answer; a trailing request gets its hidden placeholder, as Q adds one.
+  if (msgs[msgs.length - 1]?.type === "prompt") msgs.push(dummy())
+
+  const title = session.header.title ?? firstUserText(session)?.replace(/\s+/g, " ").trim().slice(0, 60) ?? "Session"
+  const tab: Row = {
+    historyId: opts.historyId,
+    // LokiJS stores a top-level Date as epoch milliseconds; nested ones as ISO strings.
+    updatedAt: opts.now.getTime(),
+    isOpen: true,
+    tabType: "cwc",
+    title: `${title} (from ${label})`,
+    conversations: [{ conversationId: opts.conversationId, clientType: "vscode", updatedAt: opts.now.toISOString(), messages: msgs }],
+  }
+  return { tab, lost: [...drops].map(([what, n]) => `${what} (${n})`), expect }
+}
+
+/** A database file as LokiJS 1.5 writes one for a workspace whose history is still empty (copied from Q's own). */
+export function emptyDb(file: string, now: Date): LokiDb {
+  const events = { insert: [], update: [], "pre-insert": [], "pre-update": [], close: [], flushbuffer: [], error: [], delete: [null], warning: [null] }
+  const collection = (name: string, extra: Row) => ({
+    name, data: [], idIndex: null, binaryIndices: {}, constraints: null, uniqueNames: [], transforms: {}, objType: name, dirty: false, cachedIndex: null,
+    cachedBinaryIndex: null, cachedData: null, adaptiveBinaryIndices: true, transactional: false, cloneObjects: false, cloneMethod: "parse-stringify",
+    asyncListeners: false, disableMeta: false, disableChangesApi: true, disableDeltaChangesApi: true, autoupdate: false, serializableIndices: true,
+    disableFreeze: true, ttl: null, maxId: 0, DynamicViews: [], events, changes: [], dirtyIds: [], isIncremental: false, ...extra,
+  })
+  return {
+    filename: basename(file),
+    collections: [
+      collection("tabs", { binaryIndices: { updatedAt: { name: "updatedAt", dirty: false, values: [] }, isOpen: { name: "isOpen", dirty: false, values: [] } }, uniqueNames: ["historyId"] }),
+      collection("settings", {}),
+    ],
+    databaseVersion: 1.5,
+    engineVersion: 1.5,
+    autosave: true,
+    autosaveInterval: 1000,
+    autosaveHandle: null,
+    throttledSaves: true,
+    options: { adapter: null, autosave: true, autoload: true, autosaveInterval: 1000, persistenceMethod: "fs", serializationMethod: "normal", destructureDelimiter: "$<\n", recursiveWait: true, recursiveWaitLimit: false, recursiveWaitLimitDuration: 2000, started: now.getTime() },
+    persistenceMethod: "adapter",
+    persistenceAdapter: null,
+    verbose: false,
+    events: { init: [null], loaded: [], flushChanges: [], close: [], changes: [], warning: [] },
+    ENV: "NODEJS",
+    isIncremental: false,
+  }
+}
+
+/** Adds `tab` to the database as LokiJS's insert would: the next $loki id, fresh meta, indices left for LokiJS to rebuild. */
+export function insertTab(db: LokiDb, tab: Row, now: Date): void {
+  const tabs = db.collections.find((c) => c.name === "tabs")
+  if (!tabs) throw new Error("the history file has no tabs collection")
+  const id = (tabs.maxId ?? 0) + 1
+  tabs.maxId = id
+  tabs.data.push({ ...tab, meta: { revision: 0, created: now.getTime(), version: 0 }, $loki: id })
+  if (Array.isArray(tabs.idIndex)) tabs.idIndex.push(id)
+  // Marked dirty, LokiJS rebuilds a binary index before its next use, as it does after its own inserts.
+  for (const index of Object.values(tabs.binaryIndices ?? {})) index.dirty = true
+}
+
+/** The Amazon Q writer; `server` and `running` are for tests, which must not depend on this machine. */
+export function amazonQWriter(opts: { server?: string; running?: () => boolean } = {}): Writer {
+  const installed = (home: string) => opts.server ?? serverVersion(home)
+  const running = opts.running ?? serverRunning
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed(w.home)
+      if (!v) return { ok: false, why: "Amazon Q's language server was not found (it is downloaded when the Amazon Q extension first starts)" }
+      if (!TESTED_SERVERS.includes(v)) return { ok: false, why: `Amazon Q language server ${v} is not a version this writer was checked against (${TESTED_SERVERS.join(", ")})` }
+      if (running()) return { ok: false, why: "Amazon Q is running (its language server keeps the chat history in memory and would overwrite the new conversation); close VS Code, Cursor or the JetBrains IDE first" }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Amazon Q keeps chat history per workspace folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = resolve(w.cwd)
+      const now = new Date()
+      const file = join(historyDir(w.home), dbName(workspaceId(cwd)))
+      const backupDir = join(w.home, ".brain", "backups", TOOL, now.toISOString().replace(/[:.]/g, "-"))
+      const had = exists(file)
+      let db: LokiDb
+      if (had) {
+        try {
+          db = JSON.parse(readFileSync(file, "utf8")) as LokiDb
+        } catch {
+          throw new Error(`${file} is not a readable Amazon Q history file; nothing was changed`)
+        }
+      } else db = emptyDb(file, now)
+      let historyId = randomUUID()
+      while (tabsOf(db).some((t) => t.historyId === historyId)) historyId = randomUUID()
+      const plan = planTab(session, { historyId, conversationId: randomUUID(), now })
+      insertTab(db, plan.tab, now)
+
+      if (!w.dryRun) {
+        mkdirSync(historyDir(w.home), { recursive: true })
+        if (had) {
+          mkdirSync(backupDir, { recursive: true })
+          copyFileSync(file, join(backupDir, basename(file)))
+        }
+        const tmp = `${file}.brain-${process.pid}`
+        writeFileSync(tmp, JSON.stringify(db), { mode: 0o600 })
+        renameSync(tmp, file)
+        try {
+          const back = await amazonQReader.read({ tool: TOOL, sourceId: historyId, path: file }, w.home)
+          const n = countTurns(back)
+          const pairs = unpaired(back)
+          if (n.user !== plan.expect.users || n.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+            throw new Error(`the new Amazon Q conversation did not read back intact (requests ${n.user}/${plan.expect.users}, tool calls ${n.tool_call}/${plan.expect.calls}, unpaired ${pairs.calls.length + pairs.results.length})`)
+        } catch (e) {
+          if (had) copyFileSync(join(backupDir, basename(file)), file)
+          else rmSync(file, { force: true })
+          throw new Error(`${(e as Error).message}; the history file was restored`)
+        }
+      }
+      const editor = editors(w.home)[0] ?? "code"
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId: historyId,
+        written: had ? [file, join(backupDir, basename(file))] : [file],
+        open: `${editor} ${shellQuote(cwd)}   # Amazon Q reopens "${plan.tab.title as string}" when the folder opens; it is also in Amazon Q's History`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const amazonQNativeWriter = amazonQWriter()

package/src/adapters/antigravity/index.ts

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { antigravityReader } from "./reader.ts"
+import { antigravityWriter } from "./writer.ts"
+
+// Antigravity (Google): reads the CLI's conversations and the IDE's SQLite ones under ~/.gemini, and continues
+// any session as a new native conversation of the Antigravity CLI (1.1.16). The IDE has no native writer; it is a
+// target through the continuation brief.
+export const readers: Reader[] = [antigravityReader]
+export const writers: Writer[] = [antigravityWriter]