@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/devin/records.ts

@@ -0,0 +1,277 @@
+import type { Database } from "bun:sqlite"
+import { join, resolve } from "node:path"
+import { appSupport, versionOf } from "../../fsutil.ts"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+
+// Devin CLI (Cognition): where its sessions are and what its rows look like. From xhluca/session-migrate (MIT):
+// docs/devin-format.md and src/session_migrate/formats/devin.py, pinned to Devin CLI 3000.6.7 (260a97c8) and
+// its SQLite schema 16, and from the store that exact CLI wrote in session-migrate's native corpus
+// (tests/native_corpus/v1/sources/devin/3000.6.7/portable-rich, copied to test/fixtures/native-corpus/devin).
+//
+// Every local conversation lives in one shared sessions.db: a `sessions` row per conversation (its id a
+// human-readable slug such as "pricey-toaster", its cwd, model and title; rows with hidden = 1 are not shown),
+// and `message_nodes`, a forest of chat messages per session. `sessions.main_chain_id` is the tip of the
+// active branch, so the conversation is the walk from that tip up the parent links; retried or edited-away
+// nodes stay in the table and are not part of it. Each node's chat_message is JSON with a role (system, user,
+// assistant, tool): user messages carry base64 `images`, assistant messages `tool_calls` and `thinking`, tool
+// messages a `tool_call_id`. `tool_call_state` keeps the ACP ToolCall / ToolCallUpdate Devin shows for each
+// call. Times in columns are epoch seconds; times inside the JSON are RFC 3339. `devin --resume <id>` resumes.
+
+export const TOOL = "devin"
+export const LABEL = "Devin CLI"
+/** Devin CLI versions whose store the reader and writer were checked against. */
+export const TESTED_VERSIONS = ["3000.6.7"]
+/** The CLI version whose schema (16 migrations below) the store has; Devin's rows do not record the version. */
+export const PINNED_VERSION = "3000.6.7"
+/** The model a continued session runs on: Devin's default (the Free plan's) in the doc and the capture. */
+export const DEFAULT_MODEL = "swe-1-6-slow"
+
+/** The devin binary on PATH, read at call time (Bun.which does not see a PATH changed after start). */
+export const devinBin = (): string | undefined => Bun.which("devin", { PATH: process.env.PATH ?? "" }) ?? undefined
+
+/** What `devin --version` says ("devin 3000.6.7 (260a97c8)") and the version in it. */
+export function devinVersion(bin: string): { raw?: string; version?: string } {
+  const raw = versionOf(bin)
+  const version = raw?.match(/\d+\.\d+\.\d+/)?.[0]
+  return { ...(raw ? { raw } : {}), ...(version ? { version } : {}) }
+}
+
+const DB = "sessions.db"
+
+/**
+ * $XDG_DATA_HOME, when it describes this home (the person's own, not a test's or another account's), else
+ * <home>/.local/share.
+ */
+function xdgDataHome(home: string): string {
+  const xdg = process.env.XDG_DATA_HOME
+  if (xdg?.startsWith("/") && process.env.HOME && resolve(home) === resolve(process.env.HOME)) return xdg
+  return join(home, ".local", "share")
+}
+
+/**
+ * The store Devin uses on this platform: ~/Library/Application Support/devin/cli/sessions.db on macOS,
+ * $XDG_DATA_HOME/devin/cli/sessions.db (else ~/.local/share/...) on Linux, %APPDATA%\devin\cli on Windows.
+ */
+export function storePath(home: string, platform: string = process.platform): string {
+  if (platform === "darwin") return join(appSupport(home), "devin", "cli", DB)
+  if (platform === "win32") return join(home, "AppData", "Roaming", "devin", "cli", DB)
+  return join(xdgDataHome(home), "devin", "cli", DB)
+}
+
+/** Every place a store may be: the platform's own first, then the Linux ones (a store copied from Linux). */
+export function storeCandidates(home: string): string[] {
+  return [...new Set([storePath(home), join(xdgDataHome(home), "devin", "cli", DB), join(home, ".local", "share", "devin", "cli", DB)])]
+}
+
+/** refinery's migrations of a schema-16 store, with their checksums: (version, name, checksum). */
+export const MIGRATIONS: Array<[number, string, string]> = [
+  [1, "initial_schema", "9244923949255133246"],
+  [2, "add_thinking_column", "14224532003883382682"],
+  [3, "add_prompt_history", "12622061916787456317"],
+  [4, "add_metadata_column", "10743897110053661924"],
+  [5, "message_forest", "9668121967925007678"],
+  [6, "add_node_metadata", "8078921727324108560"],
+  [7, "add_shell_context", "258551201440621856"],
+  [8, "add_session_cogs", "105359765896368723"],
+  [9, "add_rendered_commits", "3762685451217257726"],
+  [10, "add_workspace_dirs", "10474887258761036276"],
+  [11, "add_prompt_history_is_shell", "11375493059147639310"],
+  [12, "add_app_state", "14171664772219278324"],
+  [13, "rename_permission_mode_to_agent_mode", "14037567567567316550"],
+  [14, "tool_call_state", "9276893574920127698"],
+  [15, "add_hidden_column", "3632756168171233470"],
+  [16, "add_session_json_metadata", "4954231843905863386"],
+]
+
+/** Every table of a schema-16 store with its columns, in order. */
+export const COLUMNS: Record<string, string[]> = {
+  sessions: ["id", "working_directory", "backend_type", "model", "agent_mode", "created_at", "last_activity_at", "title", "main_chain_id", "shell_last_seen_index", "cogs_json", "workspace_dirs", "hidden", "metadata"],
+  message_nodes: ["row_id", "session_id", "node_id", "parent_node_id", "chat_message", "created_at", "metadata"],
+  prompt_history: ["id", "content", "timestamp", "session_id", "is_shell"],
+  tool_call_state: ["session_id", "tool_call_id", "tool_call_json", "tool_call_update_json"],
+  rendered_commits: ["id", "session_id", "sequence_number", "rendered_html", "created_at"],
+  app_state: ["key", "value"],
+  refinery_schema_history: ["version", "name", "applied_on", "checksum"],
+}
+
+/**
+ * The statements whose text sqlite_master holds in a store Devin 3000.6.7 made, in its order (sqlite_sequence
+ * comes by itself with the first AUTOINCREMENT table). Run as they are, a new store has the same schema text.
+ */
+export const SCHEMA: string[] = [
+  "CREATE TABLE refinery_schema_history(\n             version int4 PRIMARY KEY,\n             name VARCHAR(255),\n             applied_on VARCHAR(255),\n             checksum VARCHAR(255))",
+  "CREATE TABLE sessions (\n  id TEXT PRIMARY KEY,\n  working_directory TEXT NOT NULL,\n  backend_type TEXT NOT NULL,\n  model TEXT NOT NULL,\n  agent_mode TEXT NOT NULL,\n  created_at INTEGER NOT NULL,\n  last_activity_at INTEGER NOT NULL, title TEXT, main_chain_id INTEGER, shell_last_seen_index INTEGER DEFAULT 0, cogs_json TEXT, workspace_dirs TEXT, hidden INTEGER NOT NULL DEFAULT 0, metadata TEXT)",
+  "CREATE TABLE prompt_history (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  content TEXT NOT NULL,\n  timestamp INTEGER NOT NULL,\n  session_id TEXT NOT NULL\n, is_shell INTEGER NOT NULL DEFAULT 0)",
+  "CREATE TABLE message_nodes (\n  row_id INTEGER PRIMARY KEY AUTOINCREMENT,\n  session_id TEXT NOT NULL,\n  node_id INTEGER NOT NULL,           -- node_id within this session's forest\n  parent_node_id INTEGER,             -- NULL for root nodes\n  chat_message TEXT NOT NULL,\n  created_at INTEGER NOT NULL, metadata TEXT,\n  FOREIGN KEY (session_id) REFERENCES sessions(id),\n  UNIQUE(session_id, node_id)\n)",
+  "CREATE TABLE rendered_commits (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  session_id TEXT NOT NULL,\n  sequence_number INTEGER NOT NULL,\n  rendered_html TEXT NOT NULL,\n  created_at INTEGER NOT NULL,\n  FOREIGN KEY (session_id) REFERENCES sessions(id),\n  UNIQUE(session_id, sequence_number)\n)",
+  "CREATE TABLE app_state (\n    key TEXT PRIMARY KEY NOT NULL,\n    value TEXT NOT NULL\n)",
+  "CREATE TABLE tool_call_state (\n    session_id    TEXT    NOT NULL,\n    tool_call_id  TEXT    NOT NULL,\n    -- Serialised acp::ToolCall JSON (the initial ToolCall event).\n    -- Nullable: may be absent for interrupted sessions where the tool result\n    -- was saved but resolve_and_commit did not complete.\n    tool_call_json     TEXT,\n    -- Serialised acp::ToolCallUpdate JSON (the final completion update).\n    tool_call_update_json TEXT,\n    PRIMARY KEY (session_id, tool_call_id),\n    FOREIGN KEY (session_id) REFERENCES sessions(id)\n)",
+  "CREATE INDEX idx_sessions_activity\n  ON sessions(last_activity_at DESC)",
+  "CREATE INDEX idx_prompt_history_timestamp\n  ON prompt_history(timestamp DESC)",
+  "CREATE INDEX idx_prompt_history_session\n  ON prompt_history(session_id)",
+  "CREATE INDEX idx_message_nodes_session\n  ON message_nodes(session_id)",
+  "CREATE INDEX idx_rendered_commits_session\n  ON rendered_commits(session_id, sequence_number)",
+  "CREATE INDEX idx_sessions_hidden ON sessions(hidden)",
+]
+
+/** The columns the reader needs; a store without them is not one it knows. */
+export const NEEDED_TO_READ: Record<string, string[]> = {
+  sessions: ["id", "working_directory", "model", "created_at", "last_activity_at", "title", "main_chain_id", "hidden"],
+  message_nodes: ["session_id", "node_id", "parent_node_id", "chat_message", "created_at"],
+}
+
+/** Columns a table lacks (all of them when the table is missing). */
+export function missingColumns(d: Database, need: Record<string, string[]>): string[] {
+  const out: string[] = []
+  for (const [table, cols] of Object.entries(need)) {
+    const have = new Set((d.query(`PRAGMA table_info("${table}")`).all() as Array<{ name: string }>).map((c) => c.name))
+    for (const c of cols) if (!have.has(c)) out.push(`${table}.${c}`)
+  }
+  return out
+}
+
+/** The migrations a store has applied, or [] when it has no refinery table. */
+export function appliedMigrations(d: Database): Array<[number, string, string]> {
+  try {
+    return (d.query("SELECT version, name, checksum FROM refinery_schema_history ORDER BY version").all() as Array<{ version: number; name: string; checksum: unknown }>).map((r) => [
+      Number(r.version),
+      String(r.name),
+      String(r.checksum),
+    ])
+  } catch {
+    return []
+  }
+}
+
+/** Why a store is not one the writer may add to (exactly the schema-16 tables and migrations), or undefined. */
+export function schemaProblem(d: Database): string | undefined {
+  const applied = appliedMigrations(d)
+  const newest = applied.at(-1)?.[0] ?? 0
+  if (newest > MIGRATIONS.length) return `the Devin store was migrated by a newer Devin (schema ${newest}; this writer knows ${MIGRATIONS.length})`
+  if (JSON.stringify(applied) !== JSON.stringify(MIGRATIONS)) return `the Devin store's migrations are not the ${PINNED_VERSION} ones (schema ${newest})`
+  for (const [table, cols] of Object.entries(COLUMNS)) {
+    const have = (d.query(`PRAGMA table_info("${table}")`).all() as Array<{ name: string }>).map((c) => c.name)
+    if (JSON.stringify(have) !== JSON.stringify(cols)) return `the Devin store's ${table} table is not the one Devin ${PINNED_VERSION} makes`
+  }
+  return undefined
+}
+
+/** One image of a user message, as Devin stores it (session-migrate's own writer used media_type). */
+export interface DevinImage {
+  width: number
+  height: number
+  base64_data: string
+  mime_type?: string
+  media_type?: string
+  source_path?: string
+  caption?: string
+}
+
+export interface DevinToolCall {
+  id: string
+  name: string
+  arguments: Record<string, unknown>
+  index: number
+  kind: "function"
+}
+
+/** The metadata of a chat message; extensions are namespaced ("chisel/…", "agent-ext/…", "brain/…"). */
+export interface DevinMessageMeta {
+  num_tokens: number | null
+  is_user_input: boolean | null
+  request_id: string | null
+  metrics: Record<string, unknown> | null
+  finish_reason: string | null
+  extensions?: Record<string, unknown>
+  started_generation_at?: string
+  created_at: string
+  generation_model?: string
+  telemetry: { source: string; operation: string }
+}
+
+/** A message_nodes.chat_message. */
+export interface DevinMessage {
+  message_id: string
+  role: "system" | "user" | "assistant" | "tool"
+  content: string
+  images?: DevinImage[]
+  tool_calls?: DevinToolCall[]
+  thinking?: { thinking: string; signature: string } | null
+  tool_call_id?: string
+  metadata: DevinMessageMeta
+}
+
+/** ACP's tool kinds, which Devin records for each call, as portable ones. */
+const FROM_ACP: Record<string, ToolKind> = { read: "read", edit: "edit", search: "search", execute: "shell", fetch: "web" }
+
+/** What a Devin tool call does: from its name where that says, else from the ACP kind Devin recorded. */
+export function devinToolKind(name: string, acpKind?: string): ToolKind {
+  const byName = toolKindOf(name)
+  return byName !== "other" ? byName : (acpKind && FROM_ACP[acpKind]) || "other"
+}
+
+/** The ACP kind a portable call is shown with. */
+export function acpKindOf(kind: ToolKind): string {
+  switch (kind) {
+    case "read":
+      return "read"
+    case "edit":
+    case "write":
+      return "edit"
+    case "shell":
+      return "execute"
+    case "search":
+    case "list":
+      return "search"
+    case "web":
+      return "fetch"
+    default:
+      return "other"
+  }
+}
+
+/** The marker on a compaction the writer stores (as a system message), and the text before its summary. */
+export const COMPACTION_EXT = "brain/compaction"
+export const SUMMARY_PREFIX = "[Summary of the earlier conversation]\n"
+/** session-migrate's writer stores a compaction as a user message with this flag and prefix. */
+export const SM_SUMMARY_PREFIX = "[Imported conversation summary]\n"
+
+/** An image's type from its first bytes, for a stored image without one. */
+export function sniffImage(bytes: Uint8Array): string | undefined {
+  const b = Buffer.from(bytes.buffer, bytes.byteOffset, Math.min(bytes.length, 16))
+  if (b.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return "image/png"
+  if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return "image/jpeg"
+  if (b.subarray(0, 6).toString("latin1") === "GIF87a" || b.subarray(0, 6).toString("latin1") === "GIF89a") return "image/gif"
+  if (b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP") return "image/webp"
+  return undefined
+}
+
+/** Width and height from a PNG, JPEG, GIF or WebP header, as Devin records them; 0 × 0 when unreadable. */
+export function imageSize(bytes: Buffer): { width: number; height: number } {
+  try {
+    const type = sniffImage(bytes)
+    if (type === "image/png") return { width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) }
+    if (type === "image/gif") return { width: bytes.readUInt16LE(6), height: bytes.readUInt16LE(8) }
+    if (type === "image/jpeg") {
+      // The first start-of-frame marker (C0–CF, except C4 DHT, C8 JPG and CC DAC) holds the size.
+      for (let i = 2; i + 9 < bytes.length; ) {
+        if (bytes[i] !== 0xff) break
+        const marker = bytes[i + 1]!
+        if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc)
+          return { width: bytes.readUInt16BE(i + 7), height: bytes.readUInt16BE(i + 5) }
+        i += 2 + bytes.readUInt16BE(i + 2)
+      }
+    }
+    if (type === "image/webp") {
+      const chunk = bytes.subarray(12, 16).toString("latin1")
+      if (chunk === "VP8 ") return { width: bytes.readUInt16LE(26) & 0x3fff, height: bytes.readUInt16LE(28) & 0x3fff }
+      if (chunk === "VP8L") {
+        const [b0, b1, b2, b3] = [bytes[21]!, bytes[22]!, bytes[23]!, bytes[24]!]
+        return { width: 1 + (((b1 & 0x3f) << 8) | b0), height: 1 + (((b3 & 0xf) << 10) | (b2 << 2) | ((b1 & 0xc0) >> 6)) }
+      }
+      if (chunk === "VP8X") return { width: 1 + bytes.readUIntLE(24, 3), height: 1 + bytes.readUIntLE(27, 3) }
+    }
+  } catch {}
+  return { width: 0, height: 0 }
+}