@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/adapters/pi/writer.ts

@@ -0,0 +1,362 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { dirname, extname, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, versionOf } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, firstUserText, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../claude-code/records.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { parseSession } from "./reader.ts"
+import { type Entry, NOTE_TYPE, type PiFlavor, SESSION_VERSION, sessionDir } from "./records.ts"
+
+// Continues a portable session as a new Pi-format session (Pi, Auggie 1.x): one file in the project's
+// session folder, the header and then entries on one parentId chain, as Pi's SessionManager writes them.
+// `pi --session <id>` finds it by the header id, and /resume lists it.
+//
+// The first entry is a session_info (the name /resume shows, as `pi --name` writes it), then a hidden
+// custom_message saying where the session came from (after the last compaction, where the model's context
+// starts): Pi gives custom messages to the model as user text but `display: false` keeps it off screen,
+// so it is not a fake request. Each assistant response is one
+// message with its text, readable reasoning (a thinking block without a signature) and toolCall blocks,
+// and each result is its own toolResult message, as Pi records them. Calls from other tools become Pi's
+// own read / bash / edit / write / grep / find / ls when their arguments map; others keep their names.
+//
+// Assistant messages name the source tool as their provider and "brain-session" as their api, so Pi
+// treats them as another model's turns: it drops their reasoning from requests and normalises their call
+// ids for the model that resumes, and on resume it says it could not restore that model and uses the
+// person's default. A compaction is a Pi compaction entry that keeps nothing before it, so Pi continues
+// from its summary while the earlier turns stay on screen.
+
+const API = "brain-session"
+const IMAGE_TYPES: Record<string, string> = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" }
+const IMAGE_LIMIT = 5 * 1024 * 1024
+const ZERO_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }
+
+type Call = Extract<Turn, { kind: "tool_call" }>
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+const str = (o: Entry, ...keys: string[]): string | undefined => {
+  for (const k of keys) if (typeof o[k] === "string" && o[k]) return o[k] as string
+  return undefined
+}
+const num = (o: Entry, key: string, as: string) => (typeof o[key] === "number" ? { [as]: o[key] } : {})
+
+/** A shell call's command line: a string, or an argv (`bash -lc <script>` keeps just the script). */
+export function commandOf(i: Entry): string | undefined {
+  const c = i.command ?? i.cmd
+  if (typeof c === "string") return c || undefined
+  if (Array.isArray(c) && c.every((x) => typeof x === "string")) {
+    const [shell, flag, script] = c as string[]
+    if (c.length === 3 && /(^|\/)(ba|z)?sh$/.test(shell!) && /^-l?c$/.test(flag!)) return script
+    return c.map(shellQuote).join(" ") || undefined
+  }
+  return undefined
+}
+
+/** Replacements in a call's arguments, whatever the tool named them. */
+function editsOf(i: Entry): Array<{ oldText: string; newText: string }> | undefined {
+  const one = (e: Entry) => {
+    const oldText = e.old_string ?? e.old_str ?? e.oldText
+    const newText = e.new_string ?? e.new_str ?? e.newText
+    return typeof oldText === "string" && typeof newText === "string" ? { oldText, newText } : undefined
+  }
+  if (i.replace_all === true || i.change_all === true) return undefined // Pi's edit replaces one occurrence
+  const list = Array.isArray(i.edits) ? (i.edits as Entry[]).map(one) : [one(i)]
+  return list.length && list.every(Boolean) ? (list as Array<{ oldText: string; newText: string }>) : undefined
+}
+
+/** A call from another tool as one of Pi's built-in tools, when its arguments say enough; undefined keeps it as it was. */
+export function asPiTool(call: Call): { name: string; args: Entry } | undefined {
+  const i = call.input && typeof call.input === "object" && !Array.isArray(call.input) ? (call.input as Entry) : undefined
+  if (!i) return undefined
+  const path = str(i, "path", "file_path", "filePath", "absolute_path", "target_file")
+  switch (call.toolKind) {
+    case "read":
+      return path ? { name: "read", args: { path, ...num(i, "offset", "offset"), ...num(i, "limit", "limit") } } : undefined
+    case "write": {
+      const content = i.content ?? i.contents ?? i.file_text
+      return path && typeof content === "string" ? { name: "write", args: { path, content } } : undefined
+    }
+    case "edit": {
+      const edits = editsOf(i)
+      return path && edits ? { name: "edit", args: { path, edits } } : undefined
+    }
+    case "shell": {
+      const command = commandOf(i)
+      return command ? { name: "bash", args: { command } } : undefined
+    }
+    case "search": {
+      const where = str(i, "path", "folder", "dir_path", "directory")
+      if (/glob|find|file_search/i.test(call.name)) {
+        const pattern = str(i, "pattern") ?? (Array.isArray(i.patterns) && typeof i.patterns[0] === "string" ? i.patterns[0] : str(i, "patterns"))
+        return pattern ? { name: "find", args: { pattern, ...(where ? { path: where } : {}) } } : undefined
+      }
+      const pattern = str(i, "pattern", "regex")
+      const glob = str(i, "glob", "glob_pattern", "include")
+      return pattern ? { name: "grep", args: { pattern, ...(where ? { path: where } : {}), ...(glob ? { glob } : {}) } } : undefined
+    }
+    case "list": {
+      const where = str(i, "path", "directory_path", "dir_path", "target_directory", "directory", "folder")
+      return { name: "ls", args: where ? { path: where } : {} }
+    }
+    default:
+      return undefined
+  }
+}
+
+export interface PiPlan {
+  /** The header line and every entry, in order. */
+  lines: Entry[]
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The lines of a new Pi-format session `id` continuing `session`. Pure apart from reading attached images. */
+export function planPiSession(session: Session, opts: { flavor: PiFlavor; id: string; now: Date; cwd: string }): PiPlan {
+  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 }
+  const lines: Entry[] = [{ type: "session", version: SESSION_VERSION, id: opts.id, timestamp: opts.now.toISOString(), cwd: opts.cwd }]
+
+  // Entry ids: 8 hex characters, unique in the file, as Pi makes them. Timestamps never go backwards.
+  const used = new Set<string>()
+  const entryId = () => {
+    let v = randomUUID().slice(0, 8)
+    while (used.has(v)) v = randomUUID().slice(0, 8)
+    used.add(v)
+    return v
+  }
+  const known = session.turns.map((t) => (t.at ? Date.parse(t.at) : Number.NaN)).find(Number.isFinite)
+  let clock = (known ?? opts.now.getTime()) - 1
+  const stamp = (at?: string) => {
+    const t = at ? Date.parse(at) : Number.NaN
+    clock = Number.isFinite(t) && t > clock ? t : clock + 1
+    return clock
+  }
+  let parent: string | null = null
+  let chars = 0
+  const push = (fields: Entry, at?: string, id = entryId()) => {
+    const ms = stamp(at)
+    // A message carries its own time in milliseconds beside the entry's ISO time.
+    const body = fields.type === "message" ? { ...fields, message: { ...fields.message, timestamp: ms } } : fields
+    lines.push({ type: fields.type, id, parentId: parent, timestamp: new Date(ms).toISOString(), ...body })
+    parent = id
+  }
+  const message = (m: Entry, at?: string) => {
+    push({ type: "message", message: m }, at)
+    chars += JSON.stringify(m.content ?? "").length
+  }
+
+  const title = session.header.title ?? firstUserText(session)?.replace(/\s+/g, " ").trim().slice(0, 60) ?? "Session"
+  push({ type: "session_info", name: `${title} (from ${label})` })
+  // The note must be in the model's context, which starts at the last compaction: it goes right after that one.
+  const note = () => push({ type: "custom_message", customType: NOTE_TYPE, content: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)), display: false })
+  const lastCompaction = session.turns.map((t) => t.kind).lastIndexOf("compaction")
+  if (lastCompaction < 0) note()
+
+  // Which calls get a result somewhere, and the call ids as Pi will keep them.
+  const answered = new Set(session.turns.filter((t) => t.kind === "tool_result").map((t) => (t as Extract<Turn, { kind: "tool_result" }>).callId))
+  const ids = new Map<string, string>()
+  const takenIds = new Set<string>()
+  let remapped = 0
+  let renamed = 0
+  const callId = (id: string) => {
+    let v = ids.get(id)
+    if (v) return v
+    v = /^[A-Za-z0-9_-]{1,64}$/.test(id) && !takenIds.has(id) ? id : `call_${randomUUID().replace(/-/g, "").slice(0, 24)}`
+    if (v !== id) remapped++
+    ids.set(id, v)
+    takenIds.add(v)
+    return v
+  }
+
+  let model = session.header.models[session.header.models.length - 1] ?? "unknown"
+  let cur: { at?: string; model: string; blocks: Entry[]; calls: string[] } | undefined
+  const written = new Map<string, string>() // source call id → Pi tool name
+  const done = new Set<string>()
+  const result = (sourceId: string, ok: boolean, output: string, at?: string) => {
+    message({ role: "toolResult", toolCallId: callId(sourceId), toolName: written.get(sourceId), content: [{ type: "text", text: output.trim() ? output : "(no output)" }], isError: !ok }, at)
+    done.add(sourceId)
+  }
+  const flush = () => {
+    if (!cur?.blocks.length) {
+      cur = undefined
+      return
+    }
+    const c = cur
+    cur = undefined
+    message({ role: "assistant", content: c.blocks, api: API, provider: session.header.tool, model: c.model, usage: ZERO_USAGE, stopReason: c.calls.length ? "toolUse" : "stop" }, c.at)
+    // Pi answers every call before the next request; a call that never got a result is closed as an error.
+    for (const id of c.calls) {
+      if (answered.has(id)) continue
+      drop("tool calls without a result (closed as errors)")
+      result(id, false, "No result was recorded for this call; the session moved on before it finished.")
+    }
+  }
+  const assistant = (at?: string) => (cur ??= { ...(at ? { at } : {}), model, blocks: [], calls: [] })
+
+  for (const [i, t] of session.turns.entries()) {
+    switch (t.kind) {
+      case "user": {
+        flush()
+        const blocks: Entry[] = []
+        let text = t.text
+        for (const a of t.attachments ?? []) {
+          if (!a.path) continue // bytes the reader could not keep; it already counted them
+          if (a.kind === "file") {
+            text += `\n\n[Attached file: ${a.path}]`
+            continue
+          }
+          const mime = a.mime ?? IMAGE_TYPES[extname(a.path).toLowerCase()]
+          let size = Number.POSITIVE_INFINITY
+          try {
+            size = statSync(a.path).size
+          } catch {}
+          if (mime && Object.values(IMAGE_TYPES).includes(mime) && size <= IMAGE_LIMIT) blocks.push({ type: "image", data: readFileSync(a.path).toString("base64"), mimeType: mime })
+          else drop("images that could not be attached")
+        }
+        if (!text.trim() && !blocks.length) break
+        // Pi records a prompt as a list of content blocks even when it is only text (a real 0.80.6 session does).
+        message({ role: "user", content: [{ type: "text", text: text.trim() ? text : "(image)" }, ...blocks] }, t.at)
+        expect.users++
+        break
+      }
+      case "assistant":
+        // Text after a tool call is a new response: it was written after the call's result came back.
+        if (cur?.calls.length) flush()
+        if (t.model) model = t.model
+        if (!t.text.trim()) break
+        assistant(t.at).blocks.push({ type: "text", text: t.text })
+        if (t.model) cur!.model = t.model
+        expect.assistants++
+        break
+      case "reasoning":
+        if (cur?.calls.length) flush()
+        if (t.text.trim()) assistant(t.at).blocks.push({ type: "thinking", thinking: t.text })
+        break
+      case "tool_call": {
+        if (written.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        const pi = asPiTool(t)
+        // Unmapped names must still suit every provider's tool-name rule.
+        const name = pi?.name ?? (t.name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64) || "tool")
+        if (name !== t.name) renamed++
+        const args = pi?.args ?? (t.input && typeof t.input === "object" && !Array.isArray(t.input) ? (t.input as Entry) : { input: t.input ?? null })
+        assistant(t.at).blocks.push({ type: "toolCall", id: callId(t.id), name, arguments: args })
+        cur!.calls.push(t.id)
+        written.set(t.id, name)
+        expect.calls++
+        break
+      }
+      case "tool_result": {
+        if (!written.has(t.callId)) {
+          drop("tool results without a call")
+          break
+        }
+        if (done.has(t.callId)) {
+          drop("repeated tool results")
+          break
+        }
+        // A result closes the response that made the call; the next call is a new response.
+        if (cur?.calls.includes(t.callId)) flush()
+        result(t.callId, t.ok, t.fullPath ? `${t.output}\n\n[Full output: ${t.fullPath}]` : t.output, t.at)
+        break
+      }
+      case "compaction": {
+        flush()
+        // Keeps nothing before it (firstKeptEntryId is its own id): Pi continues from the summary.
+        const id = entryId()
+        push({ type: "compaction", summary: t.summary, firstKeptEntryId: id, tokensBefore: Math.round(chars / 4) }, t.at, id)
+        chars = 0
+        if (i === lastCompaction) note()
+        break
+      }
+      case "file_edit":
+        if (!t.callId || !written.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 (!expect.users && !expect.assistants && !expect.calls) throw new Error("nothing to continue: the session has no messages or tool calls")
+
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (renamed) lost.push(`original tool names (${renamed} calls renamed to Pi's tools or to fit its rules)`)
+  if (remapped) lost.push(`tool call ids remapped (${remapped})`)
+  return { lines, lost, expect }
+}
+
+/** The tool's version from `<bin> --version` ("1.5.0", "1.2.0-prerelease.202611061509"), or undefined when it is missing. */
+export function piFamilyVersion(bin: string): string | undefined {
+  return versionOf(bin)?.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/)?.[1]
+}
+
+/** Pi records the folder it ran in as the process saw it: the resolved path (/private/tmp, not /tmp). */
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+/** A writer for one Pi-format tool; `version` is for tests, which must not depend on the installed binary. */
+export function piFamilyWriter(f: PiFlavor, o: { tested: string[]; why?: (v: string) => string | undefined; version?: string }): Writer {
+  const installed = () => o.version ?? piFamilyVersion(f.bin)
+  return {
+    tool: f.tool,
+    label: f.label,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: `${f.label} is not installed here (\`${f.bin} --version\` failed)` }
+      const special = o.why?.(v)
+      if (special) return { ok: false, why: special }
+      if (!o.tested.includes(v)) return { ok: false, why: `${f.label} ${v} is not a version this writer was checked against (${o.tested.join(", ")})` }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; ${f.label} 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 dir = sessionDir(f, w.home, cwd)
+      let id = f.newId()
+      while (exists(join(dir, f.fileName(id, now.toISOString())))) id = f.newId()
+      const path = join(dir, f.fileName(id, now.toISOString()))
+      const plan = planPiSession(session, { flavor: f, id, now, cwd })
+      if (!w.dryRun) {
+        mkdirSync(dirname(path), { recursive: true })
+        // "wx": a new file only; an existing session is never touched.
+        writeFileSync(path, `${plan.lines.map((l) => JSON.stringify(l)).join("\n")}\n`, { flag: "wx" })
+        const back = parseSession(readFileSync(path, "utf8"), path, f, 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) {
+          rmSync(path, { force: true })
+          throw new Error(
+            `the ${f.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`,
+          )
+        }
+      }
+      return {
+        tool: f.tool,
+        way: "native",
+        sessionId: id,
+        written: [path],
+        open: `cd ${shellQuote(cwd)} && ${f.bin} --session ${id}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}

package/src/adapters/qoder-cli/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { qoderReader } from "./reader.ts"
+import { qoderNativeWriter } from "./writer.ts"
+
+// Qoder CLI (qodercli): its transcripts are Claude Code's records in ~/.qoder/projects, so it reads them
+// and continues any session as a new native Qoder session that `qodercli --resume` opens.
+export const readers: Reader[] = [qoderReader]
+export const writers: Writer[] = [qoderNativeWriter]

package/src/adapters/qoder-cli/reader.ts

@@ -0,0 +1,83 @@
+import { statSync } from "node:fs"
+import { join } from "node:path"
+import { ls } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { claudeCodeReader } from "../claude-code/reader.ts"
+import { SESSION_FILE } from "../claude-code/records.ts"
+import { LABEL, TOOL, projectsDir } from "./records.ts"
+
+// Reads Qoder CLI sessions. The records are Claude Code's, so the Claude Code parser reads them; this
+// lists Qoder's own folder and gives the sessions Qoder ids.
+
+const HEAD = 64 * 1024
+const TAIL = 256 * 1024
+const CWD = /"cwd"\s*:\s*"((?:[^"\\]|\\.)*)"/
+const unjson = (raw: string | undefined) => {
+  if (raw === undefined) return undefined
+  try {
+    return JSON.parse(`"${raw}"`) as string
+  } catch {
+    return undefined
+  }
+}
+const last = (text: string, re: RegExp) => {
+  let v: string | undefined
+  for (const m of text.matchAll(re)) v = m[1]
+  return unjson(v)
+}
+
+async function peek(path: string): Promise<Omit<SessionRef, "tool" | "sourceId" | "path"> | undefined> {
+  const file = Bun.file(path)
+  const head = await file.slice(0, Math.min(file.size, HEAD)).text()
+  const tail = file.size > HEAD ? await file.slice(Math.max(HEAD, file.size - TAIL)).text() : head
+  const cwd = unjson(head.match(CWD)?.[1])
+  // No cwd in the first records: only metadata, nothing to continue.
+  if (!cwd) return undefined
+  const title = last(tail, /"customTitle"\s*:\s*"((?:[^"\\]|\\.)*)"/g) ?? last(tail, /"aiTitle"\s*:\s*"((?:[^"\\]|\\.)*)"/g)
+  const updatedAt = last(tail, /"timestamp"\s*:\s*"((?:[^"\\]|\\.)*)"/g) ?? statSync(path).mtime.toISOString()
+  return { cwd, ...(title ? { title } : {}), updatedAt }
+}
+
+/** The Claude Code parser names everything claude-code:<id>; these are Qoder's. */
+function retag(s: Session): Session {
+  const ours = (id: string) => id.replace(/^claude-code:/, `${TOOL}:`)
+  s.header.tool = TOOL
+  s.header.id = ours(s.header.id)
+  if (s.header.parent && s.header.parent.kind !== "continued") s.header.parent.id = ours(s.header.parent.id)
+  s.turns = s.turns.map((t): Turn => (t.kind === "subagent" ? { ...t, sessionId: ours(t.sessionId) } : t))
+  for (const c of s.children ?? []) retag(c)
+  return s
+}
+
+export const qoderReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const root = projectsDir(home)
+    const refs: SessionRef[] = []
+    for (const project of ls(root)) {
+      for (const name of ls(join(root, project))) {
+        if (!SESSION_FILE.test(name)) continue
+        const path = join(root, project, name)
+        try {
+          if (!statSync(path).isFile()) continue
+          const p = await peek(path)
+          if (p) refs.push({ tool: TOOL, sourceId: name.slice(0, -".jsonl".length), path, ...p })
+        } catch {
+          // Gone or unreadable between listing and peeking.
+        }
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef, home: string): Promise<Session> {
+    try {
+      return retag(await claudeCodeReader.read(ref, home))
+    } catch (e) {
+      throw new Error((e as Error).message.replace(/Claude Code/g, LABEL))
+    }
+  },
+}

package/src/adapters/qoder-cli/records.ts

@@ -0,0 +1,45 @@
+import { join } from "node:path"
+import { exists, versionOf } from "../../fsutil.ts"
+
+// What Qoder CLI (Alibaba's `qodercli`, npm @qoder-ai/qodercli, closed source) keeps per session, as far as
+// this adapter relies on it. Checked against the 1.1.85 bundle: its session paths (vh/_m), project folder
+// name (Am), lister (--list-sessions) and resume loader (_Pe → XIo), run on sessions this adapter wrote.
+//
+// Qoder's transcripts are Claude Code's: <config>/projects/<slug>/<uuid>.jsonl holding the same records
+// (user/assistant/system chain with uuid and parentUuid, isMeta, isCompactSummary, compact_boundary,
+// custom-title, last-prompt, toolUseResult, sourceToolAssistantUUID, entrypoint "cli", userType
+// "external") and the same built-in tool names (Read, Edit, Write, Bash, Grep, Glob, WebFetch, ...).
+// So this adapter reuses the Claude Code record planner and parser, with Qoder's folder, slug and version.
+
+export const TOOL = "qoder-cli"
+export const LABEL = "Qoder CLI"
+
+/** Qoder CLI versions the writer's files were checked against. */
+export const TESTED_VERSIONS = ["1.1.85"]
+
+/** ~/.qoder (QODER_CONFIG_DIR moves it; the switcher always uses the default under the given home). */
+export const qoderHome = (home: string) => join(home, ".qoder")
+export const projectsDir = (home: string) => join(qoderHome(home), "projects")
+
+/**
+ * Qoder's project folder for a cwd (Am in 1.1.85): every non-alphanumeric becomes '-'; a name over 200
+ * characters is cut to 200 and suffixed with the base-36 of a djb2-xor hash of the full path. Same idea
+ * as Claude Code's, different hash, so long paths land in different folders in the two tools.
+ */
+export function projectSlug(cwd: string): string {
+  const slug = cwd.replace(/[^a-zA-Z0-9]/g, "-")
+  if (slug.length <= 200) return slug
+  let h = 5381
+  for (let i = 0; i < cwd.length; i++) h = (33 * h) ^ cwd.charCodeAt(i)
+  return `${slug.slice(0, 200)}-${Math.abs(h).toString(36)}`
+}
+
+/** The installed Qoder CLI version: on the PATH, or where Qoder's own installer puts it. */
+export function qoderVersion(home: string): string | undefined {
+  for (const bin of ["qodercli", join(home, ".local", "bin", "qodercli"), join(qoderHome(home), "bin", "qodercli", "qodercli")]) {
+    if (bin !== "qodercli" && !exists(bin)) continue
+    const v = versionOf(bin)?.match(/(\d+\.\d+\.\d+)/)?.[1]
+    if (v) return v
+  }
+  return undefined
+}

package/src/adapters/qoder-cli/writer.ts

@@ -0,0 +1,72 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { exists, gitInfo, isDir } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { planTranscript } from "../claude-code/writer.ts"
+import { qoderReader } from "./reader.ts"
+import { LABEL, TESTED_VERSIONS, TOOL, projectSlug, projectsDir, qoderVersion } from "./records.ts"
+
+// Continues a portable session in Qoder CLI as a new transcript in Qoder's project folder: the records
+// Claude Code's writer plans (Qoder's transcript format is Claude Code's), stamped with Qoder's version.
+// Qoder lists it (--list-sessions) and its resume loader rebuilds the conversation from it; Qoder adds
+// the session's state.json itself on first resume. The note saying where the session came from is an
+// isMeta record, which Qoder, like Claude Code, gives the model but does not count as the person's words.
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+/** The Qoder writer; `version` is for tests, which must not depend on the installed CLI. */
+export function qoderWriter(opts: { version?: string } = {}): Writer {
+  const installed = (home: string) => opts.version ?? qoderVersion(home)
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed(w.home)
+      if (!v) return { ok: false, why: "Qoder CLI is not installed (`qodercli --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Qoder CLI ${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; Qoder lists sessions by the folder they belong to` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      // Qoder names the folder after process.cwd(), which is the resolved path.
+      const cwd = isDir(w.cwd) ? realpathSync(w.cwd) : w.cwd
+      const git = gitInfo(cwd, w.home)
+      const version = installed(w.home) ?? TESTED_VERSIONS[TESTED_VERSIONS.length - 1]!
+      const dir = join(projectsDir(w.home), projectSlug(cwd))
+      let sessionId = randomUUID()
+      while (exists(join(dir, `${sessionId}.jsonl`))) sessionId = randomUUID()
+      const path = join(dir, `${sessionId}.jsonl`)
+      const plan = planTranscript(session, { sessionId, cwd, version, gitBranch: git.gitBranch ?? (git.gitCommit ? "HEAD" : ""), now: new Date() })
+      if (!w.dryRun) {
+        mkdirSync(dir, { recursive: true })
+        // "wx": a new file only; an existing session is never touched.
+        writeFileSync(path, `${plan.lines.map((l) => JSON.stringify(l)).join("\n")}\n`, { flag: "wx" })
+        const back = await qoderReader.read({ tool: TOOL, sourceId: sessionId, path }, w.home)
+        const pairs = unpaired(back)
+        const got = countTurns(back).tool_call
+        if (got !== plan.expect.calls || pairs.calls.length || pairs.results.length) {
+          rmSync(path, { force: true })
+          throw new Error(`the new Qoder transcript did not read back intact (${got} of ${plan.expect.calls} tool calls, ${pairs.calls.length + pairs.results.length} unpaired); nothing was kept`)
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId,
+        written: [path],
+        open: `cd ${shellQuote(cwd)} && qodercli --resume ${sessionId}`,
+        // The planner words its reasoning loss for Claude Code; for Qoder it is simply reasoning not carried.
+        lost: plan.lost.map((l) => l.replace(/^reasoning \(Claude Code[^)]*\)/, "reasoning")),
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const qoderNativeWriter = qoderWriter()

package/src/adapters/qwen-code/index.ts

@@ -0,0 +1,84 @@
+import { join } from "node:path"
+import { isDir, ls, mtime, readJson } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { header, iso, lossCounter } from "../../session/util.ts"
+import type { Reader, SessionRef, Writer } from "../types.ts"
+import { CONTINUED_NOTE, toParts } from "../gemini-cli/records.ts"
+import { activeChain, chainToTurns, type ChatRecord, LABEL, readRecords, SESSION_FILE, TOOL } from "./records.ts"
+import { qwenNativeWriter } from "./writer.ts"
+
+// Qwen Code keeps each project's sessions in ~/.qwen/projects/<sanitized cwd>/chats/<uuid>.jsonl, with a
+// <uuid>.title.json sidecar for the list's label (records.ts has the format). The list reads the first
+// records for the folder and first prompt, and the last custom_title record for the title, as Qwen Code's
+// SessionService does; archived sessions (chats/archive) are left out, as its own list leaves them out.
+
+const oneLine = (s: string) => s.replace(/\s+/g, " ").trim()
+
+/** A session's title: its last custom_title, else the sidecar's label, else its first prompt. */
+function titleOf(records: ChatRecord[], sidecar: string): string | undefined {
+  let title: string | undefined
+  for (const r of records) if (r.type === "system" && r.subtype === "custom_title" && typeof r.systemPayload?.customTitle === "string") title = r.systemPayload.customTitle
+  title ??= readJson<{ displayName?: string }>(sidecar)?.displayName
+  if (!title) {
+    for (const r of records) {
+      if (r.type !== "user" || r.subtype) continue
+      const shown = r.systemPayload?.displayText
+      const text = typeof shown === "string" ? shown : toParts(r.message?.parts).filter((p) => !(typeof p.text === "string" && CONTINUED_NOTE.test(p.text))).map((p) => p.text ?? "").join("")
+      if (oneLine(text)) {
+        title = text
+        break
+      }
+    }
+  }
+  return title && oneLine(title) ? oneLine(title).slice(0, 120) : undefined
+}
+
+export const reader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home) {
+    const projects = join(home, ".qwen", "projects")
+    if (!isDir(projects)) return []
+    const refs: SessionRef[] = []
+    for (const project of ls(projects)) {
+      const chats = join(projects, project, "chats")
+      for (const name of ls(chats)) {
+        if (!SESSION_FILE.test(name)) continue
+        const path = join(chats, name)
+        const { records } = readRecords(path)
+        const first = records[0]
+        if (!first || !records.some((r) => r.type === "user")) continue
+        const id = name.replace(/\.jsonl$/, "")
+        const title = titleOf(records, join(chats, `${id}.title.json`))
+        const updatedAt = mtime(path)
+        refs.push({ tool: TOOL, sourceId: first.sessionId, path, ...(title ? { title } : {}), ...(first.cwd ? { cwd: first.cwd } : {}), ...(updatedAt ? { updatedAt } : {}), extra: { project } })
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref) {
+    const { records, bad } = readRecords(ref.path)
+    if (!records.length) throw new Error(`${ref.path} holds no Qwen Code records`)
+    const first = records[0]!
+    const lost = lossCounter()
+    if (bad) lost.add("unreadable lines", bad)
+    const { chain, offBranch } = activeChain(records)
+    if (offBranch) lost.add("records on rewound branches", offBranch)
+    const h = header(TOOL, first.sessionId, {
+      sourcePath: ref.path,
+      project: { cwd: first.cwd, ...(first.gitBranch ? { gitBranch: first.gitBranch } : {}) },
+      ...(iso(first.timestamp) ? { startedAt: iso(first.timestamp) } : {}),
+      ...(iso(records[records.length - 1]!.timestamp) ? { updatedAt: iso(records[records.length - 1]!.timestamp) } : {}),
+    })
+    const title = titleOf(records, ref.path.replace(/\.jsonl$/, ".title.json"))
+    if (title) h.title = title
+    const turns = chainToTurns(chain, h, lost)
+    lost.flush(h)
+    return { header: h, turns } satisfies Session
+  },
+}
+
+export const readers: Reader[] = [reader]
+export const writers: Writer[] = [qwenNativeWriter]