@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/iflow-cli/records.ts

@@ -0,0 +1,215 @@
+import { readFileSync } from "node:fs"
+import { resolve } from "node:path"
+import type { SessionHeader, Turn } from "../../session/types.ts"
+import { asText, clip, iso, noteModel, toolKindOf, type lossCounter } from "../../session/util.ts"
+import { CONTINUED_NOTE, idMaker, type PartList, resultText, snapshotText } from "../gemini-cli/records.ts"
+
+// Facts about iFlow CLI's session records, shared by its reader and writer. iFlow CLI is a Gemini CLI fork
+// that records sessions in Claude Code's shape. Checked against its last release, 0.5.19 (bundle/iflow.js:
+// the session message builder, the JSONL storage, and the resume path that turns records back into the
+// screen's history and the model's).
+//
+// A session is ~/.iflow/projects/<project name>/session-<uuid>.jsonl (IFLOW_HOME moves ~/.iflow), one record
+// per line, linked by uuid/parentUuid. The loader sorts records by timestamp and starts from the last
+// compression record. type "user" holds the person's text (a string, or text and image blocks), a tool
+// result (a tool_result block whose content is the tool's response object, plus toolUseResult), a
+// compression summary (isCompactSummary) or a hidden note (isMeta); type "assistant" holds a Claude-style
+// message whose content is text and tool_use blocks. iFlow keeps no reasoning in its records.
+
+export const TOOL = "iflow-cli"
+export const LABEL = "iFlow CLI"
+
+/** What iFlow CLI writes in every record's `version` (process.env.IFLOW_CLI_VERSION, which it never sets). */
+export const RECORD_VERSION = "1.0.0"
+
+/** iFlow CLI's project folder name (ProjectNameGenerator.fromPath). */
+export function projectName(cwd: string): string {
+  let n = resolve(cwd)
+    .replace(/^\//, "")
+    .replace(/\\/g, "-")
+    .replace(/\//g, "-")
+    .replace(/:/g, "-")
+    .replace(/\s+/g, "-")
+    .replace(/[^\w\-_.]/g, "-")
+  if (!n.startsWith("-")) n = `-${n}`
+  n = n.replace(/-+/g, "-")
+  return n || "-unnamed-project"
+}
+
+export type Block =
+  | { type: "text"; text: string }
+  | { type: "image"; source?: { type?: string; media_type?: string; data?: string } }
+  | { type: "tool_use"; id: string; name: string; input: unknown }
+  | { type: "tool_result"; tool_use_id: string; content: unknown }
+  | { type: "thinking"; thinking?: string }
+
+export interface IflowRecord {
+  uuid: string
+  parentUuid: string | null
+  sessionId: string
+  timestamp: string
+  type: "user" | "assistant"
+  isSidechain?: boolean
+  userType?: string
+  message: { role: string; content: string | Block[]; id?: string; type?: string; model?: string; stop_reason?: null | string; stop_sequence?: null | string; usage?: { input_tokens?: number; output_tokens?: number } }
+  cwd?: string
+  gitBranch?: string | null
+  version?: string
+  toolUseResult?: { toolName?: string; status?: string; timestamp?: number }
+  isCompactSummary?: boolean
+  compressionInfo?: { originalTokenCount?: number; newTokenCount?: number; summary?: string }
+  isMeta?: boolean
+}
+
+/** The note that ends the first message of a session brain continued, with the blank line before it. */
+const NOTE_SUFFIX = /(?:^|\n\n)(\[This session continues [^\n]*\])$/
+
+/** Text without brain's note, and the source session it names. */
+export function stripNote(text: string): { text: string; source?: string } {
+  const m = text.match(NOTE_SUFFIX)
+  const source = m?.[1]!.match(CONTINUED_NOTE)?.[1]
+  return source ? { text: text.slice(0, m!.index), source } : { text }
+}
+
+const isObj = (v: unknown): v is Record<string, any> => typeof v === "object" && v !== null && !Array.isArray(v)
+
+/** A session file's records in the order iFlow loads them: by timestamp, file order breaking ties. */
+export function readRecords(path: string): { records: IflowRecord[]; bad: number } {
+  let text: string
+  try {
+    text = readFileSync(path, "utf8")
+  } catch {
+    return { records: [], bad: 0 }
+  }
+  const rows: Array<{ r: IflowRecord; i: number }> = []
+  let bad = 0
+  text.split("\n").forEach((line, i) => {
+    if (!line.trim()) return
+    try {
+      const r = JSON.parse(line)
+      if (isObj(r) && (r.type === "user" || r.type === "assistant") && isObj(r.message)) rows.push({ r: r as IflowRecord, i })
+      else bad++
+    } catch {
+      bad++
+    }
+  })
+  const time = (r: IflowRecord) => {
+    const t = Date.parse(r.timestamp)
+    return Number.isFinite(t) ? t : 0
+  }
+  rows.sort((a, b) => time(a.r) - time(b.r) || a.i - b.i)
+  return { records: rows.map((x) => x.r), bad }
+}
+
+/** iFlow's own names for tools whose kind toolKindOf cannot tell from the name. */
+const KIND: Record<string, Extract<Turn, { kind: "tool_call" }>["toolKind"]> = { replace: "edit" }
+
+/** A tool result's text and whether it failed: the tool's response object (responseParts), or plain text. */
+function resultOf(content: unknown, status: string | undefined): { text: string; ok: boolean } {
+  const failed = status !== undefined && status !== "success"
+  if (isObj(content)) {
+    if (content.responseParts !== undefined) {
+      const r = resultText(content.responseParts as PartList)
+      const error = content.error ? asText(isObj(content.error) ? content.error.message ?? content.error : content.error) : ""
+      return { text: r.text || error || (typeof content.resultDisplay === "string" ? content.resultDisplay : ""), ok: r.ok && !error && !failed }
+    }
+    if (typeof content.resultDisplay === "string") return { text: content.resultDisplay, ok: !failed }
+  }
+  return { text: asText(content), ok: !failed }
+}
+
+/** The portable turns of a session's records; `h` gets its models, version and source note. */
+export function recordsToTurns(records: IflowRecord[], h: SessionHeader, lost: ReturnType<typeof lossCounter>): Turn[] {
+  const turns: Turn[] = []
+  const newId = idMaker()
+  // iFlow's own call ids, to the turn ids given to them, while a call waits for its result.
+  const waiting = new Map<string, Extract<Turn, { kind: "tool_call" }>>()
+  for (const r of records) {
+    const at = iso(r.timestamp)
+    const content = r.message.content
+    const blocks: Block[] = typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : []
+    if (r.version && r.version !== RECORD_VERSION && !h.toolVersion) h.toolVersion = r.version
+    if (r.isSidechain) {
+      lost.add("subagent records")
+      continue
+    }
+    if (r.type === "assistant") {
+      noteModel(h, r.message.model)
+      let text = ""
+      const flush = () => {
+        if (text.trim()) turns.push({ kind: "assistant", ...(at ? { at } : {}), text, ...(r.message.model ? { model: r.message.model } : {}) })
+        text = ""
+      }
+      for (const b of blocks) {
+        if (b.type === "text") text += text ? `\n${b.text}` : b.text
+        else if (b.type === "thinking") {
+          flush()
+          if (b.thinking?.trim()) turns.push({ kind: "reasoning", ...(at ? { at } : {}), text: b.thinking })
+        } else if (b.type === "tool_use") {
+          flush()
+          const call = { kind: "tool_call" as const, ...(at ? { at } : {}), id: newId(b.id), name: b.name, toolKind: KIND[b.name] ?? toolKindOf(b.name), input: b.input ?? {} }
+          waiting.set(b.id, call)
+          turns.push(call)
+        }
+      }
+      flush()
+      const u = r.message.usage
+      const last = [...turns].reverse().find((t) => t.kind === "assistant") as Extract<Turn, { kind: "assistant" }> | undefined
+      if (u && last && last.at === at && (u.input_tokens || u.output_tokens)) last.usage = { input: u.input_tokens ?? 0, output: u.output_tokens ?? 0 }
+      continue
+    }
+    if (r.isCompactSummary) {
+      const text = r.compressionInfo?.summary ?? stripNote(blocks.map((b) => (b.type === "text" ? b.text : "")).join("")).text
+      const note = stripNote(typeof content === "string" ? content : "")
+      if (note.source) h.parent = { id: note.source, kind: "continued" }
+      turns.push({ kind: "compaction", ...(at ? { at } : {}), summary: text })
+      continue
+    }
+    if (r.isMeta) {
+      lost.add("iFlow CLI meta messages")
+      continue
+    }
+    const results = blocks.filter((b): b is Extract<Block, { type: "tool_result" }> => b.type === "tool_result")
+    if (results.length) {
+      for (const b of results) {
+        const call = waiting.get(b.tool_use_id)
+        if (!call) {
+          lost.add("tool results without a call")
+          continue
+        }
+        waiting.delete(b.tool_use_id)
+        const res = resultOf(b.content, r.toolUseResult?.status)
+        const c = clip(res.text)
+        turns.push({ kind: "tool_result", ...(at ? { at } : {}), callId: call.id, ok: res.ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+      }
+      continue
+    }
+    let text = blocks.map((b) => (b.type === "text" ? b.text : "")).join("")
+    const note = stripNote(text)
+    if (note.source) {
+      h.parent = { id: note.source, kind: "continued" }
+      text = note.text
+    }
+    // A summary brain wrote for a compacted session, in the form Gemini CLI's compression writes.
+    const summary = snapshotText(text)
+    if (summary !== undefined) {
+      turns.push({ kind: "compaction", ...(at ? { at } : {}), summary })
+      continue
+    }
+    const images = blocks.filter((b) => b.type === "image").length
+    if (images) lost.add("inline images", images)
+    if (text.trim()) turns.push({ kind: "user", ...(at ? { at } : {}), text })
+  }
+  // Calls that never got a result (iFlow records only successful ones) are closed as failed, after the call.
+  if (waiting.size) {
+    lost.add("tool results not recorded", waiting.size)
+    const open = new Set(waiting.values())
+    const out: Turn[] = []
+    for (const t of turns) {
+      out.push(t)
+      if (t.kind === "tool_call" && open.has(t)) out.push({ kind: "tool_result", ...(t.at ? { at: t.at } : {}), callId: t.id, ok: false, output: "(no result recorded: iFlow CLI keeps only successful results)" })
+    }
+    return out
+  }
+  return turns
+}

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

@@ -0,0 +1,204 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, gitInfo, isDir, readJson, versionOf } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { countTurns, header, lossCounter, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { ALIASES, type Call, clock, drops, imageData, mapCall, realCwd, regroup, resultOutput, shellQuote, type ToolSpec } from "../gemini-cli/exchanges.ts"
+import { continuedNote, snapshotOf } from "../gemini-cli/records.ts"
+import { type Block, type IflowRecord, LABEL, projectName, RECORD_VERSION, readRecords, recordsToTurns, TOOL } from "./records.ts"
+
+// Continues a portable session in iFlow CLI as a new session of its own: projects/<project name>/
+// session-<uuid>.jsonl under ~/.iflow, with the session added to config/projects.json as iFlow's
+// createSession adds it. Records are built the way its session message builder builds them, so
+// `iflow --resume <id>` loads the file (checked by running 0.5.19's own loader code, taken from its bundle).
+//
+// The person's messages are string content; a model response is one assistant record of text and tool_use
+// blocks; each result is a user record holding a tool_result block with the tool's response object
+// (responseParts, resultDisplay) and toolUseResult, which is what iFlow's resume turns into a tool group.
+// A compacted session starts from its last summary, as iFlow loads its own from the last compression record
+// on. The summary is a <state_snapshot> user message, not iFlow's isCompactSummary record: resuming from that
+// record (rQ) gives the model the calls after it without their results, which the API rejects, while a plain
+// message goes through the resume that pairs every call with its result. iFlow keeps no reasoning.
+// iFlow hides isMeta messages from the model as well as the screen, so the note on where the session came
+// from ends the first message the model reads (the first user message, or the summary); at the end, the
+// session picker, which shows each session's first message, still shows the person's request.
+
+/** Versions this writer was checked against; others get the brief. 0.5.19 is iFlow CLI's last release. */
+export const TESTED_VERSIONS = ["0.5.19"]
+
+/** The installed iFlow CLI version ("0.5.19"), or undefined when it is not installed. */
+export const iflowVersion = (bin = "iflow") => versionOf(bin)?.match(/(\d+\.\d+\.\d+)/)?.[1]
+
+/** iFlow CLI's own tool for a portable call, by what the call does. */
+function iflowTool(call: Call): ToolSpec | undefined {
+  const input = (call.input ?? {}) as Record<string, unknown>
+  switch (call.toolKind) {
+    case "read":
+      return { name: "read_file", args: { absolute_path: ALIASES.file } }
+    case "edit":
+      return { name: "replace", args: { file_path: ALIASES.file, old_string: ALIASES.oldText, new_string: ALIASES.newText } }
+    case "write":
+      return { name: "write_file", args: { file_path: ALIASES.file, content: ALIASES.content } }
+    case "shell":
+      return { name: "run_shell_command", args: { command: ALIASES.command } }
+    case "search":
+      return { name: /glob/i.test(call.name) ? "glob" : "search_file_content", args: { pattern: ALIASES.pattern, path: ALIASES.dir } }
+    case "list":
+      return { name: "list_directory", args: { path: ALIASES.dir } }
+    case "web":
+      return ALIASES.url.some((k) => input[k] !== undefined) ? { name: "web_fetch", args: { url: ALIASES.url, prompt: ["prompt"] } } : { name: "web_search", args: { query: ALIASES.query } }
+    case "todo":
+      return { name: "todo_write", args: { todos: ["todos"] } }
+    default:
+      return undefined
+  }
+}
+
+export interface IflowPlan {
+  records: IflowRecord[]
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The records of the new session `sessionId` continuing `session`. Pure apart from reading attached images. */
+export function planRecords(session: Session, opts: { sessionId: string; cwd: string; gitBranch?: string; now: Date }): IflowPlan {
+  const { drop, list } = drops()
+  const exchanges = regroup(session, { fromLastCompaction: true, keepReasoning: false, drop })
+  const label = toolLabel(session.header.tool)
+  const stamp = clock(session, opts.now)
+  const note = continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10))
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const records: IflowRecord[] = []
+  let parent: string | null = null
+  let lastModel = session.header.models[session.header.models.length - 1] ?? "unknown"
+  let noted = false
+  const withNote = (text: string) => {
+    if (noted) return text
+    noted = true
+    return text ? `${text}\n\n${note}` : note
+  }
+  const where = { cwd: opts.cwd, gitBranch: opts.gitBranch ?? null, version: RECORD_VERSION }
+  const add = (at: string | undefined, r: Omit<IflowRecord, "uuid" | "parentUuid" | "sessionId" | "timestamp" | "isSidechain" | "userType">, withPlace = true) => {
+    const out = { uuid: randomUUID(), parentUuid: parent, sessionId: opts.sessionId, timestamp: stamp(at), isSidechain: false, userType: "external", ...r, ...(withPlace ? where : {}) } as IflowRecord
+    records.push(out)
+    parent = out.uuid
+    return out
+  }
+
+  // A session that opens with the model gets the note on its own first.
+  if (exchanges[0]?.kind === "model") add(exchanges[0].at, { type: "user", message: { role: "user", content: withNote("") } })
+  for (const x of exchanges) {
+    if (x.kind === "user") {
+      let text = x.text
+      const images: Block[] = []
+      for (const a of x.attachments) {
+        if (a.kind === "file") {
+          if (a.path) text += `\n\n[Attached file: ${a.path}]`
+          continue
+        }
+        const img = imageData(a)
+        if (img) images.push({ type: "image", source: { type: "base64", media_type: img.mimeType, data: img.data } })
+        else if (a.path) drop("images that could not be attached")
+      }
+      if (!text.trim() && !images.length) continue
+      const body = withNote(text)
+      add(x.at, { type: "user", message: { role: "user", content: images.length ? [{ type: "text", text: body }, ...images] : body } })
+      if (text.trim()) expect.users++
+    } else if (x.kind === "compaction") {
+      add(x.at, { type: "user", message: { role: "user", content: withNote(snapshotOf(label, x.summary)) } })
+    } else {
+      if (x.model) lastModel = x.model
+      const calls = x.calls.map((a) => ({ a, id: `call_${randomUUID().replace(/-/g, "").slice(0, 24)}`, ...mapCall(a.call, iflowTool(a.call)) }))
+      const content: Block[] = [...(x.text.trim() ? [{ type: "text" as const, text: x.text }] : []), ...calls.map((c) => ({ type: "tool_use" as const, id: c.id, name: c.name, input: c.args }))]
+      if (!content.length) continue
+      const usage = { input_tokens: (x.usage?.input ?? 0) + (x.usage?.cacheRead ?? 0), output_tokens: x.usage?.output ?? 0 }
+      // Assistant records carry no cwd, branch or version, as iFlow writes them.
+      add(x.at, { type: "assistant", message: { id: `msg-${randomUUID()}`, type: "message", role: "assistant", content, model: lastModel, stop_reason: null, stop_sequence: null, usage } }, false)
+      if (x.text.trim()) expect.assistants++
+      for (const c of calls) {
+        if (!c.a.result) drop("tool calls without a result (closed as errors)")
+        if (c.a.edits.length) drop("file edit diffs", c.a.edits.length)
+        const ok = c.a.result?.ok ?? false
+        const output = resultOutput(c.a.result)
+        const response = { callId: c.id, responseParts: [{ functionResponse: { id: c.id, name: c.name, response: ok ? { output } : { error: output } } }], resultDisplay: output }
+        const r = add(c.a.result?.at ?? c.a.call.at, { type: "user", message: { role: "user", content: [{ tool_use_id: c.id, type: "tool_result", content: response }] }, toolUseResult: { toolName: c.name, status: ok ? "success" : "error" } })
+        r.toolUseResult!.timestamp = Date.parse(r.timestamp)
+        expect.calls++
+      }
+    }
+  }
+  if (!records.length) throw new Error("nothing iFlow CLI can resume: the session has no messages")
+  return { records, lost: list(), expect }
+}
+
+/** Adds the session to config/projects.json as createSession does, replacing the file in one step. */
+function register(home: string, project: string, sessionId: string, now: Date) {
+  const file = join(home, ".iflow", "config", "projects.json")
+  mkdirSync(join(home, ".iflow", "config"), { recursive: true })
+  const data = readJson<Record<string, { name?: string; path?: string; sessions?: string[]; createdAt?: string; lastActivity?: string }>>(file) ?? {}
+  const entry = data[project] ?? { name: project, path: project, sessions: [], createdAt: now.toISOString() }
+  data[project] = { ...entry, sessions: [...(entry.sessions ?? []), sessionId], lastActivity: now.toISOString() }
+  const tmp = `${file}.${randomUUID()}.tmp`
+  writeFileSync(tmp, JSON.stringify(data, null, 2))
+  renameSync(tmp, file)
+}
+
+/** The iFlow CLI writer; `version` and `bin` are for tests, which must not depend on the installed binary. */
+export function iflowWriter(opts: { bin?: string; version?: string } = {}): Writer {
+  const installed = () => opts.version ?? iflowVersion(opts.bin)
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "iFlow CLI is not installed (`iflow --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `iFlow 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; iFlow CLI lists and resumes sessions per project folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = realCwd(w.cwd)
+      const project = projectName(cwd)
+      const dir = join(w.home, ".iflow", "projects", project)
+      let sessionId = `session-${randomUUID()}`
+      while (exists(join(dir, `${sessionId}.jsonl`))) sessionId = `session-${randomUUID()}`
+      const path = join(dir, `${sessionId}.jsonl`)
+      const now = new Date()
+      const branch = gitInfo(cwd, w.home).gitBranch
+      const plan = planRecords(session, { sessionId, cwd, now, ...(branch ? { gitBranch: branch } : {}) })
+      if (!w.dryRun) {
+        mkdirSync(dir, { recursive: true })
+        // "wx": a new file only; an existing session is never touched.
+        writeFileSync(path, `${plan.records.map((r) => JSON.stringify(r)).join("\n")}\n`, { flag: "wx" })
+        const h = header(TOOL, sessionId)
+        const turns = recordsToTurns(readRecords(path).records, h, lossCounter())
+        const got = countTurns({ header: h, turns })
+        const pairs = unpaired({ header: h, turns })
+        if (got.user !== plan.expect.users || got.assistant !== plan.expect.assistants || got.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length) {
+          rmSync(path, { force: true })
+          throw new Error(`the new iFlow CLI session did not read back as written (users ${got.user}/${plan.expect.users}, replies ${got.assistant}/${plan.expect.assistants}, tool calls ${got.tool_call}/${plan.expect.calls}); nothing was kept`)
+        }
+        register(w.home, project, sessionId, now)
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId,
+        written: [path, join(w.home, ".iflow", "config", "projects.json")],
+        open: `cd ${shellQuote(cwd)} && iflow --resume ${sessionId}`,
+        note: "iFlow CLI's service shut down on 2026-04-17, so the session opens but its models may no longer answer.",
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const iflowNativeWriter = iflowWriter()

package/src/adapters/index.ts

@@ -0,0 +1,112 @@
+import type { Reader, Writer } from "./types.ts";
+import * as claudeCode from "./claude-code/index.ts";
+import * as codex from "./codex/index.ts";
+import * as cursorIde from "./cursor-ide/index.ts";
+import * as cursorCli from "./cursor-cli/index.ts";
+import * as geminiCli from "./gemini-cli/index.ts";
+import * as vscodeCopilot from "./vscode-copilot/index.ts";
+import * as copilotCli from "./copilot-cli/index.ts";
+import * as cline from "./cline/index.ts";
+import * as opencode from "./opencode/index.ts";
+import * as aider from "./aider/index.ts";
+import * as amazonQCli from "./amazon-q-cli/index.ts";
+import * as amazonQIde from "./amazon-q-ide/index.ts";
+import * as auggie from "./auggie/index.ts";
+import * as cline4 from "./cline4/index.ts";
+import * as codebuff from "./codebuff/index.ts";
+import * as continueAdapter from "./continue/index.ts";
+import * as crush from "./crush/index.ts";
+import * as factoryDroid from "./factory-droid/index.ts";
+import * as goose from "./goose/index.ts";
+import * as grokCli from "./grok-cli/index.ts";
+import * as iflowCli from "./iflow-cli/index.ts";
+import * as kiloCli from "./kilo-cli/index.ts";
+import * as kiloCode from "./kilo-code/index.ts";
+import * as kimi from "./kimi/index.ts";
+import * as kiroCli from "./kiro-cli/index.ts";
+import * as kiroIde from "./kiro-ide/index.ts";
+import * as letta from "./letta/index.ts";
+import * as mistralVibe from "./mistral-vibe/index.ts";
+import * as openhands from "./openhands/index.ts";
+import * as pearai from "./pearai/index.ts";
+import * as pi from "./pi/index.ts";
+import * as qoderCli from "./qoder-cli/index.ts";
+import * as qwenCode from "./qwen-code/index.ts";
+import * as tabnineCli from "./tabnine-cli/index.ts";
+import * as voidAdapter from "./void/index.ts";
+import * as zed from "./zed/index.ts";
+import * as antigravity from "./antigravity/index.ts";
+import * as devin from "./devin/index.ts";
+import * as hermes from "./hermes/index.ts";
+import * as mastracode from "./mastracode/index.ts";
+import * as muse from "./muse/index.ts";
+import * as omp from "./omp/index.ts";
+import { briefWriter, briefWriters } from "../brief-writers.ts";
+
+// Every adapter. Each module exports the readers and writers for one tool or format family; a tool with
+// no native or import writer is still a target through the continuation brief (brief-writers.ts).
+const MODULES = [
+  claudeCode,
+  codex,
+  cursorIde,
+  cursorCli,
+  geminiCli,
+  vscodeCopilot,
+  copilotCli,
+  cline,
+  opencode,
+  aider,
+  amazonQCli,
+  amazonQIde,
+  auggie,
+  cline4,
+  codebuff,
+  continueAdapter,
+  crush,
+  factoryDroid,
+  goose,
+  grokCli,
+  iflowCli,
+  kiloCli,
+  kiloCode,
+  kimi,
+  kiroCli,
+  kiroIde,
+  letta,
+  mistralVibe,
+  openhands,
+  pearai,
+  pi,
+  qoderCli,
+  qwenCode,
+  tabnineCli,
+  voidAdapter,
+  zed,
+  antigravity,
+  devin,
+  hermes,
+  mastracode,
+  muse,
+  omp,
+];
+
+export const READERS: Reader[] = MODULES.flatMap((m) => m.readers);
+
+const OWN: Writer[] = MODULES.flatMap((m) => m.writers);
+const BRIEFED = new Set(briefWriters.map((w) => w.tool));
+/**
+ * Every other target with its own writer gets the brief too, as the last resort: when its native or import writer is not
+ * ready (the tool missing, or a version that format was never checked on), the session still goes there as a brief.
+ */
+const FALLBACK_BRIEFS: Writer[] = [...new Map(OWN.filter((w) => !BRIEFED.has(w.tool)).map((w) => [w.tool, w.label] as const))].map(([tool, label]) => briefWriter(tool, label));
+
+/** Native and import writers first, so a target that has one prefers it over the brief. */
+export const WRITERS: Writer[] = [...OWN, ...briefWriters, ...FALLBACK_BRIEFS];
+
+export const readerFor = (tool: string) => READERS.find((r) => r.tool === tool);
+
+/** The writers that can continue a session in `target`, best way first: native, then import, then brief. */
+export function writersFor(target: string): Writer[] {
+  const order = { native: 0, import: 1, brief: 2 } as const;
+  return WRITERS.filter((w) => w.tool === target).sort((a, b) => order[a.way] - order[b.way]);
+}

package/src/adapters/kilo-cli/index.ts

@@ -0,0 +1,21 @@
+import type { Reader, Writer } from "../types.ts"
+import { familyReader } from "../opencode/reader.ts"
+import { KILO_V1 } from "../opencode/tools.ts"
+import { importWriter, type Target } from "../opencode/writer.ts"
+
+// Kilo CLI 7.x (Kilo-Org/kilocode), an OpenCode fork: the OpenCode 1.x session, message and part tables in
+// ~/.local/share/kilo/kilo.db (kilo-<channel>.db on other channels), and OpenCode's export/import JSON with
+// the same schema (packages/schema/src/v1/session.ts; packages/opencode/src/cli/cmd/import.ts). So it reads
+// with OpenCode's reader and continues a session through `kilo import`, verified live on 7.8.27 (temp home,
+// no network): import, then `kilo session list` and `kilo export`. On 7.8.28 the wire harness (wire/run.ts kilo-cli) imports
+// and continues the session with the real binary against a fake model server, plain and compacted.
+//
+// Checked against a real Kilo 7.5.0 export (session-migrate's capture, test/native-corpus-stores.test.ts): its default agent is
+// `code` (OpenCode's is `build`), so the session is written with that agent.
+//
+// A signed-in Kilo also syncs every new session, an imported one included, to Kilo's cloud (KiloSessions).
+
+export const KILO_TARGET: Target = { tool: "kilo-cli", label: "Kilo CLI", bin: "kilo", installDir: ".kilo", tested: ["7.8.27", "7.8.28"], slug: true, dialect: KILO_V1 }
+
+export const readers: Reader[] = [familyReader({ tool: "kilo-cli", label: "Kilo CLI", app: "kilo", sqlite: true })]
+export const writers: Writer[] = [importWriter(KILO_TARGET)]

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

@@ -0,0 +1,11 @@
+import type { Reader, Writer } from "../types.ts"
+import { taskReader } from "../cline/reader.ts"
+import { kiloCodeWriters } from "./writer.ts"
+
+// The Kilo Code extension. Its 7.x sessions live in the Kilo CLI's database, which the kilo-cli reader already
+// lists (listing them here too would show each twice), so this reader covers what only the extension has: the
+// Cline-style task folders of Kilo Code before 7.0 (a Roo Code fork), in <app>/User/globalStorage/kilocode.kilo-code/
+// tasks, which 7.x still reads for its legacy migration (packages/kilo-vscode/src/legacy-migration). The writer
+// continues a session as a 7.x session through the extension's bundled CLI (writer.ts).
+export const readers: Reader[] = [taskReader({ tool: "kilo-code", label: "Kilo Code", extension: "kilocode.kilo-code" })]
+export const writers: Writer[] = kiloCodeWriters

package/src/adapters/kilo-code/writer.ts

@@ -0,0 +1,92 @@
+import { mkdirSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { exists, isDir, ls, readJson } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { HOSTS, compareVersions } from "../cline/records.ts"
+import { buildExport, continuedTitle, projectIdOf, sh } from "../opencode/writer.ts"
+import { OPENCODE_V1 } from "../opencode/tools.ts"
+
+// Continuing a session in the Kilo Code extension (kilocode.kilo-code 7.x). The extension no longer keeps
+// Cline-style task folders: it runs the Kilo CLI it bundles (<extension>/bin/kilo serve, with
+// KILO_DISABLE_CHANNEL_DB=true; packages/kilo-vscode/src/services/cli-backend/server-manager.ts), so its sessions
+// are the CLI's, in ~/.local/share/kilo/kilo.db, and its panel lists them with session.list({directory, roots}).
+// So the session is written as the export bundle Kilo's own importer takes (the OpenCode 1.x format the Kilo CLI
+// writer also uses, ../opencode/writer.ts), and `open` runs the bundled binary's `import` from the folder, with
+// the same environment the extension gives it, so the session lands in the store the panel reads.
+//
+// Verified live on the 7.8.27 and 7.8.28 binaries (the extension and the CLI are released together, from one
+// monorepo at one version): import, then the extension's own listing and message routes on `kilo serve`, in a
+// temp home with outbound network denied.
+
+const EXTENSION = "kilocode.kilo-code"
+export const TESTED_VERSIONS = ["7.8.27", "7.8.28"]
+
+/** The installed extension's folder and version in an app: extensions.json names the active copy; else the newest folder. */
+export function installedExtension(home: string, app: string): { dir: string; version: string } | undefined {
+  const host = HOSTS.find((h) => h.app === app)
+  if (!host) return undefined
+  const root = join(home, host.extensions)
+  const manifest = readJson<Array<{ identifier?: { id?: string }; version?: string; relativeLocation?: string; location?: { path?: string } }>>(join(root, "extensions.json"))
+  const entry = Array.isArray(manifest) ? manifest.find((e) => e?.identifier?.id?.toLowerCase() === EXTENSION && typeof e.version === "string") : undefined
+  if (entry?.version) {
+    const dir = entry.relativeLocation ? join(root, entry.relativeLocation) : entry.location?.path
+    if (dir && isDir(dir)) return { dir, version: entry.version }
+  }
+  const found = ls(root)
+    .map((d) => ({ d, v: d.match(/^kilocode\.kilo-code-(\d+\.\d+\.\d+)/i)?.[1] }))
+    .filter((x): x is { d: string; v: string } => !!x.v)
+    .sort((a, b) => compareVersions(a.v, b.v))
+    .at(-1)
+  return found ? { dir: join(root, found.d), version: found.v } : undefined
+}
+
+export function kiloCodeWriter(app: string): Writer {
+  const host = HOSTS.find((h) => h.app === app)!
+  const tool = app === "Code" ? "kilo-code" : `kilo-code-${app.toLowerCase()}`
+  const label = app === "Code" ? "Kilo Code" : `Kilo Code (${app})`
+  const where = app === "Code" ? "VS Code" : app
+  const binOf = (dir: string) => join(dir, "bin", process.platform === "win32" ? "kilo.exe" : "kilo")
+
+  return {
+    tool,
+    label,
+    way: "import",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const ext = installedExtension(w.home, app)
+      if (!ext) return { ok: false, why: `Kilo Code is not installed in ${where}` }
+      if (compareVersions(ext.version, "7.0.0") < 0) return { ok: false, why: `Kilo Code ${ext.version} keeps Cline-style tasks; this writer targets the 7.x extension, which runs the Kilo CLI` }
+      if (!TESTED_VERSIONS.includes(ext.version)) return { ok: false, why: `Kilo Code ${ext.version} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!exists(binOf(ext.dir))) return { ok: false, why: `Kilo Code ${ext.version} has no bundled CLI at ${binOf(ext.dir)}` }
+      if (!isDir(w.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${w.cwd}` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const ext = installedExtension(w.home, app)
+      const version = ext?.version ?? TESTED_VERSIONS.at(-1)!
+      const bin = ext ? binOf(ext.dir) : `<${where} extensions>/kilocode.kilo-code-${version}/bin/kilo`
+      const { bundle, sessionId, lost } = buildExport(session, { label: "Kilo Code", dialect: OPENCODE_V1, cwd: w.cwd, version, projectID: projectIdOf(w.cwd, "kilo"), slug: true })
+      const file = join(w.home, ".brain", "exports", `${tool}-${sessionId}.json`)
+      if (!w.dryRun) {
+        mkdirSync(dirname(file), { recursive: true })
+        writeFileSync(file, `${JSON.stringify(bundle, null, 2)}\n`)
+      }
+      return {
+        tool,
+        way: "import",
+        sessionId,
+        written: [file],
+        // The importer files the session under the project of the folder it runs in; the channel setting is the
+        // extension's own, so the session goes to the database its panel reads.
+        open: `cd ${sh(w.cwd)} && KILO_DISABLE_CHANNEL_DB=true ${sh(bin)} import ${sh(file)} && ${host.cli} ${sh(w.cwd)}`,
+        note: `In ${where}, open Kilo Code's session history and pick "${continuedTitle(session).slice(0, 80)}".`,
+        lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const kiloCodeWriters: Writer[] = ["Code", "Cursor", "Windsurf"].map(kiloCodeWriter)