@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/cline/reader.ts

@@ -0,0 +1,432 @@
+import { closeSync, openSync, readSync } from "node:fs"
+import { join } from "node:path"
+import { appSupport, exists, gitInfo, isDir, ls, mtime, readJson } from "../../fsutil.ts"
+import type { Attachment, Session, Turn } from "../../session/types.ts"
+import { asText, clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUED_NOTE, HOSTS, SHOWN, SUMMARY_LEAD, extensionVersion } from "./records.ts"
+import { XML_TOOLS, resultHeader, skipNotice, splitAssistantText } from "./xml.ts"
+
+// Cline's classic task store, and Roo Code's, which forked from it (catalogue entries 37 and 39). Each
+// VS Code-family app keeps its own copy under <app>/User/globalStorage/<extension id>/:
+//   tasks/<id>/api_conversation_history.json  what the model saw: Anthropic-style {role, content} messages
+//   tasks/<id>/ui_messages.json               what the panel showed, with timestamps
+//   tasks/<id>/task_metadata.json             models used, files in context
+//   state/taskHistory.json (Cline), tasks/_index.json and tasks/<id>/history_item.json (Roo): the task list
+// Tool calls are either native tool_use/tool_result blocks or XML in the text (see xml.ts).
+
+interface Flavor {
+  tool: string
+  label: string
+  /** The extension's id, which names its globalStorage folder. */
+  extension: string
+}
+
+/** One task's line in the extension's own task list. */
+interface IndexEntry {
+  task?: string
+  ts?: number
+  cwd?: string
+  parentId?: string
+  native?: boolean
+}
+
+type Block = Record<string, any>
+/** Roo also marks its own context management: a condensed summary (isSummary) and a sliding-window note (isTruncationMarker). */
+type Msg = { role?: string; content?: unknown; ts?: number; isSummary?: boolean; isTruncationMarker?: boolean }
+
+const API_FILE = "api_conversation_history.json"
+const UI_FILE = "ui_messages.json"
+
+export function taskReader(f: Flavor): Reader {
+  return {
+    tool: f.tool,
+    label: f.label,
+    async list(home) {
+      const refs: SessionRef[] = []
+      for (const host of HOSTS) {
+        const root = join(appSupport(home), host.app, "User", "globalStorage", f.extension)
+        const tasks = join(root, "tasks")
+        if (!isDir(tasks)) continue
+        const index = loadIndex(root)
+        for (const id of ls(tasks)) {
+          const dir = join(tasks, id)
+          // The index can list tasks whose folder is gone, and folders can lack the index entry: the folder decides.
+          if (!exists(join(dir, API_FILE))) continue
+          let e = index.get(id) ?? historyItem(dir)
+          // Older index entries lack the folder, and some tasks have no entry: the history's first message says both.
+          if (!e?.cwd || !e.task) e = { ...peek(join(dir, API_FILE)), ...e }
+          const times = [iso(e?.ts), mtime(join(dir, API_FILE)), mtime(join(dir, UI_FILE))].filter((t): t is string => !!t)
+          refs.push({
+            tool: f.tool,
+            sourceId: id,
+            path: dir,
+            ...(e?.task ? { title: titleOf(e.task) } : {}),
+            ...(e?.cwd ? { cwd: e.cwd } : {}),
+            ...(times.length ? { updatedAt: times.sort().at(-1)! } : {}),
+            extra: { host: host.app },
+          })
+        }
+      }
+      return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+    },
+    async read(ref, home) {
+      return readTask(f, ref, home)
+    },
+  }
+}
+
+const titleOf = (task: string) => {
+  const line = task.replace(/\s+/g, " ").trim()
+  return line.length > 120 ? `${line.slice(0, 119)}…` : line
+}
+
+/** The task list: Cline's state/taskHistory.json or Roo's tasks/_index.json. */
+function loadIndex(root: string): Map<string, IndexEntry> {
+  const out = new Map<string, IndexEntry>()
+  const add = (items: unknown) => {
+    if (!Array.isArray(items)) return
+    for (const it of items as Array<Record<string, any>>) if (typeof it?.id === "string") out.set(it.id, entryOf(it))
+  }
+  add(readJson(join(root, "state", "taskHistory.json")))
+  add(readJson<{ entries?: unknown }>(join(root, "tasks", "_index.json"))?.entries)
+  return out
+}
+
+/**
+ * The task text and folder from the start of a task's history, for tasks the index does not list (older Roo
+ * kept its list in VS Code's own database): the first 64 KB hold the first message, without parsing the rest.
+ */
+function peek(apiFile: string): IndexEntry | undefined {
+  let head = ""
+  try {
+    const fd = openSync(apiFile, "r")
+    try {
+      const buf = Buffer.alloc(64 * 1024)
+      head = buf.toString("utf8", 0, readSync(fd, buf, 0, buf.length, 0))
+    } finally {
+      closeSync(fd)
+    }
+  } catch {
+    return undefined
+  }
+  const out: IndexEntry = {}
+  const raw = head.match(/"text"\s*:\s*"((?:[^"\\]|\\.)*)"/)?.[1]
+  if (raw) {
+    try {
+      const task = unwrap(JSON.parse(`"${raw}"`) as string)
+      if (task) out.task = task
+    } catch {}
+  }
+  const cwd = head.match(/# Current (?:Working|Workspace) Directory \((.+?)\) Files/)?.[1]
+  if (cwd) out.cwd = cwd
+  return out.task || out.cwd ? out : undefined
+}
+
+/** Roo's per-task copy of its index entry (newer versions). */
+function historyItem(dir: string): IndexEntry | undefined {
+  const it = readJson<Record<string, any>>(join(dir, "history_item.json"))
+  return it && typeof it === "object" ? entryOf(it) : undefined
+}
+
+function entryOf(it: Record<string, any>): IndexEntry {
+  const cwd = it.cwdOnTaskInitialization ?? it.workspace ?? it.shadowGitConfigWorkTree
+  return {
+    ...(typeof it.task === "string" ? { task: it.task } : {}),
+    ...(typeof it.ts === "number" ? { ts: it.ts } : {}),
+    ...(typeof cwd === "string" && cwd ? { cwd } : {}),
+    ...(typeof it.parentTaskId === "string" ? { parentId: it.parentTaskId } : {}),
+    ...(it.toolProtocol === "native" ? { native: true } : {}),
+  }
+}
+
+function readTask(f: Flavor, ref: SessionRef, home: string): Session {
+  const dir = ref.path
+  const api = readJson<Msg[]>(join(dir, API_FILE))
+  if (!Array.isArray(api)) throw new Error(`${API_FILE} is missing or not JSON in ${dir}`)
+  const ui = readJson<Array<Record<string, any>>>(join(dir, UI_FILE))
+  const meta = readJson<Record<string, any>>(join(dir, "task_metadata.json")) ?? {}
+  const root = join(dir, "..", "..")
+  const entry = loadIndex(root).get(ref.sourceId) ?? historyItem(dir)
+  const app = (ref.extra?.host as string | undefined) ?? HOSTS.find((h) => dir.includes(`/${h.app}/User/globalStorage/`))?.app
+
+  // When each message was sent. Roo stamps its messages; Cline does not, but every panel message records how
+  // long the conversation was when it appeared (conversationHistoryIndex), which dates each message closely.
+  const uiTimes = new Map<number, number>()
+  const uiTs: number[] = []
+  for (const u of Array.isArray(ui) ? ui : []) {
+    if (typeof u?.ts !== "number") continue
+    uiTs.push(u.ts)
+    const k = u.conversationHistoryIndex
+    if (typeof k === "number" && !uiTimes.has(k)) uiTimes.set(k, u.ts)
+  }
+  const at = (i: number) => iso(api[i]?.ts) ?? iso(uiTimes.get(i))
+
+  const usage = (Array.isArray(meta.model_usage) ? meta.model_usage : [])
+    .filter((u: any) => typeof u?.model_id === "string")
+    .sort((a: any, b: any) => (a.ts ?? 0) - (b.ts ?? 0)) as Array<{ ts?: number; model_id: string }>
+  const modelAt = (when: string | undefined): string | undefined => {
+    if (!usage.length) return undefined
+    if (!when) return usage.at(-1)!.model_id
+    const t = Date.parse(when)
+    return [...usage].reverse().find((u) => (u.ts ?? 0) <= t)?.model_id ?? usage[0]!.model_id
+  }
+
+  const lost = lossCounter()
+  let cwd = ref.cwd ?? entry?.cwd
+  /** The session this task continues, when the writer made it. */
+  let continued: string | undefined
+  const native = !!entry?.native || api.some((m) => Array.isArray(m.content) && (m.content as Block[]).some((b) => b?.type === "tool_use"))
+  const turns: Turn[] = []
+  const models: string[] = []
+  /** XML calls from the last assistant message, waiting for their results. */
+  let waiting: Array<{ id: string; name: string; done: boolean }> = []
+  // Native call ids are the provider's, and some repeat them across a task (Gemini numbers calls per message:
+  // "read_file-0" again and again). Turns need them unique, so a repeat gets a suffix, and a result answers the
+  // latest call issued under its id, since results come in the message right after their call.
+  const usedIds = new Set<string>()
+  const latestId = new Map<string, string>()
+  const callIdFor = (raw: string) => {
+    let id = raw
+    for (let k = 2; usedIds.has(id); k++) id = `${raw}#${k}`
+    usedIds.add(id)
+    latestId.set(raw, id)
+    return id
+  }
+
+  api.forEach((m, i) => {
+    const blocks: Block[] = typeof m.content === "string" ? [{ type: "text", text: m.content }] : Array.isArray(m.content) ? (m.content as Block[]) : []
+    const when = at(i)
+    // Roo condenses the context without deleting anything: the older messages stay (marked condenseParent) and a
+    // summary is added, as an assistant message (3.38) or a user one (3.54). It is the tool's own compaction,
+    // not something the model or the person said. A sliding-window truncation leaves a marker message the same way.
+    if (m.isSummary) {
+      // A summary the writer made also repeats the continuation note and carries what the person said next.
+      const texts = blocks.filter((b) => b?.type === "text").map((b) => String(b.text ?? ""))
+      const said = texts.filter((t) => /^\s*<user_message>/.test(t)).map(unwrap).filter(Boolean)
+      const summary = texts
+        .filter((t) => !CONTINUED_NOTE.test(t.trimStart()) && !/^\s*<user_message>/.test(t))
+        .join("\n\n")
+        .replace(/^\s*## Conversation Summary\n/, "")
+        .trim()
+      if (texts.some((t) => CONTINUED_NOTE.test(t.trimStart()))) continued ??= texts.find((t) => CONTINUED_NOTE.test(t.trimStart()))!.trimStart().match(CONTINUED_NOTE)![1]
+      if (summary) turns.push({ kind: "compaction", ...(when ? { at: when } : {}), summary })
+      if (said.length) turns.push({ kind: "user", ...(when ? { at: when } : {}), text: said.join("\n\n") })
+      return
+    }
+    if (m.isTruncationMarker) {
+      lost.add("context truncation markers")
+      return
+    }
+    if (m.role === "assistant") {
+      waiting = []
+      const model = modelAt(when)
+      if (model && !models.includes(model)) models.push(model)
+      const next = api[i + 1]
+      const answered = new Set<string>()
+      if (next?.role === "user" && Array.isArray(next.content))
+        for (const b of next.content as Block[]) if (b?.type === "text") {
+          const h = resultHeader(String(b.text ?? ""))
+          if (h) answered.add(h.name)
+          const skipped = skipNotice(String(b.text ?? ""))
+          if (skipped) answered.add(skipped)
+        }
+      // XML is read only in tasks on the XML protocol: in a native task, tags in the text were never run.
+      const isTool = native ? () => false : (name: string) => XML_TOOLS.has(name) || answered.has(name)
+      let n = 0
+      for (const b of blocks) {
+        switch (b?.type) {
+          case "text":
+            for (const p of splitAssistantText(String(b.text ?? ""), isTool)) {
+              if (p.kind === "text") turns.push({ kind: "assistant", ...(when ? { at: when } : {}), text: p.text, ...(model ? { model } : {}) })
+              else if (p.kind === "thinking") turns.push({ kind: "reasoning", ...(when ? { at: when } : {}), text: p.text })
+              else {
+                const id = `xml-${i}-${n++}`
+                pushCall(turns, { id, name: p.name, input: p.input, at: when, model })
+                waiting.push({ id, name: p.name, done: false })
+              }
+            }
+            break
+          case "thinking":
+            if (typeof b.thinking === "string" && b.thinking.trim()) {
+              turns.push({ kind: "reasoning", ...(when ? { at: when } : {}), text: b.thinking })
+              if (b.signature) lost.add("reasoning signatures")
+            } else lost.add("signed reasoning")
+            break
+          case "redacted_thinking":
+            lost.add("encrypted reasoning")
+            break
+          case "thoughtSignature":
+            lost.add("Gemini thought signatures")
+            break
+          case "tool_use":
+            pushCall(turns, { id: callIdFor(String(b.id ?? `tool-${i}-${n++}`)), name: String(b.name ?? "unknown"), input: b.input ?? {}, at: when, model })
+            break
+          case "image":
+            lost.add("image data")
+            break
+          default:
+            lost.add(`unknown block types: ${String(b?.type)}`)
+        }
+      }
+      return
+    }
+    if (m.role !== "user") {
+      lost.add(`unknown message roles: ${String(m.role)}`)
+      return
+    }
+
+    // A user message: tool results first (they answer the message before), then what the person wrote.
+    const texts: string[] = []
+    const attachments: Attachment[] = []
+    let result: { id: string; body: string[] } | undefined
+    const flush = () => {
+      if (!result) return
+      const { output, feedback } = splitFeedback(result.body.join("\n\n"))
+      const c = clip(output || "(no output)")
+      turns.push({ kind: "tool_result", ...(when ? { at: when } : {}), callId: result.id, ok: !FAILED.test(output), output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+      if (feedback) texts.push(feedback)
+      result = undefined
+    }
+    for (const b of blocks) {
+      if (b?.type === "text") {
+        const t = String(b.text ?? "")
+        const lead = t.trimStart()
+        if (lead.startsWith("<environment_details>")) {
+          flush()
+          cwd ??= t.match(/# Current (?:Working|Workspace) Directory \((.+?)\) Files/)?.[1]
+          lost.add("environment details blocks")
+          continue
+        }
+        // A call the extension skipped is answered by a notice of its own, not by the open result's output.
+        const skipped = skipNotice(t)
+        if (skipped) {
+          flush()
+          const call = waiting.find((w) => !w.done && w.name === skipped) ?? waiting.find((w) => !w.done)
+          if (call) {
+            call.done = true
+            turns.push({ kind: "tool_result", ...(when ? { at: when } : {}), callId: call.id, ok: false, output: t.trim() })
+          } else lost.add("harness notices")
+          continue
+        }
+        const h = resultHeader(t)
+        if (h) {
+          flush()
+          const call = waiting.find((w) => !w.done && w.name === h.name) ?? waiting.find((w) => !w.done)
+          if (call) {
+            call.done = true
+            result = { id: call.id, body: h.rest.trim() ? [h.rest] : [] }
+          } else texts.push(t.trim()) // a result for no call we know: keep what the model saw, as text
+          continue
+        }
+        // Resuming a task adds the extension's notice, and Cline 3.5x puts the person's words in a block of their
+        // own after a lead-in ("New instructions for task continuation: <user_message>…"): only the words are theirs.
+        if (lead.startsWith("[TASK RESUMPTION]") || RESUME_LEAD.test(lead)) {
+          flush()
+          const said = t.match(/<user_message>([\s\S]*?)<\/user_message>/)?.[1]?.trim()
+          if (said) texts.push(said)
+          else lost.add("task resumption notices")
+          continue
+        }
+        if (result) {
+          result.body.push(t)
+          continue
+        }
+        // The writer's note on where the task came from, and its marker for a summary that replaced earlier turns.
+        const note = lead.match(CONTINUED_NOTE)
+        if (note) {
+          continued ??= note[1]
+          continue
+        }
+        if (lead.startsWith(SUMMARY_LEAD)) {
+          flush()
+          // What the person said before the summary in the same message comes first.
+          if (texts.length) turns.push({ kind: "user", ...(when ? { at: when } : {}), text: texts.splice(0).join("\n\n") })
+          const summary = t.slice(t.indexOf("]") + 1).trim()
+          if (summary) turns.push({ kind: "compaction", ...(when ? { at: when } : {}), summary })
+          continue
+        }
+        if (lead.startsWith("[ERROR]")) {
+          lost.add("harness notices")
+          continue
+        }
+        const own = unwrap(t)
+        if (own) texts.push(own)
+      } else if (b?.type === "tool_result") {
+        flush()
+        const c = clip(resultText(b.content, lost) || "(no output)")
+        const raw = String(b.tool_use_id)
+        turns.push({ kind: "tool_result", ...(when ? { at: when } : {}), callId: latestId.get(raw) ?? raw, ok: !b.is_error, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+      } else if (b?.type === "image") {
+        if (result) lost.add("images in tool results")
+        else {
+          const mime = b.source?.media_type
+          attachments.push({ kind: "image", ...(typeof mime === "string" ? { mime } : {}) })
+          lost.add("image data")
+        }
+      } else lost.add(`unknown block types: ${String(b?.type)}`)
+    }
+    flush()
+    if (texts.length || attachments.length)
+      turns.push({ kind: "user", ...(when ? { at: when } : {}), text: texts.join("\n\n"), ...(attachments.length ? { attachments } : {}) })
+  })
+
+  const firstAt = /^\d{12,14}$/.test(ref.sourceId) ? iso(Number(ref.sourceId)) : undefined
+  const startedAt = firstAt ?? turns.find((t) => t.at)?.at ?? iso(uiTs[0])
+  const updatedAt = iso(uiTs.reduce((a, b) => Math.max(a, b), 0)) ?? iso(entry?.ts) ?? mtime(join(dir, API_FILE))
+  const toolVersion = extensionVersion(home, app, f.extension)
+  const h = header(f.tool, ref.sourceId, {
+    ...(toolVersion ? { toolVersion } : {}),
+    sourcePath: dir,
+    ...(entry?.task ? { title: titleOf(entry.task) } : ref.title ? { title: ref.title } : {}),
+    project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd) },
+    ...(startedAt ? { startedAt } : {}),
+    ...(updatedAt ? { updatedAt } : {}),
+    ...(entry?.parentId
+      ? { parent: { id: `${f.tool}:${entry.parentId}`, kind: "subagent" as const } }
+      : continued
+        ? { parent: { id: continued, kind: "continued" as const } }
+        : {}),
+  })
+  for (const m of models) noteModel(h, m)
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+/** Cline's lead-ins to what the person typed when resuming, and its note when they typed nothing (plan mode). */
+const RESUME_LEAD = /^(?:New instructions for task continuation|New message to respond to with plan_mode_respond tool|\(The user did not provide a new message)/
+
+/** Results that say the call did not go through. */
+const FAILED = /The user denied this operation|The tool execution failed|^\s*<error>|^\s*Error[: ]/i
+
+function pushCall(turns: Turn[], c: { id: string; name: string; input: unknown; at: string | undefined; model: string | undefined }) {
+  const shown = SHOWN[c.name]
+  const text = shown ? (c.input as Record<string, unknown> | undefined)?.[shown] : undefined
+  if (typeof text === "string" && text.trim()) turns.push({ kind: "assistant", ...(c.at ? { at: c.at } : {}), text: text.trim(), ...(c.model ? { model: c.model } : {}) })
+  turns.push({ kind: "tool_call", ...(c.at ? { at: c.at } : {}), id: c.id, name: c.name, toolKind: toolKindOf(c.name), input: c.input })
+}
+
+/** What the person typed, out of the tags Cline wraps it in. */
+function unwrap(t: string): string {
+  return t.replace(/<(task|feedback|answer|user_message)>\s*([\s\S]*?)\s*<\/\1>/g, "$2").trim()
+}
+
+/** Feedback the person gave in reply to a tool (a denied edit, a finished task) is their message, not the tool's output. */
+function splitFeedback(body: string): { output: string; feedback?: string } {
+  const m = body.match(/<feedback>\s*([\s\S]*?)\s*<\/feedback>/)
+  if (!m) return { output: body.trim() }
+  return { output: body.replace(m[0], "").trim(), feedback: m[1]! }
+}
+
+/** A native tool_result's content as text; images in it are counted, not kept. */
+function resultText(content: unknown, lost: ReturnType<typeof lossCounter>): string {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return asText(content)
+  const out: string[] = []
+  for (const c of content as Block[]) {
+    if (c?.type === "text") out.push(String(c.text ?? ""))
+    else if (c?.type === "image") lost.add("images in tool results")
+    else out.push(asText(c))
+  }
+  return out.join("\n")
+}

package/src/adapters/cline/records.ts

@@ -0,0 +1,151 @@
+import { join } from "node:path"
+import { appSupport, ls, readJson } from "../../fsutil.ts"
+import type { ToolKind } from "../../session/types.ts"
+
+// Facts about the Cline-lineage task store shared by the reader and the writers: which editors host the
+// extensions, which versions the writers were checked against, and the tool names each extension's model
+// knows. Checked against the sources at the installed versions (cline v3.56.2 and v4.1.26, Roo-Code v3.38.1
+// and v3.54.0) and the task folders on the author's Mac (structure only).
+
+/** VS Code-family apps that host the extensions: their data folder, extensions folder and process name. */
+export interface Host {
+  app: string
+  extensions: string
+  process: string
+  /** The command that opens a folder in the app. */
+  cli: string
+}
+
+export const HOSTS: Host[] = [
+  { app: "Code", extensions: ".vscode/extensions", process: "Code", cli: "code" },
+  { app: "Code - Insiders", extensions: ".vscode-insiders/extensions", process: "Code - Insiders", cli: "code-insiders" },
+  { app: "Cursor", extensions: ".cursor/extensions", process: "Cursor", cli: "cursor" },
+  { app: "Windsurf", extensions: ".windsurf/extensions", process: "Windsurf", cli: "windsurf" },
+  { app: "VSCodium", extensions: ".vscode-oss/extensions", process: "VSCodium", cli: "codium" },
+]
+
+export const hostByApp = (app: string) => HOSTS.find((h) => h.app === app)
+
+/** The extension's folder in a host's global storage. */
+export const storageDir = (home: string, app: string, extension: string) => join(appSupport(home), app, "User", "globalStorage", extension)
+
+/** The host's own global state database, where VS Code keeps every extension's globalState. */
+export const stateDb = (home: string, app: string) => join(appSupport(home), app, "User", "globalStorage", "state.vscdb")
+
+const num = (v: string) => v.split(".").map(Number)
+
+/** Semantic-version order: negative when a is older than b. */
+export function compareVersions(a: string, b: string): number {
+  const [x, y] = [num(a), num(b)]
+  for (let i = 0; i < 3; i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) - (y[i] ?? 0)
+  return 0
+}
+
+/**
+ * The extension's version installed in an app. The host's extensions.json names the active copy (an
+ * update can leave the old folder behind until the editor cleans up); without it the newest folder wins.
+ */
+export function extensionVersion(home: string, app: string | undefined, extension: string): string | undefined {
+  const host = HOSTS.find((h) => h.app === app)
+  if (!host) return undefined
+  const dir = join(home, host.extensions)
+  const manifest = readJson<Array<{ identifier?: { id?: string }; version?: string }>>(join(dir, "extensions.json"))
+  const listed = Array.isArray(manifest)
+    ? manifest.find((e) => e?.identifier?.id?.toLowerCase() === extension.toLowerCase() && typeof e.version === "string")?.version
+    : undefined
+  if (listed) return listed
+  const versions = ls(dir)
+    .map((d) => d.match(new RegExp(`^${extension.replace(/\./g, "\\.")}-(\\d+\\.\\d+\\.\\d+)`, "i"))?.[1])
+    .filter((v): v is string => !!v)
+  return versions.sort(compareVersions).at(-1)
+}
+
+/**
+ * The note that opens a task the writer creates, as its own text block in the first API message: the model
+ * reads it, the task panel does not show it (the panel shows ui_messages.json, not the API history), and the
+ * reader recognises it.
+ */
+export const continuedNote = (label: string, id: string, when: string) =>
+  `[This task continues ${label} session ${id}, carried over by brain session on ${when}. The turns below are its history; reasoning and anything listed as lost did not carry over. Tool names may differ from yours. Check files before relying on details, since they may have changed.]`
+export const CONTINUED_NOTE = /^\[This task continues .+? session (\S+), carried over by brain session/
+
+/** Tools whose input is the text the person saw (the final answer, a plan): that text is also an assistant turn. */
+export const SHOWN: Record<string, string> = { attempt_completion: "result", plan_mode_respond: "response" }
+
+/** How the writer marks a compaction summary in Cline's history, where the summary is a plain user text block. */
+export const SUMMARY_LEAD = "[Summary of the earlier conversation"
+export const summaryText = (label: string, summary: string) => `${SUMMARY_LEAD} in ${label}, which replaced the turns before it]\n\n${summary}`
+
+type Input = Record<string, unknown>
+const str = (v: unknown) => (typeof v === "string" && v ? v : undefined)
+const pathOf = (i: Input) => str(i.file_path) ?? str(i.path) ?? str(i.filePath) ?? str(i.target_file) ?? str(i.absolute_path) ?? str(i.file)
+const commandOf = (i: Input) => (Array.isArray(i.command) ? i.command.map(String).join(" ") : str(i.command) ?? str(i.cmd))
+
+/** A native tool call in the target's own vocabulary, or undefined to keep the call as it was. */
+export type Mapping = (input: Input, name: string) => { name: string; input: Input } | undefined
+
+/**
+ * Portable tool kinds to the native tools each extension defines (Cline src/core/prompts/system-prompt/tools,
+ * Roo src/core/prompts/tools/native-tools). Only shapes that translate cleanly are mapped; anything else keeps
+ * its own name and input, which the model still reads as a past call.
+ */
+const COMMON: Partial<Record<ToolKind, Mapping>> = {
+  shell: (i) => {
+    const command = commandOf(i)
+    return command ? { name: "execute_command", input: { command } } : undefined
+  },
+  read: (i) => {
+    const path = pathOf(i)
+    return path ? { name: "read_file", input: { path } } : undefined
+  },
+  write: (i) => {
+    const path = pathOf(i)
+    const content = str(i.content) ?? str(i.file_text) ?? str(i.contents) ?? (typeof i.content === "string" ? "" : undefined)
+    return path && content !== undefined ? { name: "write_to_file", input: { path, content } } : undefined
+  },
+  search: (i, name) => {
+    // A glob search (Glob, glob_file_search) matches file names, which search_files cannot express.
+    const regex = /glob/i.test(name) ? undefined : str(i.pattern) ?? str(i.regex) ?? str(i.query)
+    if (!regex) return undefined
+    const pattern = str(i.glob) ?? str(i.include) ?? str(i.file_pattern)
+    return { name: "search_files", input: { path: str(i.path) ?? ".", regex, ...(pattern ? { file_pattern: pattern } : {}) } }
+  },
+  list: (i) => ({ name: "list_files", input: { path: pathOf(i) ?? str(i.dir_path) ?? str(i.target_directory) ?? ".", recursive: i.recursive === true } }),
+  ask: (i) => {
+    const question = str(i.question) ?? str((i.questions as Input[] | undefined)?.[0]?.question)
+    return question ? { name: "ask_followup_question", input: { question } } : undefined
+  },
+}
+
+const oldNew = (i: Input) => {
+  const path = pathOf(i)
+  const before = typeof i.old_string === "string" ? i.old_string : typeof i.oldString === "string" ? i.oldString : typeof i.old_str === "string" ? i.old_str : undefined
+  const after = typeof i.new_string === "string" ? i.new_string : typeof i.newString === "string" ? i.newString : typeof i.new_str === "string" ? i.new_str : undefined
+  return path && before !== undefined && after !== undefined ? { path, before, after } : undefined
+}
+
+export const CLINE_TOOLS: Partial<Record<ToolKind, Mapping>> = {
+  ...COMMON,
+  shell: (i) => {
+    const command = commandOf(i)
+    return command ? { name: "execute_command", input: { command, requires_approval: false } } : undefined
+  },
+  // Cline edits with SEARCH/REPLACE blocks in replace_in_file.
+  edit: (i) => {
+    const e = oldNew(i)
+    return e ? { name: "replace_in_file", input: { path: e.path, diff: `------- SEARCH\n${e.before}\n=======\n${e.after}\n+++++++ REPLACE` } } : undefined
+  },
+  web: (i) => {
+    const url = str(i.url)
+    return url ? { name: "web_fetch", input: { url } } : undefined
+  },
+}
+
+export const ROO_TOOLS: Partial<Record<ToolKind, Mapping>> = {
+  ...COMMON,
+  // search_replace takes Claude-style old and new strings in both 3.38 and 3.54.
+  edit: (i) => {
+    const e = oldNew(i)
+    return e ? { name: "search_replace", input: { file_path: e.path, old_string: e.before, new_string: e.after } } : undefined
+  },
+}

package/src/adapters/cline/vscdb.ts

@@ -0,0 +1,56 @@
+import { Database } from "bun:sqlite"
+import { copyFileSync, mkdirSync } from "node:fs"
+import { basename, join } from "node:path"
+import { exists } from "../../fsutil.ts"
+
+// An extension's globalState in a VS Code-family app's own database (<app>/User/globalStorage/state.vscdb):
+// one ItemTable row per extension, keyed by its id as the publisher wrote it ("RooVeterinaryInc.roo-cline"),
+// holding the whole state as JSON text. VS Code reads the table once at startup and writes its in-memory copy
+// back, so this is only written while the app is closed, after a backup.
+
+/** The row's key and JSON value, or undefined when the extension has never stored state there. */
+export function readState(db: Database, extension: string): { key: string; value: Record<string, unknown> } | undefined {
+  const row = db.query("SELECT key, value FROM ItemTable WHERE lower(key) = lower(?)").get(extension) as { key: string; value: string | Uint8Array } | null
+  if (!row) return undefined
+  const text = typeof row.value === "string" ? row.value : new TextDecoder().decode(row.value)
+  const value = JSON.parse(text) as unknown
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${extension}'s state in ${db.filename} is not a JSON object`)
+  return { key: row.key, value: value as Record<string, unknown> }
+}
+
+/** Copies the database and its journal files into `dir`, returning the copies. */
+export function backupDb(path: string, dir: string): string[] {
+  mkdirSync(dir, { recursive: true })
+  const out: string[] = []
+  for (const side of ["", "-journal", "-wal", "-shm"]) {
+    if (!exists(path + side)) continue
+    const copy = join(dir, basename(path) + side)
+    copyFileSync(path + side, copy)
+    out.push(copy)
+  }
+  return out
+}
+
+/**
+ * Applies `change` to an extension's state in one transaction. The key keeps the case the row already has;
+ * a new row takes `extension` as written.
+ */
+export function updateState(path: string, extension: string, change: (state: Record<string, unknown>) => void) {
+  // Never creates the file: an editor that has not made its database yet has no state to add to.
+  const db = new Database(path, { readwrite: true, create: false })
+  try {
+    db.exec("BEGIN IMMEDIATE")
+    try {
+      const cur = readState(db, extension)
+      const state = cur?.value ?? {}
+      change(state)
+      db.query("INSERT OR REPLACE INTO ItemTable (key, value) VALUES (?, ?)").run(cur?.key ?? extension, JSON.stringify(state))
+      db.exec("COMMIT")
+    } catch (e) {
+      db.exec("ROLLBACK")
+      throw e
+    }
+  } finally {
+    db.close()
+  }
+}