Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

7.9 KB
Raw Blame
/**
 * Devin CLI (devin.ai, Cognition) SQLite rows → shared event vocabulary.
 *
 * Devin keeps history in `<DEVIN_HOME>/sessions.db` (WAL) rather than a transcript file, so it is polled
 * like opencode/hermes (see `./reader.ts`). Two properties of that store shape this module — both
 * verified against real captured sessions (devin 3000.2.17):
 *
 * 1. **Each `message_nodes.chat_message` maps 1:1 onto Claude's content blocks**, so instead of
 *    re-implementing a normalizer we reshape a row into the Claude raw shape and hand it to the existing,
 *    battle-tested `lineToEvents`/`messagesToEvents` (`src/lib/normalize.ts`) — which already do thinking
 *    ids, tool-name tracking, `tool_result`→`tool_end` joining, truncation and tool summaries:
 *
 *      {"message_id":"…","role":"user"|"assistant"|"tool"|"system","content":"…",
 *       "thinking":{"thinking":"…"}, "tool_call_id":"call_…",
 *       "tool_calls":[{"id":"call_…","name":"exec","arguments":{…},"index":0,"kind":"function"}],
 *       "metadata":{"finish_reason":"tool_calls"|"stop", …}}
 *
 *    `metadata.finish_reason` is authoritative, so unlike Command Code nothing has to be synthesized:
 *    `tool_calls` continues the turn, anything else ends it.
 *
 * 2. **Rows repeat.** `message_nodes` is a forest — Devin re-persists the whole prompt chain as fresh
 *    `node_id`s on every inference, so one user prompt showed up 4× and its reply 2× across 29 raw rows
 *    (6 real messages). `message_id` is stable across those copies and is the dedupe key; the reader must
 *    never tail `row_id` alone or the mirror repeats every message.
 */

import {
  lastTurnTextFromRawLines,
  lineToEvents,
  messagesToEvents,
  type LastTurnText,
  type LiveEvent,
  type SessionEvent,
  type TurnState,
} from '../../lib/normalize.js'

/** One deduped row of `message_nodes`, as returned by `readDevinMessages`. */
export interface DvMessage {
  rowId: number
  messageId: string
  role: string
  content: string
  thinking: string | null
  /** Raw JSON text of the `tool_calls` array, straight out of `json_extract`. */
  toolCalls: string | null
  toolCallId: string | null
  finishReason: string | null
  /** `metadata.created_at` (RFC3339 UTC) — lets the reader tell a log failure apart from an older one. */
  createdAt?: string | null
}

/** Devin tool ids → the vocabulary the web/device cards render. */
const TOOL_NAMES: Record<string, string> = {
  exec: 'Bash',
  shell_command: 'Bash',
  get_output: 'Bash',
  kill_shell: 'Bash',
  write_to_process: 'Bash',
  read: 'Read',
  notebook_read: 'Read',
  read_subagent: 'Read',
  write: 'Write',
  edit: 'Edit',
  apply_patch: 'Edit',
  notebook_edit: 'Edit',
  find_file_by_name: 'Glob',
  grep: 'Grep',
  web_search: 'WebSearch',
  webfetch: 'WebFetch',
  todo_write: 'TodoWrite',
  update_plan: 'TodoWrite',
  run_subagent: 'Task',
  skill: 'Task',
  ask_user_question: 'AskUserQuestion',
  exit_plan_mode: 'ExitPlanMode',
}

export function devinToolName(name: string): string {
  const key = (name || '').toLowerCase()
  if (TOOL_NAMES[key]) return TOOL_NAMES[key]
  if (!name) return 'tool'
  // `mcp_call_tool` and any new/unmapped tool: snake_case → TitleCase so the card still reads well.
  return name.split('_').filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')
}

function object(value: unknown): Record<string, unknown> | null {
  return value !== null && typeof value === 'object' && !Array.isArray(value)
    ? value as Record<string, unknown>
    : null
}

function str(value: unknown): string {
  return typeof value === 'string' ? value : ''
}

/** `tool_calls` JSON text → Claude `tool_use` blocks (tool ids mapped to the shared vocabulary). */
function toolUseBlocks(toolCalls: string | null): unknown[] {
  if (!toolCalls) return []
  let parsed: unknown
  try { parsed = JSON.parse(toolCalls) } catch { return [] }
  if (!Array.isArray(parsed)) return []
  return parsed.flatMap((entry) => {
    const call = object(entry)
    if (!call) return []
    const name = str(call.name)
    return [{
      type: 'tool_use',
      id: str(call.id) || `devin-${str(call.index)}`,
      name: devinToolName(name),
      input: object(call.arguments) ?? {},
    }]
  })
}

/**
 * One Devin row → one Claude-shaped raw line (or null for system prefix / unknown roles).
 * Exported for tests; the live reader and the replay/recap helpers all funnel through it.
 */
export function reshapeMessage(msg: DvMessage): string | null {
  const common = { uuid: msg.messageId, timestamp: undefined }

  if (msg.role === 'user') {
    return JSON.stringify({
      ...common,
      type: 'user',
      message: { role: 'user', content: [{ type: 'text', text: msg.content }] },
    })
  }
  // A tool result is a role:"user" message carrying only a tool_result block — Claude's path turns that
  // into tool_end and never mistakes it for a prompt.
  if (msg.role === 'tool') {
    if (!msg.toolCallId) return null
    return JSON.stringify({
      ...common,
      type: 'user',
      message: {
        role: 'user',
        content: [{
          type: 'tool_result',
          tool_use_id: msg.toolCallId,
          content: [{ type: 'text', text: msg.content }],
        }],
      },
    })
  }
  if (msg.role === 'assistant') {
    const content: unknown[] = []
    if (msg.thinking) content.push({ type: 'thinking', thinking: msg.thinking, signature: '' })
    if (msg.content) content.push({ type: 'text', text: msg.content })
    content.push(...toolUseBlocks(msg.toolCalls))
    return JSON.stringify({
      ...common,
      type: 'assistant',
      message: {
        role: 'assistant',
        content,
        stop_reason: msg.finishReason === 'tool_calls' ? 'tool_use' : 'end_turn',
      },
    })
  }
  return null // system prefix, and any future role
}

function reshapeAll(messages: DvMessage[]): string[] {
  const out: string[] = []
  for (const msg of messages) {
    const line = reshapeMessage(msg)
    if (line) out.push(line)
  }
  return out
}

/** Live path: one row → events, advancing the shared Claude turn state. */
export function devinMessageToEvents(msg: DvMessage, state: TurnState): LiveEvent[] {
  const line = reshapeMessage(msg)
  return line ? lineToEvents(line, state) : []
}

/** True when this row closes the turn (assistant finished without calling tools). */
export function isDevinTurnEnd(msg: DvMessage): boolean {
  return msg.role === 'assistant' && msg.finishReason !== 'tool_calls'
}

/** Full-session replay (session_get) — same render path as the live stream. */
export function devinMessagesToEvents(messages: DvMessage[]): SessionEvent[] {
  return messagesToEvents(reshapeAll(messages))
}

/** Last user prompt + the assistant text that followed it — the recap source of truth. */
export function lastDevinTurnText(messages: DvMessage[]): LastTurnText | null {
  return lastTurnTextFromRawLines(reshapeAll(messages))
}

/**
 * Turn-snapped pagination window for `session_get {limit, before}`; cursor `devin:<index>`.
 * The window start snaps back to a user prompt so a turn is never split (replay is stateful: a
 * tool_use's name must still be known when its tool_result renders).
 */
export function windowDevinMessages(
  messages: DvMessage[],
  opts: { limit: number; before?: string },
): { window: DvMessage[]; hasMore: boolean; oldestCursor: string | null; staleCursor?: boolean } {
  let endIndex = messages.length
  if (opts.before) {
    const match = /^devin:(\d+)$/.exec(opts.before)
    if (!match) return { window: [], hasMore: false, oldestCursor: null, staleCursor: true }
    endIndex = Number(match[1])
    if (!Number.isSafeInteger(endIndex) || endIndex < 0 || endIndex > messages.length) {
      return { window: [], hasMore: false, oldestCursor: null, staleCursor: true }
    }
  }
  let start = Math.max(0, endIndex - opts.limit)
  while (start > 0 && messages[start].role !== 'user') start--
  return {
    window: messages.slice(start, endIndex),
    hasMore: start > 0,
    oldestCursor: `devin:${start}`,
  }
}