@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/tabnine-cli/writer.ts

@@ -0,0 +1,156 @@
+import { createHash, randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { basename, dirname, join, resolve } from "node:path"
+import { exists, isDir, ls, readJson } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { realCwd, shellQuote } from "../gemini-cli/exchanges.ts"
+import { planConversation, serialize } from "../gemini-cli/writer.ts"
+import { tabnineReader } from "./reader.ts"
+import { GEMINI_FORMAT_VERSION, LABEL, TESTED_VERSIONS, TOOL, agentDir, tabnineVersion } from "./records.ts"
+
+// Continues a portable session in the Tabnine CLI as a new session file in the project's chats folder under
+// ~/.tabnine/agent: the records the Gemini CLI planner makes (Tabnine's format is Gemini CLI's JSONL), with
+// the project folder claimed the way Tabnine's ProjectRegistry claims one. Tabnine lists it
+// (--list-sessions, /resume) and its loader gives the model the whole conversation.
+
+const sha256 = (s: string) => createHash("sha256").update(s).digest("hex")
+const readText = (p: string) => {
+  try {
+    return readFileSync(p, "utf8")
+  } catch {
+    return undefined
+  }
+}
+const slugify = (text: string) =>
+  text
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "") || "project"
+
+/**
+ * The project's folder under ~/.tabnine/agent/tmp, as ProjectRegistry.getShortId finds or claims it (the
+ * same rules as Gemini CLI's, under Tabnine's root): the registry's name when its markers agree, else a
+ * folder whose .project_root names the project, else a new name from the folder's base name.
+ */
+export function projectFolder(home: string, cwd: string): { dir: string; markers: string[]; register?: { path: string; slug: string } } {
+  const root = agentDir(home)
+  const project = resolve(cwd)
+  const tmp = join(root, "tmp")
+  const bases = [tmp, join(root, "history")]
+  const owner = (base: string, slug: string) => readText(join(base, slug, ".project_root"))?.trim()
+  const legacy = join(tmp, sha256(project))
+  const registry = readJson<{ projects?: Record<string, string> }>(join(root, "projects.json"))?.projects ?? {}
+  let slug: string | undefined = registry[project]
+  if (slug && bases.some((b) => owner(b, slug!) !== undefined && resolve(owner(b, slug!)!) !== project)) slug = undefined
+  for (const base of bases) for (const d of slug ? [] : ls(base)) if (!slug && owner(base, d) !== undefined && resolve(owner(base, d)!) === project) slug = d
+  if (!slug) {
+    const taken = new Set(Object.values(registry))
+    const base = slugify(basename(project) || "project")
+    for (let i = 0; !slug; i++) {
+      const c = i === 0 ? base : `${base}-${i}`
+      if (!taken.has(c) && bases.every((b) => owner(b, c) === undefined || resolve(owner(b, c)!) === project)) slug = c
+    }
+  }
+  const fresh = ls(join(tmp, slug)).every((f) => f === ".project_root")
+  if (isDir(legacy) && fresh) return { dir: legacy, markers: [] }
+  return {
+    dir: join(tmp, slug),
+    markers: bases.map((b) => join(b, slug!, ".project_root")).filter((p) => !exists(p)),
+    ...(registry[project] === slug ? {} : { register: { path: project, slug } }),
+  }
+}
+
+/** Adds the registry entry under Tabnine's lock (proper-lockfile's `<file>.lock` folder), atomically. */
+function register(home: string, entry: { path: string; slug: string }) {
+  const file = join(agentDir(home), "projects.json")
+  const lock = `${file}.lock`
+  mkdirSync(agentDir(home), { recursive: true })
+  for (let tries = 0; ; tries++) {
+    try {
+      mkdirSync(lock)
+      break
+    } catch {
+      let age = 0
+      try {
+        age = Date.now() - statSync(lock).mtimeMs
+      } catch {}
+      if (age > 10_000) rmdirSync(lock)
+      else if (tries > 50) throw new Error(`Tabnine is updating ${file}; try again`)
+      else Bun.sleepSync(100)
+    }
+  }
+  try {
+    const data = readJson<{ projects?: Record<string, string> }>(file) ?? {}
+    const tmp = `${file}.${randomUUID()}.tmp`
+    writeFileSync(tmp, JSON.stringify({ ...data, projects: { ...(data.projects ?? {}), [entry.path]: entry.slug } }, null, 2))
+    renameSync(tmp, file)
+  } finally {
+    rmdirSync(lock)
+  }
+}
+
+/** The Tabnine writer; `version` is for tests, which must not depend on what is installed. */
+export function tabnineWriter(opts: { version?: string } = {}): Writer {
+  const installed = (home: string) => opts.version ?? tabnineVersion(home)
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed(w.home)
+      if (!v) return { ok: false, why: "the Tabnine CLI is not installed (no active bundle in ~/.tabnine/agent/.bundles)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Tabnine CLI ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Tabnine lists and resumes sessions per project folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = realCwd(w.cwd)
+      const now = new Date()
+      const folder = projectFolder(w.home, cwd)
+      const chats = join(folder.dir, "chats")
+      let sessionId = randomUUID()
+      const name = () => `session-${now.toISOString().slice(0, 16).replace(/:/g, "-")}-${sessionId.slice(0, 8)}.jsonl`
+      while (exists(join(chats, name()))) sessionId = randomUUID()
+      const path = join(chats, name())
+      const plan = planConversation(session, { sessionId, projectHash: sha256(cwd), now, version: GEMINI_FORMAT_VERSION })
+      const written = [path, ...folder.markers, ...(folder.register ? [join(agentDir(w.home), "projects.json")] : [])]
+      if (!w.dryRun) {
+        for (const m of folder.markers) {
+          mkdirSync(dirname(m), { recursive: true })
+          writeFileSync(m, cwd, { flag: "wx" })
+        }
+        if (folder.register) register(w.home, folder.register)
+        mkdirSync(chats, { recursive: true })
+        // "wx": a new file only; an existing session is never touched.
+        writeFileSync(path, serialize(plan, "jsonl"), { flag: "wx" })
+        try {
+          const back = await tabnineReader.read({ tool: TOOL, sourceId: sessionId, path, cwd }, w.home)
+          const got = countTurns(back)
+          const pairs = unpaired(back)
+          if (got.user !== plan.expect.users || got.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+            throw new Error(`the new Tabnine session did not read back as written (users ${got.user}/${plan.expect.users}, tool calls ${got.tool_call}/${plan.expect.calls})`)
+        } catch (e) {
+          rmSync(path, { force: true })
+          throw new Error(`${(e as Error).message}; the session file was removed`)
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId,
+        written,
+        open: `cd ${shellQuote(cwd)} && tabnine --resume ${sessionId}`,
+        note: "If Tabnine's OpenCode-based CLI is installed, this CLI is `tabnine-legacy`.",
+        lost: plan.lost.map((l) => l.replace(/Gemini CLI/g, LABEL)),
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const tabnineNativeWriter = tabnineWriter()

package/src/adapters/types.ts

@@ -0,0 +1,73 @@
+import type { Session } from "../session/types.ts"
+
+// The contract every tool adapter implements. A reader finds a tool's sessions under a home folder and
+// turns one into the portable session; a writer continues a portable session in its tool. Readers and
+// writers take `home` explicitly so tests run against a fake home and never touch the real one.
+
+export interface SessionRef {
+  /** Reader id, e.g. "claude-code". */
+  tool: string
+  /** The session's id in its own tool. */
+  sourceId: string
+  /** The file, folder or database the session lives in. */
+  path: string
+  title?: string
+  cwd?: string
+  updatedAt?: string
+  /** Whatever else the reader needs to find this session again (a workspace hash, a row key). */
+  extra?: Record<string, unknown>
+}
+
+export interface Reader {
+  tool: string
+  /** Name shown to people, e.g. "Claude Code". */
+  label: string
+  /**
+   * Every session this tool keeps under `home`, newest first. Reads only; returns [] when the tool has
+   * never stored a session here. Must be cheap enough to run for every tool on `brain session list`.
+   */
+  list(home: string): Promise<SessionRef[]>
+  /** One session in full. Throws a plain Error with a reason when it cannot be read. */
+  read(ref: SessionRef, home: string): Promise<Session>
+}
+
+/** How a writer continues a session: as the tool's own session, through the tool's importer, or by a brief. */
+export type Way = "native" | "import" | "brief"
+
+export interface WriteOptions {
+  home: string
+  /** The folder to continue in: the session's own project folder unless the person chose another. */
+  cwd: string
+  dryRun?: boolean
+  /** For brief writers: a lean brief and what the project remembers (see BriefOptions); other writers ignore it. */
+  brief?: { lean?: boolean; memory?: Array<{ kind?: string; text: string; source?: string }>; map?: string }
+}
+
+export interface WriteResult {
+  tool: string
+  way: Way
+  /** The new session's id in the target tool, when there is one. */
+  sessionId?: string
+  /** Files written (or that would be written, in a dry run). */
+  written: string[]
+  /** What the person runs or does next, e.g. `claude --resume <id>`. */
+  open: string
+  /** What the person does after `open`, when it is more than a command (a click in the app). */
+  note?: string
+  /** What the target cannot keep, on top of what reading already lost. */
+  lost: string[]
+  dryRun: boolean
+}
+
+export type Readiness = { ok: true } | { ok: false; why: string }
+
+export interface Writer {
+  /** Target id, e.g. "claude-code" or "cursor". */
+  tool: string
+  label: string
+  way: Way
+  /** Whether it can write now on this machine: the tool installed, a tested version, the app closed if that matters. */
+  ready(opts: WriteOptions): Promise<Readiness>
+  /** Continues the session as a new session in the target; never modifies the source. */
+  write(session: Session, opts: WriteOptions): Promise<WriteResult>
+}

package/src/adapters/void/index.ts

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { reader } from "./reader.ts"
+import { voidNativeWriter } from "./writer.ts"
+
+// Void (a VS Code fork): reads its chat threads from its global state.vscdb, and continues any session as a
+// new thread in its chat history (Void must be closed while it is written).
+export { reader }
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [voidNativeWriter]

package/src/adapters/void/reader.ts

@@ -0,0 +1,48 @@
+import type { Database } from "bun:sqlite"
+import { exists } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { KEY, LABEL, TOOL, dbPath, parseThreads, threadTitle, toPortable } from "./records.ts"
+
+type Json = Record<string, any>
+
+/** The value of an ItemTable key, as text. */
+export function itemValue(db: Database, key: string): string | undefined {
+  const row = db.query("SELECT value FROM ItemTable WHERE key = ?").get(key) as { value: string | Uint8Array } | null
+  return row ? (typeof row.value === "string" ? row.value : new TextDecoder().decode(row.value)) : undefined
+}
+
+/** Every stored thread, read from a copy of Void's global storage. */
+export function readThreads(home: string): { threads: Json; path: string } {
+  const path = dbPath(home)
+  if (!exists(path)) return { threads: {}, path }
+  const text = withSnapshot(path, (db) => itemValue(db, KEY))
+  return { threads: text ? parseThreads(text) : {}, path }
+}
+
+export const reader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const { threads, path } = readThreads(home)
+    return Object.values(threads)
+      .filter((t: Json) => typeof t?.id === "string" && Array.isArray(t.messages) && t.messages.length)
+      .map((t: Json) => ({
+        tool: TOOL,
+        sourceId: t.id,
+        path,
+        ...(threadTitle(t) ? { title: threadTitle(t)!.replace(/\s+/g, " ").slice(0, 120) } : {}),
+        ...(typeof t.lastModified === "string" ? { updatedAt: t.lastModified } : {}),
+      }))
+      .sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef, home: string): Promise<Session> {
+    const { threads, path } = readThreads(home)
+    const t = threads[ref.sourceId]
+    if (!t) throw new Error(`Void has no thread ${ref.sourceId} in ${path}`)
+    return toPortable(t, path)
+  },
+}

package/src/adapters/void/records.ts

@@ -0,0 +1,285 @@
+import { randomUUID } from "node:crypto"
+import { join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { appSupport } from "../../fsutil.ts"
+import type { Session, ToolKind, Turn } from "../../session/types.ts"
+import { asText, clip, header, lossCounter, toolKindOf } from "../../session/util.ts"
+import { CONTINUED_NOTE, continuedNote } from "../claude-code/records.ts"
+import { ARG, type ToolMap, asArgs, mapTool, pick, safeToolName } from "../vscode-copilot/shared.ts"
+
+// Void's chat threads, checked against voideditor/void main at 1.4.9 (b3166e7e): chatThreadService.ts,
+// chatThreadServiceTypes.ts, convertToLLMMessageService.ts, SidebarThreadSelector.tsx and SidebarChat.tsx.
+//
+// Every thread lives in one JSON value in Void's global storage, User/globalStorage/state.vscdb, ItemTable key
+// 'void.chatThreadStorageII': {[threadId]: {id, createdAt, lastModified, messages, state, filesWithUserChanges}}.
+// Void reads it once when it starts and rewrites the whole value from memory on every change, so it must
+// be closed while the value is written. URIs inside are marshalled VS Code URIs ($mid 1).
+//
+// A user message has `content` (sent to the model) and `displayContent` (shown), which is where the note
+// that the session was carried over goes. Tool calls exist only as tool messages ({role: 'tool', id, name,
+// rawParams, params, result, content}); when Void builds the model's messages it attaches each tool
+// message to the assistant message right before it as that message's single call, so every tool message
+// gets its own assistant message before it. The thread list names a thread by its first user message.
+
+export const TOOL = "void"
+export const LABEL = "Void"
+export const KEY = "void.chatThreadStorageII"
+
+export const dbPath = (home: string) => join(appSupport(home), "Void", "User", "globalStorage", "state.vscdb")
+
+type Json = Record<string, any>
+const isObj = (v: unknown): v is Json => typeof v === "object" && v !== null && !Array.isArray(v)
+
+const KIND: Record<string, ToolKind> = {
+  read_file: "read",
+  ls_dir: "list",
+  get_dir_tree: "list",
+  search_pathnames_only: "search",
+  search_for_files: "search",
+  search_in_file: "search",
+  read_lint_errors: "read",
+  rewrite_file: "write",
+  edit_file: "edit",
+  create_file_or_folder: "write",
+  delete_file_or_folder: "edit",
+  run_command: "shell",
+  run_persistent_command: "shell",
+  open_persistent_terminal: "shell",
+  kill_persistent_terminal: "shell",
+}
+
+/** A marshalled file URI, as Void stores one. */
+const fileUri = (path: string) => ({ $mid: 1, fsPath: path, external: `file://${encodeURI(path)}`, path, scheme: "file" })
+
+/** The JSON Void stores, with URIs (objects with $mid 1) turned into their paths. */
+export function parseThreads(text: string): Json {
+  const v = JSON.parse(text, (_k, value) => (isObj(value) && value.$mid === 1 && typeof value.path === "string" ? value.path : value))
+  return isObj(v) ? v : {}
+}
+
+/** The first user message as the thread list shows it. */
+export const threadTitle = (t: Json): string | undefined => {
+  const m = Array.isArray(t.messages) ? t.messages.find((x: Json) => x?.role === "user") : undefined
+  return typeof m?.displayContent === "string" && m.displayContent ? m.displayContent : undefined
+}
+
+// --- Reading ---------------------------------------------------------------------------------------------
+
+export function toPortable(thread: Json, path: string): Session {
+  const lost = lossCounter()
+  const h = header(TOOL, String(thread.id), {
+    ...(threadTitle(thread) ? { title: threadTitle(thread)!.replace(/\s+/g, " ").slice(0, 120) } : {}),
+    sourcePath: path,
+    project: {},
+    ...(typeof thread.createdAt === "string" ? { startedAt: thread.createdAt } : {}),
+    ...(typeof thread.lastModified === "string" ? { updatedAt: thread.lastModified } : {}),
+  })
+  const turns: Turn[] = []
+  for (const m of Array.isArray(thread.messages) ? thread.messages.filter(isObj) : []) {
+    if (m.role === "user") {
+      // What the person typed is displayContent; content adds their selections (and brain's note).
+      const shown = typeof m.displayContent === "string" ? m.displayContent : ""
+      const sent = typeof m.content === "string" ? m.content : ""
+      const from = sent.match(CONTINUED_NOTE)?.[1]
+      if (from && !h.parent) h.parent = { id: from, kind: "continued" }
+      // A request that is only brain's note (its shown label is not in what was sent) is not the person's.
+      if (from && !sent.includes(shown)) continue
+      const text = shown || sent
+      if (Array.isArray(m.selections) && m.selections.length) lost.add("code selections", m.selections.length)
+      if (text.trim()) turns.push({ kind: "user", text })
+    } else if (m.role === "assistant") {
+      if (Array.isArray(m.anthropicReasoning) && m.anthropicReasoning.length) lost.add("signed reasoning", m.anthropicReasoning.length)
+      else if (typeof m.reasoning === "string" && m.reasoning.trim()) turns.push({ kind: "reasoning", text: m.reasoning })
+      if (typeof m.displayContent === "string" && m.displayContent.trim()) turns.push({ kind: "assistant", text: m.displayContent })
+    } else if (m.role === "tool") {
+      const id = String(m.id ?? "")
+      const name = String(m.name ?? "")
+      if (!id || !name) {
+        lost.add("tool calls without an id or name")
+        continue
+      }
+      turns.push({ kind: "tool_call", id, name, toolKind: KIND[name] ?? toolKindOf(name), input: isObj(m.params) ? m.params : isObj(m.rawParams) ? m.rawParams : {} })
+      const output = typeof m.content === "string" && m.content ? m.content : typeof m.result === "string" ? m.result : asText(m.result ?? "")
+      const failed = m.type !== "success"
+      const why = m.type === "rejected" ? "The user rejected this tool call." : m.type === "invalid_params" ? "The tool call had invalid parameters." : m.type === "tool_request" || m.type === "running_now" ? "The tool call did not finish." : ""
+      const c = clip(why && !output ? why : output)
+      turns.push({ kind: "tool_result", callId: id, ok: !failed, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+    } else if (m.role === "interrupted_streaming_tool") lost.add("tool calls interrupted while streaming")
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+// --- Writing ---------------------------------------------------------------------------------------------
+
+/** A tool message Void can show, for a call it would have made itself where the arguments map. */
+interface VoidTool {
+  name: string
+  params: Json
+  rawParams: Json
+  result: (output: string) => unknown
+}
+
+const TOOLS: ToolMap = {
+  read: (i) => {
+    const path = pick(i, ARG.path)
+    return path ? { name: "read_file", args: { path } } : undefined
+  },
+  shell: (i) => {
+    const command = pick(i, ARG.command)
+    return command ? { name: "run_command", args: { command } } : undefined
+  },
+}
+
+function voidTool(t: Extract<Turn, { kind: "tool_call" }>): VoidTool {
+  const mapped = mapTool(TOOLS, t.toolKind, t.input)
+  if (mapped?.name === "read_file") {
+    const path = String(mapped.args.path)
+    return {
+      name: "read_file",
+      params: { uri: fileUri(path), startLine: null, endLine: null, pageNumber: 1 },
+      rawParams: { uri: path },
+      result: (out) => ({ fileContents: out, totalFileLen: out.length, totalNumLines: out.split("\n").length, hasNextPage: false }),
+    }
+  }
+  if (mapped?.name === "run_command") {
+    const command = String(mapped.args.command)
+    // The terminal is gone; the result view shows the stored output without it.
+    return { name: "run_command", params: { command, cwd: null, terminalId: "brain" }, rawParams: { command }, result: (out) => ({ result: out, resolveReason: { type: "done", exitCode: 0 } }) }
+  }
+  // Anything else is shown the way Void shows an MCP tool's call: its inputs and a text result.
+  const name = safeToolName(t.name)
+  const args = asArgs(t.input)
+  return { name, params: args, rawParams: args, result: (out) => ({ event: "text", text: out, toolName: name }) }
+}
+
+export interface VoidPlan {
+  thread: Json
+  lost: string[]
+  expect: { users: number; calls: number }
+}
+
+/** The thread Void would store for `session` continued as thread `threadId`. Pure. */
+export function planThread(session: Session, opts: { threadId: string; now: Date }): VoidPlan {
+  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 note = continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10))
+  const results = new Map<string, Extract<Turn, { kind: "tool_result" }>>()
+  const callIds = new Set<string>()
+  for (const t of session.turns) {
+    if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+    if (t.kind === "tool_call") callIds.add(t.id)
+  }
+  // Void has no summary record: the thread starts from the last compaction, its summary in the note.
+  let turns = session.turns
+  let carried: string | undefined
+  const last = turns.map((t) => t.kind).lastIndexOf("compaction")
+  if (last >= 0) {
+    const before = turns.slice(0, last).filter((t) => t.kind === "user" || t.kind === "assistant" || t.kind === "tool_call").length
+    if (before) drop("messages and tool calls before the last compaction (its summary is kept)", before)
+    carried = (turns[last] as Extract<Turn, { kind: "compaction" }>).summary
+    turns = turns.slice(last + 1)
+  }
+  const sent = carried ? `${note}\n\nSummary of the earlier conversation:\n${carried}` : note
+
+  const messages: Json[] = []
+  let noteGiven = false
+  let users = 0
+  let calls = 0
+  let reasoning: string[] = []
+  const seen = new Set<string>()
+  const user = (shown: string, extra?: string) => {
+    const content = noteGiven ? shown : `${sent}\n\n${shown}`
+    noteGiven = true
+    messages.push({ role: "user", content: extra ? `${content}\n\n${extra}` : content, displayContent: shown, selections: null, state: { stagingSelections: [], isBeingEdited: false } })
+  }
+  const assistant = (text: string) => {
+    if (!messages.some((m) => m.role === "user")) {
+      // Replies before any request: a request that is only the note, labelled for the thread list.
+      messages.push({ role: "user", content: sent, displayContent: `Continued from ${label}: ${session.header.title ?? session.header.sourceId}`, selections: null, state: { stagingSelections: [], isBeingEdited: false } })
+      noteGiven = true
+    }
+    messages.push({ role: "assistant", displayContent: text, reasoning: reasoning.join("\n\n"), anthropicReasoning: null })
+    reasoning = []
+  }
+
+  for (const t of turns) {
+    switch (t.kind) {
+      case "user": {
+        const files = (t.attachments ?? []).filter((a) => a.kind === "file" && a.path).map((a) => `[Attached file: ${a.path}]`)
+        if ((t.attachments?.length ?? 0) > files.length) drop("attachments that are not files", (t.attachments?.length ?? 0) - files.length)
+        if (!t.text.trim() && !files.length) break
+        if (reasoning.length) drop("reasoning with no reply after it", reasoning.length)
+        reasoning = []
+        user(t.text, files.join("\n") || undefined)
+        users++
+        break
+      }
+      case "assistant":
+        if (t.text.trim()) assistant(t.text)
+        break
+      case "reasoning":
+        if (t.text.trim()) {
+          reasoning.push(t.text)
+          drop("reasoning (shown in the chat, not sent back to the model)")
+        }
+        break
+      case "tool_call": {
+        if (seen.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        seen.add(t.id)
+        // Void sends a tool message as the call of the assistant message right before it.
+        if (messages.at(-1)?.role !== "assistant") assistant("")
+        const res = results.get(t.id)
+        const tool = voidTool(t)
+        let out = res?.output ?? "No result was recorded for this call; the session moved on before it finished."
+        if (res?.fullPath) out += `\n\n[Full output: ${res.fullPath}]`
+        if (!res) drop("tool calls without a result (kept as errors)")
+        const ok = !!res?.ok
+        messages.push({
+          role: "tool",
+          type: ok ? "success" : "tool_error",
+          name: tool.name,
+          params: tool.params,
+          result: ok ? tool.result(out) : out,
+          content: out,
+          id: t.id,
+          rawParams: tool.rawParams,
+          mcpServerName: undefined,
+        })
+        calls++
+        break
+      }
+      case "tool_result":
+        if (!callIds.has(t.callId)) drop("tool results without a call")
+        break
+      case "file_edit":
+        if (!t.callId || !callIds.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions (their call and result are kept)")
+        break
+      case "compaction":
+        break
+    }
+  }
+  if (reasoning.length) drop("reasoning with no reply after it", reasoning.length)
+  if (!messages.length) throw new Error("nothing to continue: the session has no messages")
+
+  const created = opts.now.toISOString()
+  const thread = {
+    id: opts.threadId,
+    createdAt: created,
+    lastModified: created,
+    messages,
+    state: { currCheckpointIdx: null, stagingSelections: [], linksOfMessageIdx: {} },
+    // A Set in Void's memory, which JSON.stringify writes as {}.
+    filesWithUserChanges: {},
+  }
+  return { thread, lost: [...drops].map(([what, n]) => `${what} (${n})`), expect: { users, calls } }
+}
+
+export const newThreadId = () => randomUUID()

package/src/adapters/void/writer.ts

@@ -0,0 +1,93 @@
+import { Database } from "bun:sqlite"
+import { mkdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { exists, isRunning, readJson } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { backup, shellQuote } from "../vscode-copilot/shared.ts"
+import { itemValue } from "./reader.ts"
+import { KEY, LABEL, TOOL, dbPath, newThreadId, parseThreads, planThread, toPortable } from "./records.ts"
+
+// Continues a portable session as a new Void chat thread: the thread is added to the JSON value Void keeps
+// all threads in, in its global state.vscdb. Void holds that value in memory and writes all of it back on
+// every change, so this runs only with Void closed, and backs the database up first.
+
+/** Void releases this writer was checked against (the source at 1.4.9). */
+export const TESTED_VOID = ["1.4"]
+
+/** The installed Void's version (product.json voidVersion). */
+export function installedVoid(home: string): string | undefined {
+  for (const root of ["/Applications", join(home, "Applications")]) {
+    const p = readJson<{ voidVersion?: string; version?: string }>(join(root, "Void.app", "Contents", "Resources", "app", "product.json"))
+    if (p) return p.voidVersion ?? p.version ?? "unknown"
+  }
+  return undefined
+}
+
+const line = (v: string | undefined) => v?.match(/\d+\.\d+/)?.[0]
+
+/** The Void writer; `version` and `running` are for tests, which must not depend on the installed app. */
+export function voidWriter(opts: { version?: string | null; running?: () => boolean } = {}): Writer {
+  const version = (home: string) => (opts.version === undefined ? installedVoid(home) : (opts.version ?? undefined))
+  const running = opts.running ?? (() => isRunning("Void"))
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = version(w.home)
+      if (!v) return { ok: false, why: "Void is not installed (no Void.app in /Applications or ~/Applications)" }
+      if (!TESTED_VOID.includes(line(v) ?? "")) return { ok: false, why: `Void ${v} is not a version this writer was checked against (${TESTED_VOID.join(", ")})` }
+      if (running()) return { ok: false, why: "Void is running; quit it first (it rewrites all chat threads from memory)" }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      if (!w.dryRun && running()) throw new Error("Void is running; quit it first")
+      const db = dbPath(w.home)
+      const threadId = newThreadId()
+      const plan = planThread(session, { threadId, now: new Date() })
+      // What Void will read back, checked before anything is written.
+      const back = toPortable(parseThreads(JSON.stringify({ [threadId]: plan.thread }))[threadId], db)
+      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 thread did not read back intact (${n.user} of ${plan.expect.users} messages, ${n.tool_call} of ${plan.expect.calls} tool calls)`)
+      let backedUp: string | undefined
+      if (!w.dryRun) {
+        if (exists(db)) backedUp = backup(w.home, TOOL, [db])
+        else mkdirSync(dirname(db), { recursive: true })
+        const conn = new Database(db, { create: true })
+        try {
+          // The schema VS Code (and so Void) creates; a no-op on an existing store.
+          conn.exec("CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB)")
+          conn.transaction(() => {
+            const text = itemValue(conn, KEY)
+            // Parsed without reviving URIs, so every other thread is written back exactly as Void stored it.
+            const threads = text ? JSON.parse(text) : {}
+            if (typeof threads !== "object" || threads === null || Array.isArray(threads)) throw new Error(`Void's thread store in ${db} is not the format this writer knows`)
+            threads[threadId] = plan.thread
+            conn.query("INSERT OR REPLACE INTO ItemTable (key, value) VALUES (?, ?)").run(KEY, JSON.stringify(threads))
+          })()
+        } finally {
+          conn.close()
+        }
+      }
+      const first = (plan.thread.messages as Array<{ role: string; displayContent?: string }>).find((m) => m.role === "user")?.displayContent ?? ""
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId: threadId,
+        written: [db],
+        open: `open -a Void ${shellQuote(w.cwd)}`,
+        note: `In Void's chat, open the thread history and pick the thread that starts "${first.replace(/\s+/g, " ").slice(0, 60)}".${backedUp ? ` Void's state.vscdb was backed up to ${backedUp}.` : ""}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const voidNativeWriter = voidWriter()