@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/kimi/index.ts

@@ -0,0 +1,9 @@
+import type { Reader, Writer } from "../types.ts"
+import { reader } from "./reader.ts"
+import { kimiCodeNativeWriter } from "./writer.ts"
+
+// Kimi Code (Moonshot, the TypeScript successor of the archived Kimi CLI): reads ~/.kimi-code sessions, and
+// continues any session as a new native Kimi Code session that `kimi --session <id>` opens.
+export { reader }
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [kimiCodeNativeWriter]

package/src/adapters/kimi/reader.ts

@@ -0,0 +1,92 @@
+import { statSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { exists, gitInfo, isDir, ls, readJson, readJsonl } from "../../fsutil.ts"
+import { header, iso, lossCounter } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { LABEL, str, TOOL, wireToTurns } from "./records.ts"
+
+// Kimi Code keeps each session in ~/.kimi-code/sessions/<wd_slug_hash>/<sessionId>/: state.json and the main
+// agent's journal, agents/main/wire.jsonl (records.ts). Subagents have journals of their own beside it.
+// The archived Python Kimi CLI (~/.kimi) is not read: Kimi Code's own `kimi migrate` converts it.
+
+/** Wire protocol versions this reader was checked against (Kimi Code migrates 1.0–1.4 up to 1.5). */
+const KNOWN_WIRE = new Set(["1.0", "1.1", "1.2", "1.3", "1.4", "1.5"])
+
+type State = Record<string, any>
+
+function sessionDirs(home: string): string[] {
+  const root = join(home, ".kimi-code", "sessions")
+  const out: string[] = []
+  for (const ws of ls(root)) {
+    if (!ws.startsWith("wd_") || !isDir(join(root, ws))) continue
+    for (const id of ls(join(root, ws))) {
+      const dir = join(root, ws, id)
+      if (exists(join(dir, "state.json"))) out.push(dir)
+    }
+  }
+  return out
+}
+
+const mainWire = (dir: string, state: State | undefined) => {
+  const given = str(state?.agents?.main?.homedir)
+  // Kimi Code 0.38.0 records the agent folder relative to the session folder ("agents/main"); older ones an absolute path.
+  const home = given ? resolve(dir, given) : undefined
+  return home && exists(join(home, "wire.jsonl")) ? join(home, "wire.jsonl") : join(dir, "agents", "main", "wire.jsonl")
+}
+
+export const reader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home) {
+    const refs: SessionRef[] = []
+    for (const dir of sessionDirs(home)) {
+      const state = readJson<State>(join(dir, "state.json"))
+      const wire = mainWire(dir, state)
+      let size = 0
+      try {
+        size = statSync(wire).size
+      } catch {
+        continue
+      }
+      // A session never prompted has only its metadata line.
+      if (!str(state?.lastPrompt) && size < 256) continue
+      const sourceId = str(state?.id) ?? dir.split("/").pop()!
+      const title = str(state?.title)
+      const cwd = str(state?.cwd)
+      const updatedAt = iso(state?.updatedAt)
+      refs.push({ tool: TOOL, sourceId, path: wire, ...(title ? { title } : {}), ...(cwd ? { cwd } : {}), ...(updatedAt ? { updatedAt } : {}), extra: { dir } })
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref, home) {
+    if (!exists(ref.path)) throw new Error(`${ref.path} does not exist`)
+    const dir = typeof ref.extra?.dir === "string" ? ref.extra.dir : join(ref.path, "..", "..", "..")
+    const state = readJson<State>(join(dir, "state.json"))
+    const { rows, bad } = readJsonl(ref.path)
+    if (!rows.length) throw new Error(`${ref.path} has no Kimi Code wire records`)
+    const lost = lossCounter()
+    if (bad) lost.add("unreadable lines", bad)
+    const meta = rows[0]?.type === "metadata" ? rows[0] : undefined
+    if (meta && !KNOWN_WIRE.has(String(meta.protocol_version))) lost.add(`unverified wire protocol ${String(meta.protocol_version)}`)
+
+    const cwd = str(state?.cwd) ?? ref.cwd
+    const title = str(state?.title)
+    const startedAt = iso(state?.createdAt) ?? iso(meta?.created_at)
+    const updatedAt = iso(state?.updatedAt)
+    const h = header(TOOL, str(state?.id) ?? ref.sourceId, {
+      sourcePath: ref.path,
+      ...(title ? { title } : {}),
+      project: { ...(cwd ? { cwd } : {}), ...gitInfo(cwd, home) },
+      ...(startedAt ? { startedAt } : {}),
+      ...(updatedAt ? { updatedAt } : {}),
+    })
+    const turns = wireToTurns(rows, h, lost)
+    // Subagents keep their own journals; their results stay in the parent's tool results.
+    const subs = Object.entries(state?.agents ?? {}).filter(([id, a]) => id !== "main" && (a as State)?.type === "sub").length
+    if (subs) lost.add("subagent transcripts (their results stay in the parent's tool results)", subs)
+    lost.flush(h)
+    return { header: h, turns }
+  },
+}

package/src/adapters/kimi/records.ts

@@ -0,0 +1,221 @@
+import { createHash } from "node:crypto"
+import { keepImage, parseDataUrl } from "../../session/attachments.ts"
+import type { Attachment, SessionHeader, Turn } from "../../session/types.ts"
+import { clip, iso, noteModel, toolKindOf, type lossCounter } from "../../session/util.ts"
+
+// Facts about Kimi Code's session store, shared by its reader and writer. They come from Kimi Code's source
+// (MoonshotAI/kimi-code, packages/agent-core-v2: wire/, agent/contextMemory/, agent/replayBuilder/fold.ts,
+// _base/utils/workdir-slug.ts; packages/migration-legacy: the writer Kimi uses for sessions converted from
+// elsewhere) and from the bundle of @moonshot-ai/kimi-code 2.5.2, which wrote and listed sessions here.
+//
+// ~/.kimi-code/sessions/<wd_slug_hash>/<sessionId>/ holds state.json (title, cwd, times, agents) and
+// agents/<agentId>/wire.jsonl, the journal every resume replays: a metadata line, then turn.* records and
+// context.* records. Messages arrive two ways: context.append_message (user prompts, and every message of
+// a converted session), and context.append_loop_event (a live model step: step.begin, content.part,
+// tool.call, step.end, tool.result). ~/.kimi-code/session_index.jsonl maps ids to folders.
+
+export const TOOL = "kimi-code"
+export const LABEL = "Kimi Code"
+
+/** The wire protocol Kimi Code 2.5.2 writes (createWireMetadataRecord). */
+export const WIRE_PROTOCOL = "1.5"
+/** state.json's `version` in Kimi Code 2.5.2. */
+export const META_VERSION = 2
+
+type Lost = ReturnType<typeof lossCounter>
+type Json = Record<string, any>
+const isObj = (v: unknown): v is Json => typeof v === "object" && v !== null && !Array.isArray(v)
+
+/** The bucket folder for a working directory, `wd_<slug>_<sha256[:12]>`, as encodeWorkDirKey makes it. */
+export function workDirKey(workDir: string): string {
+  const normalized = workDir.replaceAll("\\", "/").replace(/\/+$/, "")
+  const base = normalized.split("/").pop() ?? normalized
+  let slug = base
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9._-]+/g, "-")
+    .replaceAll(/^-+|-+$/g, "")
+    .slice(0, 40)
+    .replaceAll(/^-+|-+$/g, "")
+  if (slug === "" || slug === "." || slug === "..") slug = "workspace"
+  return `wd_${slug}_${createHash("sha256").update(normalized).digest("hex").slice(0, 12)}`
+}
+
+/**
+ * Origins whose user-role messages are not anyone's request: reminders and other injected context
+ * (injection), system wake-ups, hook output, task notices and retries. A compaction summary is its own turn.
+ */
+const CONTEXT_ORIGINS = new Set(["injection", "system_trigger", "hook_result", "task", "retry", "cron_missed"])
+
+/** Tool calls as wire 1.1+ stores them ({name, arguments}) or as 1.0 did ({function: {name, arguments}}). */
+function callOf(c: Json): { id: string; name: string; input: unknown } | undefined {
+  if (typeof c.id !== "string" || !c.id) return undefined
+  const fn = isObj(c.function) ? c.function : c
+  const name = typeof fn.name === "string" && fn.name ? fn.name : "unknown"
+  return { id: c.id, name, input: parseArgs(fn.arguments ?? fn.args) }
+}
+
+function parseArgs(a: unknown): unknown {
+  if (typeof a !== "string") return a ?? {}
+  try {
+    return JSON.parse(a)
+  } catch {
+    return { arguments: a }
+  }
+}
+
+/** Text of a message's parts; the other kinds are counted as lost. */
+function partsText(parts: unknown, lost: Lost, kinds: { think?: string[] } = {}): { text: string; attachments: Attachment[] } {
+  const texts: string[] = []
+  const attachments: Attachment[] = []
+  for (const p of Array.isArray(parts) ? parts : typeof parts === "string" ? [{ type: "text", text: parts }] : []) {
+    if (!isObj(p)) continue
+    if (p.type === "text" && typeof p.text === "string") texts.push(p.text)
+    else if (p.type === "think") {
+      if (typeof p.encrypted === "string" && p.encrypted) lost.add("signed or encrypted reasoning")
+      else if (typeof p.think === "string" && p.think.trim() && kinds.think) kinds.think.push(p.think)
+    } else if (p.type === "image_url") {
+      const url = isObj(p.imageUrl) ? p.imageUrl.url : undefined
+      const d = parseDataUrl(url)
+      const kept = d ? keepImage(d.base64, d.mime) : undefined
+      if (kept) attachments.push(kept)
+      else {
+        attachments.push({ kind: "image" })
+        lost.add("images")
+      }
+    } else if (p.type === "audio_url" || p.type === "video_url") lost.add("audio and video parts")
+  }
+  return { text: texts.join(""), attachments }
+}
+
+const toolOutput = (output: unknown, lost: Lost) => (typeof output === "string" ? output : partsText(output, lost).text)
+
+/**
+ * The turns of one agent's wire records, in order: messages appended directly and the model steps folded
+ * from loop events, compactions as compaction turns, undone exchanges removed.
+ */
+export function wireToTurns(records: Json[], h: SessionHeader, lost: Lost): Turn[] {
+  const turns: Turn[] = []
+  const calls = new Set<string>()
+  const answered = new Set<string>()
+  let step: Extract<Turn, { kind: "assistant" }> | undefined
+  const at = (r: Json) => iso(typeof r.time === "number" ? r.time : undefined)
+
+  const call = (id: string, name: string, input: unknown, when?: string) => {
+    if (calls.has(id)) return
+    calls.add(id)
+    turns.push({ kind: "tool_call", ...(when ? { at: when } : {}), id, name, toolKind: toolKindOf(name), input })
+  }
+  const result = (id: string, output: string, ok: boolean, when?: string) => {
+    if (answered.has(id) || !calls.has(id)) return
+    answered.add(id)
+    const c = clip(output)
+    turns.push({ kind: "tool_result", ...(when ? { at: when } : {}), callId: id, ok, output: c.text, ...(c.truncated ? { truncated: true } : {}) })
+  }
+
+  for (const r of records) {
+    const when = at(r)
+    switch (r.type) {
+      // A live session records the provider model on each request (messages carry none).
+      case "llm.request":
+        if (typeof r.model === "string") noteModel(h, r.model)
+        break
+      case "context.append_message": {
+        const m = isObj(r.message) ? r.message : {}
+        if (m.role === "user") {
+          const origin = isObj(m.origin) ? m.origin.kind : undefined
+          if (origin === "compaction_summary") {
+            const s = partsText(m.content, lost).text
+            if (s.trim()) turns.push({ kind: "compaction", ...(when ? { at: when } : {}), summary: s })
+            break
+          }
+          if (typeof origin === "string" && CONTEXT_ORIGINS.has(origin)) break
+          const { text, attachments } = partsText(m.content, lost)
+          // Sessions migrated from the Python Kimi CLI carry its reminders as plain user messages.
+          if (/^\s*<system-reminder>[\s\S]*<\/system-reminder>\s*$/.test(text)) break
+          if (text.trim() || attachments.length) turns.push({ kind: "user", ...(when ? { at: when } : {}), text, ...(attachments.length ? { attachments } : {}) })
+        } else if (m.role === "assistant") {
+          const think: string[] = []
+          const { text } = partsText(m.content, lost, { think })
+          for (const t of think) turns.push({ kind: "reasoning", ...(when ? { at: when } : {}), text: t })
+          if (text.trim()) turns.push({ kind: "assistant", ...(when ? { at: when } : {}), text })
+          for (const c of Array.isArray(m.toolCalls) ? m.toolCalls : []) {
+            const v = isObj(c) ? callOf(c) : undefined
+            if (v) call(v.id, v.name, v.input, when)
+          }
+        } else if (m.role === "tool" && typeof m.toolCallId === "string") {
+          const out = toolOutput(m.content, lost)
+          // The Python Kimi CLI marked a failure in the text itself; migrated sessions keep that.
+          result(m.toolCallId, out, m.isError !== true && !out.startsWith("<system>ERROR"), when)
+        }
+        break
+      }
+      case "context.append_loop_event": {
+        const e = isObj(r.event) ? r.event : {}
+        if (e.type === "step.begin") step = undefined
+        else if (e.type === "content.part" && isObj(e.part)) {
+          const p = e.part
+          if (p.type === "text" && typeof p.text === "string") {
+            if (!step) {
+              step = { kind: "assistant", ...(when ? { at: when } : {}), text: "" }
+              turns.push(step)
+            }
+            step.text += p.text
+          } else {
+            const think: string[] = []
+            partsText([p], lost, { think })
+            for (const t of think) turns.push({ kind: "reasoning", ...(when ? { at: when } : {}), text: t })
+          }
+        } else if (e.type === "tool.call" && typeof e.toolCallId === "string") {
+          call(e.toolCallId, typeof e.name === "string" ? e.name : "unknown", parseArgs(e.args), when)
+        } else if (e.type === "tool.result" && typeof e.toolCallId === "string" && isObj(e.result)) {
+          result(e.toolCallId, toolOutput(e.result.output, lost), e.result.isError !== true, when)
+        } else if (e.type === "step.end") {
+          if (step && isObj(e.usage) && step.text.trim()) {
+            const u = { input: e.usage.inputOther, output: e.usage.output, cacheRead: e.usage.inputCacheRead, cacheWrite: e.usage.inputCacheCreation }
+            const usage = Object.fromEntries(Object.entries(u).filter(([, v]) => typeof v === "number"))
+            if (Object.keys(usage).length) step.usage = usage
+          }
+          if (step && !step.text.trim()) turns.splice(turns.indexOf(step), 1)
+          step = undefined
+        }
+        break
+      }
+      case "context.apply_compaction": {
+        const s = typeof r.contextSummary === "string" ? r.contextSummary : typeof r.summary === "string" ? r.summary : isObj(r.summary) ? partsText(r.summary.content, lost).text : ""
+        if (s.trim()) turns.push({ kind: "compaction", ...(when ? { at: when } : {}), summary: s })
+        break
+      }
+      case "context.undo": {
+        // Undo removes the last `count` exchanges, each back to its user message.
+        let left = typeof r.count === "number" ? r.count : 0
+        while (left > 0 && turns.length) {
+          const t = turns.pop()!
+          if (t.kind === "compaction") {
+            turns.push(t)
+            break
+          }
+          if (t.kind === "user") left--
+        }
+        break
+      }
+      case "context.clear":
+        lost.add("context clears (the turns before them are kept)")
+        break
+    }
+  }
+  // Calls the journal never answered get a result saying so, as Kimi does on resume, so every call is paired.
+  const open = [...calls].filter((id) => !answered.has(id) && turns.some((t) => t.kind === "tool_call" && t.id === 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)" })
+  }
+  if (!h.title) {
+    const first = turns.find((t) => t.kind === "user")
+    if (first?.kind === "user") h.title = first.text.replace(/\s+/g, " ").trim().slice(0, 120) || undefined
+  }
+  return turns
+}
+
+/** A state.json value as text, for titles and paths. */
+export const str = (v: unknown) => (typeof v === "string" && v.trim() ? v : undefined)