@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/mistral-vibe/writer.ts

@@ -0,0 +1,359 @@
+import { createHash, randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs"
+import { userInfo } from "node:os"
+import { extname, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { gitInfo, isDir, ls, versionOf } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { reader } from "./reader.ts"
+import { LABEL, MESSAGES, META, TOOL } from "./records.ts"
+
+// Continues a portable session in Mistral Vibe through its own importer. Vibe 3.x keeps sessions in a
+// private Unified store that is not a supported write target (ADR 0006); what it does accept is a session
+// folder in the format Vibe 2.x wrote ($VIBE_HOME/logs/session/session_<time>_<id8>/: meta.json and
+// messages.jsonl). Vibe 3.1.0 lists such a folder in `vibe --resume`, previews it, and on resume imports
+// its history into a new Unified session (session_interop.export_legacy_committed_history), keeping each
+// message, each tool call with its arguments and each result, failures included, and readable reasoning.
+//
+// Calls become Vibe's own tools where their arguments fit (read_file, write_file, edit, bash, grep). The
+// note saying where the session came from is an injected user message right after the first request;
+// Vibe's legacy history skips injected messages, though its importer turns the note into a plain one.
+// The importer does not carry a compaction boundary into the Unified store either, so the session starts
+// from the last compaction summary, written as Vibe writes one (context_boundary "compaction").
+
+/** Vibe versions whose resume importer this writer was checked against. */
+export const TESTED_VERSIONS = ["3.1.0"]
+
+/** False for 3.1.0: see imagesOf in planMessages. */
+export const VIBE_RESUMES_IMPORTED_IMAGES = false
+
+/** The installed version (`vibe --version` prints "vibe 3.1.0"), or undefined when it is missing. */
+export function vibeVersion(bin = "vibe"): string | undefined {
+  return versionOf(bin)?.match(/(\d+\.\d+\.\d+(?:[-.\w]*)?)/)?.[1]
+}
+
+const continuedNote = (label: string, id: string, when: string) =>
+  `<system-reminder>\nThis session continues ${label} session ${id}, carried over by brain session on ${when}. The messages below are its history; anything listed as lost did not carry over. Check files before relying on details, since they may have changed.\n</system-reminder>`
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+/** Vibe matches a session to the folder it is resumed from by the resolved path. */
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Json = Record<string, unknown>
+
+// Argument names other tools use for the same thing.
+const FILE = ["file_path", "path", "filePath", "absolute_path", "target_file", "file", "filename"]
+const OLD = ["old_string", "oldString", "old_str", "old_text"]
+const NEW = ["new_string", "newString", "new_str", "new_text"]
+const CONTENT = ["content", "contents", "file_text", "text"]
+const COMMAND = ["command", "cmd", "commandLine"]
+const PATTERN = ["pattern", "regex", "query"]
+const DIR = ["path", "dir_path", "directory", "target_directory"]
+
+/** The call as Vibe's own tool when its arguments fit one; otherwise undefined and it keeps its own. */
+export function vibeTool(c: Call): { name: string; args: Json } | undefined {
+  const input = c.input && typeof c.input === "object" && !Array.isArray(c.input) ? (c.input as Json) : {}
+  const str = (keys: string[]) => {
+    const v = keys.map((k) => input[k]).find((x) => typeof x === "string" || (Array.isArray(x) && x.every((y) => typeof y === "string")))
+    return Array.isArray(v) ? v.join(" ") : (v as string | undefined)
+  }
+  const path = str(FILE)
+  switch (c.toolKind) {
+    case "read":
+      return path ? { name: "read_file", args: { file_path: path } } : undefined
+    case "edit": {
+      const [o, n] = [str(OLD), str(NEW)]
+      return path && o && n !== undefined ? { name: "edit", args: { file_path: path, old_string: o, new_string: n } } : undefined
+    }
+    case "write": {
+      const content = str(CONTENT)
+      return path && content !== undefined ? { name: "write_file", args: { file_path: path, content } } : undefined
+    }
+    case "shell": {
+      const command = str(COMMAND)
+      return command ? { name: "bash", args: { command } } : undefined
+    }
+    case "search": {
+      // Vibe has grep and no glob tool; a glob search keeps its own name.
+      const pattern = str(PATTERN)
+      const dir = str(DIR)
+      return pattern && !/glob/i.test(c.name) ? { name: "grep", args: { pattern, ...(dir ? { path: dir } : {}) } } : undefined
+    }
+    default:
+      return undefined
+  }
+}
+
+export interface MessagesPlan {
+  messages: Json[]
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+  /** Image bytes to write under the session folder, by relative path (attachments/<sha1>.<ext>). */
+  assets: Map<string, Buffer>
+}
+
+/** The messages.jsonl lines of a new Vibe session folder continuing `session`. Pure. */
+export function planMessages(session: Session, opts: { now: Date }): MessagesPlan {
+  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)
+
+  // Vibe's importer copies every message into the model's context, so the session starts from the last summary.
+  let turns = session.turns
+  let last = -1
+  turns.forEach((t, i) => {
+    if (t.kind === "compaction") last = i
+  })
+  if (last >= 0) {
+    const before = turns.slice(0, last).filter((t) => t.kind !== "compaction").length
+    if (before) drop("turns before the last compaction (the summary stands in for them)", before)
+    turns = turns.slice(last)
+  }
+
+  const note: Json = { role: "user", content: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)), injected: true, message_id: randomUUID() }
+  // The note follows the first request: Vibe's import drops `injected`, and the first user message becomes
+  // the imported session's preview, which should be the person's words.
+  const firstUser = turns.findIndex((t) => t.kind === "user" && t.text.trim())
+  const messages: Json[] = firstUser < 0 ? [note] : []
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const assets = new Map<string, Buffer>()
+  // An image whose bytes are still on disk is snapshotted the way Vibe 2.24.3 does for an @mentioned image:
+  // attachments/<sha1 of the bytes>.<ext> and {source: {kind: "file", path}, alias, mime_type} on the message.
+  const imagesOf = (list: NonNullable<Extract<Turn, { kind: "user" }>["attachments"]>) => {
+    const out: Json[] = []
+    for (const a of list) {
+      // Vibe 3.1.0 imports a message with an image into its own store as {type: "image", data, mimeType}, then refuses
+      // to resume it ("image.attachment: Field required"): the whole session becomes unresumable. Found by the wire
+      // harness with the real tool, for file and inline sources and for blob resources alike. Until a Vibe version
+      // resumes its own imported images, an image is dropped and listed as lost.
+      if (!VIBE_RESUMES_IMPORTED_IMAGES) {
+        drop("images (Vibe 3.1.0 cannot resume an imported session that holds one)")
+        continue
+      }
+      let bytes: Buffer | undefined
+      if (a.kind === "image" && a.path) {
+        try {
+          bytes = readFileSync(a.path)
+        } catch {
+          bytes = undefined
+        }
+      }
+      if (!bytes || !a.path) {
+        drop("attachments")
+        continue
+      }
+      const rel = `attachments/${createHash("sha1").update(bytes).digest("hex")}${extname(a.path).toLowerCase() || ".png"}`
+      assets.set(rel, bytes)
+      out.push({ source: { kind: "file", path: rel }, alias: a.name ?? a.path.split("/").pop(), mime_type: a.mime ?? "image/png" })
+    }
+    return out
+  }
+  // Call ids stay as they were when an OpenAI-style API takes them, else get a call_ id; each is used once.
+  const ids = new Map<string, string>()
+  const used = new Set<string>()
+  const idFor = (id: string) => {
+    let v = ids.get(id)
+    if (v) return v
+    const base = /^[A-Za-z0-9_-]{1,64}$/.test(id) ? id : `call_${id.replace(/[^A-Za-z0-9]/g, "").slice(-40) || "x"}`
+    v = base
+    for (let n = 2; used.has(v); n++) v = `${base}_${n}`
+    ids.set(id, v)
+    used.add(v)
+    return v
+  }
+  const results = new Map<string, Extract<Turn, { kind: "tool_result" }>>()
+  for (const t of turns) if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+
+  let cur: { reasoning: string[]; text: string; calls: Call[] } | undefined
+  let pendingReasoning: string[] = []
+  const answered = new Set<string>()
+  const nameOf = (c: Call) => vibeTool(c)?.name ?? (c.name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64) || "tool")
+  const flush = () => {
+    if (!cur) return
+    const reasoning = cur.reasoning.join("\n\n")
+    const toolCalls = cur.calls.map((c, index) => ({ id: idFor(c.id), index, function: { name: nameOf(c), arguments: JSON.stringify(vibeTool(c)?.args ?? c.input ?? {}) }, type: "function" }))
+    messages.push({ role: "assistant", content: cur.text, ...(reasoning ? { reasoning_content: reasoning } : {}), ...(toolCalls.length ? { tool_calls: toolCalls } : {}), message_id: randomUUID() })
+    if (cur.text.trim()) expect.assistants++
+    // A call the session never answered is closed as a failure, so every request has its result.
+    for (const c of cur.calls) {
+      if (results.has(c.id)) continue
+      messages.push({ role: "tool", content: "<tool_error>No result was recorded for this call; the session moved on before it finished.</tool_error>", tool_call_id: idFor(c.id), name: nameOf(c) })
+      answered.add(c.id)
+      drop("tool calls without a result (closed as failures)")
+    }
+    cur = undefined
+  }
+
+  for (const [i, t] of turns.entries()) {
+    switch (t.kind) {
+      case "user":
+        flush()
+        if (pendingReasoning.length) drop("reasoning without a reply", pendingReasoning.length)
+        pendingReasoning = []
+        const images = imagesOf(t.attachments ?? [])
+        if (!t.text.trim()) break
+        messages.push({ role: "user", content: t.text, ...(images.length ? { images } : {}), message_id: randomUUID() })
+        if (i === firstUser) messages.push(note)
+        expect.users++
+        break
+      case "assistant":
+        if (cur?.calls.length || (cur?.text.trim() && t.text.trim())) flush()
+        cur ??= { reasoning: pendingReasoning, text: "", calls: [] }
+        pendingReasoning = []
+        cur.text = t.text
+        break
+      case "reasoning":
+        if (cur?.calls.length || cur?.text.trim()) flush()
+        pendingReasoning.push(t.text)
+        break
+      case "tool_call":
+        if (ids.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        idFor(t.id)
+        cur ??= { reasoning: pendingReasoning, text: "", calls: [] }
+        pendingReasoning = []
+        cur.calls.push(t)
+        expect.calls++
+        break
+      case "tool_result": {
+        if (!ids.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (answered.has(t.callId) || results.get(t.callId) !== t) {
+          drop("repeated tool results")
+          break
+        }
+        const call = cur?.calls.find((c) => c.id === t.callId)
+        if (call) flush()
+        let text = t.output
+        if (t.fullPath) text += `\n\n[Full output: ${t.fullPath}]`
+        const name = call ? nameOf(call) : undefined
+        messages.push({ role: "tool", content: t.ok ? text : `<tool_error>${text || "The tool failed."}</tool_error>`, tool_call_id: idFor(t.callId), ...(name ? { name } : {}) })
+        answered.add(t.callId)
+        break
+      }
+      case "compaction":
+        flush()
+        messages.push({ role: "user", content: `[Summary of the earlier conversation in ${label}, which replaced the turns before it]\n\n${t.summary}`, context_boundary: "compaction", message_id: randomUUID() })
+        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
+    }
+  }
+  flush()
+  if (pendingReasoning.length) drop("reasoning without a reply", pendingReasoning.length)
+  // A tool message names its tool; one answered after the assistant message was flushed gets it here.
+  const names = new Map<string, string>()
+  for (const m of messages) for (const c of (m.tool_calls as Array<{ id: string; function: { name: string } }> | undefined) ?? []) names.set(c.id, c.function.name)
+  for (const m of messages) if (m.role === "tool" && !m.name) m.name = names.get(m.tool_call_id as string) ?? "tool"
+  return { messages, lost: [...drops].map(([what, n]) => `${what} (${n})`), expect, assets }
+}
+
+/** `2026-11-08T10:00:00.000Z` → `20261108_100000`, the folder-name stamp Vibe uses (local time). */
+function stamp(d: Date): string {
+  const p = (n: number) => String(n).padStart(2, "0")
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}_${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`
+}
+
+/** The Mistral Vibe writer; `version` is for tests, which must not depend on an installed binary. */
+export function mistralVibeWriter(opts: { version?: string } = {}): Writer {
+  const installed = () => opts.version ?? vibeVersion()
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "import",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "Mistral Vibe is not installed (`vibe --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Mistral Vibe ${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; Vibe offers a session from its working directory` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const cwd = realCwd(w.cwd)
+      const root = join(w.home, ".vibe", "logs", "session")
+      const now = new Date()
+      let sessionId = randomUUID()
+      // Vibe finds a folder by the first 8 characters of the id, so no other folder may share them.
+      const taken = (id: string) => ls(root).some((n) => n.startsWith("session_") && n.endsWith(`_${id.slice(0, 8)}`))
+      while (taken(sessionId)) sessionId = randomUUID()
+      const dir = join(root, `session_${stamp(now)}_${sessionId.slice(0, 8)}`)
+      const plan = planMessages(session, { now })
+      const git = gitInfo(cwd, w.home)
+      const title = `${session.header.title ?? firstUserText(session)?.replace(/\s+/g, " ").trim().slice(0, 60) ?? "Session"} (from ${toolLabel(session.header.tool)})`
+      const meta = {
+        session_id: sessionId,
+        parent_session_id: null,
+        start_time: now.toISOString(),
+        end_time: now.toISOString(),
+        git_commit: git.gitCommit ?? null,
+        git_branch: git.gitBranch ?? null,
+        environment: { working_directory: cwd },
+        origin_directory: cwd,
+        username: userInfo().username,
+        title,
+        // "manual" keeps Vibe from replacing the title with a generated one.
+        title_source: "manual",
+        total_messages: plan.messages.length,
+        import_provenance: { source: session.header.tool, session_id: session.header.sourceId, by: "brain session" },
+      }
+      const paths = { meta: join(dir, META), messages: join(dir, MESSAGES) }
+      if (!w.dryRun) {
+        mkdirSync(root, { recursive: true })
+        // mkdir without recursive on the session folder itself: an existing session is never touched.
+        mkdirSync(dir)
+        try {
+          for (const [rel, bytes] of plan.assets) {
+            mkdirSync(join(dir, "attachments"), { recursive: true })
+            writeFileSync(join(dir, rel), bytes)
+          }
+          writeFileSync(paths.messages, plan.messages.map((m) => `${JSON.stringify(m)}\n`).join(""), { flag: "wx" })
+          // meta.json last: the listing reads it, and a folder without it is skipped.
+          writeFileSync(paths.meta, JSON.stringify(meta, null, 2), { flag: "wx" })
+          const back = await reader.read({ tool: TOOL, sourceId: sessionId, path: paths.messages, extra: { dir } }, 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 Mistral Vibe 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: "import",
+        sessionId,
+        written: [paths.messages, paths.meta],
+        open: `cd ${shellQuote(cwd)} && vibe --resume ${sessionId}`,
+        note: "Vibe imports the session into its own store the first time it is resumed.",
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const mistralVibeImportWriter = mistralVibeWriter()

package/src/adapters/muse/index.ts

@@ -0,0 +1,10 @@
+import type { Reader, Writer } from "../types.ts"
+import { reader } from "./reader.ts"
+import { museNativeWriter } from "./writer.ts"
+
+// Muse Code (Meta's coding agent): reads its durable session event streams under ~/.local/share/muse, and
+// continues any session as a new native Muse session that `muse exec --session-id <id>` resumes.
+// Format and lifecycle ported from session-migrate (xhluca/session-migrate, MIT), checked against Muse 0.2.1.
+export { reader }
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [museNativeWriter]