@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/pi/reader.ts

@@ -0,0 +1,261 @@
+import { readFileSync, statSync } from "node:fs"
+import { basename, join } from "node:path"
+import { exists, gitInfo, ls, mtime } from "../../fsutil.ts"
+import type { Session, Turn, Usage } from "../../session/types.ts"
+import { clip, header, iso, lossCounter, noteModel } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../claude-code/records.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { type Entry, NOTE_TYPE, type PiFlavor, activeBranch, bashExecutionText, kindOf, migrate, parseEntries } from "./records.ts"
+
+// Reads Pi-format sessions (Pi, and Auggie 1.x which is built on it): <root>/--<cwd>--/<file>.jsonl.
+// The session is the active branch, the walk Pi resumes. Compactions become compaction turns placed where
+// the model's context starts over (before the first entry they kept), with every earlier turn kept in
+// front of them, so a writer can start from the summary or carry the whole history. Context edits are
+// applied as Pi applies them: a removed entry is left out, a replaced one carries its new content.
+
+const PEEK = 64 * 1024
+
+type Lost = ReturnType<typeof lossCounter>
+
+const textOf = (content: unknown, lost?: Lost, imageWhat = "images"): string => {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  const parts: string[] = []
+  for (const b of content as Entry[]) {
+    if (b?.type === "text" && typeof b.text === "string") parts.push(b.text)
+    else if (b?.type === "image") lost?.add(imageWhat)
+  }
+  return parts.join("\n")
+}
+
+const usageOf = (u: Entry | undefined): Usage | undefined => {
+  if (!u || typeof u !== "object") return undefined
+  const out: Usage = {}
+  if (u.input) out.input = u.input
+  if (u.output) out.output = u.output
+  if (u.cacheRead) out.cacheRead = u.cacheRead
+  if (u.cacheWrite) out.cacheWrite = u.cacheWrite
+  return Object.keys(out).length ? out : undefined
+}
+
+/** One Pi session file as the portable session. */
+export function parseSession(text: string, path: string, f: PiFlavor, home?: string): Session {
+  const entries = parseEntries(text)
+  if (!entries.length) throw new Error(`${path} is not a ${f.label} session (no session header)`)
+  migrate(entries)
+  const head = entries[0]!
+  const id = String(head.id)
+  const cwd = typeof head.cwd === "string" && head.cwd ? head.cwd : undefined
+  const branch = activeBranch(entries)
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const h = header(f.tool, id, { sourcePath: path, project: { ...(cwd ? { cwd, ...gitInfo(cwd, home) } : {}) }, ...(iso(head.timestamp) ? { startedAt: iso(head.timestamp) } : {}) })
+
+  // Where each compaction's context starts over: before the first entry it kept, when that comes before it.
+  const indexOf = new Map(branch.map((e, i) => [e.id as string, i]))
+  const placedBefore = new Map<number, Entry[]>()
+  const moved = new Set<Entry>()
+  for (const [i, e] of branch.entries()) {
+    if (e.type !== "compaction") continue
+    const k = indexOf.get(e.firstKeptEntryId)
+    if (k !== undefined && k < i) {
+      placedBefore.set(k, [...(placedBefore.get(k) ?? []), e])
+      moved.add(e)
+    }
+  }
+  // The latest context edit of each entry on the branch wins.
+  const edits = new Map<string, Entry>()
+  for (const e of branch) if (e.type === "context_edit" && typeof e.targetId === "string") edits.set(e.targetId, e)
+
+  const calls = new Map<string, Extract<Turn, { kind: "tool_call" }>>()
+  const compaction = (e: Entry) => {
+    if (typeof e.summary === "string" && e.summary.trim()) turns.push({ kind: "compaction", ...at(e.timestamp), summary: e.summary })
+  }
+  let title: string | undefined
+  let continued: string | undefined
+  let last: string | undefined
+
+  for (const [i, e] of branch.entries()) {
+    for (const c of placedBefore.get(i) ?? []) compaction(c)
+    if (typeof e.timestamp === "string") last = e.timestamp
+    switch (e.type) {
+      case "message": {
+        const edit = edits.get(e.id)
+        if (edit && edit.replacement === null) break
+        const m = edit ? { ...e.message, content: edit.replacement?.content } : e.message
+        message(m, e.timestamp)
+        break
+      }
+      case "compaction":
+        if (!moved.has(e)) compaction(e)
+        break
+      case "custom_message": {
+        const note = typeof e.content === "string" ? e.content.match(CONTINUED_NOTE) : null
+        if (e.customType === NOTE_TYPE) {
+          if (note) continued = note[1]
+        } else lost.add("extension messages")
+        break
+      }
+      case "session_info":
+        title = typeof e.name === "string" && e.name.trim() ? e.name.trim() : undefined
+        break
+      case "model_change":
+        noteModel(h, typeof e.modelId === "string" ? e.modelId : undefined)
+        break
+      case "branch_summary":
+        lost.add("summaries of abandoned branches")
+        break
+      case "thinking_level_change":
+      case "usage":
+      case "custom":
+      case "label":
+      case "context_edit":
+        break
+      default:
+        lost.add(`unknown entry types: ${String(e.type)}`)
+    }
+  }
+
+  function message(m: Entry, when: string | undefined) {
+    if (!m || typeof m !== "object") return
+    const stamp = at(typeof m.timestamp === "number" ? m.timestamp : when)
+    switch (m.role) {
+      case "user": {
+        const text = textOf(m.content, lost)
+        if (text.trim()) turns.push({ kind: "user", ...stamp, text })
+        break
+      }
+      // Auggie's slash-command and rule messages reach the model as the user's text.
+      case "promptCommandInvocation":
+        if (typeof m.expandedBody === "string" && m.expandedBody.trim()) turns.push({ kind: "user", ...stamp, text: m.expandedBody })
+        break
+      case "ruleReference":
+        if (typeof m.llmText === "string" && m.llmText.trim()) turns.push({ kind: "user", ...stamp, text: m.llmText })
+        break
+      case "assistant": {
+        const model = typeof m.model === "string" ? m.model : undefined
+        noteModel(h, model)
+        let usage = usageOf(m.usage)
+        for (const b of Array.isArray(m.content) ? (m.content as Entry[]) : []) {
+          if (b?.type === "text" && typeof b.text === "string" && b.text.trim()) {
+            turns.push({ kind: "assistant", ...stamp, text: b.text, ...(model ? { model } : {}), ...(usage ? { usage } : {}) })
+            usage = undefined
+          } else if (b?.type === "thinking") {
+            if (b.redacted) lost.add("redacted reasoning")
+            else if (typeof b.thinking === "string" && b.thinking.trim()) turns.push({ kind: "reasoning", ...stamp, text: b.thinking })
+            else if (b.thinkingSignature) lost.add("signed reasoning")
+          } else if (b?.type === "toolCall" && typeof b.id === "string") {
+            const name = typeof b.name === "string" ? b.name : "tool"
+            const call: Extract<Turn, { kind: "tool_call" }> = { kind: "tool_call", ...stamp, id: b.id, name, toolKind: kindOf(name), input: b.arguments ?? {} }
+            calls.set(b.id, call)
+            turns.push(call)
+          }
+        }
+        break
+      }
+      case "toolResult": {
+        if (typeof m.toolCallId !== "string") break
+        const full = clip(textOf(m.content, lost, "tool result images"))
+        const d = m.details && typeof m.details === "object" ? (m.details as Entry) : {}
+        const fullPath = typeof d.fullOutputPath === "string" ? d.fullOutputPath : undefined
+        const ok = m.isError !== true
+        turns.push({ kind: "tool_result", ...stamp, callId: m.toolCallId, ok, output: full.text, ...(full.truncated || d.truncation?.truncated ? { truncated: true } : {}), ...(fullPath ? { fullPath } : {}) })
+        // Pi's edit and write tools change one file each; the diff is in the edit's details.
+        const call = calls.get(m.toolCallId)
+        const target = (call?.input as Entry | undefined)?.path
+        if (ok && call && (call.name === "edit" || call.name === "write") && typeof target === "string")
+          turns.push({ kind: "file_edit", ...stamp, path: target, ...(typeof d.diff === "string" ? { patch: d.diff } : {}), callId: call.id })
+        break
+      }
+      case "bashExecution":
+        // A command the person ran with `!`: the model reads it as their message, unless kept out of context.
+        if (!m.excludeFromContext) turns.push({ kind: "user", ...stamp, text: bashExecutionText(m) })
+        break
+      case "custom":
+        lost.add("extension messages")
+        break
+      case "compactionSummary":
+        if (typeof m.summary === "string") turns.push({ kind: "compaction", ...stamp, summary: m.summary })
+        break
+      case "branchSummary":
+        lost.add("summaries of abandoned branches")
+        break
+      case "system":
+        lost.add(`${f.label} system prompt and tool declarations (not carried)`)
+        break
+      default:
+        lost.add(`unknown message roles: ${String(m.role)}`)
+    }
+  }
+
+  h.title = title ?? (turns.find((t) => t.kind === "user") as Extract<Turn, { kind: "user" }> | undefined)?.text.replace(/\s+/g, " ").trim().slice(0, 80)
+  if (!h.title) delete h.title
+  const updated = iso(last)
+  if (updated) h.updatedAt = updated
+  if (continued) h.parent = { id: continued, kind: "continued" }
+  else if (typeof head.parentSession === "string" && head.parentSession) {
+    const parent = basename(head.parentSession, ".jsonl").replace(/^.*_/, "")
+    if (parent) h.parent = { id: `${f.tool}:${parent}`, kind: "fork" }
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+function at(v: unknown): { at?: string } {
+  const t = iso(v)
+  return t ? { at: t } : {}
+}
+
+/** The header, the name the person gave it, and the first request, from the start and end of a file. */
+async function peek(path: string): Promise<Omit<SessionRef, "tool" | "path"> | undefined> {
+  const file = Bun.file(path)
+  const text = file.size <= 4 * PEEK ? await file.text() : `${await file.slice(0, PEEK).text()}\n${await file.slice(file.size - PEEK).text()}`
+  const entries = parseEntries(text)
+  const head = entries[0]
+  if (!head) return undefined
+  let name: string | undefined
+  let first: string | undefined
+  for (const e of entries) {
+    if (e.type === "session_info") name = typeof e.name === "string" && e.name.trim() ? e.name.trim() : undefined
+    if (!first && e.type === "message" && e.message?.role === "user") first = textOf(e.message.content).replace(/\s+/g, " ").trim().slice(0, 80) || undefined
+  }
+  const title = name ?? first
+  return {
+    sourceId: String(head.id),
+    ...(title ? { title } : {}),
+    ...(typeof head.cwd === "string" && head.cwd ? { cwd: head.cwd } : {}),
+    ...(mtime(path) ? { updatedAt: mtime(path) } : {}),
+  }
+}
+
+export function piFamilyReader(f: PiFlavor): Reader {
+  return {
+    tool: f.tool,
+    label: f.label,
+
+    async list(home: string): Promise<SessionRef[]> {
+      const root = f.sessionsRoot(home)
+      const refs: SessionRef[] = []
+      for (const project of ls(root)) {
+        const dir = join(root, project)
+        for (const name of ls(dir)) {
+          if (!name.endsWith(".jsonl")) continue
+          const path = join(dir, name)
+          try {
+            if (!statSync(path).isFile()) continue
+            const p = await peek(path)
+            if (p) refs.push({ tool: f.tool, path, ...p })
+          } catch {
+            // Deleted or unreadable between listing and reading: not a session to offer.
+          }
+        }
+      }
+      return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+    },
+
+    async read(ref: SessionRef, home: string): Promise<Session> {
+      if (!exists(ref.path)) throw new Error(`no ${f.label} session at ${ref.path}`)
+      return parseSession(readFileSync(ref.path, "utf8"), ref.path, f, home)
+    },
+  }
+}

package/src/adapters/pi/records.ts

@@ -0,0 +1,99 @@
+import { join } from "node:path"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+
+// Facts about Pi's session files, shared by the Pi and Auggie 1.x adapters: Auggie 1.x is built on Pi and
+// keeps the same entries in a different folder. Checked against earendil-works/pi at 1.5.0
+// (packages/coding-agent/src/core/session-manager.ts, messages.ts, tools/*.ts) and the bundle of
+// @augmentcode/auggie 1.2.0-prerelease.202611061509; see docs/sessions/2026-11-08-session-formats.md, entries 17 and 43.
+//
+// A file is a header line {type:"session", version:3, id, timestamp, cwd} and then entries on a tree:
+// each has an id (8 hex characters) and a parentId. Pi resumes at the last entry and walks parentId back to
+// the root, so the active branch is that walk. Messages hold Pi's AgentMessage: user, assistant (content
+// blocks text / thinking / toolCall), toolResult (one message per call, joined by toolCallId), plus
+// Pi's own roles (bashExecution, custom). A compaction entry replaces everything before firstKeptEntryId
+// with its summary; one that keeps nothing names itself.
+
+export const SESSION_VERSION = 3
+
+/** customType of the hidden note a writer adds; readers skip it. */
+export const NOTE_TYPE = "brain-continued"
+
+export type Entry = Record<string, any>
+
+export interface PiFlavor {
+  /** Reader and writer id, e.g. "pi". */
+  tool: string
+  label: string
+  /** The command, for `--version` and the open command. */
+  bin: string
+  /** The folder holding one sub-folder of session files per project. */
+  sessionsRoot(home: string): string
+  /** The session file's name: Pi prefixes the start time, Auggie does not. */
+  fileName(id: string, startedAt: string): string
+  /** A new session id in the tool's style. */
+  newId(): string
+}
+
+/** The folder Pi keeps a project's sessions in: the cwd without its leading separator, / \ and : turned into -, between --. */
+export const projectFolder = (cwd: string) => `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`
+
+export const sessionDir = (f: PiFlavor, home: string, cwd: string) => join(f.sessionsRoot(home), projectFolder(cwd))
+
+/** Every entry of a session file, header first; none when the first line is not a session header (Pi's own check). */
+export function parseEntries(text: string): Entry[] {
+  const out: Entry[] = []
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue
+    try {
+      out.push(JSON.parse(line))
+    } catch {
+      // a half-written line: Pi skips it too
+    }
+  }
+  const h = out[0]
+  return h?.type === "session" && typeof h.id === "string" ? out : []
+}
+
+/** Version 1 files have no ids: give them the linear chain Pi's own migration gives them, so one walk reads every version. */
+export function migrate(entries: Entry[]): void {
+  if ((entries[0]?.version ?? 1) >= 2) return
+  let prev: string | null = null
+  entries.forEach((e, i) => {
+    if (i === 0) return
+    e.id = `v1-${i}`
+    e.parentId = prev
+    prev = e.id
+  })
+  for (const e of entries) {
+    if (e.type === "compaction" && typeof e.firstKeptEntryIndex === "number") e.firstKeptEntryId = entries[e.firstKeptEntryIndex]?.id
+  }
+}
+
+/** The active branch: from the last entry back to the root, as Pi resumes it. */
+export function activeBranch(entries: Entry[]): Entry[] {
+  const body = entries.filter((e) => e.type !== "session" && e.type !== "queue_state" && typeof e.id === "string")
+  const byId = new Map(body.map((e) => [e.id as string, e]))
+  const path: Entry[] = []
+  const seen = new Set<string>()
+  for (let e = body[body.length - 1]; e && !seen.has(e.id); e = e.parentId ? byId.get(e.parentId) : undefined) {
+    seen.add(e.id)
+    path.push(e)
+  }
+  return path.reverse()
+}
+
+/** What Pi's built-in tools do, so a call reads back with the right kind. */
+const PI_KINDS: Record<string, ToolKind> = { read: "read", bash: "shell", edit: "edit", write: "write", grep: "search", find: "search", ls: "list" }
+
+export const kindOf = (name: string): ToolKind => PI_KINDS[name] ?? toolKindOf(name)
+
+/** The text Pi gives the model for a shell command the person ran with `!` (messages.ts bashExecutionToText). */
+export function bashExecutionText(m: Entry): string {
+  let text = `Ran \`${m.command}\`\n`
+  text += m.output ? `\`\`\`\n${m.output}\n\`\`\`` : "(no output)"
+  if (m.cancelled) text += "\n\n(command cancelled)"
+  else if (m.exitCode !== null && m.exitCode !== undefined && m.exitCode !== 0) text += `\n\nCommand exited with code ${m.exitCode}`
+  if (m.truncated && m.fullOutputPath) text += `\n\n[Output truncated. Full output: ${m.fullOutputPath}]`
+  return text
+}