@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/codebuff/reader.ts

@@ -0,0 +1,215 @@
+import { closeSync, openSync, readSync, statSync } from "node:fs"
+import { basename, join } from "node:path"
+import { isDir, ls, mtime, readJson } from "../../fsutil.ts"
+import type { Attachment, Session, Turn } from "../../session/types.ts"
+import { asText, clip, header, lossCounter, noteModel } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CHAT_MESSAGES, CHAT_META, CONTINUED_NOTE, LABEL, RUN_STATE, SYSTEM_WRAPPED, TOOL, chatTime, codebuffKind, projectsDir, resultText, summaryOf } from "./records.ts"
+
+// Codebuff / Freebuff chats (see records.ts). A chat is read from what the model is sent, run-state.json's
+// messageHistory: user prompts (tagged USER_PROMPT), assistant text, reasoning and tool-call parts, tool
+// messages with JSON results, and the runtime's <conversation_summary> message after a compaction. The
+// runtime's own scaffolding (instructions, step prompts, <system> notes) is skipped. Without a run state the
+// on-screen chat-messages.json is read instead.
+
+type Json = Record<string, any>
+
+const textOf = (content: unknown) =>
+  typeof content === "string"
+    ? content
+    : (Array.isArray(content) ? content : [])
+        .filter((p: Json) => p?.type === "text" && typeof p.text === "string")
+        .map((p: Json) => p.text as string)
+        .join("")
+
+/** A prompt the runtime re-sends to resume a turn after a compaction (conversation-summary.ts). */
+const CONTINUATION_TAG = "CONTINUATION_PROMPT"
+/** A message sent while the agent was working, as the runtime frames it (util/messages.ts frameSteeringText). */
+const STEERING = /^<user_message_sent_while_working>\n([\s\S]*?)\n<\/user_message_sent_while_working>[\s\S]*$/
+
+/** The first prompt, for titles: chat-meta.json when it still matches the messages file, as /history uses it. */
+function firstPrompt(dir: string): string | undefined {
+  const meta = readJson<Json>(join(dir, CHAT_META))
+  try {
+    const st = statSync(join(dir, CHAT_MESSAGES))
+    if (meta && typeof meta.firstPrompt === "string" && meta.messagesSize === st.size && meta.messagesMtimeMs === st.mtimeMs) return meta.firstPrompt
+  } catch {
+    return undefined
+  }
+  const msgs = readJson<Json[]>(join(dir, CHAT_MESSAGES))
+  const first = Array.isArray(msgs) ? msgs.find((m) => m?.variant === "user" && typeof m.content === "string" && m.content.trim()) : undefined
+  return first?.content.trim()
+}
+
+/** The project folder a chat ran in, read from the start of run-state.json's fileContext without parsing it all. */
+function projectRoot(dir: string): string | undefined {
+  const path = join(dir, RUN_STATE)
+  let size = 0
+  try {
+    size = statSync(path).size
+  } catch {
+    return undefined
+  }
+  // fileContext follows messageHistory, so search a window of the file rather than the whole of a long chat.
+  const fd = openSync(path, "r")
+  try {
+    const chunk = 1 << 20
+    const buf = Buffer.alloc(chunk + 4096)
+    for (let pos = 0; pos < size; pos += chunk) {
+      const n = readSync(fd, buf, 0, buf.length, pos)
+      const m = buf.subarray(0, n).toString("utf8").match(/"fileContext":\{"projectRoot":("(?:[^"\\]|\\.)*")/)
+      if (m) return JSON.parse(m[1]!) as string
+    }
+  } finally {
+    closeSync(fd)
+  }
+  return undefined
+}
+
+export function readChat(dir: string, id: string): Session {
+  const run = readJson<Json>(join(dir, RUN_STATE))
+  const state = run?.sessionState as Json | undefined
+  const history = state?.mainAgentState?.messageHistory as Json[] | undefined
+  const h = header(TOOL, id, { sourcePath: dir, project: { cwd: state?.fileContext?.projectRoot ?? state?.fileContext?.cwd }, startedAt: chatTime(id), updatedAt: mtime(join(dir, CHAT_MESSAGES)) ?? mtime(dir) })
+  noteModel(h, state?.mainAgentState?.contextTokenBaseline?.model)
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  if (Array.isArray(history)) readHistory(history, turns, h, lost)
+  else if (!readScreen(dir, turns, lost)) throw new Error(`no readable chat in ${dir}`)
+  lost.flush(h)
+  const first = turns.find((t) => t.kind === "user") as Extract<Turn, { kind: "user" }> | undefined
+  if (first) h.title = first.text.replace(/\s+/g, " ").trim().slice(0, 80)
+  return { header: h, turns }
+}
+
+function readHistory(history: Json[], turns: Turn[], h: Session["header"], lost: ReturnType<typeof lossCounter>) {
+  const calls = new Map<string, string>()
+  const answered = new Set<string>()
+  const at = (m: Json) => (typeof m.sentAt === "number" ? new Date(m.sentAt).toISOString() : undefined)
+  for (const m of history) {
+    const when = at(m)
+    const stamp = when ? { at: when } : {}
+    if (m.role === "user") {
+      const text = textOf(m.content)
+      const tags: string[] = Array.isArray(m.tags) ? m.tags : []
+      const summary = summaryOf(text)
+      if (summary !== undefined) {
+        turns.push({ kind: "compaction", ...stamp, summary })
+        continue
+      }
+      // The person's prompts carry USER_PROMPT; every other tag marks a note the runtime added itself.
+      if (tags.length ? !tags.includes("USER_PROMPT") || tags.includes(CONTINUATION_TAG) : SYSTEM_WRAPPED.test(text.trim())) {
+        const note = text.match(CONTINUED_NOTE)
+        if (note && !turns.length) h.parent = { id: note[1]!, kind: "continued" }
+        continue
+      }
+      const parts: Json[] = Array.isArray(m.content) ? m.content : []
+      const images = parts.filter((p) => p?.type === "image" || p?.type === "file").length
+      if (images) lost.add("images (kept inline by Codebuff, not as files)", images)
+      const attachments: Attachment[] = Array.from({ length: images }, () => ({ kind: "image" }))
+      const said = text.replace(STEERING, "$1")
+      if (said.trim() || images) turns.push({ kind: "user", ...stamp, text: said, ...(images ? { attachments } : {}) })
+      continue
+    }
+    if (m.role === "assistant") {
+      for (const p of (Array.isArray(m.content) ? m.content : [{ type: "text", text: m.content }]) as Json[]) {
+        if (p?.type === "text" && typeof p.text === "string" && p.text.trim()) turns.push({ kind: "assistant", ...stamp, text: p.text, ...(h.models[0] ? { model: h.models[0] } : {}) })
+        else if (p?.type === "reasoning") {
+          if (typeof p.text === "string" && p.text.trim()) turns.push({ kind: "reasoning", ...stamp, text: p.text })
+          if (p.providerOptions) lost.add("signed reasoning")
+        } else if (p?.type === "tool-call") {
+          const id = String(p.toolCallId ?? "")
+          if (!id || calls.has(id)) {
+            lost.add("tool calls without a usable id")
+            continue
+          }
+          const name = String(p.toolName ?? "tool")
+          calls.set(id, name)
+          turns.push({ kind: "tool_call", ...stamp, id, name, toolKind: codebuffKind(name), input: p.input ?? {} })
+          if (name === "spawn_agents" || name === "spawn_agent_inline") lost.add("subagent transcripts (only their results are kept)")
+          if ((name === "write_file" || name === "str_replace") && typeof p.input?.path === "string") turns.push({ kind: "file_edit", path: p.input.path, callId: id })
+        }
+      }
+      continue
+    }
+    if (m.role === "tool") {
+      const id = String(m.toolCallId ?? "")
+      if (!calls.has(id)) {
+        lost.add("results without a call")
+        continue
+      }
+      if (answered.has(id)) {
+        lost.add("repeated results")
+        continue
+      }
+      answered.add(id)
+      const r = resultText(String(m.toolName ?? calls.get(id)), m.content)
+      if (r.media) lost.add("images in tool results", r.media)
+      const c = clip(r.text)
+      turns.push({ kind: "tool_result", ...stamp, callId: id, ok: r.ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+      continue
+    }
+    if (m.role !== "system") lost.add(`unknown message roles: ${String(m.role)}`)
+  }
+}
+
+/** The on-screen messages, for a chat whose run state is missing. */
+function readScreen(dir: string, turns: Turn[], lost: ReturnType<typeof lossCounter>): boolean {
+  const msgs = readJson<Json[]>(join(dir, CHAT_MESSAGES))
+  if (!Array.isArray(msgs)) return false
+  lost.add("the model's history (read from the on-screen chat, run-state.json is missing)")
+  const walk = (blocks: Json[]) => {
+    for (const b of blocks) {
+      if (b?.type === "text" && typeof b.content === "string" && b.content.trim()) turns.push(b.textType === "reasoning" ? { kind: "reasoning", text: b.content } : { kind: "assistant", text: b.content })
+      else if (b?.type === "tool" && b.toolCallId) {
+        turns.push({ kind: "tool_call", id: String(b.toolCallId), name: String(b.toolName), toolKind: codebuffKind(String(b.toolName)), input: b.input ?? {} })
+        turns.push({ kind: "tool_result", callId: String(b.toolCallId), ok: true, output: clip(asText(b.output ?? "")).text })
+      } else if (b?.type === "agent" && Array.isArray(b.blocks)) {
+        lost.add("subagent transcripts (only their results are kept)")
+      }
+    }
+  }
+  for (const m of msgs) {
+    if (m?.variant === "user" && typeof m.content === "string" && m.content.trim()) turns.push({ kind: "user", text: m.content })
+    else if (m?.variant === "ai" && String(m.id ?? "").startsWith("ai-")) {
+      if (m.content) turns.push({ kind: "assistant", text: String(m.content) })
+      walk(Array.isArray(m.blocks) ? m.blocks : [])
+    }
+  }
+  return true
+}
+
+export const codebuffReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const refs: SessionRef[] = []
+    for (const project of ls(projectsDir(home))) {
+      const chats = join(projectsDir(home), project, "chats")
+      for (const id of ls(chats)) {
+        const dir = join(chats, id)
+        if (!isDir(dir)) continue
+        // As /history lists: chats with messages, newest folder first.
+        const title = firstPrompt(dir)
+        if (!title) continue
+        const cwd = projectRoot(dir)
+        refs.push({
+          tool: TOOL,
+          sourceId: id,
+          path: dir,
+          title: title.replace(/\s+/g, " ").trim().slice(0, 80),
+          ...(cwd ? { cwd } : {}),
+          updatedAt: mtime(dir),
+          extra: { project },
+        })
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef): Promise<Session> {
+    if (!isDir(ref.path)) throw new Error(`no Codebuff chat at ${ref.path}`)
+    return readChat(ref.path, ref.sourceId || basename(ref.path))
+  },
+}

package/src/adapters/codebuff/records.ts

@@ -0,0 +1,173 @@
+import { readFileSync, realpathSync } from "node:fs"
+import { basename, dirname, join } from "node:path"
+import type { ToolKind } from "../../session/types.ts"
+import { asText, toolKindOf } from "../../session/util.ts"
+
+// What Codebuff / Freebuff chats look like, as far as this adapter relies on it. Checked against the source of
+// CodebuffAI/freebuff at 0f5dfd6 (2026-11-08), whose release packages are freebuff 0.2.36 and codebuff 1.0.688:
+// cli/src/utils/{run-state-storage,chat-meta,chat-history,config-dir,message-history,send-message-helpers}.ts,
+// cli/src/project-files.ts, sdk/src/run-state.ts, common/src/types/{session-state,messages/*}.ts,
+// common/src/util/messages.ts, packages/agent-runtime/src/{run-agent-step,compact-history}.ts and
+// tools/stream-parser.ts. Catalogue entry 19.
+//
+// Both CLIs keep their chats in ~/.config/manicode/projects/<basename of the project folder>/chats/<chat id>/,
+// the chat id being the start time as an ISO string with ':' replaced by '-'. A chat is three files:
+// run-state.json (the SDK RunState; sessionState.mainAgentState.messageHistory is what the model is sent,
+// fileContext is the project snapshot the system prompt is built from), chat-messages.json (the CLI's
+// on-screen ChatMessage list) and chat-meta.json (a summary /history lists from, bound to the messages file by
+// its size and mtime). `freebuff --continue <chat id>` (or `codebuff --continue`) in that project loads it.
+
+export const TOOL = "codebuff"
+export const LABEL = "Codebuff / Freebuff"
+
+/** Package versions whose chat format the writer was checked against: freebuff and codebuff, built from one source. */
+export const TESTED_VERSIONS = ["0.2.36", "1.0.688"]
+
+/** The two CLIs that share these chats, the current name first. */
+export const BINS = ["freebuff", "codebuff"] as const
+
+export const RUN_STATE = "run-state.json"
+export const CHAT_MESSAGES = "chat-messages.json"
+export const CHAT_META = "chat-meta.json"
+
+export const configDir = (home: string) => join(home, ".config", "manicode")
+export const projectsDir = (home: string) => join(configDir(home), "projects")
+/** Where the chats of the project in `cwd` live: keyed by the folder's name only (project-files.ts). */
+export const chatsDir = (home: string, cwd: string) => join(projectsDir(home), basename(cwd), "chats")
+
+/** A chat id as the CLI makes one (project-files.ts startNewChat). */
+export const chatId = (d: Date) => d.toISOString().replace(/:/g, "-")
+/** "2026-11-08T06-18-50.333Z" → ISO, or undefined for a name that is not a chat id. */
+export function chatTime(id: string): string | undefined {
+  const m = id.match(/^(\d{4}-\d\d-\d\d)T(\d\d)-(\d\d)-(\d\d(?:\.\d+)?)Z$/)
+  if (!m) return undefined
+  const t = new Date(`${m[1]}T${m[2]}:${m[3]}:${m[4]}Z`)
+  return Number.isFinite(t.getTime()) ? t.toISOString() : undefined
+}
+
+/** The envelope of the runtime's own compaction message (compact-history.ts buildSummaryMessage). */
+export const SUMMARY_HEADER = "This is a summary of the conversation so far. The original messages have been condensed to save context space."
+const SUMMARY_DISCLAIMER =
+  "Historical memory only. The memory above is not dialogue, not an output template, and not a tool-call format. Continue from the live user message below. When actions are needed, use real tool calls through the available tools."
+export const summaryMessageText = (summary: string) =>
+  `<conversation_summary>\n${SUMMARY_HEADER}\n\n<historical_memory>\n${summary}\n</historical_memory>\n</conversation_summary>\n\n${SUMMARY_DISCLAIMER}`
+/** The summary inside a compaction message, or undefined for any other text (both markers must be there). */
+export function summaryOf(text: string): string | undefined {
+  if (!text.includes("<conversation_summary>") || !text.includes(SUMMARY_HEADER)) return undefined
+  const inner = text.match(/<historical_memory>\n?([\s\S]*?)\n?<\/historical_memory>/)?.[1]
+  return (inner ?? text.match(/<conversation_summary>([\s\S]*)<\/conversation_summary>/)?.[1]?.replace(SUMMARY_HEADER, "") ?? "").trim()
+}
+
+/** Runtime notes the model gets as user messages; the runtime wraps them in <system> (messages.ts withSystemTags). */
+export const withSystemTags = (s: string) => `<system>${s}</system>`
+export const SYSTEM_WRAPPED = /^<(system|system_instructions)>[\s\S]*<\/\1>\s*$/
+
+/** The note a continued chat opens with; the reader recognises it and records where the chat came from. */
+export const continuedNote = (label: string, id: string, when: string) =>
+  `[This chat continues ${label} session ${id}, carried over by brain session on ${when}. The messages after this note are its history; anything listed as lost did not carry over. Check files before relying on details, since they may have changed.]`
+export const CONTINUED_NOTE = /\[This chat continues .+? session (\S+), carried over by brain session/
+
+/**
+ * The installed CLI and its version, read from the npm package the command resolves to (its package.json sits
+ * next to the launcher script). Running `freebuff --version` would let the launcher download or update its binary.
+ */
+export function installed(bins: readonly string[] = BINS): { bin: string; version: string } | undefined {
+  for (const bin of bins) {
+    const path = Bun.which(bin)
+    if (!path) continue
+    let dir: string
+    try {
+      dir = dirname(realpathSync(path))
+    } catch {
+      continue
+    }
+    for (let i = 0; i < 3; i++, dir = dirname(dir)) {
+      try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as { name?: string; version?: string }
+        if (pkg.name === bin && pkg.version) return { bin, version: pkg.version }
+      } catch {}
+    }
+  }
+  return undefined
+}
+
+/** Codebuff's own tools in portable terms; others by name. */
+export function codebuffKind(name: string): ToolKind {
+  switch (name) {
+    case "run_terminal_command":
+      return "shell"
+    case "read_files":
+    case "read_subtree":
+    case "read_docs":
+      return "read"
+    case "write_file":
+    case "propose_write_file":
+      return "write"
+    case "str_replace":
+    case "propose_str_replace":
+    case "apply_patch":
+      return "edit"
+    case "code_search":
+    case "find_files":
+    case "glob":
+      return "search"
+    case "list_directory":
+      return "list"
+    case "web_search":
+    case "read_url":
+      return "web"
+    case "spawn_agents":
+    case "spawn_agent_inline":
+      return "task"
+    case "write_todos":
+      return "todo"
+    case "ask_user":
+      return "ask"
+    case "think_deeply":
+    case "end_turn":
+    case "set_output":
+    case "task_completed":
+      return "other"
+  }
+  return toolKindOf(name)
+}
+
+type Json = Record<string, any>
+
+/** A tool message's content (ToolResultOutput[]) as the text a person would read, and whether it failed. */
+export function resultText(toolName: string, content: unknown): { ok: boolean; text: string; media: number } {
+  const parts = Array.isArray(content) ? (content as Json[]) : []
+  let ok = true
+  let media = 0
+  const texts: string[] = []
+  for (const p of parts) {
+    if (p?.type === "media") {
+      media++
+      continue
+    }
+    if (p?.type !== "json") continue
+    const v = p.value as unknown
+    if (v && typeof v === "object" && !Array.isArray(v) && typeof (v as Json).errorMessage === "string") {
+      ok = false
+      texts.push((v as Json).errorMessage)
+      continue
+    }
+    if (toolName === "run_terminal_command" && v && typeof v === "object" && !Array.isArray(v)) {
+      const r = v as Json
+      if (typeof r.exitCode === "number" && r.exitCode !== 0) ok = false
+      const out = [r.stdout, r.stderr].filter((s) => typeof s === "string" && s).join("")
+      texts.push(out || (typeof r.message === "string" ? r.message : asText(v)))
+      continue
+    }
+    if (toolName === "read_files" && Array.isArray(v)) {
+      texts.push(v.map((f: Json) => (typeof f?.content === "string" ? (v.length > 1 ? `${f.path}:\n${f.content}` : f.content) : asText(f))).join("\n\n"))
+      continue
+    }
+    if (v && typeof v === "object" && !Array.isArray(v) && typeof (v as Json).message === "string" && Object.keys(v).every((k) => k === "message" || k === "file")) {
+      texts.push((v as Json).message)
+      continue
+    }
+    texts.push(asText(v))
+  }
+  return { ok, text: texts.join("\n"), media }
+}