@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/omp/reader.ts

@@ -0,0 +1,314 @@
+import { readFileSync, statSync } from "node:fs"
+import { basename, join } from "node:path"
+import { exists, gitInfo, ls, mtime } from "../../fsutil.ts"
+import { keepImage } from "../../session/attachments.ts"
+import type { Attachment, 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 Entry, NOTE_TYPE, activeBranch, bashExecutionText, kindOf, migrate, parseEntries } from "../pi/records.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { SETTING_TYPES, agentDirOf, agentDirs, blobRef, checkedBlob, splitTitleSlot } from "./records.ts"
+
+// Reads Oh My Pi sessions: <agent>/sessions/<bucket>/<file>.jsonl for the default agent folder and each
+// profile's. Ported from session-migrate's omp.py (MIT, xhluca) onto our Pi reader's rules: the session is the
+// active branch OMP resumes, compactions sit where the model's context starts over with the earlier turns
+// kept in front, context edits apply as Pi applies them. On top of Pi:
+// - the title is the slot's (else the last title_change, else the header's);
+// - a reset_boundary hides everything before it from the model, so those turns are left out and counted;
+// - blob-backed media become attachments pointing at the blob file (after checking its hash): images as
+//   images, PDFs, audio and video as files with their type;
+// - model_change names "<provider>/<model>"; the model part is kept.
+
+const PEEK = 64 * 1024
+const LABEL = "Oh My Pi"
+
+type Lost = ReturnType<typeof lossCounter>
+
+const textOf = (content: unknown): string => {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  return (content as Entry[])
+    .filter((b) => b?.type === "text" && typeof b.text === "string")
+    .map((b) => b.text as string)
+    .join("\n")
+}
+
+/** A user message's media as attachments: blob files where OMP keeps them, inline images saved by the brain. */
+function attachmentsOf(content: unknown, agentDir: string | undefined, lost: Lost): Attachment[] {
+  const out: Attachment[] = []
+  for (const b of Array.isArray(content) ? (content as Entry[]) : []) {
+    if (b?.type !== "image") continue
+    const mime = typeof b.mimeType === "string" ? b.mimeType : undefined
+    const hex = blobRef(b.data)
+    if (hex) {
+      const path = agentDir ? checkedBlob(agentDir, hex) : undefined
+      if (path) out.push({ kind: mime?.startsWith("image/") ? "image" : "file", path, ...(mime ? { mime } : {}) })
+      else lost.add("attachments whose blob is missing or altered")
+      continue
+    }
+    if (mime?.startsWith("image/") && typeof b.data === "string") {
+      const kept = keepImage(b.data, mime)
+      if (kept) out.push(kept)
+      else lost.add("images")
+    } else lost.add(`inline attachments (${mime ?? "unknown type"})`)
+  }
+  return out
+}
+
+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
+}
+
+/** The model part of a model_change: OMP writes "<provider>/<model>", Pi writes modelId. */
+const changedModel = (e: Entry): string | undefined => {
+  if (typeof e.modelId === "string" && e.modelId) return e.modelId
+  if (typeof e.model !== "string" || !e.model) return undefined
+  const slash = e.model.indexOf("/")
+  return slash >= 0 ? e.model.slice(slash + 1) || undefined : e.model
+}
+
+/** The name the picker shows: the slot's, else the last rename, else the header's. */
+function titleOf(slot: Entry | undefined, entries: Entry[]): string | undefined {
+  const clean = (v: unknown) => (typeof v === "string" && v.trim() ? v.trim() : undefined)
+  if (clean(slot?.title)) return clean(slot!.title)
+  for (let i = entries.length - 1; i > 0; i--) {
+    const e = entries[i]!
+    if (e.type === "title_change" && clean(e.title)) return clean(e.title)
+    if (e.type === "session_info" && clean(e.name)) return clean(e.name)
+  }
+  return clean(entries[0]?.title)
+}
+
+/** One OMP session file as the portable session; `home` is for git details only. */
+export function parseOmpSession(text: string, path: string, home?: string): Session {
+  const { slot, rest } = splitTitleSlot(text)
+  const entries = parseEntries(rest)
+  if (!entries.length) throw new Error(`${path} is not an ${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 agentDir = agentDirOf(path)
+  const lost = lossCounter()
+  const turns: Turn[] = []
+  const h = header("omp", id, { sourcePath: path, project: { ...(cwd ? { cwd, ...gitInfo(cwd, home) } : {}) }, ...(iso(head.timestamp) ? { startedAt: iso(head.timestamp) } : {}) })
+
+  // A reset boundary starts the model's context afresh: what came before it is not part of the session OMP resumes.
+  let branch = activeBranch(entries)
+  const reset = branch.map((e) => e.type).lastIndexOf("reset_boundary")
+  if (reset >= 0) {
+    const hidden = branch.slice(0, reset).filter((e) => e.type === "message" || e.type === "compaction").length
+    if (hidden) lost.add("messages hidden by a context reset", hidden)
+    branch = branch.slice(reset + 1)
+  }
+
+  // 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)
+    }
+  }
+  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 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
+        message(edit ? { ...e.message, content: edit.replacement?.content } : e.message, 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 "model_change":
+        noteModel(h, changedModel(e))
+        break
+      case "branch_summary":
+        lost.add("summaries of abandoned branches")
+        break
+      case "session_init":
+        lost.add(`${LABEL} session setup records`)
+        break
+      case "ttsr_injection":
+        lost.add(`${LABEL} rule injections`)
+        break
+      case "title_change":
+      case "session_info":
+        break
+      default:
+        if (!SETTING_TYPES.has(String(e.type))) 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)
+        const attachments = attachmentsOf(m.content, agentDir, lost)
+        if (text.trim() || attachments.length) turns.push({ kind: "user", ...stamp, text, ...(attachments.length ? { attachments } : {}) })
+        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 })
+              if (b.thinkingSignature) lost.add("reasoning signatures, text kept")
+            } 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
+        if (Array.isArray(m.content) && (m.content as Entry[]).some((b) => b?.type === "image")) lost.add("tool result images")
+        const full = clip(textOf(m.content))
+        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 } : {}) })
+        const call = calls.get(m.toolCallId)
+        const input = call?.input as Entry | undefined
+        const target = input?.path ?? input?.file_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":
+        if (!m.excludeFromContext) turns.push({ kind: "user", ...stamp, text: bashExecutionText(m) })
+        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 "custom":
+        lost.add("extension messages")
+        break
+      case "developer":
+      case "system":
+        lost.add(`${LABEL} system and developer messages`)
+        break
+      default:
+        lost.add(`unknown message roles: ${String(m.role)}`)
+    }
+  }
+
+  const title = titleOf(slot, entries) ?? (turns.find((t) => t.kind === "user") as Extract<Turn, { kind: "user" }> | undefined)?.text.replace(/\s+/g, " ").trim().slice(0, 80)
+  if (title) h.title = 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: `omp:${parent}`, kind: "fork" }
+  }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+function at(v: unknown): { at?: string } {
+  const t = iso(v)
+  return t ? { at: t } : {}
+}
+
+/** Id, folder and title from the start and end of a file: the title slot makes the name the first line. */
+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 { slot, rest } = splitTitleSlot(text)
+  const entries = parseEntries(rest)
+  const head = entries[0]
+  if (!head) return undefined
+  let first: string | undefined
+  for (const e of entries) {
+    if (e.type === "message" && e.message?.role === "user") {
+      first = textOf(e.message.content).replace(/\s+/g, " ").trim().slice(0, 80) || undefined
+      if (first) break
+    }
+  }
+  const title = titleOf(slot, entries) ?? first
+  return {
+    sourceId: String(head.id),
+    ...(title ? { title } : {}),
+    ...(typeof head.cwd === "string" && head.cwd ? { cwd: head.cwd } : {}),
+    ...(mtime(path) ? { updatedAt: mtime(path) } : {}),
+  }
+}
+
+export const ompReader: Reader = {
+  tool: "omp",
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const refs: SessionRef[] = []
+    for (const agent of agentDirs(home)) {
+      const root = join(agent, "sessions")
+      for (const bucket of ls(root)) {
+        const dir = join(root, bucket)
+        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: "omp", 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 ${LABEL} session at ${ref.path}`)
+    return parseOmpSession(readFileSync(ref.path, "utf8"), ref.path, home)
+  },
+}

package/src/adapters/omp/records.ts

@@ -0,0 +1,153 @@
+import { createHash, randomUUID } from "node:crypto"
+import { lstatSync, readFileSync, realpathSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { basename, dirname, isAbsolute, join, relative, sep } from "node:path"
+import { isDir, ls } from "../../fsutil.ts"
+import type { PiFlavor } from "../pi/records.ts"
+
+// Facts about Oh My Pi's session files (can1357/oh-my-pi, a fork of Pi), checked against OMP 18.0.5 (tag v18.0.5,
+// commit eab72e88e447a4be45bea2bc302995844c0c51a2) through session-migrate's notes, its adapter and a real 18.0.5
+// capture: xhluca/session-migrate (MIT, copyright (c) 2026 xhluca), docs/omp-format.md and
+// src/session_migrate/formats/omp.py. The semantics are ported from there; the code is ours.
+//
+// The store is the agent folder ~/.omp/agent (PI_CODING_AGENT_DIR moves it, which brain does not follow) and
+// one per named profile, ~/.omp/profiles/<name>/agent. Sessions live at
+// <agent>/sessions/<cwd bucket>/<start time>_<uuid>.jsonl and pasted media at <agent>/blobs/<sha256>.
+//
+// A file is Pi's version 3 session (header line, then entries on an id/parentId tree, see ../pi/records.ts)
+// with three differences:
+// - It starts with a fixed-width title slot: one JSON line {type:"title", v:1, title, source, updatedAt, pad}
+//   padded with spaces to exactly 256 bytes, newline included, so OMP can rename a session in place. The slot
+//   is the name the picker shows; the header repeats it (title, titleSource) and renames append title_change.
+// - Media leave the file: an image block's data is "blob:sha256:<hex>", the bytes in <agent>/blobs/<hex>.
+//   OMP takes PDFs, audio and video through the same image field and stores them the same way.
+// - The project folder ("cwd bucket") is relative to home or to the temp folder when the cwd is under one.
+// OMP also adds entry types (title_change, reset_boundary, credential_pin, mode_change, service_tier_change,
+// session_init, ttsr_injection), writes model_change as {model: "<provider>/<model>"}, and marks prompts with
+// attribution: "user".
+
+/** OMP versions whose session format this adapter was checked against. */
+export const OMP_TESTED_VERSIONS = ["18.0.5"]
+
+export const TITLE_SLOT_BYTES = 256
+const BLOB_PREFIX = "blob:sha256:"
+/** Blobs larger than this are not read (session-migrate's bound). */
+export const BLOB_LIMIT = 64 * 1024 * 1024
+
+/** The default agent folder and each named profile's, whether or not they exist. */
+export function agentDirs(home: string): string[] {
+  const profiles = join(home, ".omp", "profiles")
+  return [join(home, ".omp", "agent"), ...ls(profiles).map((p) => join(profiles, p, "agent")).filter(isDir)]
+}
+
+/** The agent folder a session file belongs to: the parent of its `sessions` folder. */
+export function agentDirOf(sessionPath: string): string | undefined {
+  for (let d = dirname(sessionPath); d && d !== dirname(d); d = dirname(d)) if (basename(d) === "sessions") return dirname(d)
+  return undefined
+}
+
+export const blobPath = (agentDir: string, hex: string) => join(agentDir, "blobs", hex)
+
+/** The sha256 an image block's data points at, when it is a blob reference. */
+export function blobRef(data: unknown): string | undefined {
+  if (typeof data !== "string" || !data.startsWith(BLOB_PREFIX)) return undefined
+  const hex = data.slice(BLOB_PREFIX.length)
+  return /^[0-9a-f]{64}$/.test(hex) ? hex : undefined
+}
+
+export const blobData = (hex: string) => `${BLOB_PREFIX}${hex}`
+
+export const sha256 = (bytes: Uint8Array) => createHash("sha256").update(bytes).digest("hex")
+
+/**
+ * A blob's path when it is a plain file (not a link), within the size bound, and its bytes hash to its name,
+ * as OMP checks it; undefined otherwise.
+ */
+export function checkedBlob(agentDir: string, hex: string): string | undefined {
+  const path = blobPath(agentDir, hex)
+  try {
+    const st = lstatSync(path)
+    if (!st.isFile() || st.size > BLOB_LIMIT) return undefined
+    return sha256(readFileSync(path)) === hex ? path : undefined
+  } catch {
+    return undefined
+  }
+}
+
+const resolved = (p: string) => {
+  try {
+    return realpathSync(p)
+  } catch {
+    return p
+  }
+}
+
+/** A path inside `root` as OMP spells it in a bucket name, or undefined when it is not inside. */
+function inside(path: string, root: string): string | undefined {
+  const rel = relative(root, path)
+  if (rel === "") return ""
+  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return undefined
+  return rel.replace(/[/\\:]/g, "-")
+}
+
+/**
+ * OMP 18.0.5's folder name for a project (session-migrate's session_directory_name): under home it is "-" and
+ * the home-relative path ("-" for home itself), under the temp folder "-tmp" and the relative path, and
+ * anywhere else the absolute path between "--", leading separators dropped. / \ and : become -. Paths are
+ * compared resolved, as OMP sees the process's folder.
+ */
+export function bucketName(cwd: string, home: string, temp = tmpdir()): string {
+  const path = resolved(cwd)
+  const inHome = inside(path, resolved(home))
+  if (inHome !== undefined) return inHome ? `-${inHome}` : "-"
+  const inTemp = inside(path, resolved(temp))
+  if (inTemp !== undefined) return inTemp ? `-tmp-${inTemp}` : "-tmp"
+  return `--${path.replace(/^[/\\]+/, "").replace(/[/\\:]/g, "-")}--`
+}
+
+const slotText = (title: string, updatedAt: string, pad: string) =>
+  `${JSON.stringify({ type: "title", v: 1, title, ...(title ? { source: "user" } : {}), updatedAt, pad })}\n`
+
+/** The 256-byte title line and the title as it fits there (cut at a character, never mid-character). */
+export function titleSlot(title: string, updatedAt: string): { line: string; title: string } {
+  const chars = Array.from(title)
+  let lo = 0
+  let hi = chars.length
+  let fit = ""
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1
+    const candidate = chars.slice(0, mid).join("")
+    if (Buffer.byteLength(slotText(candidate, updatedAt, "")) <= TITLE_SLOT_BYTES) {
+      fit = candidate
+      lo = mid + 1
+    } else hi = mid - 1
+  }
+  const line = slotText(fit, updatedAt, " ".repeat(TITLE_SLOT_BYTES - Buffer.byteLength(slotText(fit, updatedAt, ""))))
+  return { line, title: fit }
+}
+
+/** The title slot and the rest of the file; files from before the slot (legacy v3) have none. */
+export function splitTitleSlot(text: string): { slot?: Record<string, any>; rest: string } {
+  const nl = text.indexOf("\n")
+  const first = nl < 0 ? text : text.slice(0, nl)
+  try {
+    const v = JSON.parse(first)
+    if (v && typeof v === "object" && v.type === "title") return { slot: v, rest: nl < 0 ? "" : text.slice(nl + 1) }
+  } catch {
+    // not a slot: the file starts with its header
+  }
+  return { rest: text }
+}
+
+/** Entry types that are OMP settings, not conversation: skipped without counting. */
+export const SETTING_TYPES = new Set(["credential_pin", "mode_change", "service_tier_change", "thinking_level_change", "usage", "label", "custom", "context_edit"])
+
+/** OMP's flavor of the Pi family, for Pi's planner: OMP prefixes the start time like Pi and uses v4 UUIDs. */
+export const ompFlavor: PiFlavor = {
+  tool: "omp",
+  label: "Oh My Pi",
+  bin: "omp",
+  sessionsRoot: (home) => join(home, ".omp", "agent", "sessions"),
+  fileName: (id, startedAt) => `${startedAt.replace(/[:.]/g, "-")}_${id}.jsonl`,
+  newId: () => randomUUID(),
+}