@100xprompt/brain 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,370 @@
+import { Database } from "bun:sqlite"
+import { randomUUID } from "node:crypto"
+import { copyFileSync, mkdirSync, readFileSync, realpathSync, statSync } from "node:fs"
+import { extname, join, resolve } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, isRunning } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../claude-code/records.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { readQ } from "./reader.ts"
+import {
+  type AssistantToolUse,
+  type ConversationState,
+  DEFAULT_AGENT,
+  DEFAULT_CONTEXT_FILES_SIZE,
+  DEFAULT_CONTEXT_PATHS,
+  type HistoryEntry,
+  LABEL,
+  NO_REPLY,
+  TESTED_VERSIONS,
+  TOOL,
+  type ToolUseResult,
+  type UserMessage,
+  dbPath,
+  qCall,
+  qVersion,
+} from "./records.ts"
+
+// Continues a portable session as the Amazon Q CLI conversation of a folder: a new row of data.sqlite3's
+// `conversations` table, keyed by the folder's real path (what std::env::current_dir gives `q chat`), holding
+// the ConversationState JSON Q itself saves. History entries pair a user message with the reply: a prompt, or
+// the results of the previous reply's tool uses (both, as CancelledToolUses, when the person typed before the
+// model answered the results). Calls are mapped onto Q's built-ins (execute_bash, fs_read, fs_write) when their
+// arguments carry what those need; Q shows the model any other tool's calls under the name "dummy" when it
+// resumes. A compaction is written as /compact leaves it: its summary in latest_summary and only the turns
+// after it in the history. The note saying where the session came from is the first message's
+// additional_context, which Q sends the model with the message and never shows.
+//
+// Q keeps one conversation per folder, so this refuses a folder whose conversation has history rather than
+// replace it, writes only with Q closed, and copies the database to ~/.brain/backups/amazon-q-cli/<time>/ first.
+
+const IMAGE_FORMATS: Record<string, string> = { ".png": "Png", ".jpg": "Jpeg", ".jpeg": "Jpeg", ".gif": "Gif", ".webp": "Webp" }
+const MIME_FORMATS: Record<string, string> = { "image/png": "Png", "image/jpeg": "Jpeg", "image/gif": "Gif", "image/webp": "Webp" }
+/** MAX_IMAGE_SIZE in Q's chat consts. */
+const IMAGE_LIMIT = 10 * 1024 * 1024
+const NO_RESULT = "No result was recorded for this call; the session moved before it finished."
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+type QImage = { format: string; source: { Bytes: number[] } }
+type UserDraft = { role: "user"; prompt?: string; results: ToolUseResult[]; images: QImage[]; at?: string }
+type ReplyDraft = { role: "assistant"; text: string; uses: AssistantToolUse[] }
+
+const OS = process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : process.platform
+/** A time as chrono serializes a DateTime<FixedOffset> at UTC: "Z", and no fraction when it is zero. */
+const qTime = (at?: string) => (at && Number.isFinite(Date.parse(at)) ? new Date(at).toISOString().replace(".000Z", "Z") : null)
+
+export interface QPlan {
+  state: ConversationState
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The ConversationState for `session` continued in `cwd` (a real path). Pure apart from reading attached images. */
+export function planQ(session: Session, opts: { cwd: string; now: Date }): QPlan {
+  const label = toolLabel(session.header.tool)
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const lastCompaction = session.turns.map((t) => t.kind).lastIndexOf("compaction")
+  const summary = lastCompaction >= 0 ? (session.turns[lastCompaction] as Extract<Turn, { kind: "compaction" }>).summary : undefined
+  if (lastCompaction > 0) drop("turns before the last compaction, which Q keeps only as its summary", lastCompaction)
+  const turns = session.turns.slice(lastCompaction + 1)
+  const answered = new Set(turns.filter((t) => t.kind === "tool_result").map((t) => (t as Extract<Turn, { kind: "tool_result" }>).callId))
+
+  // Tool use ids: the service takes [A-Za-z0-9_-]; others are mapped once, the same way for call and result.
+  const ids = new Map<string, string>()
+  const used = new Set<string>()
+  let remapped = 0
+  const callId = (raw: string) => {
+    let v = ids.get(raw)
+    if (v) return v
+    const base = /^[A-Za-z0-9_-]{1,64}$/.test(raw) ? raw : `tooluse_${raw.replace(/[^A-Za-z0-9]/g, "").slice(-40) || "x"}`
+    v = base
+    for (let n = 2; used.has(v); n++) v = `${base}_${n}`
+    ids.set(raw, v)
+    used.add(v)
+    if (v !== raw) remapped++
+    return v
+  }
+
+  // Regroup the flat turns into alternating user messages and replies.
+  const msgs: Array<UserDraft | ReplyDraft> = []
+  const last = () => msgs[msgs.length - 1]
+  const userMsg = (at?: string): UserDraft => {
+    const l = last()
+    if (l?.role === "user") return l
+    const u: UserDraft = { role: "user", results: [], images: [], ...(at ? { at } : {}) }
+    msgs.push(u)
+    return u
+  }
+  const reply = (): ReplyDraft => {
+    const l = last()
+    if (l?.role === "assistant") return l
+    const a: ReplyDraft = { role: "assistant", text: "", uses: [] }
+    msgs.push(a)
+    return a
+  }
+  const result = (raw: string, ok: boolean, output: string, at?: string) =>
+    userMsg(at).results.push({ tool_use_id: callId(raw), content: [{ Text: output || "(no output)" }], status: ok ? "Success" : "Error" })
+  const written = new Set<string>()
+  const done = new Set<string>()
+  let joined = 0
+  let dummies = 0
+
+  for (const t of turns) {
+    switch (t.kind) {
+      case "user": {
+        let text = t.text
+        const u = userMsg(t.at)
+        for (const a of t.attachments ?? []) {
+          if (!a.path) continue // bytes the reader could not keep; it already counted them
+          if (a.kind === "file") {
+            text += `\n\n[Attached file: ${a.path}]`
+            continue
+          }
+          const format = (a.mime ? MIME_FORMATS[a.mime] : undefined) ?? IMAGE_FORMATS[extname(a.path).toLowerCase()]
+          let size = Number.POSITIVE_INFINITY
+          try {
+            size = statSync(a.path).size
+          } catch {}
+          if (format && size <= IMAGE_LIMIT) u.images.push({ format, source: { Bytes: [...readFileSync(a.path)] } })
+          else drop("images that could not be attached")
+        }
+        if (!text.trim()) break
+        if (u.prompt !== undefined) joined++
+        u.prompt = u.prompt === undefined ? text : `${u.prompt}\n\n${text}`
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        const a = reply()
+        if (a.text) joined++
+        a.text = a.text ? `${a.text}\n\n${t.text}` : t.text
+        break
+      }
+      case "reasoning":
+        drop("reasoning (Q has no record for it)")
+        break
+      case "tool_call": {
+        if (written.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        written.add(t.id)
+        const mapped = qCall(t as Call)
+        const args = mapped?.args ?? (t.input && typeof t.input === "object" && !Array.isArray(t.input) ? t.input : { input: t.input ?? null })
+        if (!mapped) dummies++
+        const name = mapped?.name ?? t.name
+        reply().uses.push({ id: callId(t.id), name, orig_name: name, args, orig_args: args })
+        if (!answered.has(t.id)) {
+          result(t.id, false, NO_RESULT, t.at)
+          done.add(t.id)
+          drop("tool calls without a result (closed as errors)")
+        }
+        break
+      }
+      case "tool_result": {
+        if (!written.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (done.has(t.callId)) {
+          drop("repeated tool results")
+          break
+        }
+        done.add(t.callId)
+        result(t.callId, t.ok, t.fullPath ? `${t.output}\n\n[Full output: ${t.fullPath}]` : t.output, t.at)
+        break
+      }
+      case "compaction":
+        break // only the last one is kept, as latest_summary
+      case "file_edit":
+        if (!t.callId || !written.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent transcripts (their results stay in the parent's tool results)")
+        break
+    }
+  }
+
+  // Pair them into history entries; the first message carries the note.
+  const note = continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10))
+  const envContext = { env_state: { operating_system: OS, current_working_directory: opts.cwd, environment_variables: [] } }
+  const toUser = (u: UserDraft | undefined, first: boolean): UserMessage => {
+    const prompt = u?.prompt ?? (u?.results.length ? undefined : first ? note : "")
+    const content: UserMessage["content"] =
+      u?.results.length && prompt !== undefined
+        ? { CancelledToolUses: { prompt, tool_use_results: u.results } }
+        : u?.results.length
+          ? { ToolUseResults: { tool_use_results: u.results } }
+          : { Prompt: { prompt: prompt ?? "" } }
+    return {
+      additional_context: first && prompt !== note ? note : "",
+      env_context: envContext,
+      content,
+      timestamp: qTime(u?.at),
+      images: u?.images.length ? u.images : null,
+    }
+  }
+  const history: HistoryEntry[] = []
+  const transcript: string[] = []
+  let pending: UserDraft | undefined
+  let first = true
+  const entry = (u: UserDraft | undefined, a: ReplyDraft | undefined) => {
+    const user = toUser(u, first)
+    first = false
+    const content = a?.text ?? NO_REPLY
+    const assistant: HistoryEntry["assistant"] = a?.uses.length
+      ? { ToolUse: { message_id: randomUUID(), content, tool_uses: a.uses } }
+      : { Response: { message_id: randomUUID(), content } }
+    history.push({ user, assistant, request_metadata: null })
+    const c = user.content as Record<string, any>
+    const typed = c.Prompt?.prompt ?? c.CancelledToolUses?.prompt
+    if (typeof typed === "string" && typed && typed !== note) transcript.push(`> ${typed.replace(/\n/g, "> \n")}`)
+    transcript.push(`${content}\n[Tool uses: ${a?.uses.length ? a.uses.map((x) => x.name).join(",") : "none"}]`)
+  }
+  for (const m of msgs) {
+    if (m.role === "user") pending = m
+    else {
+      entry(pending, m)
+      pending = undefined
+    }
+  }
+  if (pending) entry(pending, undefined)
+
+  const nowMs = opts.now.getTime()
+  const state: ConversationState = {
+    conversation_id: randomUUID(),
+    next_message: null,
+    history,
+    valid_history_range: [0, history.length],
+    transcript,
+    tools: {},
+    context_manager: { max_context_files_size: DEFAULT_CONTEXT_FILES_SIZE, current_profile: DEFAULT_AGENT, paths: DEFAULT_CONTEXT_PATHS, hooks: {} },
+    context_message_length: null,
+    latest_summary:
+      summary !== undefined
+        ? [
+            `[Summary of the earlier conversation in ${label}, which replaced the turns before it]\n\n${summary}`,
+            {
+              request_id: null,
+              message_id: randomUUID(),
+              request_start_timestamp_ms: nowMs,
+              stream_end_timestamp_ms: nowMs,
+              time_to_first_chunk: null,
+              time_between_chunks: [],
+              user_prompt_length: 0,
+              response_size: summary.length,
+              chat_conversation_type: null,
+              tool_use_ids_and_names: [],
+              model_id: null,
+              message_meta_tags: [],
+            },
+          ]
+        : null,
+    file_line_tracker: {},
+    checkpoint_manager: null,
+    mcp_enabled: true,
+  }
+  const expect = {
+    users: msgs.filter((m) => m.role === "user" && m.prompt !== undefined).length,
+    assistants: msgs.filter((m) => m.role === "assistant" && m.text.trim()).length,
+    calls: written.size,
+  }
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (joined) lost.push(`consecutive messages joined into one, as Q alternates them (${joined})`)
+  if (dummies) lost.push(`calls to tools Q does not have, which Q shows the model as "dummy" (${dummies})`)
+  if (remapped) lost.push(`tool call ids, remapped to ids Q accepts (${remapped})`)
+  return { state, lost, expect }
+}
+
+/** The history length of the conversation already stored for `key`, or undefined when there is none. */
+function storedHistory(d: Database, key: string): number | undefined {
+  const r = d.query("SELECT value FROM conversations WHERE key = ?").get(key) as { value: string } | null
+  if (!r) return undefined
+  try {
+    const h = (JSON.parse(r.value) as ConversationState).history
+    return Array.isArray(h) ? h.length : 0
+  } catch {
+    return 1 // unreadable: treat as a conversation, never overwrite it
+  }
+}
+
+const hasTable = (d: Database) => !!d.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'conversations'").get()
+const realCwd = (cwd: string) => {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return resolve(cwd)
+  }
+}
+const sh = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+const stamp = (d: Date) => d.toISOString().replace(/[:.]/g, "-")
+
+/** The Amazon Q CLI writer; `version` and `running` are for tests, which must not depend on an installed Q. */
+export function amazonQCliWriter(opts: { version?: string; running?: () => boolean } = {}): Writer {
+  const running = opts.running ?? (() => isRunning("qchat") || isRunning("q"))
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = opts.version ?? qVersion()
+      if (!v) return { ok: false, why: "Amazon Q CLI is not installed (neither `qchat --version` nor `q --version` ran)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Amazon Q CLI ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${w.cwd}` }
+      const db = dbPath(w.home)
+      if (!exists(db)) return { ok: false, why: "Amazon Q CLI has no database yet; run `q chat` once first" }
+      if (running()) return { ok: false, why: "Amazon Q CLI is running; close it first, since it writes the same database" }
+      const key = realCwd(w.cwd)
+      const n = withSnapshot(db, (d) => (hasTable(d) ? storedHistory(d, key) : -1))
+      if (n === -1) return { ok: false, why: `${db} has no conversations table; it is not a database this writer knows` }
+      if (n) return { ok: false, why: `Amazon Q keeps one conversation per folder and ${key} already has one; continue in another folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const now = new Date()
+      const key = realCwd(w.cwd)
+      const plan = planQ(session, { cwd: key, now })
+      const db = dbPath(w.home)
+      const backup = join(w.home, ".brain", "backups", TOOL, stamp(now))
+      const result = { tool: TOOL, way: "native" as const, sessionId: plan.state.conversation_id, written: [db, backup], open: `cd ${sh(key)} && q chat --resume`, lost: plan.lost }
+      if (w.dryRun) return { ...result, dryRun: true }
+
+      if (!exists(db)) throw new Error("Amazon Q CLI has no database yet; run `q chat` once first")
+      mkdirSync(backup, { recursive: true })
+      for (const side of ["", "-wal", "-shm"]) if (exists(db + side)) copyFileSync(db + side, join(backup, `data.sqlite3${side}`))
+
+      const d = new Database(db)
+      try {
+        d.exec("PRAGMA busy_timeout = 5000")
+        if (!hasTable(d)) throw new Error(`${db} has no conversations table; it is not a database this writer knows`)
+        d.transaction(() => {
+          const n = storedHistory(d, key)
+          if (n) throw new Error(`Amazon Q keeps one conversation per folder and ${key} already has one; nothing was written`)
+          // An empty conversation (what /clear leaves) is replaced, as Q replaces it on the next message.
+          d.prepare("INSERT INTO conversations (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, JSON.stringify(plan.state))
+          // Read back as the reader reads Q; throwing here rolls the transaction back.
+          const back = readQ(d, db, key, w.home)
+          const c = countTurns(back)
+          const pairs = unpaired(back)
+          const e = plan.expect
+          if (c.user !== e.users || c.assistant !== e.assistants || c.tool_call !== e.calls || pairs.calls.length || pairs.results.length)
+            throw new Error(
+              `the Amazon Q conversation did not read back as written (users ${c.user}/${e.users}, replies ${c.assistant}/${e.assistants}, tool calls ${c.tool_call}/${e.calls}, unpaired ${pairs.calls.length + pairs.results.length}); nothing was written`,
+            )
+        })()
+      } finally {
+        d.close()
+      }
+      return { ...result, dryRun: false }
+    },
+  }
+}
+
+export const amazonQCliNativeWriter = amazonQCliWriter()

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

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { amazonQReader } from "./reader.ts"
+import { amazonQNativeWriter } from "./writer.ts"
+
+// Amazon Q Developer's IDE chat (VS Code-family extension and JetBrains plugin, one shared language
+// server): reads the per-workspace history databases and continues any session as a new conversation in
+// the workspace's database, opened by Amazon Q when the editor next opens the folder.
+export const readers: Reader[] = [amazonQReader]
+export const writers: Writer[] = [amazonQNativeWriter]

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"