@100xprompt/brain 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,194 @@
+import { readFileSync } from "node:fs"
+import type { SessionHeader, Turn, Usage } from "../../session/types.ts"
+import { iso, noteModel, type lossCounter } from "../../session/util.ts"
+import { closeOpenCalls, CONTINUED_NOTE, type Ctx, newCtx, type Part, partsToTurns, snapshotText, toParts } from "../gemini-cli/records.ts"
+
+// Facts about Qwen Code's session records, shared by its reader and writer. Checked against Qwen Code 0.27.0
+// (packages/core/src/services/chatRecordingService.ts, sessionService.ts, session-api-history.ts and
+// utils/transcript-records.ts; packages/cli/src/ui/utils/resumeHistoryUtils.ts).
+//
+// A session is ~/.qwen/projects/<cwd with every non-alphanumeric as '-'>/chats/<uuid>.jsonl, one ChatRecord
+// per line: Claude-style uuid/parentUuid links around Gemini Content ({role, parts}). type is user, assistant
+// (the model's parts: thoughts, text, functionCall), tool_result (one per call: a functionResponse part, plus
+// toolCallResult for the screen) or system (titles, compression and other session state, by subtype).
+// Loading walks parentUuid back from the last conversation record, so only the active branch counts, and
+// records sharing a uuid are fragments of one message.
+
+export const TOOL = "qwen-code"
+export const LABEL = "Qwen Code"
+
+export interface ChatRecord {
+  uuid: string
+  parentUuid: string | null
+  sessionId: string
+  timestamp: string
+  type: "user" | "assistant" | "tool_result" | "system"
+  subtype?: string
+  provenance?: string
+  cwd: string
+  version: string
+  gitBranch?: string
+  message?: { role?: string; parts?: Part[] }
+  model?: string
+  usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number; cachedContentTokenCount?: number; thoughtsTokenCount?: number; totalTokenCount?: number }
+  toolCallResult?: { callId?: string; status?: string; resultDisplay?: unknown; error?: unknown }
+  systemPayload?: Record<string, any>
+  isSidechain?: boolean
+}
+
+/** Session files are named by a UUID; the list skips anything else in chats/. */
+export const SESSION_FILE = /^[0-9a-fA-F-]{32,36}\.jsonl$/
+
+/** Qwen Code's folder name for a project (sanitizeCwd; lower-cased on Windows only). */
+export const projectId = (cwd: string) => cwd.replace(/[^a-zA-Z0-9]/g, "-")
+
+/** System records that are never part of the conversation chain. */
+const OUTSIDE_CHAIN = new Set(["session_sources_snapshot", "managed_session_header_v1", "managed_session_event_v1", "managed_session_commit_v1", "managed_session_snapshot_base_v1", "session_artifact_event", "session_artifact_snapshot"])
+
+const isObj = (v: unknown): v is Record<string, any> => typeof v === "object" && v !== null && !Array.isArray(v)
+
+/** The records of a session file, in file order; lines that are not records are counted. */
+export function readRecords(path: string): { records: ChatRecord[]; bad: number } {
+  let text: string
+  try {
+    text = readFileSync(path, "utf8")
+  } catch {
+    return { records: [], bad: 0 }
+  }
+  const records: ChatRecord[] = []
+  let bad = 0
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue
+    try {
+      const r = JSON.parse(line)
+      if (isObj(r) && typeof r.uuid === "string" && typeof r.sessionId === "string" && typeof r.type === "string" && (typeof r.parentUuid === "string" || r.parentUuid === null)) records.push(r as ChatRecord)
+      else bad++
+    } catch {
+      bad++
+    }
+  }
+  return { records, bad }
+}
+
+/**
+ * The active conversation, as prepareTranscriptRecords builds it: from the last record that is part of the
+ * conversation, back along parentUuid to the root, with the fragments of each uuid merged (parts appended,
+ * the latest timestamp). Records on other branches (a rewind) are left out.
+ */
+export function activeChain(records: ChatRecord[]): { chain: ChatRecord[]; offBranch: number } {
+  const inChain = (r: ChatRecord) => !(r.type === "system" && r.subtype && OUTSIDE_CHAIN.has(r.subtype))
+  const byUuid = new Map<string, ChatRecord[]>()
+  for (const r of records) if (inChain(r)) byUuid.set(r.uuid, [...(byUuid.get(r.uuid) ?? []), r])
+  const leaf = [...records].reverse().find(inChain)
+  const uuids: string[] = []
+  const seen = new Set<string>()
+  for (let u: string | null | undefined = leaf?.uuid; u && !seen.has(u) && byUuid.has(u); u = byUuid.get(u)![0]!.parentUuid) {
+    seen.add(u)
+    uuids.push(u)
+  }
+  const chain = uuids.reverse().map((u) => {
+    const [first, ...rest] = byUuid.get(u)!
+    const out: ChatRecord = { ...first!, ...(first!.message ? { message: { ...first!.message, parts: [...(first!.message.parts ?? [])] } } : {}) }
+    for (const r of rest) {
+      if (r.message) out.message = { role: out.message?.role ?? r.message.role, parts: [...(out.message?.parts ?? []), ...(r.message.parts ?? [])] }
+      if (r.usageMetadata) out.usageMetadata = r.usageMetadata
+      if (r.toolCallResult && !out.toolCallResult) out.toolCallResult = r.toolCallResult
+      if (r.model && !out.model) out.model = r.model
+      if (r.timestamp > out.timestamp) out.timestamp = r.timestamp
+    }
+    return out
+  })
+  const kept = new Set(uuids)
+  return { chain, offBranch: records.filter((r) => inChain(r) && !kept.has(r.uuid)).length }
+}
+
+/** Qwen's token counts in the portable form: cached input apart, thinking counted as output. */
+function usageOf(u: ChatRecord["usageMetadata"]): Usage | undefined {
+  if (!u) return undefined
+  const cached = u.cachedContentTokenCount ?? 0
+  const out: Usage = {}
+  if (typeof u.promptTokenCount === "number") out.input = Math.max(0, u.promptTokenCount - cached)
+  if (typeof u.candidatesTokenCount === "number") out.output = u.candidatesTokenCount + (u.thoughtsTokenCount ?? 0)
+  if (cached) out.cacheRead = cached
+  return Object.keys(out).length ? out : undefined
+}
+
+/** The text of a user record's parts, without brain's note on a continued session. */
+const textOf = (parts: Part[]) => parts.map((p) => (typeof p.text === "string" && !p.thought ? p.text : "")).join("")
+
+/** User subtypes that are something other than the person typing (background notices, agents, goals). */
+const INJECTED = new Set(["notification", "cron", "goal_runtime", "agent_mention", "agent_message", "agent_launch_prompt", "agent_bootstrap", "realtime_message"])
+
+/** A file edit from a tool result's display (FileDiff), named by the call's own path where it has one. */
+function editOf(r: ChatRecord, callId: string, turns: Turn[], at: string | undefined): Turn | undefined {
+  const d = r.toolCallResult?.resultDisplay
+  if (!isObj(d) || typeof d.fileDiff !== "string") return undefined
+  const call = turns.find((t) => t.kind === "tool_call" && t.id === callId) as Extract<Turn, { kind: "tool_call" }> | undefined
+  const input = isObj(call?.input) ? call!.input : {}
+  const path = [input.file_path, input.path, d.filePath, d.fileName].find((p): p is string => typeof p === "string" && p.length > 0)
+  return path ? { kind: "file_edit", ...(at ? { at } : {}), path, patch: d.fileDiff, callId } : undefined
+}
+
+/** The portable turns of a session's active chain; `h` gets its models, version and source note. */
+export function chainToTurns(chain: ChatRecord[], h: SessionHeader, lost: ReturnType<typeof lossCounter>): Turn[] {
+  const ctx: Ctx = newCtx(h, lost)
+  const turns: Turn[] = []
+  for (const r of chain) {
+    const at = iso(r.timestamp)
+    const parts = toParts(r.message?.parts)
+    if (r.version && !h.toolVersion) h.toolVersion = r.version
+    if (r.isSidechain) {
+      lost.add("subagent records")
+      continue
+    }
+    switch (r.type) {
+      case "user": {
+        if (r.subtype && r.subtype !== "mid_turn_user_message") {
+          lost.add(INJECTED.has(r.subtype) ? "notifications and injected messages" : `user records of kind ${r.subtype}`)
+          break
+        }
+        let ps = parts
+        const note = ps[0]?.text?.match(CONTINUED_NOTE)
+        if (note) {
+          h.parent = { id: note[1]!, kind: "continued" }
+          ps = ps.slice(1)
+        }
+        // What the person typed, when the record keeps it apart from what the model got (hook context, @-files).
+        const shown = r.systemPayload?.displayText
+        if (typeof shown === "string" && typeof r.systemPayload?.hookContext === "string") ps = [...(shown ? [{ text: shown }] : []), ...ps.filter((p) => typeof p.text !== "string")]
+        turns.push(...partsToTurns(ps, "user", at, ctx))
+        break
+      }
+      case "assistant":
+        noteModel(h, r.model)
+        turns.push(...partsToTurns(parts, "model", at, ctx, r.model, usageOf(r.usageMetadata)))
+        break
+      case "tool_result": {
+        if (r.subtype === "code_mode_tool_result") {
+          lost.add("internal tool results")
+          break
+        }
+        const got = partsToTurns(parts, "user", at, ctx)
+        const status = r.toolCallResult?.status
+        for (const t of got) {
+          if (t.kind === "tool_result" && (status === "error" || status === "cancelled")) t.ok = false
+          turns.push(t)
+          if (t.kind === "tool_result") {
+            const edit = editOf(r, t.callId, turns, at)
+            if (edit) turns.push(edit)
+          }
+        }
+        break
+      }
+      case "system":
+        if (r.subtype === "chat_compression" && Array.isArray(r.systemPayload?.compressedHistory)) {
+          const first = (r.systemPayload.compressedHistory as Array<{ role?: string; parts?: Part[] }>).find((c) => c.role === "user")
+          const ps = toParts(first?.parts).filter((p) => !(typeof p.text === "string" && CONTINUED_NOTE.test(p.text)))
+          const text = textOf(ps)
+          turns.push({ kind: "compaction", ...(at ? { at } : {}), summary: snapshotText(text) ?? text.trim() })
+        } else if (r.subtype === "slash_command") lost.add("slash commands")
+        break
+    }
+  }
+  return closeOpenCalls(turns, ctx.pair.open(), ctx, () => "the session ended before it finished")
+}

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

@@ -0,0 +1,224 @@
+import { randomUUID } from "node:crypto"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, gitInfo, isDir, versionOf } from "../../fsutil.ts"
+import type { Session } from "../../session/types.ts"
+import { countTurns, header, lossCounter, unpaired } from "../../session/util.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { ALIASES, type Call, clock, drops, imageData, mapCall, realCwd, regroup, resultOutput, shellQuote, titleOf, type ToolSpec } from "../gemini-cli/exchanges.ts"
+import { continuedNote, type Part, SNAPSHOT_ACK, snapshotOf } from "../gemini-cli/records.ts"
+import { activeChain, chainToTurns, type ChatRecord, LABEL, projectId, readRecords, TOOL } from "./records.ts"
+
+// Continues a portable session in Qwen Code as a new session of its own: chats/<uuid>.jsonl in the project's
+// folder, written the way ChatRecordingService records a live session, so SessionService lists it and
+// `qwen --resume <id>` loads it (checked with Qwen Code 0.27.0's own loader, run from source).
+//
+// One linked chain of records: the person's messages; one assistant record per model response (readable
+// thoughts as thought parts, its text, its functionCall parts); one tool_result record per call, holding the
+// functionResponse the model gets back and toolCallResult for the screen. A compaction is written the way
+// Qwen Code compresses: a chat_compression system record whose compressedHistory (the summary and its
+// acknowledgement) replaces what the model sees, while the screen keeps the earlier turns. The note on where
+// the session came from is the first part of the first user message; the record's displayText (with an empty
+// hookContext, as a recorded prompt has) shows the person's own words without it. The title is a
+// custom_title record plus the title sidecar the list falls back on, and having one stops Qwen Code asking a
+// model for a title.
+
+/** Versions this writer was checked against; others get the brief. */
+export const TESTED_VERSIONS = ["0.27.0"]
+
+/** The installed Qwen Code version ("0.27.0"), or undefined when it is not installed. */
+export const qwenVersion = (bin = "qwen") => versionOf(bin)?.match(/(\d+\.\d+\.\d+)/)?.[1]
+
+/** Qwen Code's own tool for a portable call, by what the call does. */
+function qwenTool(call: Call): ToolSpec | undefined {
+  const input = (call.input ?? {}) as Record<string, unknown>
+  switch (call.toolKind) {
+    case "read":
+      return { name: "read_file", args: { file_path: ALIASES.file } }
+    case "edit":
+      return { name: "edit", args: { file_path: ALIASES.file, old_string: ALIASES.oldText, new_string: ALIASES.newText } }
+    case "write":
+      return { name: "write_file", args: { file_path: ALIASES.file, content: ALIASES.content } }
+    case "shell":
+      return { name: "run_shell_command", args: { command: ALIASES.command } }
+    case "search":
+      return { name: /glob/i.test(call.name) ? "glob" : "grep_search", args: { pattern: ALIASES.pattern, path: ALIASES.dir } }
+    case "list":
+      return { name: "list_directory", args: { path: ALIASES.dir } }
+    case "web":
+      return ALIASES.url.some((k) => input[k] !== undefined) ? { name: "web_fetch", args: { url: ALIASES.url, prompt: ["prompt"] } } : { name: "web_search", args: { query: ALIASES.query } }
+    case "todo":
+      return { name: "todo_write", args: { todos: ["todos"] } }
+    default:
+      return undefined
+  }
+}
+
+export interface RecordPlan {
+  records: ChatRecord[]
+  title: string
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The records of the new session `sessionId` continuing `session`. Pure apart from reading attached images. */
+export function planRecords(session: Session, opts: { sessionId: string; cwd: string; version: string; gitBranch?: string; now: Date }): RecordPlan {
+  const { drop, list } = drops()
+  const exchanges = regroup(session, { fromLastCompaction: false, keepReasoning: true, drop })
+  const label = toolLabel(session.header.tool)
+  const stamp = clock(session, opts.now)
+  const note: Part = { text: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)) }
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const records: ChatRecord[] = []
+  let parent: string | null = null
+  let lastModel = session.header.models[session.header.models.length - 1] ?? "unknown"
+  let noted = false
+  const add = (type: ChatRecord["type"], at: string | undefined, fields: Partial<ChatRecord>) => {
+    const provenance = { user: "real_user", assistant: "assistant_output", tool_result: "tool_result", system: "system" }[type]
+    const r: ChatRecord = {
+      uuid: randomUUID(),
+      parentUuid: parent,
+      sessionId: opts.sessionId,
+      timestamp: stamp(at),
+      type,
+      provenance,
+      cwd: opts.cwd,
+      version: opts.version,
+      ...(opts.gitBranch ? { gitBranch: opts.gitBranch } : {}),
+      ...fields,
+    }
+    records.push(r)
+    parent = r.uuid
+    return r
+  }
+  const user = (at: string | undefined, parts: Part[], shown: string) => {
+    if (noted) return add("user", at, { message: { role: "user", parts } })
+    noted = true
+    return add("user", at, { message: { role: "user", parts: [note, ...parts] }, systemPayload: { displayText: shown, hookContext: "" } })
+  }
+
+  // A session that opens with the model gets the note on its own first.
+  if (exchanges[0]?.kind === "model") user(exchanges[0].at, [], "")
+  exchanges.forEach((x, i) => {
+    if (x.kind === "user") {
+      let text = x.text
+      const images: Part[] = []
+      for (const a of x.attachments) {
+        if (a.kind === "file") {
+          if (a.path) text += `\n\n[Attached file: ${a.path}]`
+          continue
+        }
+        const img = imageData(a)
+        if (img) images.push({ inlineData: img })
+        else if (a.path) drop("images that could not be attached")
+      }
+      const parts: Part[] = [...(text.trim() ? [{ text }] : []), ...images]
+      if (!parts.length) return
+      user(x.at, parts, text)
+      if (text.trim()) expect.users++
+    } else if (x.kind === "compaction") {
+      // The model resumes from compressedHistory, so the note goes there too. Qwen Code never puts two model
+      // turns side by side, so a summary followed by a model response goes without the acknowledgement.
+      const ack = exchanges[i + 1]?.kind === "model" ? [] : [{ role: "model", parts: [{ text: SNAPSHOT_ACK }] }]
+      add("system", x.at, {
+        subtype: "chat_compression",
+        systemPayload: {
+          info: { originalTokenCount: 0, newTokenCount: 0, compressionStatus: 1 },
+          compressedHistory: [{ role: "user", parts: [note, { text: snapshotOf(label, x.summary) }] }, ...ack],
+        },
+      })
+    } else {
+      if (x.model) lastModel = x.model
+      const calls = x.calls.map((a) => ({ a, id: `call_${randomUUID().replace(/-/g, "").slice(0, 24)}`, ...mapCall(a.call, qwenTool(a.call)) }))
+      const parts: Part[] = [
+        ...x.thoughts.map((t) => ({ text: t.text, thought: true })),
+        ...(x.text.trim() ? [{ text: x.text }] : []),
+        ...calls.map((c) => ({ functionCall: { id: c.id, name: c.name, args: c.args } })),
+      ]
+      const usage = x.usage
+        ? (() => {
+            const prompt = (x.usage.input ?? 0) + (x.usage.cacheRead ?? 0)
+            const out = x.usage.output ?? 0
+            return { promptTokenCount: prompt, candidatesTokenCount: out, totalTokenCount: prompt + out, ...(x.usage.cacheRead ? { cachedContentTokenCount: x.usage.cacheRead } : {}) }
+          })()
+        : undefined
+      add("assistant", x.at, { model: lastModel, message: { role: "model", parts }, ...(usage ? { usageMetadata: usage } : {}) })
+      if (x.text.trim()) expect.assistants++
+      for (const c of calls) {
+        if (!c.a.result) drop("tool calls without a result (closed as errors)")
+        if (c.a.edits.length) drop("file edit diffs (Qwen Code keeps one only with the whole file before and after)", c.a.edits.length)
+        const ok = c.a.result?.ok ?? false
+        const output = resultOutput(c.a.result)
+        add("tool_result", c.a.result?.at ?? c.a.call.at, {
+          message: { role: "user", parts: [{ functionResponse: { id: c.id, name: c.name, response: ok ? { output } : { error: output } } }] },
+          toolCallResult: { callId: c.id, status: ok ? "success" : "error", resultDisplay: output },
+        })
+        expect.calls++
+      }
+    }
+  })
+  if (!records.some((r) => r.type !== "system")) throw new Error("nothing Qwen Code can resume: the session has no messages")
+  const title = `${titleOf(session)} (from ${label})`
+  add("system", undefined, { subtype: "custom_title", systemPayload: { customTitle: title, titleSource: "auto" } })
+  return { records, title, lost: list(), expect }
+}
+
+/** The Qwen Code writer; `version` and `bin` are for tests, which must not depend on the installed binary. */
+export function qwenWriter(opts: { bin?: string; version?: string } = {}): Writer {
+  const installed = () => opts.version ?? qwenVersion(opts.bin)
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "Qwen Code is not installed (`qwen --version` did not run)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Qwen Code ${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; Qwen Code lists and resumes sessions per project folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const version = installed() ?? TESTED_VERSIONS[TESTED_VERSIONS.length - 1]!
+      // Qwen Code files a session under the folder it runs in, and lists only those whose cwd hashes the same.
+      const cwd = realCwd(w.cwd)
+      const chats = join(w.home, ".qwen", "projects", projectId(cwd), "chats")
+      let sessionId = randomUUID()
+      while (exists(join(chats, `${sessionId}.jsonl`))) sessionId = randomUUID()
+      const path = join(chats, `${sessionId}.jsonl`)
+      const sidecar = join(chats, `${sessionId}.title.json`)
+      const now = new Date()
+      const branch = gitInfo(cwd, w.home).gitBranch
+      const plan = planRecords(session, { sessionId, cwd, version, now, ...(branch ? { gitBranch: branch } : {}) })
+      if (!w.dryRun) {
+        mkdirSync(chats, { recursive: true })
+        // "wx": a new file only; an existing session is never touched.
+        writeFileSync(path, `${plan.records.map((r) => JSON.stringify(r)).join("\n")}\n`, { flag: "wx" })
+        writeFileSync(sidecar, `${JSON.stringify({ version: 1, displayName: plan.title, source: "auto", updatedAt: now.toISOString() }, null, 2)}\n`, { flag: "wx", mode: 0o600 })
+        const h = header(TOOL, sessionId)
+        const turns = chainToTurns(activeChain(readRecords(path).records).chain, h, lossCounter())
+        const got = countTurns({ header: h, turns })
+        const pairs = unpaired({ header: h, turns })
+        if (got.user !== plan.expect.users || got.assistant !== plan.expect.assistants || got.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length) {
+          rmSync(path, { force: true })
+          rmSync(sidecar, { force: true })
+          throw new Error(`the new Qwen Code session did not read back as written (users ${got.user}/${plan.expect.users}, replies ${got.assistant}/${plan.expect.assistants}, tool calls ${got.tool_call}/${plan.expect.calls}); nothing was kept`)
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId,
+        written: [path, sidecar],
+        open: `cd ${shellQuote(cwd)} && qwen --resume ${sessionId}`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const qwenNativeWriter = qwenWriter()

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

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { tabnineReader } from "./reader.ts"
+import { tabnineNativeWriter } from "./writer.ts"
+
+// Tabnine CLI (the Gemini CLI fork, `tabnine` / `tabnine-legacy`): its sessions are Gemini CLI's files under
+// ~/.tabnine/agent, so it reads them and continues any session as a new native Tabnine session.
+export const readers: Reader[] = [tabnineReader]
+export const writers: Writer[] = [tabnineNativeWriter]

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

@@ -0,0 +1,106 @@
+import { readFileSync, statSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { isDir, ls, readJson } from "../../fsutil.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { reader as geminiReader } from "../gemini-cli/index.ts"
+import { LABEL, TOOL, agentDir } from "./records.ts"
+
+// Reads Tabnine CLI sessions. The files are Gemini CLI's, so the Gemini CLI parser reads them; this lists
+// Tabnine's own folder, finds each project's path there (Gemini's parser would look in ~/.gemini) and gives
+// the sessions Tabnine ids.
+
+/** Project folder name → project path, from Tabnine's registry and its .project_root markers. */
+function projectPaths(home: string): Map<string, string> {
+  const root = agentDir(home)
+  const out = new Map<string, string>()
+  const registry = readJson<{ projects?: Record<string, string> }>(join(root, "projects.json"))?.projects ?? {}
+  for (const [path, slug] of Object.entries(registry)) out.set(slug, path)
+  for (const slug of ls(join(root, "tmp"))) {
+    if (out.has(slug)) continue
+    try {
+      out.set(slug, resolve(readFileSync(join(root, "tmp", slug, ".project_root"), "utf8").trim()))
+    } catch {
+      // A legacy hash-named folder without a marker: its path is not recorded.
+    }
+  }
+  return out
+}
+
+/** The session id, start and title from the file's first record and its last summary update. */
+function summarize(path: string): { sessionId: string; kind?: string; title?: string } | undefined {
+  const text = readFileSync(path, "utf8")
+  const first = text.slice(0, text.indexOf("\n") >>> 0)
+  let meta: { sessionId?: unknown; kind?: unknown }
+  try {
+    meta = JSON.parse(path.endsWith(".jsonl") ? first : text)
+  } catch {
+    return undefined
+  }
+  if (typeof meta.sessionId !== "string") return undefined
+  let title: string | undefined
+  for (const m of text.matchAll(/"summary"\s*:\s*("(?:[^"\\]|\\.)*")/g)) title = JSON.parse(m[1]!) as string
+  return { sessionId: meta.sessionId, ...(typeof meta.kind === "string" ? { kind: meta.kind } : {}), ...(title ? { title } : {}) }
+}
+
+/** The Gemini CLI parser names everything gemini-cli:<id>; these are Tabnine's. */
+function retag(s: Session): Session {
+  const ours = (id: string) => id.replace(/^gemini-cli:/, `${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 => {
+    if (t.kind === "subagent") return { ...t, sessionId: ours(t.sessionId) }
+    // The shared name patterns do not know Gemini's edit tool, `replace`.
+    if (t.kind === "tool_call" && t.name === "replace" && t.toolKind === "other") return { ...t, toolKind: "edit" }
+    return t
+  })
+  for (const c of s.children ?? []) retag(c)
+  return s
+}
+
+export const tabnineReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const tmp = join(agentDir(home), "tmp")
+    if (!isDir(tmp)) return []
+    const paths = projectPaths(home)
+    const refs: SessionRef[] = []
+    for (const folder of ls(tmp)) {
+      const chats = join(tmp, folder, "chats")
+      for (const name of ls(chats)) {
+        if (!/^session-.*\.jsonl?$/.test(name)) continue
+        const path = join(chats, name)
+        try {
+          const s = summarize(path)
+          if (!s || s.kind === "subagent") continue
+          const cwd = paths.get(folder)
+          refs.push({
+            tool: TOOL,
+            sourceId: s.sessionId,
+            path,
+            ...(s.title ? { title: s.title } : {}),
+            ...(cwd ? { cwd } : {}),
+            updatedAt: statSync(path).mtime.toISOString(),
+            extra: { folder },
+          })
+        } catch {
+          // Gone or unreadable between listing and reading.
+        }
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef, home: string): Promise<Session> {
+    const folder = (ref.extra?.folder as string | undefined) ?? ref.path.split("/").slice(-3, -2)[0]
+    const cwd = ref.cwd ?? (folder ? projectPaths(home).get(folder) : undefined)
+    try {
+      return retag(await geminiReader.read({ ...ref, ...(cwd ? { cwd } : {}) }, home))
+    } catch (e) {
+      throw new Error((e as Error).message.replace(/Gemini CLI/g, LABEL))
+    }
+  },
+}

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

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+
+// What the Tabnine CLI (the Gemini CLI fork Tabnine ships as `tabnine`, renamed `tabnine-legacy` once its
+// OpenCode-based successor is installed) keeps per session, as far as this adapter relies on it. Checked
+// against the public 0.36.1 bundle (console.tabnine.com/update/cli/0.36.1/tabnine.tar): Storage,
+// ProjectRegistry, ChatRecordingService and loadConversationRecord, run on sessions this adapter wrote.
+//
+// It is Gemini CLI's layout under ~/.tabnine/agent instead of ~/.gemini: projects.json names each project's
+// folder, tmp/<project>/chats/session-<time>-<id8>.jsonl holds a session (a metadata record, then message
+// records, then `$set` updates), and `.project_root` markers in tmp/<project> and history/<project> claim the
+// name. So the Gemini CLI planner writes the records; only the root and the version differ.
+
+export const TOOL = "tabnine-cli"
+export const LABEL = "Tabnine CLI"
+
+/** Tabnine CLI versions the writer's files were checked against. */
+export const TESTED_VERSIONS = ["0.36.1"]
+
+/** The Gemini CLI release whose session format 0.36.1 writes: JSONL, which upstream adopted in 0.39.0. */
+export const GEMINI_FORMAT_VERSION = "0.39.0"
+
+/** ~/.tabnine/agent (TABNINE_DEV_CONFIG_DIR only applies to Tabnine's development builds). */
+export const agentDir = (home: string) => join(home, ".tabnine", "agent")
+
+/** The active Tabnine CLI version: the installer records it in .bundles/.active, so nothing is run to learn it. */
+export function tabnineVersion(home: string): string | undefined {
+  try {
+    return readFileSync(join(agentDir(home), ".bundles", ".active"), "utf8").trim().match(/^\d+\.\d+\.\d+$/)?.[0]
+  } catch {
+    return undefined
+  }
+}