@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/continue/records.ts

@@ -0,0 +1,418 @@
+import { randomUUID } from "node:crypto"
+import { join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import type { Session, ToolKind, Turn } from "../../session/types.ts"
+import { asText, clip, firstUserText, header, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import { CONTINUED_NOTE, continuedNote } from "../claude-code/records.ts"
+import { imageData } from "../gemini-cli/exchanges.ts"
+import { fileUri } from "../vscode-copilot/writer.ts"
+import { ARG, type ToolMap, asArgs, mapTool, pick, safeToolName } from "../vscode-copilot/shared.ts"
+
+// Continue's session store, which its VS Code and JetBrains extensions and its `cn` CLI share, and the
+// older copy of it PearAI's chat still uses. Checked against continuedev/continue main (core/util/history.ts,
+// gui/src/redux/util/constructMessages.ts, core/util/messageConversion.ts, extensions/cli/src/session.ts
+// and compaction.ts) and trypear/pearai-submodule main (core/util/history.ts, core/llm/constructMessages.ts):
+//
+// - <dir>/sessions/<sessionId>.json: {sessionId, title, workspaceDirectory, history: ChatHistoryItem[], mode?}.
+// - <dir>/sessions/sessions.json: the list both history views and `cn ls` read, in creation order, one
+//   {sessionId, title, dateCreated (epoch ms as a string), workspaceDirectory, messageCount} per session.
+//   Entries with a string `session_id` are the pre-2024 format and are skipped.
+//
+// A history item is {message, contextItems, ...}. In Continue an assistant message carries its tool calls
+// (message.toolCalls) and the item their states and outputs (toolCallStates); the model is sent one tool
+// message per state, rebuilt from it, so no separate tool items are written (the CLI would send them twice).
+// The note that the session was carried over rides as a context item on a user message: both extensions
+// and the CLI send a context item's content to the model ahead of the message, and the chat shows it as an
+// attachment, not as the person's words. A compaction is an assistant item whose `conversationSummary` is
+// set, as the CLI writes one: the GUI sends only what follows the last such item, with the summary in the
+// system message.
+
+type Json = Record<string, any>
+const isObj = (v: unknown): v is Json => typeof v === "object" && v !== null && !Array.isArray(v)
+/** The index of the last element matching `ok`, or -1 (the project's lib predates findLastIndex). */
+function lastIndex<T>(xs: T[], ok: (x: T) => boolean): number {
+  for (let i = xs.length - 1; i >= 0; i--) if (ok(xs[i]!)) return i
+  return -1
+}
+
+/** What differs between Continue's store and PearAI's older copy of it. */
+export interface Flavor {
+  tool: string
+  label: string
+  /** The folder under home: CONTINUE_GLOBAL_DIR's default. */
+  dir: string
+  /** Continue's format: tool calls, thinking and summaries as records. PearAI's messages are text only. */
+  structured: boolean
+  /** Continue's VS Code extension stores the workspace as a file:// URI; PearAI and the CLI as a path. */
+  uriWorkspace: boolean
+}
+
+export const CONTINUE: Flavor = { tool: "continue", label: "Continue", dir: ".continue", structured: true, uriWorkspace: true }
+export const PEARAI: Flavor = { tool: "pearai", label: "PearAI", dir: ".pearai", structured: false, uriWorkspace: false }
+
+export const sessionsDir = (home: string, f: Flavor) => join(home, f.dir, "sessions")
+export const listPath = (home: string, f: Flavor) => join(sessionsDir(home, f), "sessions.json")
+
+const BRAIN_PROVIDER = "brain"
+
+/** Continue's own tool names (core/tools/builtIn.ts) by what they do; others fall back to the shared guess. */
+const KIND: Record<string, ToolKind> = {
+  read_file: "read",
+  read_file_range: "read",
+  read_currently_open_file: "read",
+  read_skill: "read",
+  edit_existing_file: "edit",
+  single_find_and_replace: "edit",
+  multi_edit: "edit",
+  create_new_file: "write",
+  run_terminal_command: "shell",
+  grep_search: "search",
+  file_glob_search: "search",
+  codebase: "search",
+  search_web: "web",
+  fetch_url_content: "web",
+  ls: "list",
+  view_subdirectory: "list",
+}
+export const continueKind = (name: string): ToolKind => KIND[name] ?? toolKindOf(name)
+
+/** A message's text: a string, or the text parts of a part list. */
+export function messageText(content: unknown): { text: string; images: number } {
+  if (typeof content === "string") return { text: content, images: 0 }
+  if (!Array.isArray(content)) return { text: "", images: 0 }
+  let images = 0
+  const text = content
+    .map((p) => {
+      if (isObj(p) && p.type === "text" && typeof p.text === "string") return p.text
+      if (isObj(p) && p.type === "imageUrl") images++
+      return ""
+    })
+    .filter(Boolean)
+    .join("\n")
+  return { text, images }
+}
+
+/** A workspace folder as a path, whether stored as a path or a file:// URI. */
+export function workspacePath(v: unknown): string | undefined {
+  if (typeof v !== "string" || !v) return undefined
+  if (!v.startsWith("file://")) return v
+  try {
+    return decodeURIComponent(new URL(v).pathname)
+  } catch {
+    return undefined
+  }
+}
+
+// --- Reading ---------------------------------------------------------------------------------------------
+
+/** One stored session as a portable session. `raw` is the parsed <sessionId>.json. */
+export function toPortable(raw: Json, f: Flavor, path: string, meta: { dateCreated?: string; mtime?: string } = {}): Session {
+  const lost = lossCounter()
+  const cwd = workspacePath(raw.workspaceDirectory)
+  const created = meta.dateCreated && /^\d+$/.test(meta.dateCreated) ? new Date(Number(meta.dateCreated)).toISOString() : undefined
+  const h = header(f.tool, String(raw.sessionId), {
+    ...(typeof raw.title === "string" ? { title: raw.title } : {}),
+    sourcePath: path,
+    project: cwd ? { cwd } : {},
+    ...(created ? { startedAt: created } : {}),
+    ...(meta.mtime ? { updatedAt: meta.mtime } : {}),
+  })
+  if (typeof raw.chatModelTitle === "string") noteModel(h, raw.chatModelTitle)
+  const turns: Turn[] = []
+  const history: Json[] = Array.isArray(raw.history) ? raw.history.filter(isObj) : []
+  // Results the GUI also keeps as separate tool items, for calls whose state has no output.
+  const toolItems = new Map<string, string>()
+  for (const item of history) if (item.message?.role === "tool" && typeof item.message.toolCallId === "string") toolItems.set(item.message.toolCallId, messageText(item.message.content).text)
+  const answered = new Set<string>()
+
+  for (const item of history) {
+    const m = item.message
+    if (!isObj(m)) continue
+    const { text, images } = messageText(m.content)
+    if (images) lost.add("images", images)
+    if (m.role === "user") {
+      const ctx = Array.isArray(item.contextItems) ? item.contextItems.filter(isObj) : []
+      const attachments = ctx
+        .filter((c) => c.id?.providerTitle !== BRAIN_PROVIDER)
+        .map((c) => (c.uri?.type === "file" && typeof c.uri.value === "string" ? workspacePath(c.uri.value) : undefined))
+      const kept = attachments.filter((p): p is string => !!p)
+      if (attachments.length > kept.length) lost.add("context items that are not files", attachments.length - kept.length)
+      // brain's note, as a context item or as a request of its own, says which session this continues.
+      const from = ctx.find((c) => c.id?.providerTitle === BRAIN_PROVIDER)?.id?.itemId ?? text.trim().match(CONTINUED_NOTE)?.[1]
+      if (from && !h.parent) h.parent = { id: String(from), kind: "continued" }
+      if (CONTINUED_NOTE.test(text.trim())) continue
+      if (text.trim() || kept.length) turns.push({ kind: "user", text, ...(kept.length ? { attachments: kept.map((p) => ({ kind: "file" as const, path: p })) } : {}) })
+    } else if (m.role === "thinking") {
+      if (m.signature || m.redactedThinking) lost.add("signed reasoning")
+      else if (text.trim()) turns.push({ kind: "reasoning", text })
+    } else if (m.role === "assistant") {
+      if (isObj(item.reasoning) && typeof item.reasoning.text === "string" && item.reasoning.text.trim()) turns.push({ kind: "reasoning", text: item.reasoning.text })
+      // The CLI's compaction item holds the summary as its text too; keep it once, as the compaction.
+      const summary = typeof item.conversationSummary === "string" ? item.conversationSummary : undefined
+      if (text.trim() && text !== summary) turns.push({ kind: "assistant", text })
+      const states = new Map<string, Json>()
+      for (const s of Array.isArray(item.toolCallStates) ? item.toolCallStates.filter(isObj) : []) states.set(String(s.toolCallId), s)
+      for (const call of Array.isArray(m.toolCalls) ? m.toolCalls.filter(isObj) : []) {
+        const id = String(call.id ?? "")
+        const name = String(call.function?.name ?? "")
+        if (!id || !name) {
+          lost.add("tool calls without an id or name")
+          continue
+        }
+        const state = states.get(id)
+        let input: unknown = state?.parsedArgs
+        if (input === undefined) {
+          try {
+            input = JSON.parse(String(call.function?.arguments || "{}"))
+          } catch {
+            input = { arguments: String(call.function?.arguments ?? "") }
+          }
+        }
+        turns.push({ kind: "tool_call", id, name, toolKind: continueKind(name), input })
+        const outputs = Array.isArray(state?.output) ? state.output.filter(isObj) : []
+        const out = outputs.length ? outputs.map((o) => asText(o.content)).join("\n\n") : toolItems.get(id)
+        const status = state?.status
+        if (status === "canceled") turns.push({ kind: "tool_result", callId: id, ok: false, output: "The user cancelled this tool call." })
+        else if (out !== undefined || status === "errored" || status === "done") {
+          const c = clip(out ?? (status === "errored" ? "There was an error calling the tool." : "No tool output"))
+          turns.push({ kind: "tool_result", callId: id, ok: status !== "errored", output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+        } else lost.add("tool calls still running when the session was saved")
+        answered.add(id)
+      }
+      if (summary) turns.push({ kind: "compaction", summary })
+    } else if (m.role === "tool") {
+      if (!answered.has(String(m.toolCallId))) lost.add("tool results without a call")
+    }
+    if (m.role !== "assistant" && typeof item.conversationSummary === "string") turns.push({ kind: "compaction", summary: item.conversationSummary })
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+// --- Writing ---------------------------------------------------------------------------------------------
+
+// Continue's own tools (core/tools/definitions), where the arguments map cleanly.
+const TOOLS: ToolMap = {
+  read: (i) => {
+    const filepath = pick(i, ARG.path)
+    return filepath ? { name: "read_file", args: { filepath } } : undefined
+  },
+  write: (i) => {
+    const filepath = pick(i, ARG.path)
+    const contents = pick(i, ARG.content)
+    return filepath && contents !== undefined ? { name: "create_new_file", args: { filepath, contents } } : undefined
+  },
+  edit: (i) => {
+    const filepath = pick(i, ARG.path)
+    const old_string = pick(i, ARG.old)
+    const new_string = pick(i, ARG.new)
+    return filepath && old_string !== undefined && new_string !== undefined ? { name: "single_find_and_replace", args: { filepath, old_string, new_string } } : undefined
+  },
+  shell: (i) => {
+    const command = pick(i, ARG.command)
+    return command ? { name: "run_terminal_command", args: { command, waitForCompletion: true } } : undefined
+  },
+  list: (i) => {
+    const dirPath = pick(i, ARG.dir)
+    return dirPath ? { name: "ls", args: { dirPath, recursive: false } } : undefined
+  },
+  search: (i) => {
+    const query = pick(i, ARG.query)
+    return query ? { name: "grep_search", args: { query } } : undefined
+  },
+  web: (i) => {
+    const url = pick(i, ARG.url)
+    return url ? { name: "fetch_url_content", args: { url } } : undefined
+  },
+}
+
+type Result = Extract<Turn, { kind: "tool_result" }>
+
+export interface ContinuePlan {
+  /** The <sessionId>.json Continue would write. */
+  file: Json
+  /** The session's entry in sessions.json. */
+  entry: Json
+  lost: string[]
+  expect: { users: number; calls: number }
+}
+
+/** The session Continue (or PearAI) would store for `session` continued as `sessionId`. Pure. */
+export function planContinue(session: Session, f: Flavor, opts: { sessionId: string; cwd: string; now: Date }): ContinuePlan {
+  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 id = () => randomUUID()
+  const results = new Map<string, 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)
+  }
+  // Without a summary record, PearAI starts from the last compaction, with its summary in the note.
+  let turns = session.turns
+  let carried: string | undefined
+  if (!f.structured) {
+    const last = lastIndex(turns, (t) => t.kind === "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 ids = new Map<string, string>()
+  const callId = (src: string) => {
+    let v = ids.get(src)
+    if (!v) {
+      v = /^[A-Za-z0-9_-]{1,64}$/.test(src) && ![...ids.values()].includes(src) ? src : `call_${randomUUID().replace(/-/g, "").slice(0, 24)}`
+      ids.set(src, v)
+    }
+    return v
+  }
+
+  const history: Json[] = []
+  let assistant: Json | undefined
+  let users = 0
+  let calls = 0
+  const seen = new Set<string>()
+  let noteItem: Json | undefined
+  const pushUser = (text: string, attachments: string[] = [], images: Array<{ mimeType: string; data: string }> = []) => {
+    // Pasted images are imageUrl parts (data URLs), the shape Continue stores them in.
+    const content = images.length ? [...(text.trim() ? [{ type: "text", text }] : []), ...images.map((i) => ({ type: "imageUrl", imageUrl: { url: `data:${i.mimeType};base64,${i.data}` } }))] : text
+    history.push({ message: { role: "user", content, id: id() }, contextItems: attachments.map((p) => ({ name: p.split("/").pop(), description: p, content: `[Attached file: ${p}]`, uri: { type: "file", value: fileUri(p) }, id: { providerTitle: "file", itemId: id() } })) })
+    assistant = undefined
+  }
+  const openAssistant = (): Json => {
+    if (!assistant) {
+      // Assistant output before any request: the carried-over note stands in for the person's words.
+      if (!history.some((h) => h.message.role === "user")) {
+        pushUser(note)
+        noteItem = history.at(-1)
+      }
+      assistant = { message: { role: "assistant", content: "", id: id() }, contextItems: [] }
+      history.push(assistant)
+    }
+    return assistant
+  }
+  const textOf = (item: Json, extra: string) => {
+    if (Array.isArray(item.message.content)) {
+      const part = item.message.content.find((p: Json) => p.type === "text")
+      if (part) part.text = `${part.text}\n\n${extra}`
+      else item.message.content.unshift({ type: "text", text: extra })
+      return
+    }
+    const cur = String(item.message.content ?? "")
+    item.message.content = cur ? `${cur}\n\n${extra}` : extra
+  }
+
+  for (const t of turns) {
+    switch (t.kind) {
+      case "user": {
+        const files = (t.attachments ?? []).filter((a) => a.kind === "file" && a.path).map((a) => a.path!)
+        const images = (t.attachments ?? []).flatMap((a) => (a.kind === "image" ? [imageData(a)] : [])).filter((i): i is { mimeType: string; data: string } => !!i)
+        const unusable = (t.attachments?.length ?? 0) - files.length - images.length
+        if (unusable > 0) drop("attachments that are not files or readable images", unusable)
+        if (!t.text.trim() && !files.length && !images.length) break
+        pushUser(t.text, f.structured ? files : [], images)
+        if (!f.structured && files.length) textOf(history.at(-1)!, files.map((p) => `[Attached file: ${p}]`).join("\n"))
+        users++
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        // Text after a tool call is the model's next reply.
+        if (assistant?.message.toolCalls?.length) assistant = undefined
+        textOf(openAssistant(), t.text)
+        break
+      }
+      case "reasoning":
+        if (!t.text.trim()) break
+        if (f.structured) {
+          // Continue keeps readable thinking as its own message; providers that need a signature skip it.
+          history.push({ message: { role: "thinking", content: t.text, id: id() }, contextItems: [] })
+          assistant = undefined
+        } else drop("reasoning")
+        break
+      case "tool_call": {
+        if (seen.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        seen.add(t.id)
+        const res = results.get(t.id)
+        if (!f.structured) {
+          // PearAI's messages have no tool calls: the call and its result are kept as the reply's text.
+          let out = res ? res.output : "(no result was recorded)"
+          if (res?.fullPath) out += `\n[Full output: ${res.fullPath}]`
+          textOf(openAssistant(), `[Tool call ${t.name}: ${JSON.stringify(t.input)}]\n[Result${res && !res.ok ? " (error)" : ""}: ${out}]`)
+          drop("tool calls (kept as text)")
+          break
+        }
+        const a = openAssistant()
+        const mapped = mapTool(TOOLS, t.toolKind, t.input)
+        const name = mapped?.name ?? safeToolName(t.name)
+        const args = mapped?.args ?? asArgs(t.input)
+        const cid = callId(t.id)
+        const toolCall = { id: cid, type: "function", function: { name, arguments: JSON.stringify(args) } }
+        a.message.toolCalls = [...(a.message.toolCalls ?? []), toolCall]
+        let output = res?.output
+        if (output !== undefined && res?.fullPath) output += `\n\n[Full output: ${res.fullPath}]`
+        if (!res) drop("tool calls without a result (kept as cancelled)")
+        a.toolCallStates = [
+          ...(a.toolCallStates ?? []),
+          {
+            toolCallId: cid,
+            toolCall,
+            status: !res ? "canceled" : res.ok ? "done" : "errored",
+            parsedArgs: args,
+            ...(output !== undefined ? { output: [{ name: name === "run_terminal_command" ? "Terminal" : name, description: "Tool output", content: output }] } : {}),
+          },
+        ]
+        calls++
+        break
+      }
+      case "tool_result":
+        if (!callIds.has(t.callId)) drop("tool results without a call")
+        break
+      case "compaction": {
+        if (!f.structured) break
+        // As the CLI stores one: an assistant item holding the summary, marked as the cut.
+        for (const h of history) delete h.conversationSummary
+        history.push({ message: { role: "assistant", content: t.summary, id: id() }, contextItems: [], conversationSummary: t.summary })
+        assistant = undefined
+        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
+    }
+  }
+  if (!history.length) throw new Error("nothing to continue: the session has no messages")
+
+  // The note goes on the first user message the model still sees: after the last summary, if any.
+  const cut = lastIndex(history, (h) => h.conversationSummary !== undefined)
+  const target = history.findIndex((h, i) => i > cut && h.message.role === "user")
+  const noteText = carried ? `${note}\n\nSummary of the earlier conversation:\n${carried}` : note
+  if (target < 0) history.splice(cut + 1, 0, { message: { role: "user", content: noteText, id: id() }, contextItems: [] })
+  else if (noteItem && history[target] === noteItem) noteItem.message.content = noteText
+  else history[target]!.contextItems = [{ name: `Continued from ${label}`, description: `Continued from ${label} session ${session.header.sourceId}`, content: noteText, id: { providerTitle: BRAIN_PROVIDER, itemId: session.header.id } }, ...history[target]!.contextItems]
+
+  const title = `${(session.header.title ?? firstUserText(session) ?? "Session").replace(/\s+/g, " ").trim().slice(0, 80)} (from ${label})`
+  const workspaceDirectory = f.uriWorkspace ? fileUri(opts.cwd) : opts.cwd
+  const file: Json = { sessionId: opts.sessionId, title, workspaceDirectory, history }
+  if (f.structured) file.mode = "agent"
+  else file.perplexityHistory = []
+  const entry: Json = { sessionId: opts.sessionId, title, dateCreated: String(opts.now.getTime()), workspaceDirectory }
+  if (f.structured) entry.messageCount = history.filter((h) => h.message.role === "assistant").length
+  else entry.integrationType = "continue"
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  const remapped = [...ids].filter(([a, b]) => a !== b).length
+  if (remapped) lost.push(`tool call ids, replaced with ids every provider accepts (${remapped})`)
+  return { file, entry, lost, expect: { users, calls } }
+}
+

package/src/adapters/continue/writer.ts

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { exists, isDir, 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 { continueReader } from "./reader.ts"
+import { CONTINUE, type Flavor, PEARAI, listPath, planContinue, sessionsDir } from "./records.ts"
+
+// Continues a portable session as a new Continue (or PearAI) chat: the session file the HistoryManager
+// loads, and its entry appended to sessions.json, which both history views and `cn ls` list from. The
+// list is read, changed and written back the way HistoryManager.save does it, after a backup; the
+// extensions re-read the file each time they list or save, so the editor may stay open.
+
+/** Continue builds this writer was checked against: the VS Code/JetBrains extension and the `cn` CLI. */
+export const TESTED_CONTINUE = { extension: ["1.2", "1.3", "2.0"], cli: ["1.5"] }
+/** PearAI's chat extension (pearai.pearai), from trypear/pearai-submodule. */
+export const TESTED_PEARAI = ["2.0"]
+
+const line = (v: string | undefined) => v?.match(/\d+\.\d+/)?.[0]
+
+/** Versions of an extension in VS Code-style extension folders under `home` (extensions.json, else folder names). */
+function extensionVersions(home: string, folders: string[], id: string): string[] {
+  const out: string[] = []
+  for (const folder of folders) {
+    const dir = join(home, folder, "extensions")
+    const listed = readJson<Array<{ identifier?: { id?: string }; version?: string }>>(join(dir, "extensions.json"))
+    if (Array.isArray(listed)) {
+      for (const e of listed) if (e.identifier?.id?.toLowerCase() === id && e.version) out.push(e.version)
+    } else if (isDir(dir)) {
+      for (const name of readdirSync(dir)) {
+        const m = name.toLowerCase().startsWith(`${id}-`) ? name.slice(id.length + 1).match(/^\d+\.\d+\.\d+/) : null
+        if (m) out.push(m[0])
+      }
+    }
+  }
+  return out
+}
+
+/** The `cn` CLI's version, from the package it was installed from: running it would start its telemetry. */
+function cliVersion(): string | undefined {
+  const bin = Bun.which("cn", { PATH: process.env.PATH ?? "" }) // Bun.which does not see a PATH changed after start
+  if (!bin) return undefined
+  try {
+    const pkg = readJson<{ name?: string; version?: string }>(join(dirname(realpathSync(bin)), "..", "package.json"))
+    return pkg?.name === "@continuedev/cli" ? pkg.version : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export interface Installed {
+  /** Continue extension versions, with the editor they are in. */
+  extensions: Array<{ editor: "code" | "cursor" | "pearai"; version: string }>
+  cli?: string
+}
+
+/** What is installed: Continue in VS Code or Cursor and the `cn` CLI, or PearAI's chat extension. */
+export function installed(home: string, f: Flavor): Installed {
+  if (f.tool === PEARAI.tool) {
+    const v = extensionVersions(home, [".pearai"], "pearai.pearai")
+    const app = ["/Applications", join(home, "Applications")].some((d) => exists(join(d, "PearAI.app")))
+    return { extensions: v.length ? v.map((version) => ({ editor: "pearai", version })) : app ? [{ editor: "pearai", version: "unknown" }] : [] }
+  }
+  const extensions = [
+    ...extensionVersions(home, [".vscode"], "continue.continue").map((version) => ({ editor: "code" as const, version })),
+    ...extensionVersions(home, [".cursor"], "continue.continue").map((version) => ({ editor: "cursor" as const, version })),
+  ]
+  const cli = cliVersion()
+  return { extensions, ...(cli ? { cli } : {}) }
+}
+
+/** The sessions.json list, or [] when there is none; throws on a list Continue itself would refuse. */
+function readListStrict(path: string): unknown[] {
+  if (!exists(path)) return []
+  const text = readFileSync(path, "utf8")
+  if (!text.trim()) return []
+  let v: unknown
+  try {
+    v = JSON.parse(text)
+  } catch {
+    throw new Error(`${path} is not valid JSON; Continue refuses to save sessions until it is fixed, so this writer does too`)
+  }
+  if (!Array.isArray(v)) throw new Error(`${path} is not a list of sessions`)
+  return v
+}
+
+/** The Continue or PearAI writer; `found` is for tests, which must not depend on what is installed. */
+export function continueWriter(f: Flavor, opts: { found?: (home: string) => Installed } = {}): Writer {
+  const find = opts.found ?? ((home: string) => installed(home, f))
+  const read = continueReader(f)
+  return {
+    tool: f.tool,
+    label: f.label,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const i = find(w.home)
+      if (f.tool === PEARAI.tool) {
+        if (!i.extensions.length) return { ok: false, why: "PearAI is not installed (no PearAI.app and no pearai.pearai extension under ~/.pearai)" }
+        if (!i.extensions.some((e) => TESTED_PEARAI.includes(line(e.version) ?? ""))) return { ok: false, why: `PearAI's chat extension ${i.extensions.map((e) => e.version).join(", ")} is not a version this writer was checked against (${TESTED_PEARAI.join(", ")})` }
+        return { ok: true }
+      }
+      if (!i.extensions.length && !i.cli) return { ok: false, why: "Continue is not installed (no continue.continue extension in VS Code or Cursor, and no cn CLI)" }
+      const tested = i.extensions.some((e) => TESTED_CONTINUE.extension.includes(line(e.version) ?? "")) || TESTED_CONTINUE.cli.includes(line(i.cli) ?? "")
+      if (!tested) {
+        const have = [...i.extensions.map((e) => `extension ${e.version}`), ...(i.cli ? [`cn ${i.cli}`] : [])].join(", ")
+        return { ok: false, why: `Continue ${have} is not a version this writer was checked against (extension ${TESTED_CONTINUE.extension.join(", ")}; cn ${TESTED_CONTINUE.cli.join(", ")})` }
+      }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const sessionId = randomUUID()
+      const dir = sessionsDir(w.home, f)
+      const file = join(dir, `${sessionId}.json`)
+      const list = listPath(w.home, f)
+      const entries = readListStrict(list)
+      const plan = planContinue(session, f, { sessionId, cwd: w.cwd, now: new Date() })
+      let backedUp: string | undefined
+      if (!w.dryRun) {
+        mkdirSync(dir, { recursive: true })
+        // Continue writes the session with two-space indentation, PearAI on one line.
+        writeFileSync(file, f.structured ? JSON.stringify(plan.file, undefined, 2) : JSON.stringify(plan.file), { flag: "wx" })
+        try {
+          const back = await read.read({ tool: f.tool, sourceId: sessionId, path: file }, w.home)
+          const n = countTurns(back)
+          const pairs = unpaired(back)
+          if (n.user !== plan.expect.users || n.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+            throw new Error(`the new session did not read back intact (${n.user} of ${plan.expect.users} messages, ${n.tool_call} of ${plan.expect.calls} tool calls, ${pairs.calls.length + pairs.results.length} unpaired)`)
+          if (exists(list)) backedUp = backup(w.home, f.tool, [list])
+          const next = [...entries, plan.entry]
+          writeFileSync(list, f.structured ? JSON.stringify(next, undefined, 2) : JSON.stringify(next))
+        } catch (e) {
+          rmSync(file, { force: true })
+          throw e
+        }
+      }
+      const i = find(w.home)
+      const editor = f.tool === PEARAI.tool ? "pearai" : (i?.extensions.find((e) => e.editor === "code") ?? i?.extensions[0])?.editor
+      const open =
+        f.tool === PEARAI.tool ? `open -a PearAI ${shellQuote(w.cwd)}`
+        : editor === "code" || editor === "cursor" ? `${editor} ${shellQuote(w.cwd)}`
+        : "cn ls"
+      const where = f.tool === PEARAI.tool ? "In PearAI Chat, open History" : "In Continue, open History"
+      return {
+        tool: f.tool,
+        way: "native",
+        sessionId,
+        written: [file, list],
+        open,
+        note: `${where} and pick "${plan.entry.title}".${f.tool === CONTINUE.tool ? " In a terminal, `cn ls` lists it too." : ""}${backedUp ? ` sessions.json was backed up to ${backedUp}.` : ""}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const continueNativeWriter = continueWriter(CONTINUE)

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

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { reader } from "./reader.ts"
+import { copilotCliNativeWriter } from "./writer.ts"
+
+// GitHub Copilot CLI: reads ~/.copilot/session-state journals, and continues any session as a new native
+// Copilot CLI session that `copilot --resume` opens.
+export { reader }
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [copilotCliNativeWriter]