@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/muse/writer.ts

@@ -0,0 +1,387 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs"
+import { basename, dirname } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, readJsonl, versionOf } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../claude-code/records.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { parseSession, sessionFiles } from "./reader.ts"
+import { BIN, BUILD_SHA, FAILED_PREFIX, isObj, LABEL, type Rec, sessionPath, TOOL } from "./records.ts"
+
+// Continues a portable session in Muse Code as a new session of its own: one durable event stream at
+// sessions/YYYY/MM/DD/<uuid>/session.jsonl under Muse's data home, which `muse exec --session-id <uuid>`
+// resumes. The record lifecycle is the one session-migrate (xhluca/session-migrate, MIT) found Muse needs to
+// rebuild a model's context from a history it did not write itself (docs/muse-qwen-kimi-formats.md), with the
+// field values Muse 0.2.1 writes in the real capture:
+//
+//   runtime.session.metadata, session.opened.observed, then per prompt runtime.user_intent.accepted (the
+//   prompt as model_messages and refill_blocks), a run `started` event, runtime.user_intent.materialized
+//   naming both, the model's committed messages, tool-call batches and their result batch, a `terminal` run
+//   event; session.end last.
+//
+// Envelopes carry contiguous sequences, fresh UUIDs and strictly increasing recorded_at microseconds. Each run
+// event other than a result batch has its own source_run_record_id and per-run sequence, a result batch's
+// batch_id is its call batch's message_id, and a call keeps its id as call_id with `fc_<id>` as its item id,
+// as Muse writes them. Muse keeps no error flag on a result: a failure is worded "tool failed: ...", as Muse
+// words its own. Read calls become Muse's read_file; other calls keep their names.
+//
+// The note on where the session came from is a first text block of the first prompt's model_messages (what
+// the model gets); refill_blocks and the started event hold the person's words alone. Muse keeps no images,
+// and replays no reasoning or compaction from outside, so those are counted as lost.
+
+/** Muse Code versions whose session format this writer was checked against. */
+export const TESTED_VERSIONS = ["0.2.1"]
+
+/** The model and provider Muse 0.2.1 recorded in the capture, and session-migrate's documented Muse target. */
+export const DEFAULT_MODEL = "meta/muse-glimmer-30b"
+export const DEFAULT_PROVIDER = "meta"
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+/**
+ * The installed version ("Muse Code 0.2.1 (0.2.1-R1215.1)" gives "0.2.1"), or undefined when it is missing.
+ * The binary is looked up on `PATH` as it is now: Bun.which without one does not see a PATH changed after start.
+ */
+export function museVersion(bin = BIN, PATH = process.env.PATH ?? ""): string | undefined {
+  const path = bin.includes("/") ? bin : Bun.which(bin, { PATH })
+  if (!path) return undefined
+  return versionOf(path)?.match(/(\d+\.\d+\.\d+)/)?.[1]
+}
+
+/** Muse records the workspace as the process sees it: the resolved path (/private/tmp, not /tmp). */
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+
+const hex = () => randomUUID().replace(/-/g, "").slice(0, 24)
+
+/** A read from another tool as Muse's own read_file, when it names a file; undefined keeps the call as it was. */
+function asMuseTool(c: Call): { name: string; args: Rec } | undefined {
+  if (c.toolKind !== "read" || !isObj(c.input)) return undefined
+  const path = ["path", "file_path", "filePath", "absolute_path", "target_file", "file"].map((k) => (c.input as Rec)[k]).find((v) => typeof v === "string" && v)
+  return path ? { name: "read_file", args: { path } } : undefined
+}
+
+export interface MusePlan {
+  /** Every record of the new session file, in order. */
+  records: Rec[]
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The records of a new Muse session `id` continuing `session`. Pure apart from random ids. */
+export function planMuse(session: Session, o: { id: string; cwd: string; now: Date; model: string; provider: string; version: string }): MusePlan {
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const label = toolLabel(session.header.tool)
+  const expect = { users: 0, assistants: 0, calls: 0 }
+
+  // recorded_at: microseconds, strictly increasing; turn times where they move forward, never past now.
+  const nowUs = o.now.getTime() * 1000
+  const known = session.turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let clock = Math.min(known ?? o.now.getTime(), o.now.getTime()) * 1000 - 1
+  const stamp = (at?: string) => {
+    const t = at ? Date.parse(at) * 1000 : Number.NaN
+    clock = Number.isFinite(t) && t > clock && t <= nowUs ? t : clock + 1
+    return clock
+  }
+
+  const records: Rec[] = []
+  const append = (payloadType: string, payload: Rec, at?: string, causation: string | null = null) => {
+    const r: Rec = {
+      schema_version: 1,
+      id: randomUUID(),
+      stream: { kind: "session", id: o.id },
+      sequence: records.length + 1,
+      recorded_at: stamp(at),
+      record_type: "event",
+      durability: "durable",
+      causation_id: causation,
+      payload_type: payloadType,
+      payload_schema_version: 1,
+      payload,
+    }
+    records.push(r)
+    return r
+  }
+
+  append("runtime.session.metadata", {
+    kind: "metadata",
+    record: { build: { semver: o.version, sha: BUILD_SHA }, model_id: o.model, provider_id: o.provider, tool_surface_version: "2", web_search_mode: "client", workspace_root: o.cwd },
+  })
+  append("session.opened.observed", {
+    kind: "session_opened",
+    record: { data_dir_free_bytes: 0, resume: false, schema_version: 1, security_mode: "normal", session_id: o.id, workspace_free_bytes: 0 },
+  })
+
+  // A run is one prompt and everything the model did for it.
+  let run: { id: string; seq: number } | undefined
+  let turn = 0
+  let noted = false
+  const note = continuedNote(label, session.header.id, o.now.toISOString().slice(0, 10))
+  const runEvent = (event: Rec, at?: string, source = true) =>
+    append("runtime.session", { event, kind: "run", run_id: run!.id, ...(source ? { source_run_record_id: randomUUID(), source_run_record_sequence: ++run!.seq } : {}) }, at)
+  const endRun = () => {
+    if (!run) return
+    runEvent({ eot_gate_ms: 0, kind: "terminal", reason: null, terminal: "completed", time_to_first_token_ms: 0, turn_duration_ms: 0 })
+    run = undefined
+  }
+  /** Opens a run for `prompt`; without one (the session opens with the model), the note is the prompt. */
+  const startRun = (prompt: string | undefined, at?: string) => {
+    endRun()
+    const text = prompt ?? note
+    const blocks = noted || prompt === undefined ? [{ kind: "text", text }] : [{ kind: "text", text: note }, { kind: "text", text }]
+    noted = true
+    // Muse uses one id for the command, the intent and its run.
+    const id = randomUUID()
+    const accepted = append(
+      "runtime.user_intent.accepted",
+      { bindings: [], delivery_policy: "session_current", intent_id: id, model_messages: [{ content: blocks }], refill_blocks: [{ kind: "text", text }], semantic_kind: { kind: "chat" }, source_session_id: o.id, surface: "main", wake_policy: "start_once" },
+      at,
+      id,
+    )
+    run = { id, seq: 0 }
+    const started = runEvent({ kind: "started", prompt: text }, at)
+    append(
+      "runtime.user_intent.materialized",
+      {
+        envelope_record_id: accepted.id,
+        envelope_sequence: accepted.sequence,
+        intent_id: id,
+        outcome: { cut_before: `session:${o.id}:turn:${turn}`, kind: "top_level_turn_started", run_id: id, run_started_session_record_id: started.id, run_started_source_record_id: started.payload.source_run_record_id },
+        source_session_id: o.id,
+      },
+      at,
+    )
+    turn++
+  }
+  const ensureRun = (at?: string) => {
+    if (!run) startRun(undefined, at)
+  }
+
+  // Call ids stay as they were when Muse can carry them, else get a call_ id; each is used once.
+  const ids = new Map<string, string>()
+  const used = new Set<string>()
+  let remapped = 0
+  let renamed = 0
+  const idFor = (src: string) => {
+    let v = ids.get(src)
+    if (v) return v
+    v = /^[A-Za-z0-9_.:-]{1,64}$/.test(src) && !used.has(src) ? src : `call_${hex()}`
+    while (used.has(v)) v = `call_${hex()}`
+    if (v !== src) remapped++
+    ids.set(src, v)
+    used.add(v)
+    return v
+  }
+
+  // One model response: its text and its tool-call batch share a response id; results come back as one batch.
+  let response: string | undefined
+  type Batch = { messageId: string; calls: Array<{ src: string; id: string; name: string; args: string }>; results: Map<string, string>; written: boolean; at?: string }
+  let batch: Batch | undefined
+  const given = new Set<string>()
+  const writeCalls = () => {
+    if (!batch || batch.written) return
+    response ??= `resp_${hex()}`
+    runEvent({ kind: "assistant_tool_calls_committed", message_id: batch.messageId, response_id: response, tool_calls: batch.calls.map((c) => ({ args: c.args, call_id: c.id, id: `fc_${c.id}`, name: c.name })) }, batch.at)
+    batch.written = true
+  }
+  const closeBatch = () => {
+    if (!batch) return
+    writeCalls()
+    const b = batch
+    const results = b.calls.map((c, i) => {
+      let text = b.results.get(c.src)
+      if (text === undefined) {
+        drop("tool calls without a result (closed as failed)")
+        text = `${FAILED_PREFIX}no result was recorded for this call; the session moved on before it finished.`
+      }
+      return { text, tool_call_id: c.id, tool_call_index: i }
+    })
+    // A result batch carries no source run record, as Muse writes it.
+    runEvent({ batch_id: b.messageId, kind: "tool_result_batch_committed", results }, b.at, false)
+    batch = undefined
+    response = undefined
+  }
+
+  for (const t of session.turns) {
+    switch (t.kind) {
+      case "user": {
+        closeBatch()
+        response = undefined
+        let text = t.text
+        for (const a of t.attachments ?? []) {
+          if (a.kind === "file" && a.path) text += `\n\n[Attached file: ${a.path}]`
+          else drop(`${a.kind === "image" ? "images" : "attachments"} (a Muse session keeps no image)`)
+        }
+        if (!text.trim()) break
+        startRun(text, t.at)
+        expect.users++
+        break
+      }
+      case "assistant": {
+        closeBatch()
+        if (!t.text.trim()) break
+        ensureRun(t.at)
+        response = `resp_${hex()}`
+        runEvent({ kind: "assistant_message_committed", message_id: randomUUID(), provider_item_id: `msg_${response}`, response_id: response, text: t.text }, t.at)
+        expect.assistants++
+        break
+      }
+      case "reasoning":
+        if (t.text.trim()) drop("reasoning (Muse replays no reasoning written from outside)")
+        break
+      case "tool_call": {
+        if (ids.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        // A call after results is the next response.
+        if (batch?.results.size) closeBatch()
+        ensureRun(t.at)
+        const own = asMuseTool(t)
+        const name = own?.name ?? (t.name.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 64) || "tool")
+        if (name !== t.name) renamed++
+        let args: Rec
+        if (own) args = own.args
+        else if (isObj(t.input)) args = t.input
+        else {
+          args = { input: t.input ?? null }
+          drop("tool inputs that were not objects (wrapped)")
+        }
+        batch ??= { messageId: randomUUID(), calls: [], results: new Map(), written: false, ...(t.at ? { at: t.at } : {}) }
+        batch.calls.push({ src: t.id, id: idFor(t.id), name, args: JSON.stringify(args) })
+        expect.calls++
+        break
+      }
+      case "tool_result": {
+        if (!ids.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (given.has(t.callId)) {
+          drop("repeated tool results")
+          break
+        }
+        // Its call's batch was already closed (with a failure) when something else came between them.
+        if (!batch || !batch.calls.some((c) => c.src === t.callId)) {
+          drop("tool results recorded after the session moved on")
+          break
+        }
+        given.add(t.callId)
+        writeCalls()
+        let out = t.fullPath ? `${t.output}\n\n[Full output: ${t.fullPath}]` : t.output
+        if (!t.ok && !out.startsWith(FAILED_PREFIX.trimEnd())) out = `${FAILED_PREFIX}${out}`
+        batch.results.set(t.callId, out)
+        if (t.at) batch.at = t.at
+        if (batch.results.size === batch.calls.length) closeBatch()
+        break
+      }
+      case "compaction":
+        closeBatch()
+        drop("compaction summaries (the turns they replaced are all kept)")
+        break
+      case "file_edit":
+        if (!t.callId || !ids.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent transcripts (their results stay in the parent's tool results)")
+        break
+    }
+  }
+  closeBatch()
+  endRun()
+  if (!expect.users && !expect.assistants && !expect.calls) throw new Error("nothing to continue: the session has no messages or tool calls")
+  append("session.end", { kind: "session_end", record: { exit_reason: "clean", resource_usage: {}, schema_version: 1, session_id: o.id, uptime_ms: 0 } })
+
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (renamed) lost.push(`original tool names (${renamed} calls renamed to Muse's read_file or to fit its rules)`)
+  if (remapped) lost.push(`tool call ids remapped (${remapped})`)
+  return { records, lost, expect }
+}
+
+/** Options for tests and for people who run Muse with another model; the defaults suit an installed Muse 0.2.1. */
+export interface MuseWriterOptions {
+  /** The installed version, instead of asking `muse --version`. */
+  version?: string
+  bin?: string
+  /** The PATH to look the binary up on (default: process.env.PATH when ready() runs). */
+  PATH?: string
+  model?: string
+  provider?: string
+  /** New session ids (default: random UUIDs). */
+  newId?: () => string
+}
+
+export function museWriter(opts: MuseWriterOptions = {}): Writer {
+  const installed = () => opts.version ?? museVersion(opts.bin ?? BIN, opts.PATH ?? process.env.PATH ?? "")
+  const newId = opts.newId ?? (() => randomUUID())
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: `${LABEL} is not installed (\`${opts.bin ?? BIN} --version\` did not run)` }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `${LABEL} ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; ${LABEL} records the workspace a session runs in` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = realCwd(w.cwd)
+      const now = new Date()
+      // Muse finds a session by its id in any date folder, so the id must be new in all of them.
+      const taken = new Set(sessionFiles(w.home).map((p) => basename(dirname(p))))
+      let id = newId()
+      for (let tries = 0; taken.has(id) || exists(dirname(sessionPath(w.home, id, now))); tries++) {
+        if (tries >= 20) throw new Error(`could not find an unused ${LABEL} session id; nothing was written`)
+        id = newId()
+      }
+      const path = sessionPath(w.home, id, now)
+      const plan = planMuse(session, { id, cwd, now, model: opts.model ?? DEFAULT_MODEL, provider: opts.provider ?? DEFAULT_PROVIDER, version: TESTED_VERSIONS[TESTED_VERSIONS.length - 1]! })
+      if (!w.dryRun) {
+        const dir = dirname(path)
+        mkdirSync(dirname(dir), { recursive: true, mode: 0o700 })
+        // mkdir without recursive on the session folder itself: an existing session is never touched.
+        mkdirSync(dir, { mode: 0o700 })
+        try {
+          writeFileSync(path, `${plan.records.map((r) => JSON.stringify(r)).join("\n")}\n`, { flag: "wx", mode: 0o600 })
+          const { rows, bad } = readJsonl(path)
+          const back = parseSession(rows, bad, path, w.home)
+          const n = countTurns(back)
+          const pairs = unpaired(back)
+          if (n.user !== plan.expect.users || n.assistant !== plan.expect.assistants || n.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+            throw new Error(
+              `the new ${LABEL} 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}, unpaired ${pairs.calls.length + pairs.results.length}); nothing was kept`,
+            )
+        } catch (e) {
+          rmSync(dir, { recursive: true, force: true })
+          throw e
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId: id,
+        written: [path],
+        open: `cd ${shellQuote(cwd)} && ${opts.bin ?? BIN} exec --session-id ${id} --workspace ${shellQuote(cwd)} "<your next message>"`,
+        note: `${LABEL} resumes a session by id with \`muse exec --session-id\` (the path session-migrate checked with Muse 0.2.1); it answers with your own Muse provider and model settings.`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const museNativeWriter = museWriter()

package/src/adapters/omp/index.ts

@@ -0,0 +1,13 @@
+import type { Reader, Writer } from "../types.ts"
+import { ompReader } from "./reader.ts"
+import { ompWriter } from "./writer.ts"
+
+// Oh My Pi (can1357/oh-my-pi, `omp`), a fork of Pi: reads its sessions from ~/.omp/agent and each profile's
+// ~/.omp/profiles/<name>/agent, and continues any session as a new native OMP session, `omp --resume <id>`.
+// Format and checks ported from xhluca/session-migrate (MIT), docs/omp-format.md and formats/omp.py; see records.ts.
+
+export { OMP_TESTED_VERSIONS } from "./records.ts"
+export { ompReader, ompWriter }
+
+export const readers: Reader[] = [ompReader]
+export const writers: Writer[] = [ompWriter()]