@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/muse/reader.ts

@@ -0,0 +1,332 @@
+import { statSync } from "node:fs"
+import { basename, dirname, join } from "node:path"
+import { exists, gitInfo, isDir, ls, mtime, readJsonl } from "../../fsutil.ts"
+import { keepImage, parseDataUrl } from "../../session/attachments.ts"
+import type { Attachment, Session, Turn, Usage } from "../../session/types.ts"
+import { clip, header, lossCounter, noteModel } from "../../session/util.ts"
+import { CONTINUED_NOTE } from "../claude-code/records.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { FAILED_PREFIX, isObj, isRetainedMarker, KNOWN_TYPES, kindOf, LABEL, QUIET_RUN_EVENTS, type Rec, runEvent, sessionsRoot, str, textBlocks, TOOL, usIso } from "./records.ts"
+
+// Reads Muse Code sessions: <home>/.local/share/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl (records.ts).
+// Semantics ported from session-migrate's Muse adapter (xhluca/session-migrate, MIT).
+//
+// A person's prompt is the text of runtime.user_intent.accepted; a run `started` event repeats it, and is the
+// only record of a prompt Muse took another way (the capture's `--image` turn has no accepted intent), so a
+// started prompt becomes a turn only when no accepted intent already gave it. The model's text, tool calls
+// and tool results are the run's committed events; a failed call is the one whose tool_batch.effect.terminal
+// outcome is not "completed", or whose result text Muse prefixed "tool failed:". Muse keeps no image bytes:
+// when the request the model got carried far more user bytes than the prompt, that is counted as lost.
+
+const PEEK = 64 * 1024
+/** Extra bytes in a run's first request beyond its prompt that mean something else was sent with it. */
+const ATTACHED_SLACK = 1024
+
+type Lost = ReturnType<typeof lossCounter>
+
+/** The prompt of an accepted intent: its text blocks without brain's note, which names the session it continues. */
+function intentPrompt(p: Rec, lost?: Lost): { text: string; attachments: Attachment[]; continued?: string } {
+  const texts: string[] = []
+  const attachments: Attachment[] = []
+  for (const m of Array.isArray(p.model_messages) ? p.model_messages : []) {
+    if (!isObj(m) || !Array.isArray(m.content)) continue
+    for (const b of m.content) {
+      if (!isObj(b)) continue
+      if (b.kind === "text" && typeof b.text === "string") texts.push(b.text)
+      else if (lost) {
+        // Not seen in Muse 0.2.1's log; kept when it is a data URL, counted otherwise.
+        const d = parseDataUrl(b.url ?? b.image_url ?? b.data)
+        const kept = d ? keepImage(d.base64, d.mime) : undefined
+        if (kept) attachments.push(kept)
+        else lost.add("prompt attachments Muse did not keep")
+      }
+    }
+  }
+  let continued: string | undefined
+  const note = texts[0]?.match(CONTINUED_NOTE)
+  if (note) {
+    continued = note[1]
+    texts.shift()
+  }
+  return { text: texts.join("\n\n"), attachments, ...(continued ? { continued } : {}) }
+}
+
+const usageOf = (u: unknown): Usage | undefined => {
+  if (!isObj(u)) return undefined
+  const out: Usage = {}
+  const cached = typeof u.cache_read_tokens === "number" ? u.cache_read_tokens : typeof u.cached_tokens === "number" ? u.cached_tokens : 0
+  if (typeof u.input_tokens === "number") out.input = Math.max(0, u.input_tokens - cached)
+  if (typeof u.output_tokens === "number") out.output = u.output_tokens
+  if (cached) out.cacheRead = cached
+  if (typeof u.cache_write_tokens === "number" && u.cache_write_tokens) out.cacheWrite = u.cache_write_tokens
+  return Object.keys(out).length ? out : undefined
+}
+
+function parseArgs(a: unknown): unknown {
+  if (typeof a !== "string") return a ?? {}
+  try {
+    return JSON.parse(a)
+  } catch {
+    return { arguments: a }
+  }
+}
+
+/** One Muse session's records (in file order) as the portable session; `bad` is the count of unreadable lines. */
+export function parseSession(rows: Rec[], bad: number, path: string, home?: string): Session {
+  const first = rows.find((r) => !isRetainedMarker(r))
+  const meta = first?.payload_type === "runtime.session.metadata" && isObj(first.payload?.record) ? (first.payload.record as Rec) : undefined
+  if (!first || !meta) throw new Error(`${path} is not a ${LABEL} session (it does not begin with runtime.session.metadata)`)
+  const lost = lossCounter()
+  if (bad) lost.add("unreadable lines", bad)
+
+  const sourceId = str(first.stream?.id) ?? basename(dirname(path))
+  let cwd = str(meta.workspace_root)
+  if (!cwd) cwd = str(rows.find((r) => r.payload_type === "runtime.session.route_facts")?.payload?.record?.cwd)
+  const startedAt = usIso(first.recorded_at)
+  const h = header(TOOL, sourceId, { sourcePath: path, project: cwd ? { cwd, ...gitInfo(cwd, home) } : {}, ...(startedAt ? { startedAt } : {}) })
+  const version = str(meta.build?.semver)
+  if (version) h.toolVersion = version
+  let model = str(meta.model_id)
+  noteModel(h, model)
+
+  const turns: Turn[] = []
+  /** Accepted prompts whose run has not started yet, by text: the started event repeats them. */
+  const pending = new Map<string, number>()
+  const calls = new Map<string, Extract<Turn, { kind: "tool_call" }>>()
+  const answered = new Set<string>()
+  const failed = new Set<string>()
+  const prompts = new Map<string, string>() // run id → prompt
+  const traced = new Set<string>()
+  const reminders = new Set<string>()
+  let reply: Extract<Turn, { kind: "assistant" }> | undefined
+  let continued: string | undefined
+  let last: string | undefined
+
+  for (const r of rows) {
+    if (isRetainedMarker(r)) {
+      lost.add("status records Muse left out of its log")
+      continue
+    }
+    const when = usIso(r.recorded_at)
+    if (when) last = when
+    const at = when ? { at: when } : {}
+    const p = isObj(r.payload) ? r.payload : {}
+    switch (r.payload_type) {
+      case "run.model.configured":
+        model = str(p.record?.model_id) ?? model
+        noteModel(h, model)
+        break
+      case "runtime.user_intent.accepted": {
+        const { text, attachments, continued: from } = intentPrompt(p, lost)
+        if (from) continued = from
+        if (!text.trim() && !attachments.length) break
+        turns.push({ kind: "user", ...at, text, ...(attachments.length ? { attachments } : {}) })
+        pending.set(text, (pending.get(text) ?? 0) + 1)
+        break
+      }
+      case "tool_batch.effect.terminal": {
+        const rec = isObj(p.record) ? p.record : {}
+        const outcome = isObj(rec.outcome) ? str(rec.outcome.kind) : undefined
+        const callId = str(rec.call_id)
+        if (callId && outcome && outcome !== "completed") failed.add(callId)
+        break
+      }
+      case "runtime.session":
+        run(r, at)
+        break
+      default:
+        if (!KNOWN_TYPES.has(String(r.payload_type))) lost.add(`unknown ${LABEL} record types: ${String(r.payload_type)}`)
+    }
+  }
+
+  function run(r: Rec, at: { at?: string }) {
+    const e = runEvent(r)
+    if (!e) return // security mode, agent tree, task lifecycle: Muse's own bookkeeping
+    const runId = String(r.payload.run_id ?? "")
+    const kind = String(e.kind)
+    switch (kind) {
+      case "started": {
+        const prompt = typeof e.prompt === "string" ? e.prompt : ""
+        prompts.set(runId, prompt)
+        const note = prompt.match(CONTINUED_NOTE)
+        if (note) {
+          continued = note[1]
+          return
+        }
+        const waiting = pending.get(prompt) ?? 0
+        if (waiting) pending.set(prompt, waiting - 1)
+        else if (prompt.trim()) turns.push({ kind: "user", ...at, text: prompt })
+        return
+      }
+      case "assistant_message_committed": {
+        if (typeof e.text !== "string" || !e.text.trim()) return
+        reply = { kind: "assistant", ...at, text: e.text, ...(model ? { model } : {}) }
+        turns.push(reply)
+        return
+      }
+      case "reasoning_committed":
+        if (typeof e.text === "string" && e.text.trim()) turns.push({ kind: "reasoning", ...at, text: e.text })
+        else lost.add("encrypted or empty reasoning")
+        return
+      case "assistant_tool_calls_committed":
+        for (const c of Array.isArray(e.tool_calls) ? e.tool_calls : []) {
+          if (!isObj(c)) continue
+          const id = str(c.call_id) ?? str(c.id)
+          if (!id || calls.has(id)) continue
+          const name = str(c.name) ?? "unknown_tool"
+          const call: Extract<Turn, { kind: "tool_call" }> = { kind: "tool_call", ...at, id, name, toolKind: kindOf(name), input: parseArgs(c.args ?? c.arguments) }
+          calls.set(id, call)
+          turns.push(call)
+        }
+        return
+      case "tool_result_batch_committed":
+        for (const res of Array.isArray(e.results) ? e.results : []) {
+          if (!isObj(res)) continue
+          const callId = str(res.tool_call_id)
+          if (!callId || !calls.has(callId)) {
+            lost.add("tool results without a call")
+            continue
+          }
+          if (answered.has(callId)) continue
+          answered.add(callId)
+          const text = typeof res.text === "string" ? res.text : ""
+          const ok = !failed.has(callId) && !text.startsWith(FAILED_PREFIX.trimEnd())
+          const c = clip(text)
+          turns.push({ kind: "tool_result", ...at, callId, ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+          // A file tool that succeeded changed the file it names; Muse keeps no diff beside the call.
+          const call = calls.get(callId)!
+          const input = isObj(call.input) ? call.input : {}
+          const target = str(input.path) ?? str(input.file_path)
+          if (ok && target && (call.toolKind === "edit" || call.toolKind === "write")) turns.push({ kind: "file_edit", ...at, path: target, callId })
+        }
+        return
+      case "model_completed": {
+        noteModel(h, str(e.model))
+        const usage = usageOf(e.usage)
+        if (reply && usage && !reply.usage) reply.usage = usage
+        reply = undefined
+        return
+      }
+      case "model_input_trace_recorded": {
+        // The first request of a run says how many bytes the person's message had; Muse logs only its text.
+        if (traced.has(runId) || !prompts.has(runId)) return
+        traced.add(runId)
+        const lanes = Array.isArray(e.bounded?.aggregates) ? (e.bounded.aggregates as Rec[]) : []
+        const sent = lanes.filter((l) => l?.source?.value === "current_user").reduce((n, l) => n + (typeof l.byte_count === "number" ? l.byte_count : 0), 0)
+        if (sent > Buffer.byteLength(prompts.get(runId)!) + ATTACHED_SLACK) lost.add(`images or expanded files sent with prompts, not kept by ${LABEL}`)
+        return
+      }
+      case "memory_reminder_child_session_linked":
+        reminders.add(String(e.child_session_id ?? e.task_id ?? reminders.size))
+        return
+      case "context_block_updated":
+        lost.add(`context blocks ${LABEL} injected`)
+        return
+      default:
+        if (/compact/i.test(kind)) {
+          const summary = str(e.summary) ?? str(e.text)
+          if (summary) turns.push({ kind: "compaction", ...at, summary })
+          else lost.add("compactions without a readable summary")
+        } else if (!QUIET_RUN_EVENTS.has(kind)) lost.add(`unknown ${LABEL} run events: ${kind}`)
+    }
+  }
+
+  if (reminders.size) lost.add(`${LABEL} reminder-agent runs`, reminders.size)
+  // Calls the log never answered get a result saying so, so every call is paired.
+  const open = [...calls.keys()].filter((id) => !answered.has(id))
+  if (open.length) lost.add("tool results not recorded", open.length)
+  for (const id of open) {
+    const i = turns.findIndex((t) => t.kind === "tool_call" && t.id === id)
+    turns.splice(i + 1, 0, { kind: "tool_result", callId: id, ok: false, output: "(no result recorded)" })
+  }
+
+  const title = (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
+  if (last) h.updatedAt = last
+  if (continued) h.parent = { id: continued, kind: "continued" }
+  lost.flush(h)
+  return { header: h, turns }
+}
+
+/** The session id, folder and first prompt, from the start of a file only. */
+async function peek(path: string): Promise<Omit<SessionRef, "tool" | "path"> | undefined> {
+  const file = Bun.file(path)
+  const whole = file.size <= PEEK
+  const lines = (whole ? await file.text() : await file.slice(0, PEEK).text()).split("\n")
+  if (!whole) lines.pop() // the cut line
+  let meta: Rec | undefined
+  let prompt: string | undefined
+  for (const line of lines) {
+    if (!line.trim()) continue
+    let r: Rec
+    try {
+      r = JSON.parse(line)
+    } catch {
+      continue // a torn last line
+    }
+    if (!isObj(r) || isRetainedMarker(r)) continue
+    if (!meta) {
+      if (r.payload_type !== "runtime.session.metadata") return undefined
+      meta = r
+      continue
+    }
+    if (r.payload_type === "runtime.user_intent.accepted") prompt = intentPrompt(r.payload ?? {}).text
+    else {
+      const e = runEvent(r)
+      if (e?.kind === "started" && typeof e.prompt === "string" && !CONTINUED_NOTE.test(e.prompt)) prompt = e.prompt
+    }
+    if (prompt?.trim()) break
+    prompt = undefined
+  }
+  // A session Muse opened but never prompted has nothing to continue.
+  if (!meta || (!prompt && whole)) return undefined
+  const cwd = str(meta.payload?.record?.workspace_root)
+  const title = prompt?.replace(/\s+/g, " ").trim().slice(0, 80)
+  const updatedAt = mtime(path)
+  return {
+    sourceId: str(meta.stream?.id) ?? basename(dirname(path)),
+    ...(title ? { title } : {}),
+    ...(cwd ? { cwd } : {}),
+    ...(updatedAt ? { updatedAt } : {}),
+  }
+}
+
+/** Every session file: sessions/<year>/<month>/<day>/<id>/session.jsonl (subagent logs below a session are not sessions). */
+export function sessionFiles(home: string): string[] {
+  const root = sessionsRoot(home)
+  const out: string[] = []
+  for (const y of ls(root).filter((n) => /^\d{4}$/.test(n)))
+    for (const m of ls(join(root, y)).filter((n) => /^\d{2}$/.test(n)))
+      for (const d of ls(join(root, y, m)).filter((n) => /^\d{2}$/.test(n)))
+        for (const id of ls(join(root, y, m, d))) {
+          const p = join(root, y, m, d, id, "session.jsonl")
+          if (isDir(join(root, y, m, d, id)) && exists(p)) out.push(p)
+        }
+  return out
+}
+
+export const reader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home) {
+    const refs: SessionRef[] = []
+    for (const path of sessionFiles(home)) {
+      try {
+        if (!statSync(path).isFile()) continue
+        const p = await peek(path)
+        if (p) refs.push({ tool: 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, home) {
+    if (!exists(ref.path)) throw new Error(`no ${LABEL} session at ${ref.path}`)
+    const { rows, bad } = readJsonl(ref.path)
+    if (!rows.length) throw new Error(`${ref.path} holds no ${LABEL} records`)
+    return parseSession(rows, bad, ref.path, home)
+  },
+}

package/src/adapters/muse/records.ts

@@ -0,0 +1,104 @@
+import { join } from "node:path"
+import type { ToolKind } from "../../session/types.ts"
+import { toolKindOf } from "../../session/util.ts"
+
+// Facts about Muse Code's session store, shared by its reader and writer. Ported from session-migrate
+// (xhluca/session-migrate, MIT licence: src/session_migrate/formats/muse.py and docs/muse-qwen-kimi-formats.md),
+// checked against the real capture of Muse Code 0.2.1 (0.2.1-R1215.1, build b3170a534f) in
+// test/fixtures/native-corpus/muse.
+//
+// Muse keeps one durable JSONL event stream per session:
+//   $XDG_DATA_HOME/muse/sessions/YYYY/MM/DD/<uuid>/session.jsonl   (XDG data home defaults to ~/.local/share)
+// Every line is an envelope {schema_version: 1, id, stream: {kind: "session", id}, sequence (1, 2, ...),
+// recorded_at (microseconds, strictly increasing), record_type: "event", durability: "durable", causation_id,
+// payload_type, payload_schema_version, payload}. The first is runtime.session.metadata (workspace_root, build,
+// model). Each turn the person starts is runtime.user_intent.accepted (the prompt as model_messages and
+// refill_blocks), a runtime.session run event `started`, and runtime.user_intent.materialized linking both;
+// the model's work follows as run events (assistant_message_committed, assistant_tool_calls_committed,
+// tool_result_batch_committed) and the run ends with `terminal`. Each process start and exit adds
+// session.opened.observed and session.end; a resume adds session.resumed. Most of the rest is telemetry:
+// tasks, reminder agents (child sessions under <uuid>/subagent/), context diagnostics, usage.
+
+export const TOOL = "muse"
+export const LABEL = "Muse Code"
+/** The command (`muse --version` prints "Muse Code 0.2.1 (0.2.1-R1215.1)"). */
+export const BIN = "muse"
+
+/** The build Muse Code 0.2.1 records in its session metadata. */
+export const BUILD_SHA = "b3170a534f"
+
+export type Rec = Record<string, any>
+
+export const isObj = (v: unknown): v is Rec => typeof v === "object" && v !== null && !Array.isArray(v)
+export const str = (v: unknown): string | undefined => (typeof v === "string" && v.trim() ? v : undefined)
+
+/** <home>/.local/share/muse, the default XDG data home; $XDG_DATA_HOME is not followed, as other adapters do not follow theirs. */
+export const museHome = (home: string) => join(home, ".local", "share", "muse")
+export const sessionsRoot = (home: string) => join(museHome(home), "sessions")
+
+const pad = (n: number) => String(n).padStart(2, "0")
+
+/**
+ * Where a session started at `at` lives. Muse dates the folder in local time: the capture started at
+ * 2026-09-01T00:38Z and session-migrate's reload test puts it under 2026/08/31.
+ */
+export const sessionPath = (home: string, id: string, at: Date) =>
+  join(sessionsRoot(home), String(at.getFullYear()), pad(at.getMonth() + 1), pad(at.getDate()), id, "session.jsonl")
+
+/** Muse's recorded_at (microseconds since the epoch) as ISO time. */
+export function usIso(v: unknown): string | undefined {
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) return undefined
+  return new Date(Math.floor(v / 1000)).toISOString()
+}
+
+/** The durable placeholder Muse writes in place of an ephemeral status record it left out. */
+export function isRetainedMarker(r: Rec): boolean {
+  const o = r.omitted_record
+  return typeof r.retained_marker === "string" && isObj(r.position) && isObj(r.stream) && isObj(o) && o.durability === "ephemeral"
+}
+
+/** The run event of a runtime.session record, when it is one. */
+export const runEvent = (r: Rec): Rec | undefined => (r.payload_type === "runtime.session" && isObj(r.payload) && r.payload.kind === "run" && isObj(r.payload.event) ? r.payload.event : undefined)
+
+/** Text blocks of a Muse content list ({kind: "text", text}). */
+export const textBlocks = (content: unknown): string[] =>
+  Array.isArray(content) ? content.filter((b) => isObj(b) && b.kind === "text" && typeof b.text === "string").map((b) => (b as Rec).text as string) : []
+
+/** What Muse's built-in tools do; read_file is the one the capture shows, others go by name. */
+const MUSE_KINDS: Record<string, ToolKind> = { read_file: "read" }
+export const kindOf = (name: string): ToolKind => MUSE_KINDS[name] ?? toolKindOf(name)
+
+/** How Muse words a failed tool's result for the model (it keeps no separate error flag on the result). */
+export const FAILED_PREFIX = "tool failed: "
+
+/** Run events that are telemetry, not conversation. */
+export const QUIET_RUN_EVENTS = new Set([
+  "started",
+  "model_completed",
+  "model_response_created",
+  "terminal",
+  "context_block_diagnostic",
+  "model_request_configured",
+  "provider_request_options_configured",
+  "model_input_trace_recorded",
+  "goal_usage_attribution",
+  "resource_usage_sampled",
+  "task_stream_linked",
+])
+
+/** Record types that carry nothing of the conversation (or that the reader handles itself). */
+export const KNOWN_TYPES = new Set([
+  "runtime.session",
+  "runtime.session.metadata",
+  "runtime.session.route_facts",
+  "session.opened.observed",
+  "session.resumed",
+  "session.end",
+  "runtime.command_intake.received",
+  "runtime.command_intake.settled",
+  "run.model.configured",
+  "runtime.user_intent.accepted",
+  "runtime.user_intent.materialized",
+  "tool_batch.effect.started",
+  "tool_batch.effect.terminal",
+])