@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/cline/xml.ts

@@ -0,0 +1,177 @@
+// Cline's original tool protocol (Cline 3.x, Roo Code before "native" tools): the model writes each tool
+// call as XML inside its text, `<read_file><path>src/a.ts</path></read_file>`, and the extension answers in
+// the next user message with a text block headed `[read_file for 'src/a.ts'] Result:`. Neither side has an
+// id, so a result is paired with a call in the assistant message just before it. `<thinking>` blocks in the
+// same text are the model's readable reasoning.
+
+/**
+ * Tool names of the XML protocol in Cline and Roo Code, from the tool enums in the installed bundles (Cline
+ * 3.56.2 and 4.1.26, Roo 3.54.0) plus names older versions used. A tag is read as a call only when it is one
+ * of these, or when the next message carries a result for it, so the HTML in a file the model wrote stays text.
+ */
+export const XML_TOOLS = new Set([
+  // Cline
+  "execute_command",
+  "read_file",
+  "write_to_file",
+  "replace_in_file",
+  "search_files",
+  "list_files",
+  "list_code_definition_names",
+  "browser_action",
+  "use_mcp_tool",
+  "access_mcp_resource",
+  "load_mcp_documentation",
+  "ask_followup_question",
+  "attempt_completion",
+  "plan_mode_respond",
+  "act_mode_respond",
+  "new_task",
+  "focus_chain",
+  "web_fetch",
+  "web_search",
+  "condense",
+  "summarize_task",
+  "report_bug",
+  "new_rule",
+  "apply_patch",
+  "generate_explanation",
+  "use_skill",
+  // Roo Code
+  "read_command_output",
+  "apply_diff",
+  "edit",
+  "search_and_replace",
+  "search_replace",
+  "edit_file",
+  "insert_content",
+  "codebase_search",
+  "switch_mode",
+  "update_todo_list",
+  "run_slash_command",
+  "skill",
+  "generate_image",
+  "custom_tool",
+  "fetch_instructions",
+])
+
+/** Parameters whose value can itself contain tags (file contents, diffs, a final answer): closed at the last close tag. */
+const LONG_PARAMS = new Set(["content", "diff", "result", "response", "question", "arguments", "todos"])
+
+export type Piece =
+  | { kind: "text"; text: string }
+  | { kind: "thinking"; text: string }
+  | { kind: "call"; name: string; input: Record<string, unknown> }
+
+const OPEN_TAG = /<([A-Za-z_][A-Za-z0-9_]*)>/g
+
+/** Assistant text split into plain text, `<thinking>` reasoning and XML tool calls, in order. */
+export function splitAssistantText(text: string, isTool: (name: string) => boolean): Piece[] {
+  const out: Piece[] = []
+  const pushText = (t: string) => {
+    // A </thinking> left after a call that ended the reasoning early (below) is not text.
+    const s = t.replace(/<\/thinking>/g, "").trim()
+    if (s) out.push({ kind: "text", text: s })
+  }
+  let pos = 0
+  const re = new RegExp(OPEN_TAG.source, "g")
+  let m: RegExpExecArray | null
+  while ((m = re.exec(text))) {
+    const name = m[1]!
+    if (name !== "thinking" && !isTool(name)) continue
+    const bodyStart = m.index + m[0].length
+    const close = `</${name}>`
+    let end = text.indexOf(close, bodyStart)
+    // An unclosed tag is a call the model was still writing when the stream stopped: take the rest.
+    let bodyEnd = end < 0 ? text.length : end
+    // The extension parses calls wherever they are, <thinking> or not, and some models never close <thinking>
+    // and go straight on to the call: reasoning ends at a call inside it (a tool tag closed within it, or any
+    // tool tag when it is never closed), and the call is read next.
+    const call = name === "thinking" ? callInside(text, bodyStart, end, isTool) : -1
+    if (call >= 0) end = bodyEnd = call
+    pushText(text.slice(pos, m.index))
+    const body = text.slice(bodyStart, bodyEnd)
+    if (name === "thinking") {
+      if (body.trim()) out.push({ kind: "thinking", text: body.trim() })
+    } else out.push({ kind: "call", name, input: parseParams(body) })
+    pos = call >= 0 ? call : end < 0 ? text.length : end + close.length
+    re.lastIndex = pos
+  }
+  pushText(text.slice(pos))
+  return out
+}
+
+/** Where a tool call starts inside a <thinking> block that runs from `from` to `end` (-1: never closed), or -1. */
+function callInside(text: string, from: number, end: number, isTool: (name: string) => boolean): number {
+  const limit = end < 0 ? text.length : end
+  const re = new RegExp(OPEN_TAG.source, "g")
+  re.lastIndex = from
+  let m: RegExpExecArray | null
+  while ((m = re.exec(text)) && m.index < limit) {
+    const name = m[1]!
+    if (name === "thinking" || !isTool(name)) continue
+    // In a closed block, a tag the model only mentioned has no close tag of its own before the block ends.
+    if (end < 0) return m.index
+    const close = text.indexOf(`</${name}>`, m.index + m[0].length)
+    if (close >= 0 && close < end) return m.index
+  }
+  return -1
+}
+
+/** `<path>a</path><content>b</content>` as { path: "a", content: "b" }; repeated tags become arrays, nested tags objects. */
+export function parseParams(body: string): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  const re = new RegExp(OPEN_TAG.source, "g")
+  let m: RegExpExecArray | null
+  while ((m = re.exec(body))) {
+    const name = m[1]!
+    const start = m.index + m[0].length
+    const close = `</${name}>`
+    const end = LONG_PARAMS.has(name) ? body.lastIndexOf(close) : body.indexOf(close, start)
+    const raw = end < start ? body.slice(start) : body.slice(start, end)
+    const value = paramValue(name, raw)
+    const prev = out[name]
+    out[name] = prev === undefined ? value : Array.isArray(prev) ? [...prev, value] : [prev, value]
+    if (end < start) break
+    re.lastIndex = end + close.length
+  }
+  return out
+}
+
+function paramValue(name: string, raw: string): unknown {
+  // Cline keeps file contents and diffs as written, less the newline after the open tag and before the close.
+  if (name === "content" || name === "diff") return raw.replace(/^\r?\n/, "").replace(/\r?\n$/, "")
+  const t = raw.trim()
+  // Roo's read_file nests its arguments: <args><file><path>a</path></file></args>.
+  if (!LONG_PARAMS.has(name) && t.startsWith("<") && t.endsWith(">")) {
+    const nested = parseParams(t)
+    if (Object.keys(nested).length) return nested
+  }
+  return t
+}
+
+/**
+ * A result header, `[read_file for 'src/a.ts'] Result:`: the tool name and the text after the header. The
+ * quoted part is the call's main argument as written, so it can run over several lines (a multi-line
+ * ask_followup_question): that form is tried when the header does not close on its first line.
+ */
+export function resultHeader(text: string): { label: string; name: string; rest: string } | undefined {
+  const m = text.match(/^\s*\[([^\n]*?)\] Result:[^\S\n]*\n?/) ?? text.match(/^\s*\[([A-Za-z0-9_]+ for '[\s\S]{0,4000}?'[^\n\]]*)\] Result:[^\S\n]*\n?/)
+  if (!m) return undefined
+  const label = m[1]!
+  return { label, name: label.match(/^[A-Za-z0-9_]+/)?.[0] ?? label, rest: text.slice(m[0].length) }
+}
+
+/**
+ * The tool named by a notice that a call never ran: the extension runs one XML call per message, or none after
+ * the person rejects one, and answers each call it skipped with a text block of its own, e.g. `Tool [x] was not
+ * executed because a tool has already been used in this message.`, Roo's `Skipping tool [x for 'a'] due to user
+ * rejecting a previous tool.`, Cline's `Skipping tool due to user rejecting a previous tool. [x for 'a']`.
+ */
+export function skipNotice(text: string): string | undefined {
+  const t = text.trimStart()
+  return (
+    t.match(/^(?:Tool|Skipping tool) \[([A-Za-z0-9_]+)[\s\S]{0,4000}?\] (?:was not executed|was interrupted and not executed|due to user rejecting)/)?.[1] ??
+    t.match(/^(?:Skipping tool|Tool was interrupted and not executed) due to user rejecting a previous tool\.\s*\[([A-Za-z0-9_]+)/)?.[1]
+  )
+}

package/src/adapters/cline4/index.ts

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { cline4Reader } from "./reader.ts"
+import { cline4NativeWriter } from "./writer.ts"
+
+// The Cline 4.x SDK runtime (the `cline` CLI 3.x, Cline Desktop, the 4.x extension): reads its sessions from
+// ~/.cline/data, and continues any session as a new one there (written only while Cline is closed, after a
+// backup of sessions.db). Cline's classic task store is the `cline` adapter's.
+export const readers: Reader[] = [cline4Reader]
+export const writers: Writer[] = [cline4NativeWriter]

package/src/adapters/cline4/reader.ts

@@ -0,0 +1,179 @@
+import { readdirSync } from "node:fs"
+import { exists, gitInfo, readJson } from "../../fsutil.ts"
+import type { Attachment, Session, Turn, Usage } from "../../session/types.ts"
+import { clip, header, iso, lossCounter, noteModel } from "../../session/util.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUED_NOTE, LABEL, NOTE_KIND, TOOL, clineToolKind, manifestPath, messagesPath, sessionsDb, sessionsDir } from "./records.ts"
+
+// Cline 4.x SDK sessions (records.ts has the layout): the root sessions in sessions.db, newest first, or
+// the manifests when there is no database. Subagent and teammate sessions belong to their root session and
+// are not listed. Cline's classic task store (~/.cline/data/tasks, globalStorage) is the `cline` reader's.
+
+type Json = Record<string, any>
+
+/** What the person typed: Cline wraps it in <user_input mode="..."> and adds <mode_notice> elements. */
+const displayText = (text: string) =>
+  text
+    .replace(/<mode_notice>[\s\S]*?<\/mode_notice>/g, "")
+    .replace(/<\/?(user_input|user_command)\b[^>]*>/g, "")
+    .trim()
+
+const usageOf = (m: Json | undefined): Usage | undefined => {
+  if (!m || typeof m !== "object") return undefined
+  const out: Usage = {}
+  if (m.inputTokens) out.input = m.inputTokens
+  if (m.outputTokens) out.output = m.outputTokens
+  if (m.cacheReadTokens) out.cacheRead = m.cacheReadTokens
+  if (m.cacheWriteTokens) out.cacheWrite = m.cacheWriteTokens
+  return Object.keys(out).length ? out : undefined
+}
+
+const resultText = (content: unknown, images: () => void): string => {
+  if (typeof content === "string") return content
+  const parts: string[] = []
+  for (const b of Array.isArray(content) ? content : []) {
+    if (b?.type === "text" && typeof b.text === "string") parts.push(b.text)
+    else if (b?.type === "file" && typeof b.path === "string") parts.push(`[File: ${b.path}]`)
+    else images()
+  }
+  return parts.join("\n")
+}
+
+export const cline4Reader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+  async list(home) {
+    const db = sessionsDb(home)
+    const rows: Json[] = exists(db)
+      ? withSnapshot(db, (d) =>
+          d
+            .query(
+              "SELECT session_id, cwd, metadata_json, prompt, started_at, ended_at, updated_at, messages_path FROM sessions WHERE is_subagent = 0 AND (parent_session_id IS NULL OR parent_session_id = '') ORDER BY started_at DESC",
+            )
+            .all() as Json[],
+        )
+      : manifestRows(home)
+    const refs: SessionRef[] = []
+    for (const r of rows) {
+      let meta: Json = {}
+      try {
+        meta = typeof r.metadata_json === "string" ? JSON.parse(r.metadata_json) : (r.metadata_json ?? {})
+      } catch {}
+      const title = typeof meta.title === "string" && meta.title ? meta.title : typeof r.prompt === "string" ? r.prompt.split("\n")[0]?.slice(0, 80) : undefined
+      const updated = iso(r.ended_at) ?? iso(r.updated_at) ?? iso(r.started_at)
+      refs.push({
+        tool: TOOL,
+        sourceId: String(r.session_id),
+        path: typeof r.messages_path === "string" && r.messages_path ? r.messages_path : messagesPath(home, String(r.session_id)),
+        ...(title ? { title } : {}),
+        ...(typeof r.cwd === "string" && r.cwd ? { cwd: r.cwd } : {}),
+        ...(updated ? { updatedAt: updated } : {}),
+      })
+    }
+    return refs
+  },
+  async read(ref, home) {
+    const path = exists(ref.path) ? ref.path : messagesPath(home, ref.sourceId)
+    const file = readJson<Json>(path)
+    if (!file || !Array.isArray(file.messages)) throw new Error(`${path} is not a Cline messages file`)
+    const manifest = readJson<Json>(manifestPath(home, ref.sourceId)) ?? {}
+    return parseMessages(file, manifest, { id: ref.sourceId, path, home })
+  },
+}
+
+/** Manifests stand in for the database's rows when Cline has not created sessions.db. */
+function manifestRows(home: string): Json[] {
+  let names: string[]
+  try {
+    names = readdirSync(sessionsDir(home))
+  } catch {
+    return []
+  }
+  const rows: Json[] = []
+  for (const id of names) {
+    const m = readJson<Json>(manifestPath(home, id))
+    if (m?.version !== 1 || m.session_id !== id) continue
+    rows.push({ session_id: id, cwd: m.cwd, metadata_json: m.metadata, prompt: m.prompt, started_at: m.started_at, ended_at: m.ended_at, messages_path: m.messages_path })
+  }
+  return rows.sort((a, b) => String(b.started_at).localeCompare(String(a.started_at)))
+}
+
+/** A messages file (with its manifest) as a portable session. */
+export function parseMessages(file: Json, manifest: Json, ctx: { id: string; path: string; home: string }): Session {
+  const cwd = typeof manifest.cwd === "string" && manifest.cwd ? manifest.cwd : undefined
+  const title = typeof manifest.metadata?.title === "string" ? manifest.metadata.title : undefined
+  const h = header(TOOL, ctx.id, {
+    sourcePath: ctx.path,
+    ...(title ? { title } : {}),
+    project: cwd ? { cwd, ...gitInfo(cwd, ctx.home) } : {},
+    ...(iso(manifest.started_at) ? { startedAt: iso(manifest.started_at) } : {}),
+    ...(iso(file.updated_at) ?? iso(manifest.ended_at) ? { updatedAt: iso(file.updated_at) ?? iso(manifest.ended_at) } : {}),
+  })
+  const lost = lossCounter()
+  const turns: Turn[] = []
+
+  for (const m of file.messages as Json[]) {
+    if (!m || (m.role !== "user" && m.role !== "assistant")) continue
+    const meta = (m.metadata ?? {}) as Json
+    const at = typeof m.ts === "number" ? iso(m.ts) : undefined
+    const when = at ? { at } : {}
+    const blocks: Json[] = typeof m.content === "string" ? [{ type: "text", text: m.content }] : Array.isArray(m.content) ? m.content : []
+    if (meta.displayOnly === true) continue // shown in the panel, never sent to the model
+    if (meta.kind === "compaction_summary" || meta.kind === "compaction") {
+      const summary = typeof meta.summary === "string" && meta.summary ? meta.summary : blocks.map((b) => (b?.type === "text" ? b.text : "")).join("\n")
+      if (summary.trim()) turns.push({ kind: "compaction", ...when, summary })
+      continue
+    }
+    if (meta.kind === NOTE_KIND) {
+      const continued = blocks.map((b) => (b?.type === "text" ? String(b.text) : "")).join("\n").match(CONTINUED_NOTE)
+      if (continued?.[1] && !h.parent) h.parent = { id: continued[1], kind: "continued" }
+      continue
+    }
+    if (m.role === "user") {
+      if (meta.displayRole === "system" || meta.displayRole === "status") {
+        lost.add("runtime notices")
+        continue
+      }
+      const parts: string[] = []
+      const attachments: Attachment[] = []
+      for (const b of blocks) {
+        if (b?.type === "tool_result") {
+          let images = 0
+          const out = clip(resultText(b.content, () => images++))
+          if (images) lost.add("images in tool results", images)
+          turns.push({ kind: "tool_result", ...when, callId: String(b.tool_use_id), ok: b.is_error !== true, output: out.text, ...(out.truncated ? { truncated: true } : {}) })
+        } else if (b?.type === "text" && typeof b.text === "string") {
+          const t = displayText(b.text)
+          if (t) parts.push(t)
+        } else if (b?.type === "file" && typeof b.path === "string") attachments.push({ kind: "file", path: b.path })
+        else if (b?.type === "image" || b?.type === "media") lost.add("images")
+        else lost.add("unknown user content")
+      }
+      const text = parts.join("\n\n")
+      if (text || attachments.length) turns.push({ kind: "user", ...when, text, ...(attachments.length ? { attachments } : {}) })
+      continue
+    }
+    const model = typeof m.modelInfo?.id === "string" && m.modelInfo.id ? m.modelInfo.id : undefined
+    noteModel(h, model)
+    const usage = usageOf(m.metrics)
+    let usageGiven = false
+    for (const b of blocks) {
+      if (b?.type === "text" && typeof b.text === "string") {
+        if (!b.text.trim()) continue
+        turns.push({ kind: "assistant", ...when, text: b.text, ...(model ? { model } : {}), ...(usage && !usageGiven ? { usage } : {}) })
+        usageGiven = true
+      } else if (b?.type === "thinking") {
+        if (typeof b.thinking === "string" && b.thinking.trim()) turns.push({ kind: "reasoning", ...when, text: b.thinking })
+        else if (b.signature) lost.add("signed reasoning")
+      } else if (b?.type === "redacted_thinking") lost.add("redacted reasoning")
+      else if (b?.type === "tool_use" && typeof b.id === "string") {
+        const name = String(b.name ?? "tool")
+        turns.push({ kind: "tool_call", ...when, id: b.id, name, toolKind: clineToolKind(name), input: b.input ?? {} })
+      } else if (b?.type === "image" || b?.type === "media") lost.add("generated media")
+      else lost.add("unknown assistant content")
+    }
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}

package/src/adapters/cline4/records.ts

@@ -0,0 +1,92 @@
+import { join } from "node:path"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+
+// What the Cline 4.x SDK runtime (the `cline` CLI 3.x, Cline Desktop, the 4.x extension) stores, as far as
+// this adapter relies on it. Checked against cline/cline at 94eecbb (2026-11-06, CLI 3.0.74):
+// sdk/packages/shared/src/db/sqlite-db.ts (the sessions table), shared/src/storage/paths.ts (the folders),
+// core/src/session/services/persistence-service.ts (createRootSessionWithArtifacts, persistSessionMessages),
+// core/src/services/session-data.ts (the messages file), core/src/session/models/session-manifest.ts,
+// core/src/runtime/host/history.ts (`cline history`), core/src/services/session-import/ (Cline's own
+// Claude Code / Codex / OpenCode importer, whose output this writer matches), shared/src/llms/messages.ts
+// and apps/cli/src/tui/utils/hydrate-messages.ts (what the CLI shows on resume). Catalogue entry 38.
+//
+//   ~/.cline/data/db/sessions.db                       SQLite (WAL): one `sessions` row per session, with
+//                                                       messages_path pointing at the messages file
+//   ~/.cline/data/sessions/<id>/<id>.json               the manifest (version 1), what the row says
+//   ~/.cline/data/sessions/<id>/<id>.messages.json     {version 1, updated_at, agent, sessionId, origin,
+//                                                       messages: MessageWithMetadata[]}
+//
+// Messages are Anthropic-shaped: an assistant message holds text, thinking and tool_use blocks, and the
+// user message after it holds the tool_result blocks. A user message whose metadata.displayRole is "system"
+// goes to the model but is not shown (compaction summaries use it). Ids are `<ms>_<5 nanoid chars>`.
+
+export const TOOL = "cline-sdk"
+export const LABEL = "Cline (CLI, Desktop)"
+
+/** Cline CLI releases whose store was checked in source; the writer was run against 3.0.74. */
+export const TESTED_VERSIONS = ["3.0.74"]
+
+export const dataDir = (home: string) => join(home, ".cline", "data")
+export const sessionsDb = (home: string) => join(dataDir(home), "db", "sessions.db")
+export const sessionsDir = (home: string) => join(dataDir(home), "sessions")
+export const sessionDir = (home: string, id: string) => join(sessionsDir(home), id)
+export const manifestPath = (home: string, id: string) => join(sessionDir(home, id), `${id}.json`)
+export const messagesPath = (home: string, id: string) => join(sessionDir(home, id), `${id}.messages.json`)
+
+/** The sessions table as Cline 3.0.74 creates it (SQLITE_STATEMENTS in sqlite-db.ts). */
+export const SESSIONS_TABLE = `CREATE TABLE IF NOT EXISTS sessions (
+		session_id TEXT PRIMARY KEY,
+		source TEXT NOT NULL,
+		pid INTEGER NOT NULL,
+		started_at TEXT NOT NULL,
+		ended_at TEXT,
+		exit_code INTEGER,
+		status TEXT NOT NULL,
+		status_lock INTEGER NOT NULL DEFAULT 0,
+		interactive INTEGER NOT NULL,
+		provider TEXT NOT NULL,
+		model TEXT NOT NULL,
+		cwd TEXT NOT NULL,
+		workspace_root TEXT NOT NULL,
+		team_name TEXT,
+		enable_tools INTEGER NOT NULL,
+		enable_spawn INTEGER NOT NULL,
+		enable_teams INTEGER NOT NULL,
+		parent_session_id TEXT,
+		parent_agent_id TEXT,
+		agent_id TEXT,
+		conversation_id TEXT,
+		is_subagent INTEGER NOT NULL DEFAULT 0,
+		prompt TEXT,
+		metadata_json TEXT,
+		transcript_path TEXT NOT NULL DEFAULT '',
+		hook_path TEXT NOT NULL,
+		messages_path TEXT,
+		updated_at TEXT NOT NULL
+	);`
+
+/** Process names of a running Cline that holds the store open: the CLI and its hub daemon, Cline Desktop. */
+export const PROCESSES = ["cline", "Cline", "Cline Desktop"]
+
+/** The metadata kind of the note saying where a session came from (a system-role message, kept off screen). */
+export const NOTE_KIND = "brain_continued_session"
+
+/** Cline's own tools (sdk/packages/core/src/extensions/tools), where the name alone does not say what they do. */
+const KINDS: Record<string, ToolKind> = {
+  read_file: "read",
+  read_files: "read",
+  run_commands: "shell",
+  editor: "edit",
+  apply_patch: "edit",
+  search_codebase: "search",
+  fetch_web_content: "web",
+  ask_question: "ask",
+  skills: "other",
+  spawn_agent: "task",
+}
+export const clineToolKind = (name: string): ToolKind => KINDS[name] ?? (name.startsWith("team_") ? "task" : toolKindOf(name))
+
+export const continuedNote = (label: string, id: string, when: string) =>
+  `This session continues ${label} session ${id}, carried over by brain session on ${when}. The messages that follow are its history; reasoning and anything listed as lost did not carry over. Check files before relying on details, since they may have changed.`
+export const CONTINUED_NOTE = /^This session continues .+? session (\S+), carried over by brain session/