@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/opencode/v2.ts

@@ -0,0 +1,367 @@
+import type { Database } from "bun:sqlite"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { gitInfo, isDir, versionOf } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { asText, clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import type { Readiness, SessionRef, WriteResult, Writer } from "../types.ts"
+import { idMinter, mintId, random62 } from "./ids.ts"
+import { CONTINUED_NOTE, continuedNote } from "./note.ts"
+import { OPENCODE_V2, mapCall } from "./tools.ts"
+import { addUsage, continuedTitle, modelRef, resolveBin, sh, versionNumber, zeroTokens } from "./writer.ts"
+
+// OpenCode 2.x (npm @opencode/cli, anomalyco/opencode packages/core). Its SQLite store keeps a session in
+// session_v2 and its messages in session_message, one row per message with the message's JSON (less id and
+// type) in `data`; an assistant step's content (text, reasoning and tool items, each tool holding its own
+// result) is inline in `data` or, since 2026-10-29, in session_part rows by ordinal. The store is event
+// sourced and owned by a background service, so a continued session goes through the service's own
+// importer (`opencode session import`, POST /api/experimental/session/import), which publishes the
+// session.created event and writes the rows itself (core/src/session/transfer.ts).
+//
+// Verified live (2026-11-08) with @opencode/cli 2.2.6 in a temp home with no network: `session import
+// --standalone`, then `session list` and `session export`. Message shapes from packages/schema/src/
+// session-message.ts at v2.2.6; how they reach the model from core/src/session/runner/to-llm-message.ts.
+
+export const TESTED_V2 = ["2.2.6"]
+
+/** A session as `session export` writes it and `session import` takes it. */
+export interface Transfer {
+  info: Record<string, any>
+  messages: Array<Record<string, any>>
+}
+
+/**
+ * The portable session as a 2.x transfer: the continuation note as a synthetic message (sent to the model,
+ * shown only as its short description), one user message per user turn, one assistant message per model step
+ * with its tool items holding their results, and a compaction as a completed summary compaction, from which
+ * the loader starts the model's history.
+ */
+export function buildTransferV2(s: Session, o: { cwd: string; now?: number }): { data: Transfer; sessionId: string; lost: string[] } {
+  const now = o.now ?? Date.now()
+  const next = idMinter(now)
+  const sessionId = mintId("ses", now, 1, true)
+  const messages: Transfer["messages"] = []
+  const lost = new Map<string, number>()
+  const drop = (what: string, n = 1) => lost.set(what, (lost.get(what) ?? 0) + n)
+  const mapped = { n: 0 }
+  const label = toolLabel(s.header.tool)
+
+  let clock = Date.parse(s.header.startedAt ?? "") || now - s.turns.length * 1000
+  const tick = (at?: string) => {
+    const t = at ? Date.parse(at) : NaN
+    clock = Number.isFinite(t) && t > clock ? t : clock + 1
+    return clock
+  }
+  const firstClock = clock
+
+  let model = modelRef(s.header.models.at(-1))
+  let step: { msg: Record<string, any>; tools: boolean; results: boolean; tokens: ReturnType<typeof zeroTokens> } | undefined
+  const calls = new Map<string, Record<string, any>>()
+  const answered = new Set<string>()
+
+  const push = (msg: Record<string, any>) => {
+    closeStep()
+    messages.push(msg)
+  }
+  const openStep = (at?: string) => {
+    if (step && !step.results) return step
+    closeStep()
+    const created = tick(at)
+    step = {
+      msg: { id: next("msg"), type: "assistant", agent: "build", model: { id: model.modelID, providerID: model.providerID }, content: [], time: { created, completed: created } },
+      tools: false,
+      results: false,
+      tokens: zeroTokens(),
+    }
+    messages.push(step.msg)
+    return step
+  }
+  function closeStep() {
+    if (!step) return
+    step.msg.finish = step.tools ? "tool-calls" : "stop"
+    step.msg.time.completed = clock
+    if (Object.values(step.tokens).some((v) => typeof v === "number" && v > 0) || step.tokens.cache.read || step.tokens.cache.write) step.msg.tokens = step.tokens
+    step = undefined
+  }
+
+  push({
+    id: next("msg"),
+    type: "synthetic",
+    text: continuedNote(label, s.header.id, new Date(now).toISOString().slice(0, 10)),
+    description: `Continued from ${label}`,
+    time: { created: tick() },
+  })
+
+  for (const t of s.turns as Turn[]) {
+    switch (t.kind) {
+      case "user": {
+        const n = t.attachments?.length ?? 0
+        if (n) drop("attachments", n)
+        const text = t.text.trim() ? t.text : n ? `(${n} attachment${n > 1 ? "s" : ""} not carried over)` : ""
+        if (text) push({ id: next("msg"), type: "user", text, time: { created: tick(t.at) } })
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        if (t.model) model = modelRef(t.model)
+        const st = openStep(t.at)
+        tick(t.at)
+        st.msg.content.push({ type: "text", text: t.text })
+        addUsage(st.tokens, t.usage)
+        break
+      }
+      case "reasoning": {
+        const st = openStep(t.at)
+        const at = tick(t.at)
+        st.msg.content.push({ type: "reasoning", text: t.text, time: { created: at, completed: at } })
+        // Without native data, 2.x hands readable reasoning to the next model's adapter as text.
+        drop("reasoning: kept as text, without provider signatures")
+        break
+      }
+      case "tool_call": {
+        const st = openStep(t.at)
+        const at = tick(t.at)
+        const call = mapCall(OPENCODE_V2, t.name, t.toolKind, t.input, mapped)
+        const item = {
+          type: "tool",
+          id: `call_${random62(24)}`,
+          name: call.tool,
+          state: { status: "error", input: call.input, error: { type: "tool.execution", message: "No result was recorded for this call." } },
+          time: { created: at, ran: at, completed: at },
+        }
+        st.msg.content.push(item)
+        st.tools = true
+        calls.set(t.id, item)
+        break
+      }
+      case "tool_result": {
+        const item = calls.get(t.callId)
+        if (!item) {
+          drop("tool results without a call")
+          break
+        }
+        answered.add(t.callId)
+        item.time.completed = Math.max(item.time.created, tick(t.at))
+        const input = item.state.input
+        item.state = t.ok
+          ? { status: "completed", input, content: [{ type: "text", text: t.output }], ...(t.truncated ? { metadata: { truncated: true } } : {}) }
+          : { status: "error", input, error: { type: "tool.execution", message: t.output || "The call failed." } }
+        if (step) step.results = true
+        break
+      }
+      case "compaction":
+        push({ id: next("msg"), type: "compaction", status: "completed", reason: "auto", summary: t.summary, time: { created: tick(t.at) } })
+        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
+    }
+  }
+  closeStep()
+
+  const unanswered = calls.size - answered.size
+  if (unanswered > 0) drop("calls with no result, marked as failed", unanswered)
+  if (calls.size) drop("tool-call ids replaced", calls.size)
+  if (mapped.n) drop("tool calls renamed to OpenCode's own tools", mapped.n)
+
+  const info = {
+    id: sessionId,
+    // The importer resolves the project from the folder; the field is required, so it carries the default.
+    projectID: "global",
+    cost: 0,
+    tokens: zeroTokens(),
+    time: { created: firstClock, updated: Math.max(now, clock) },
+    title: continuedTitle(s),
+    location: { directory: o.cwd },
+  }
+  return { data: { info, messages }, sessionId, lost: [...lost].map(([what, n]) => `${what} (${n})`) }
+}
+
+/** OpenCode 2.x through `opencode session import`; the OpenCode writer dispatches here for a 2.x install. */
+export const v2Writer: Writer = {
+  tool: "opencode",
+  label: "OpenCode",
+  way: "import",
+  async ready(opts): Promise<Readiness> {
+    const raw = versionOf(resolveBin({ bin: "opencode", installDir: ".opencode" }, opts.home).path)
+    const v = versionNumber(raw)
+    if (!raw) return { ok: false, why: "OpenCode is not installed (no opencode on PATH or in ~/.opencode/bin)" }
+    if (!v || !TESTED_V2.includes(v)) return { ok: false, why: `OpenCode ${v ?? raw} has not been tested; the 2.x import format was checked on ${TESTED_V2.join(", ")}` }
+    if (!isDir(opts.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${opts.cwd}` }
+    return { ok: true }
+  },
+  async write(session, opts): Promise<WriteResult> {
+    const bin = resolveBin({ bin: "opencode", installDir: ".opencode" }, opts.home)
+    const { data, sessionId, lost } = buildTransferV2(session, { cwd: opts.cwd })
+    const file = join(opts.home, ".brain", "exports", `opencode-${sessionId}.json`)
+    if (!opts.dryRun) {
+      mkdirSync(dirname(file), { recursive: true })
+      writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`)
+    }
+    return {
+      tool: "opencode",
+      way: "import",
+      sessionId,
+      written: [file],
+      // The background service files the session under the project of the directory it is given.
+      open: `cd ${sh(opts.cwd)} && ${sh(bin.command)} session import ${sh(file)} && ${sh(bin.command)} --session ${sessionId}`,
+      lost,
+      dryRun: !!opts.dryRun,
+    }
+  },
+}
+
+// ---- Reading 2.x stores ----
+
+const hasTable = (d: Database, name: string) => !!d.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name)
+
+const json = (s: unknown) => {
+  try {
+    return JSON.parse(String(s)) as Record<string, any>
+  } catch {
+    return undefined
+  }
+}
+
+/** Top-level sessions in a 2.x database (the reader opens a snapshot of it); none in a 1.x one. */
+export function listV2Db(d: Database, path: string, tool: string): SessionRef[] {
+  if (!hasTable(d, "session_v2")) return []
+  const rows = d.query("SELECT id, title, directory, time_updated, project_id FROM session_v2 WHERE parent_id IS NULL AND time_archived IS NULL").all() as Array<Record<string, any>>
+  return rows.map((r) => ({
+    tool,
+    sourceId: String(r.id),
+    path,
+    ...(r.title ? { title: String(r.title) } : {}),
+    ...(r.directory ? { cwd: String(r.directory) } : {}),
+    ...(iso(r.time_updated) ? { updatedAt: iso(r.time_updated)! } : {}),
+    extra: { source: "db2", projectID: r.project_id },
+  }))
+}
+
+/** One session from a 2.x database, with its subagent sessions two levels down. */
+export function readV2Db(d: Database, path: string, tool: string, id: string, depth = 0): Session {
+  if (!hasTable(d, "session_v2")) throw new Error(`no session_v2 table in ${path}`)
+  const row = d.query("SELECT * FROM session_v2 WHERE id = ?").get(id) as Record<string, any> | null
+  if (!row) throw new Error(`session ${id} not found`)
+  const cwd = row.directory ? String(row.directory) : undefined
+  const h = header(tool, id, {
+    ...(row.version ? { toolVersion: String(row.version) } : {}),
+    sourcePath: path,
+    ...(row.title ? { title: String(row.title) } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(iso(row.time_created) ? { startedAt: iso(row.time_created)! } : {}),
+    ...(iso(row.time_updated) ? { updatedAt: iso(row.time_updated)! } : {}),
+    ...(row.parent_id ? { parent: { id: `${tool}:${row.parent_id}`, kind: "subagent" as const } } : {}),
+  })
+  const lost = lossCounter()
+  const parts = new Map<string, Array<Record<string, any>>>()
+  if (hasTable(d, "session_part"))
+    for (const p of d.query("SELECT message_id, type, data FROM session_part WHERE session_id = ? ORDER BY message_id, ordinal").all(id) as Array<Record<string, any>>) {
+      const data = json(p.data)
+      if (!data) {
+        lost.add("unreadable message or part records")
+        continue
+      }
+      const list = parts.get(p.message_id) ?? []
+      list.push({ ...data, type: p.type })
+      parts.set(p.message_id, list)
+    }
+  const turns: Turn[] = []
+  const callIds = new Set<string>()
+  for (const m of d.query("SELECT id, type, time_created, data FROM session_message WHERE session_id = ? ORDER BY seq").all(id) as Array<Record<string, any>>) {
+    const data = json(m.data)
+    if (!data) {
+      lost.add("unreadable message or part records")
+      continue
+    }
+    const at = iso(m.time_created)
+    switch (m.type) {
+      case "user": {
+        const files = Array.isArray(data.files) ? data.files.length : 0
+        if (files) lost.add("attachment data", files)
+        if (typeof data.text === "string" && (data.text.trim() || files))
+          turns.push({ kind: "user", ...(at ? { at } : {}), text: data.text, ...(files ? { attachments: data.files.map((f: any) => ({ kind: String(f.mime ?? "").startsWith("image/") ? "image" : "file", ...(f.mime ? { mime: f.mime } : {}), ...(f.name ? { name: f.name } : {}) })) } : {}) })
+        break
+      }
+      case "synthetic": {
+        const continued = typeof data.text === "string" ? data.text.match(CONTINUED_NOTE)?.[1] : undefined
+        if (continued) h.parent ??= { id: continued, kind: "continued" }
+        else lost.add("messages the tool injected as the user")
+        break
+      }
+      case "assistant": {
+        const model = data.model?.id ? String(data.model.id) : undefined
+        const content: Array<Record<string, any>> = parts.get(m.id) ?? (Array.isArray(data.content) ? data.content : [])
+        if (model && content.some((c) => c.type === "text" || c.type === "tool")) noteModel(h, model)
+        if (data.error) lost.add("error notices on replies")
+        let usage = data.tokens ? { input: data.tokens.input, output: data.tokens.output, cacheRead: data.tokens.cache?.read, cacheWrite: data.tokens.cache?.write } : undefined
+        for (const c of content) {
+          if (c.type === "text" && typeof c.text === "string" && c.text.trim()) {
+            turns.push({ kind: "assistant", ...(at ? { at } : {}), text: c.text, ...(model ? { model } : {}), ...(usage && Object.values(usage).some(Boolean) ? { usage } : {}) })
+            usage = undefined
+          } else if (c.type === "reasoning") {
+            const signed = !!c.native && Object.keys(c.native).length > 0
+            if (typeof c.text === "string" && c.text.trim()) {
+              turns.push({ kind: "reasoning", ...(at ? { at } : {}), text: c.text })
+              if (signed) lost.add("reasoning signatures")
+            } else if (signed) lost.add("signed reasoning")
+          } else if (c.type === "tool") toolTurns(c, at, turns, callIds, lost)
+        }
+        break
+      }
+      case "compaction":
+        if (data.status === "completed" && typeof data.summary === "string") turns.push({ kind: "compaction", ...(at ? { at } : {}), summary: data.summary })
+        break
+      case "shell": {
+        // A command the person ran from the prompt: a call and its result, as the model was shown it.
+        const callId = `shell-${m.id}`
+        turns.push({ kind: "tool_call", ...(at ? { at } : {}), id: callId, name: "shell", toolKind: "shell", input: { command: data.command } })
+        if (data.output) turns.push({ kind: "tool_result", callId, ok: data.exit === undefined || data.exit === 0, output: clip(asText(data.output.output)).text })
+        break
+      }
+      case "system":
+      case "skill":
+        lost.add("system and skill notes")
+        break
+    }
+  }
+  lost.flush(h)
+  const s: Session = { header: h, turns }
+  if (depth < 2) {
+    const children: Session[] = []
+    for (const c of d.query("SELECT id FROM session_v2 WHERE parent_id = ?").all(id) as Array<{ id: string }>) {
+      try {
+        children.push(readV2Db(d, path, tool, c.id, depth + 1))
+      } catch {
+        h.lost.push(`unreadable subagent session (${c.id})`)
+      }
+    }
+    if (children.length) s.children = children
+  }
+  return s
+}
+
+function toolTurns(c: Record<string, any>, at: string | undefined, turns: Turn[], callIds: Set<string>, lost: ReturnType<typeof lossCounter>) {
+  const st = (c.state ?? {}) as Record<string, any>
+  const name = String(c.name ?? "unknown")
+  let id = String(c.id ?? "")
+  for (let n = 2; !id || callIds.has(id); n++) id = `${String(c.id ?? "call")}#${n}`
+  callIds.add(id)
+  const start = iso(c.time?.created) ?? at
+  const end = iso(c.time?.completed) ?? start
+  if (c.native && Object.keys(c.native).length) lost.add("tool-call signatures")
+  const input = st.status === "streaming" ? asText(st.input) : (st.input ?? {})
+  turns.push({ kind: "tool_call", ...(start ? { at: start } : {}), id, name, toolKind: toolKindOf(name), input })
+  if (st.status !== "completed" && st.status !== "error") return
+  const items: Array<Record<string, any>> = Array.isArray(st.content) ? st.content : []
+  const files = items.filter((x) => x.type === "file").length
+  if (files) lost.add("attachments in tool results", files)
+  const text = items.filter((x) => x.type === "text").map((x) => String(x.text)).join("\n")
+  const raw = st.status === "completed" ? text : [st.error?.message, text].filter(Boolean).join("\n")
+  const out = clip(raw)
+  turns.push({ kind: "tool_result", ...(end ? { at: end } : {}), callId: id, ok: st.status === "completed", output: out.text, ...(out.truncated || st.metadata?.truncated === true ? { truncated: true } : {}) })
+}