@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/omp/writer.ts

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { dirname, extname, join } from "node:path"
+import { exists, isDir, ls, versionOf } from "../../fsutil.ts"
+import { IMAGE_LIMIT, IMAGE_TYPES } from "../../session/attachments.ts"
+import type { Attachment, Session, Turn } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import type { Entry } from "../pi/records.ts"
+import { planPiSession } from "../pi/writer.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { parseOmpSession } from "./reader.ts"
+import { BLOB_LIMIT, OMP_TESTED_VERSIONS, blobData, blobPath, bucketName, ompFlavor, sha256, titleSlot } from "./records.ts"
+
+// Continues a portable session as a new Oh My Pi session: <home>/.omp/agent/sessions/<bucket>/<time>_<uuid>.jsonl,
+// which `omp --resume <uuid>` opens. Ported from session-migrate's omp.serialize (MIT, xhluca), which builds
+// on its Pi writer the same way: the entries are what our Pi writer plans (see ../pi/writer.ts for how turns
+// map, the hidden "continued" note, compactions that keep nothing before them, calls closed as errors), then
+// reshaped the way OMP 18.0.5 writes them:
+// - the 256-byte title slot comes first and the header carries the title, instead of Pi's session_info entry;
+// - prompts carry attribution: "user", and the usage block has OMP's fields (no reasoning count);
+// - pasted media go to the content-addressed blob store, <agent>/blobs/<sha256>, and the message's image block
+//   says "blob:sha256:<hex>", as OMP stores what it is given: images, and PDFs, audio and video, which OMP
+//   takes through the same field. Other files stay a line naming their path, as for Pi.
+// Blobs are written only when no file of that name exists (same name, same bytes); the session file is new.
+
+type User = Extract<Turn, { kind: "user" }>
+
+/** Media types OMP 18.0.5 accepted through its image field and stored as blobs (session-migrate's capture). */
+const MEDIA = /^(application\/pdf|audio\/[\w.+-]+|video\/[\w.+-]+)$/
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+const sizeOf = (p: string) => {
+  try {
+    return statSync(p).size
+  } catch {
+    return Number.POSITIVE_INFINITY
+  }
+}
+
+/**
+ * The attachment's type when OMP gets it as a blob: an image Pi's writer would embed (same types and size
+ * bound, so whatever is left is something Pi's writer would drop too), or a PDF, audio or video file.
+ */
+function asBlob(a: Attachment): string | undefined {
+  if (!a.path) return undefined
+  if (a.kind === "image") {
+    const mime = a.mime ?? IMAGE_TYPES[extname(a.path).toLowerCase()]
+    return mime && Object.values(IMAGE_TYPES).includes(mime) && sizeOf(a.path) <= IMAGE_LIMIT ? mime : undefined
+  }
+  return a.mime && MEDIA.test(a.mime) && sizeOf(a.path) <= BLOB_LIMIT ? a.mime : undefined
+}
+
+export interface OmpPlan {
+  /** The whole file: title slot, header, entries. */
+  text: string
+  /** The header line and every entry, in order (the slot is not among them). */
+  lines: Entry[]
+  /** Blobs the session refers to, by hash, and where their bytes are. */
+  blobs: Map<string, string>
+  lost: string[]
+  expect: { users: number; assistants: number; calls: number; attachments: number }
+}
+
+/** The file of a new OMP session `id` continuing `session`. Pure apart from reading attached files. */
+export function planOmpSession(session: Session, opts: { id: string; now: Date; cwd: string }): OmpPlan {
+  // Media OMP stores as blobs leave the turns before Pi's planner sees them and return as blocks afterwards,
+  // on the same prompt: k-th user message for the k-th user turn that makes one.
+  const blobs = new Map<string, string>()
+  const pending: Entry[][] = []
+  let attachments = 0
+  const turns = session.turns.map((t): Turn => {
+    if (t.kind !== "user") return t
+    const media: Entry[] = []
+    const rest: Attachment[] = []
+    for (const a of t.attachments ?? []) {
+      const mime = asBlob(a)
+      if (!mime) {
+        rest.push(a)
+        continue
+      }
+      const hex = sha256(readFileSync(a.path!))
+      blobs.set(hex, a.path!)
+      media.push({ type: "image", data: blobData(hex), mimeType: mime })
+    }
+    const text = t.text.trim() || !media.length ? t.text : media.every((b) => b.mimeType.startsWith("image/")) ? "(image)" : "(attachment)"
+    const { attachments: _, ...base } = t
+    const user: User = { ...base, text, ...(rest.length ? { attachments: rest } : {}) }
+    // Pi's planner writes a prompt when it has text or a file line; images left in `rest` it drops.
+    if (text.trim() || rest.some((a) => a.kind === "file" && a.path)) {
+      pending.push(media)
+      attachments += media.length
+    }
+    return user
+  })
+  const pi = planPiSession({ ...session, turns }, { flavor: ompFlavor, id: opts.id, now: opts.now, cwd: opts.cwd })
+
+  // Pi names the session with a session_info entry; OMP keeps the name in the slot and the header instead.
+  const info = pi.lines.find((e) => e.type === "session_info")
+  const name = typeof info?.name === "string" ? info.name : ""
+  const lines = pi.lines.filter((e) => e !== info)
+  for (const e of lines) if (info && e.parentId === info.id) e.parentId = info.parentId ?? null
+  const head = lines[0]!
+  const slot = titleSlot(name, head.timestamp)
+  if (slot.title) Object.assign(head, { title: slot.title, titleSource: "user" })
+
+  let k = 0
+  for (const e of lines) {
+    const m = e.message as Entry | undefined
+    if (e.type !== "message" || !m) continue
+    if (m.role === "user") {
+      const content = [...(m.content as Entry[]), ...(pending[k++] ?? [])]
+      e.message = { role: "user", content, attribution: "user", timestamp: m.timestamp }
+    } else if (m.role === "assistant" && m.usage) {
+      const { reasoning: _, ...usage } = m.usage as Entry
+      m.usage = usage
+    }
+  }
+  if (k !== pending.length) throw new Error(`internal: ${k} prompts written for ${pending.length} expected; nothing was written`)
+
+  const text = slot.line + lines.map((l) => `${JSON.stringify(l)}\n`).join("")
+  return { text, lines, blobs, lost: pi.lost, expect: { ...pi.expect, attachments } }
+}
+
+/** The version from `omp --version` ("omp/18.0.5"), found on the PATH as it is now, or undefined when missing. */
+export function ompVersion(bin = "omp"): string | undefined {
+  const path = bin.includes("/") ? bin : Bun.which(bin, { PATH: process.env.PATH ?? "" })
+  if (!path) return undefined
+  return versionOf(path)?.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/)?.[1]
+}
+
+/** OMP records the folder it ran in as the process saw it: the resolved path. */
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+/** The OMP writer; `version` and `newId` are for tests that must not depend on an installed binary or chance. */
+export function ompWriter(version?: string, o: { newId?: () => string } = {}): Writer {
+  const newId = o.newId ?? randomUUID
+  return {
+    tool: "omp",
+    label: ompFlavor.label,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = version ?? ompVersion()
+      if (!v) return { ok: false, why: "Oh My Pi is not installed here (`omp --version` failed)" }
+      if (!OMP_TESTED_VERSIONS.includes(v)) return { ok: false, why: `Oh My Pi ${v} is not a version this writer was checked against (${OMP_TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Oh My Pi keeps sessions by the folder they belong to` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = realCwd(w.cwd)
+      const now = new Date()
+      const agent = join(w.home, ".omp", "agent")
+      const sessions = join(agent, "sessions")
+      const dir = join(sessions, bucketName(cwd, w.home))
+      // `omp --resume <id>` finds a session by its id, so the id must be new to the whole store, not just the folder.
+      const used = new Set(ls(sessions).flatMap((b) => ls(join(sessions, b)).map((n) => /_([^_]+)\.jsonl$/.exec(n)?.[1])))
+      let id = newId()
+      for (let tries = 1; used.has(id); tries++) {
+        if (tries >= 10) throw new Error(`Oh My Pi already has a session with every new id tried (last ${id}); nothing was written`)
+        id = newId()
+      }
+      const path = join(dir, ompFlavor.fileName(id, now.toISOString()))
+      const plan = planOmpSession(session, { id, now, cwd })
+      const newBlobs = [...plan.blobs].filter(([hex]) => !exists(blobPath(agent, hex)))
+      if (!w.dryRun) {
+        const made: string[] = []
+        try {
+          for (const [hex, from] of newBlobs) {
+            const to = blobPath(agent, hex)
+            mkdirSync(dirname(to), { recursive: true })
+            // "wx": content-addressed, so a blob that appeared meanwhile holds these bytes and is left as it is.
+            try {
+              writeFileSync(to, readFileSync(from), { flag: "wx", mode: 0o600 })
+              made.push(to)
+            } catch (e) {
+              if ((e as NodeJS.ErrnoException).code !== "EEXIST") throw e
+            }
+          }
+          mkdirSync(dirname(path), { recursive: true })
+          writeFileSync(path, plan.text, { flag: "wx", mode: 0o600 })
+          made.push(path)
+        } catch (e) {
+          for (const p of made) rmSync(p, { force: true })
+          throw e
+        }
+        const back = parseOmpSession(readFileSync(path, "utf8"), path, w.home)
+        const n = countTurns(back)
+        const pairs = unpaired(back)
+        const kept = back.turns.reduce((s, t) => s + (t.kind === "user" ? (t.attachments?.filter((a) => a.path?.startsWith(join(agent, "blobs"))).length ?? 0) : 0), 0)
+        if (n.user !== plan.expect.users || n.assistant !== plan.expect.assistants || n.tool_call !== plan.expect.calls || kept !== plan.expect.attachments || pairs.calls.length || pairs.results.length) {
+          for (const p of made) rmSync(p, { force: true })
+          throw new Error(
+            `the Oh My Pi session did not read back as written (users ${n.user}/${plan.expect.users}, replies ${n.assistant}/${plan.expect.assistants}, tool calls ${n.tool_call}/${plan.expect.calls}, attachments ${kept}/${plan.expect.attachments}, unpaired ${pairs.calls.length + pairs.results.length}); nothing was kept`,
+          )
+        }
+      }
+      return {
+        tool: "omp",
+        way: "native",
+        sessionId: id,
+        written: [path, ...newBlobs.map(([hex]) => blobPath(agent, hex))],
+        open: `cd ${shellQuote(cwd)} && omp --resume ${id}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}

package/src/adapters/opencode/ids.ts

@@ -0,0 +1,52 @@
+// OpenCode's ids, which 100xprompt kept: a prefix ("ses", "msg", "prt"), then 12 hex characters holding the
+// low 48 bits of `ms * 0x1000 + counter` (bit-inverted for sessions, so newer sessions sort first), then 14
+// random base62 characters. Messages and parts are read back in id order, so new ids must ascend.
+
+const BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+export function random62(n: number): string {
+  return Array.from(crypto.getRandomValues(new Uint8Array(n)), (b) => BASE62[b % 62]).join("")
+}
+
+export function mintId(prefix: string, ms: number, counter: number, descending = false): string {
+  let v = BigInt(ms) * 0x1000n + BigInt(counter)
+  if (descending) v = ~v
+  const hex = Array.from({ length: 6 }, (_, i) => Number((v >> BigInt(40 - 8 * i)) & 0xffn).toString(16).padStart(2, "0")).join("")
+  return `${prefix}_${hex}${random62(14)}`
+}
+
+/** Ascending ids from `start`: 4,095 per millisecond, then the next millisecond, as OpenCode mints them. */
+export function idMinter(start: number) {
+  let ms = start
+  let n = 0
+  return (prefix: string) => {
+    if (++n > 0xfff) {
+      ms++
+      n = 1
+    }
+    return mintId(prefix, ms, n)
+  }
+}
+
+// The 48-bit field wraps every 2^36 ms (about 795 days); it last did on 2026-08-14, so a plain string sort
+// puts ids minted after that before older ones. As 100xprompt does (id-order.ts), each id is placed in the
+// latest period that is not in the future.
+const SPAN = 2 ** 36
+const SKEW = 24 * 60 * 60 * 1000
+
+function decode(id: string, now: number): { ms: number; counter: number } | undefined {
+  const sep = id.indexOf("_")
+  const hex = sep < 0 ? "" : id.slice(sep + 1, sep + 13)
+  if (!/^[0-9a-f]{12}$/.test(hex)) return undefined
+  const field = parseInt(hex, 16)
+  const wrapped = Math.floor(field / 0x1000)
+  return { ms: wrapped + SPAN * Math.floor((now + SKEW - wrapped) / SPAN), counter: field % 0x1000 }
+}
+
+/** Chronological order of two ascending ids. */
+export function compareIds(a: string, b: string, now = Date.now()): number {
+  const x = decode(a, now)
+  const y = decode(b, now)
+  if (x && y && (x.ms !== y.ms || x.counter !== y.counter)) return x.ms - y.ms || x.counter - y.counter
+  return a < b ? -1 : a > b ? 1 : 0
+}

package/src/adapters/opencode/index.ts

@@ -0,0 +1,31 @@
+import { versionOf } from "../../fsutil.ts"
+import type { Reader, Writer } from "../types.ts"
+import { familyReader } from "./reader.ts"
+import { v2Writer } from "./v2.ts"
+import { HUNDREDX_TARGET, OPENCODE_TARGET, importWriter, resolveBin, versionNumber } from "./writer.ts"
+
+// OpenCode (1.x and 2.x) and 100xprompt, which share the session/message/part layout and the export/import
+// JSON (catalogue entries 8, 9 and 71); OpenCode 2.x has its own store and transfer format (v2.ts). Every
+// one reads, and continues a session through the tool's own `import` command.
+export const readers: Reader[] = [
+  familyReader({ tool: "opencode", label: "OpenCode", app: "opencode", sqlite: true }),
+  familyReader({ tool: "100xprompt", label: "100xprompt", app: "100xprompt", sqlite: false }),
+]
+
+const v1Writer = importWriter(OPENCODE_TARGET)
+
+/** OpenCode's writer for whichever line is installed: 1.x takes the v1 export, 2.x the v2 transfer. */
+const opencodeWriter: Writer = {
+  tool: "opencode",
+  label: "OpenCode",
+  way: "import",
+  ready: (opts) => pick(opts.home).ready(opts),
+  write: (session, opts) => pick(opts.home).write(session, opts),
+}
+
+function pick(home: string): Writer {
+  const v = versionNumber(versionOf(resolveBin(OPENCODE_TARGET, home).path))
+  return v && Number(v.split(".")[0]) >= 2 ? v2Writer : v1Writer
+}
+
+export const writers: Writer[] = [importWriter(HUNDREDX_TARGET), opencodeWriter]

package/src/adapters/opencode/note.ts

@@ -0,0 +1,8 @@
+// The note that opens every session this family's writers continue: the model reads it as the tool's own
+// hidden message (a synthetic part, a synthetic message, a hidden user text), and the readers recognise it as
+// the session's origin instead of a request.
+
+export const continuedNote = (label: string, id: string, when: string) =>
+  `[This session continues ${label} session ${id}, carried over by brain session on ${when}. The turns below are its history. Check files before relying on details, since they may have changed.]`
+
+export const CONTINUED_NOTE = /^\[This session continues .+? session (\S+), carried over by brain session/