@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/cline4/writer.ts

@@ -0,0 +1,361 @@
+import { Database } from "bun:sqlite"
+import { randomBytes } from "node:crypto"
+import { copyFileSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { dirname, extname, join } from "node:path"
+import { toolLabel } from "../../brief.ts"
+import { exists, gitInfo, isDir, isRunning, 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 { cline4Reader } from "./reader.ts"
+import { LABEL, NOTE_KIND, PROCESSES, SESSIONS_TABLE, TESTED_VERSIONS, TOOL, continuedNote, manifestPath, messagesPath, sessionDir, sessionsDb } from "./records.ts"
+
+// Continues a portable session as a new Cline 4.x SDK session, written the way Cline's own session importer
+// (core/src/services/session-import) writes an imported Claude Code or Codex conversation: a `sessions` row in
+// sessions.db, a manifest and a messages file, a completed root session whose metadata carries the title,
+// sessionHistoryOrigin {mode: "import"} and continuedFrom (Cline's importer writes importedFrom, which makes Cline summarise on resume). `cline history` lists it and `cline --id <id>`
+// resumes it with the earlier turns on screen; Cline Desktop shows it in its history.
+//
+// Messages are Cline's Anthropic-shaped MessageWithMetadata: one assistant message per model response (its
+// readable reasoning as a thinking block without a signature, its text, its tool_use blocks), then one user
+// message with the tool_result blocks, as Cline's importer pairs them; a call without a result is closed as
+// an error. Tool names stay as they were, as the importer leaves them. A compaction is Cline's own: a
+// compaction_summary message replaces the turns before it. The note saying where the session came from is a
+// user message with displayRole "system", which the model reads and the panel does not show.
+//
+// sessions.db is written only while no Cline CLI, hub or Desktop process runs, after a copy of it is kept
+// under ~/.brain/backups/cline-sdk/.
+
+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 NANO = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"
+
+type Json = Record<string, any>
+type Call = Extract<Turn, { kind: "tool_call" }>
+type Result = Extract<Turn, { kind: "tool_result" }>
+
+const shellQuote = (s: string) => (/^[\w./@%+=:,-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
+
+function realCwd(cwd: string): string {
+  try {
+    return realpathSync(cwd)
+  } catch {
+    return cwd
+  }
+}
+
+/** A session id as Cline makes one: `${Date.now()}_${nanoid(5)}`. */
+export const sessionId = (now: Date) => `${now.getTime()}_${[...randomBytes(5)].map((b) => NANO[b & 63]).join("")}`
+
+/** Call ids the providers Cline talks to accept (Anthropic's ^[a-zA-Z0-9_-]{1,64}$). */
+const safeId = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "call"
+
+const objectInput = (input: unknown): Json => (input && typeof input === "object" && !Array.isArray(input) ? (input as Json) : { input: input ?? null })
+
+/** The provider a model id belongs to, for the history list; Cline resumes with the person's own provider. */
+function providerOf(model: string | undefined, tool: string): string {
+  if (!model) return tool
+  if (/claude|anthropic/i.test(model)) return "anthropic"
+  if (/gemini/i.test(model)) return "gemini"
+  if (/gpt|^o\d|codex|openai/i.test(model)) return "openai"
+  const slash = model.indexOf("/")
+  return slash > 0 ? model.slice(0, slash) : tool
+}
+
+export interface ClinePlan {
+  messages: Json[]
+  title: string
+  prompt?: string
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The messages of a new Cline session continuing `session`. Pure apart from reading attached images. */
+export function planMessages(session: Session, opts: { now: Date }): ClinePlan {
+  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)
+
+  // Cline's compaction replaces what came before it: start from the last summary.
+  const lastCompaction = session.turns.map((t) => t.kind).lastIndexOf("compaction")
+  const turns = lastCompaction >= 0 ? session.turns.slice(lastCompaction) : session.turns
+  if (lastCompaction > 0) drop("turns before the last compaction, replaced by its summary as Cline compacts", lastCompaction)
+  const droppedUsers = session.turns.slice(0, Math.max(0, lastCompaction)).filter((t) => t.kind === "user").length
+
+  const results = new Map<string, Result>()
+  for (const t of turns) if (t.kind === "tool_result" && !results.has(t.callId)) results.set(t.callId, t)
+  const ids = new Map<string, string>()
+  const used = new Set<string>()
+  let remapped = 0
+  const idFor = (id: string) => {
+    let v = ids.get(id)
+    if (v) return v
+    v = safeId(id)
+    for (let n = 2; used.has(v); n++) v = `${safeId(id)}_${n}`
+    ids.set(id, v)
+    used.add(v)
+    if (v !== id) remapped++
+    return v
+  }
+  const ts = (at?: string) => {
+    const t = at ? Date.parse(at) : Number.NaN
+    return Number.isFinite(t) ? { ts: t } : {}
+  }
+
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const messages: Json[] = []
+  const note: Json = {
+    role: "user",
+    content: [{ type: "text", text: continuedNote(label, session.header.id, opts.now.toISOString().slice(0, 10)) }],
+    metadata: { kind: NOTE_KIND, displayRole: "system", userRunSpan: 0 },
+  }
+  let cur: { msg: Json; calls: Call[] } | undefined
+  const flush = () => {
+    if (!cur) return
+    const { msg, calls } = cur
+    cur = undefined
+    if (!msg.content.length) return
+    messages.push(msg)
+    if (!calls.length) return
+    const blocks = calls.map((call) => {
+      const r = results.get(call.id)
+      if (!r) drop("tool calls without a result (closed as errors)")
+      const output = r ? (r.fullPath ? `${r.output}\n\n[Full output: ${r.fullPath}]` : r.output) : "No result was recorded for this call; the session moved on before it finished."
+      return { type: "tool_result", tool_use_id: idFor(call.id), name: call.name, content: output.trim() ? output : "(no output)", ...(r?.ok === false || !r ? { is_error: true } : {}) }
+    })
+    const last = calls.map((c) => results.get(c.id)?.at).filter(Boolean).at(-1)
+    messages.push({ role: "user", content: blocks, ...ts(last) })
+  }
+  const assistant = (at: string | undefined, model: string | undefined) => {
+    if (!cur) {
+      const id = model ?? session.header.models.at(-1)
+      cur = { msg: { role: "assistant", content: [], ...(id ? { modelInfo: { id, provider: providerOf(id, session.header.tool) } } : {}), ...ts(at) }, calls: [] }
+    }
+    return cur
+  }
+  const seen = new Set<string>()
+
+  for (const t of turns) {
+    switch (t.kind) {
+      case "user": {
+        flush()
+        const content: Json[] = []
+        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) content.push({ type: "image", data: readFileSync(a.path).toString("base64"), mediaType: mime })
+          else drop("images Cline cannot hold")
+        }
+        if (!text.trim() && !content.length) break
+        if (text.trim()) content.unshift({ type: "text", text })
+        messages.push({ role: "user", content, ...ts(t.at) })
+        if (text.trim()) expect.users++
+        break
+      }
+      case "assistant":
+        // Text after a call is a new response: it was written after the call's result came back.
+        if (cur?.calls.length) flush()
+        if (!t.text.trim()) break
+        assistant(t.at, t.model).msg.content.push({ type: "text", text: t.text })
+        expect.assistants++
+        break
+      case "reasoning":
+        if (cur?.calls.length) flush()
+        if (t.text.trim()) assistant(t.at, undefined).msg.content.push({ type: "thinking", thinking: t.text })
+        break
+      case "tool_call": {
+        if (seen.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        seen.add(t.id)
+        const a = assistant(t.at, undefined)
+        a.msg.content.push({ type: "tool_use", id: idFor(t.id), name: t.name, input: objectInput(t.input) })
+        a.calls.push(t)
+        expect.calls++
+        break
+      }
+      case "tool_result":
+        if (!seen.has(t.callId)) drop("tool results without a call")
+        else if (results.get(t.callId) !== t) drop("repeated tool results")
+        break
+      case "compaction":
+        flush()
+        // Cline's own compaction summary (compaction-shared.ts): off screen, for the model.
+        messages.push({
+          role: "user",
+          content: [{ type: "text", text: `Context summary:\n\n[Summary of the earlier conversation in ${label}]\n\n${t.summary}` }],
+          metadata: { kind: "compaction_summary", displayRole: "system", userRunSpan: droppedUsers, summary: t.summary, details: { readFiles: [], modifiedFiles: [] }, tokensBefore: 0, generatedAt: opts.now.getTime() },
+          ...ts(t.at),
+        })
+        break
+      case "file_edit":
+        if (!t.callId || !seen.has(t.callId)) drop("file edits outside a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions (their results stay in the parent's tool results)")
+        break
+    }
+  }
+  flush()
+  if (!messages.length) throw new Error("nothing Cline can show: the session has no messages or tool calls")
+  // The note opens the model's context, after a compaction summary when there is one.
+  messages.splice(lastCompaction >= 0 ? 1 : 0, 0, note)
+
+  const firstText = firstUserText(session)?.replace(/\s+/g, " ").trim()
+  const title = `${session.header.title ?? firstText?.slice(0, 60) ?? "Session"} (from ${label})`.slice(0, 120)
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (remapped) lost.push(`tool call ids, changed to fit Cline (${remapped})`)
+  return { messages, title, ...(firstText ? { prompt: firstText.slice(0, 2000) } : {}), lost, expect }
+}
+
+/** A filesystem-safe timestamp for a backup folder. */
+const stamp = (d: Date) => d.toISOString().replace(/[:.]/g, "-")
+
+/** Copies sessions.db and its -wal and -shm files; returns the folder. */
+export function backupDb(home: string, path: string, now: Date): string {
+  const dir = join(home, ".brain", "backups", TOOL, stamp(now))
+  mkdirSync(dir, { recursive: true })
+  for (const side of ["", "-wal", "-shm"]) if (exists(path + side)) copyFileSync(path + side, join(dir, `sessions.db${side}`))
+  return dir
+}
+
+const semver = (v: string | undefined) => v?.match(/(\d+\.\d+\.\d+)/)?.[1]
+
+/** The Cline 4 writer; `version` and `running` are for tests, which must not depend on what is installed or open. */
+export function cline4Writer(opts: { version?: string; running?: () => boolean } = {}): Writer {
+  const installed = () => opts.version ?? semver(versionOf("cline"))
+  const running = opts.running ?? (() => PROCESSES.some(isRunning))
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      const v = installed()
+      if (!v) return { ok: false, why: "the Cline CLI is not installed (no `cline` on the PATH)" }
+      if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Cline CLI ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+      if (running()) return { ok: false, why: "Cline is running (the CLI, its hub or Cline Desktop); quit it first, since it keeps sessions.db open" }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder` }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const now = new Date()
+      const cwd = realCwd(w.cwd)
+      const id = sessionId(now)
+      const plan = planMessages(session, { now })
+      const db = sessionsDb(w.home)
+      const files = { manifest: manifestPath(w.home, id), messages: messagesPath(w.home, id) }
+      const written = [db, files.manifest, files.messages]
+      if (!w.dryRun) {
+        if (running()) throw new Error("Cline is running; quit it before writing its sessions database")
+        if (exists(db)) written.push(backupDb(w.home, db, now))
+        const started = new Date(session.header.startedAt && Number.isFinite(Date.parse(session.header.startedAt)) ? Date.parse(session.header.startedAt) : now.getTime()).toISOString()
+        const ended = now.toISOString()
+        const model = session.header.models.at(-1) ?? "unknown"
+        const provider = providerOf(session.header.models.at(-1), session.header.tool)
+        const branch = gitInfo(cwd, w.home).gitBranch ?? session.header.project.gitBranch
+        const metadata = {
+          title: plan.title,
+          ...(branch ? { git: { branch } } : {}),
+          sessionHistoryOrigin: { mode: "import", trigger: session.header.tool },
+          // Not `importedFrom`: Cline 3.0.74 summarises a session that has it with the model the first time it resumes
+          // it (the wire harness saw the follow-up sent over a model-written summary), which would drop the turns.
+          continuedFrom: { tool: session.header.tool, sourceSessionId: session.header.sourceId, sourcePath: session.header.sourcePath ?? "", importedAt: ended },
+        }
+        const row = { source: "cli", status: "completed", interactive: true, provider, model, enableTools: true, enableSpawn: false, enableTeams: false }
+        mkdirSync(sessionDir(w.home, id), { recursive: true })
+        writeFileSync(
+          files.messages,
+          `${JSON.stringify({ version: 1, updated_at: ended, agent: "lead", sessionId: id, origin: { source: row.source, mode: "import", sessionId: id, trigger: session.header.tool }, messages: plan.messages }, null, 2)}\n`,
+        )
+        writeFileSync(
+          files.manifest,
+          `${JSON.stringify(
+            {
+              version: 1,
+              session_id: id,
+              source: row.source,
+              pid: 0,
+              started_at: started,
+              ended_at: ended,
+              exit_code: 0,
+              status: row.status,
+              interactive: row.interactive,
+              provider,
+              model,
+              cwd,
+              workspace_root: cwd,
+              enable_tools: row.enableTools,
+              enable_spawn: row.enableSpawn,
+              enable_teams: row.enableTeams,
+              ...(plan.prompt ? { prompt: plan.prompt } : {}),
+              metadata,
+              messages_path: files.messages,
+            },
+            null,
+            2,
+          )}\n`,
+        )
+        mkdirSync(dirname(db), { recursive: true })
+        const d = new Database(db)
+        try {
+          d.exec("PRAGMA journal_mode = WAL")
+          d.exec("PRAGMA busy_timeout = 5000")
+          d.exec(SESSIONS_TABLE)
+          // A plain INSERT, unlike Cline's INSERT OR REPLACE: a new session never replaces a row.
+          d.query(
+            `INSERT INTO sessions (session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive, provider, model, cwd, workspace_root, team_name,
+              enable_tools, enable_spawn, enable_teams, parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt, metadata_json, transcript_path, hook_path,
+              messages_path, updated_at) VALUES (?, ?, 0, ?, ?, 0, ?, 0, 1, ?, ?, ?, ?, NULL, 1, 0, 0, NULL, NULL, NULL, NULL, 0, ?, ?, '', '', ?, ?)`,
+          ).run(id, row.source, started, ended, row.status, provider, model, cwd, cwd, plan.prompt ?? null, JSON.stringify(metadata), files.messages, ended)
+        } finally {
+          d.close()
+        }
+        let problem: string | undefined
+        try {
+          const back = await cline4Reader.read({ tool: TOOL, sourceId: id, path: files.messages }, 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)
+            problem = `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}`
+        } catch (e) {
+          problem = e instanceof Error ? e.message : String(e)
+        }
+        if (problem) {
+          const d2 = new Database(db)
+          try {
+            d2.query("DELETE FROM sessions WHERE session_id = ?").run(id)
+          } finally {
+            d2.close()
+          }
+          rmSync(sessionDir(w.home, id), { recursive: true, force: true })
+          throw new Error(`the new Cline session did not read back as written (${problem}); it was removed`)
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId: id,
+        written,
+        open: `cd ${shellQuote(cwd)} && cline --id ${id}`,
+        note: `Cline Desktop lists it in its history as "${plan.title}".`,
+        lost: plan.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const cline4NativeWriter = cline4Writer()

package/src/adapters/codebuff/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { codebuffReader } from "./reader.ts"
+import { codebuffNativeWriter } from "./writer.ts"
+
+// Codebuff and Freebuff (one CLI under two names, sharing ~/.config/manicode): reads their chats, and continues
+// any session as a new chat that `freebuff --continue <id>` (or `codebuff --continue <id>`) opens.
+export const readers: Reader[] = [codebuffReader]
+export const writers: Writer[] = [codebuffNativeWriter]

package/src/adapters/codebuff/project.ts

@@ -0,0 +1,207 @@
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs"
+import { cpus } from "node:os"
+import { basename, dirname, join, relative } from "node:path"
+
+// The project snapshot a Freebuff chat carries (RunState.sessionState.fileContext), made the way the SDK makes
+// one for a new chat (sdk/src/run-state.ts initialSessionState, common/src/project-file-tree.ts): the folder
+// tree as the system prompt lists it, the project's AGENTS.md / CLAUDE.md, ~/.AGENTS.md, a git summary and
+// the machine. A continued chat keeps the snapshot it started with, so this is what Freebuff itself would
+// have stored had the chat begun here today. Differences from Freebuff's own, kept small on purpose:
+// - ignore rules come from git (`git ls-files --ignored`) where the folder is a git work tree, which covers
+//   .gitignore but not .codebuffignore / .manicodeignore; outside git only the default ignores apply;
+// - no symbol index (fileTokenScores is empty): Freebuff skips it for its default agent too;
+// - skills are left for the skill tool to find on disk, and the repository's commit statistics and
+//   GitHub visibility (Freebuff asks `gh`) are left out.
+
+export interface FileNode {
+  name: string
+  type: "file" | "directory"
+  filePath: string
+  children?: FileNode[]
+  lastReadTime?: number
+}
+
+/** common/src/constants/paths.ts DEFAULT_IGNORED_PATHS, as gitignore patterns on a name. */
+const DEFAULT_IGNORED = [".git", ".env", ".env.*", "*.min.*", "node_modules", "venv", "virtualenv", ".venv", ".virtualenv", "__pycache__", "*.egg-info/", "*.pyc", ".DS_Store", ".pytest_cache", ".mypy_cache", ".ruff_cache", ".next", "package-lock.json", "bun.lockb"]
+const globRe = (p: string) => new RegExp(`^${p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")}$`)
+const IGNORED = DEFAULT_IGNORED.map((p) => ({ re: globRe(p.replace(/\/$/, "")), dirOnly: p.endsWith("/") }))
+const defaultIgnored = (name: string, dir: boolean, shallow: boolean) => (shallow && name.startsWith(".")) || IGNORED.some((i) => (!i.dirOnly || dir) && i.re.test(name))
+
+export const DEFAULT_MAX_FILES = 10_000
+const SHALLOW = { depth: 3, files: 2_000, dirs: 500 }
+
+const git = (cwd: string, args: string[]) => {
+  try {
+    const p = Bun.spawnSync(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore", timeout: 20_000 })
+    return p.exitCode === 0 ? p.stdout.toString() : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** True when `dir` is `home` or holds it: Freebuff then scans only a few levels (isValidProjectRoot). */
+const holdsHome = (dir: string, home: string) => !relative(dir, home).startsWith("..")
+
+/** The folder tree, breadth first and capped, as getProjectFileTree builds it. */
+export function fileTree(cwd: string, home: string): { tree: FileNode[]; paths: string[] } {
+  const shallow = holdsHome(cwd, home)
+  const maxFiles = shallow ? SHALLOW.files : DEFAULT_MAX_FILES
+  const maxDepth = shallow ? SHALLOW.depth : Number.POSITIVE_INFINITY
+  const maxDirs = shallow ? SHALLOW.dirs : Number.POSITIVE_INFINITY
+  // Untracked paths git ignores (directories end in "/"); git applies every .gitignore on the way down.
+  const ignored = new Set((git(cwd, ["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--directory"]) ?? "").split("\0").filter(Boolean))
+  const root: FileNode = { name: basename(cwd), type: "directory", filePath: "", children: [] }
+  const queue: Array<{ node: FileNode; full: string; depth: number }> = [{ node: root, full: cwd, depth: 0 }]
+  const seen = new Set<string>()
+  const paths: string[] = []
+  let dirs = 0
+  while (queue.length && paths.length < maxFiles && dirs < maxDirs) {
+    const { node, full, depth } = queue.shift()!
+    dirs++
+    try {
+      const real = realpathSync(full)
+      if (seen.has(real)) continue
+      seen.add(real)
+    } catch {
+      continue
+    }
+    let names: string[]
+    try {
+      names = readdirSync(full).sort()
+    } catch {
+      continue
+    }
+    for (const name of names) {
+      if (paths.length >= maxFiles) break
+      const path = join(full, name)
+      const rel = relative(cwd, path).split("\\").join("/")
+      let st: ReturnType<typeof statSync>
+      try {
+        st = statSync(path)
+      } catch {
+        continue
+      }
+      const dir = st.isDirectory()
+      if (defaultIgnored(name, dir, shallow) || ignored.has(dir ? `${rel}/` : rel)) continue
+      if (dir) {
+        const child: FileNode = { name, type: "directory", children: [], filePath: rel }
+        node.children!.push(child)
+        if (depth + 1 < maxDepth) queue.push({ node: child, full: path, depth: depth + 1 })
+      } else {
+        node.children!.push({ name, type: "file", lastReadTime: st.atimeMs, filePath: rel })
+        paths.push(rel)
+      }
+    }
+  }
+  return { tree: root.children!, paths }
+}
+
+const TEST_DIRS = new Set(["__tests__", "__specs__", "test", "tests", "spec", "specs"])
+/** sdk/src/run-state.ts isTestFilePath. */
+export function isTestFilePath(filePath: string): boolean {
+  const segments = filePath.split("/")
+  const name = segments.pop() ?? ""
+  if (segments.some((s) => TEST_DIRS.has(s.toLowerCase()))) return true
+  const lower = name.toLowerCase()
+  return (
+    /\.(?:test|tests|spec|specs|cy)\./.test(lower) ||
+    /^(?:test|spec)_.+\.[^.]+$/.test(lower) ||
+    /_(?:test|tests|spec|specs)\.[^.]+$/.test(lower) ||
+    /^(?:test|tests|spec|specs)\.[^.]+$/.test(lower) ||
+    /(?:Test|Tests|TestCase|Spec)\.[^.]+$/.test(name)
+  )
+}
+
+const KNOWLEDGE_NAMES = ["agents.md", "claude.md"]
+const isKnowledgeFile = (p: string) => {
+  const name = basename(p).toLowerCase()
+  return KNOWLEDGE_NAMES.includes(name) || name.endsWith(".knowledge.md")
+}
+
+/** One instructions file per folder, AGENTS.md before CLAUDE.md (selectKnowledgeFilePaths), with its text. */
+export function knowledgeFiles(cwd: string, paths: string[]): Record<string, string> {
+  const byDir = new Map<string, string[]>()
+  for (const p of paths.filter(isKnowledgeFile)) byDir.set(dirname(p), [...(byDir.get(dirname(p)) ?? []), p])
+  const out: Record<string, string> = {}
+  for (const files of byDir.values()) {
+    const pick = KNOWLEDGE_NAMES.map((n) => files.find((f) => f.toLowerCase().endsWith(n))).find(Boolean)
+    if (!pick) continue
+    try {
+      out[pick] = readFileSync(join(cwd, pick), "utf8")
+    } catch {}
+  }
+  return out
+}
+
+/** ~/.AGENTS.md, else ~/.CLAUDE.md, matched without case (loadUserKnowledgeFiles). */
+export function userKnowledgeFiles(home: string): Record<string, string> {
+  let names: string[]
+  try {
+    names = readdirSync(home)
+  } catch {
+    return {}
+  }
+  for (const want of KNOWLEDGE_NAMES) {
+    const name = names.find((n) => n.startsWith(".") && n.slice(1).toLowerCase() === want)
+    if (!name) continue
+    try {
+      return { [`~/${name}`]: readFileSync(join(home, name), "utf8") }
+    } catch {}
+  }
+  return {}
+}
+
+const CHROME: Record<string, string[]> = {
+  darwin: ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta", "/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev", "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary", "/Applications/Chromium.app/Contents/MacOS/Chromium"],
+  linux: ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/google-chrome-beta", "/usr/bin/google-chrome-unstable", "/usr/bin/chromium", "/usr/bin/chromium-browser", "/snap/bin/chromium"],
+}
+
+/** The git summary the system prompt prints (getGitChanges), without commit statistics or visibility. */
+function gitChanges(cwd: string, counts: { fileCount: number; fileCountIsLowerBound: boolean; testFileCount: number }) {
+  const lists = [["diff", "--name-only", "--"], ["diff", "--cached", "--name-only", "--"], ["ls-files", "--others", "--exclude-standard"]].map((a) => git(cwd, a))
+  const changed = [...new Set(lists.flatMap((o) => (o ?? "").split("\n").map((l) => l.trim()).filter(Boolean)))].sort()
+  const count = Number.parseInt(git(cwd, ["rev-list", "--count", "HEAD"]) ?? "", 10)
+  const shallow = git(cwd, ["rev-parse", "--is-shallow-repository"])?.trim()
+  return {
+    gitAvailable: lists.some((o) => o !== undefined),
+    ...(git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])?.trim() ? { branch: git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])!.trim() } : {}),
+    changedFiles: changed.slice(0, 25),
+    changedFileCount: changed.length,
+    changedFileScanTruncated: false,
+    repositoryVisibility: "unknown" as const,
+    ...(Number.isFinite(count) ? { commitCount: count } : {}),
+    ...(shallow ? { historyIsShallow: shallow === "true" } : {}),
+    ...counts,
+  }
+}
+
+/** The fileContext of a new chat in `cwd`, in the SDK's key order. */
+export function fileContext(cwd: string, home: string) {
+  const { tree, paths } = fileTree(cwd, home)
+  const counts = { fileCount: paths.length, fileCountIsLowerBound: paths.length >= DEFAULT_MAX_FILES, testFileCount: paths.filter(isTestFilePath).length }
+  return {
+    projectRoot: cwd,
+    cwd,
+    fileTree: tree,
+    fileTokenScores: {},
+    tokenCallers: {},
+    knowledgeFiles: knowledgeFiles(cwd, paths),
+    userKnowledgeFiles: userKnowledgeFiles(home),
+    agentTemplates: {},
+    customToolDefinitions: {},
+    skills: {},
+    includeHomeSkills: false,
+    gitChanges: gitChanges(cwd, counts),
+    changesSinceLastChat: {},
+    shellConfigFiles: {},
+    systemInfo: {
+      platform: process.platform,
+      shell: "bash",
+      nodeVersion: process.version,
+      arch: process.arch,
+      homedir: home,
+      cpus: cpus().length,
+      chromeAvailable: (CHROME[process.platform] ?? []).some((p) => existsSync(p)),
+    },
+  }
+}