@chroxify/eunoe 0.1.0 → 1.1.0

package/src/transcript/render.ts

@@ -1,26 +1,52 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import path from "node:path"
-import { paths } from "../config/constants"
-import { INDEX_FILE, RENDER_STAMP, TURN_COUNT_FILE } from "./constants"
-import { renderIndex, renderMarkdown, renderXml, turnFile } from "./format"
-import { parseTurns } from "./parse"
-import type { RenderResult, TranscriptFormat } from "./types"
+import { paths } from "../config/paths"
+import { renderIndex, renderMarkdown, renderSubagentMarkdown, renderSubagentXml, renderXml, type SubagentRecord, subagentFile, turnFile } from "./format"
+import { parseJsonl, parseTurns, type ToolPart, type TranscriptFormat, type Turn } from "./parse"
+import { type SubagentRun, subagentEntries, subagentRuns } from "./subagents"
+
+interface RenderResult {
+  dir: string
+  changed: boolean
+  turns: number
+}
 
 export function transcriptDir(sessionId: string) {
   return path.join(paths.transcripts, sessionId)
 }
 
-export function renderTranscript(sessionFile: string, sessionId: string, outDir = transcriptDir(sessionId), format: TranscriptFormat = "markdown"): RenderResult {
-  mkdirSync(outDir, { recursive: true })
-  const stampFile = path.join(outDir, RENDER_STAMP)
-  const mtime = String(statSync(sessionFile).mtimeMs)
-  if (existsSync(stampFile) && readFileSync(stampFile, "utf8") === mtime) {
-    return { dir: outDir, changed: false, turns: Number(readFileSync(path.join(outDir, TURN_COUNT_FILE), "utf8") || 0) }
+function launchingPart(turns: Turn[], run: SubagentRun): { turn: Turn; part: ToolPart } | null {
+  for (const turn of turns) {
+    for (const part of turn.parts) {
+      if (part.kind === "tool" && (run.toolUseId ? part.id === run.toolUseId : part.prompt === run.prompt)) return { turn, part }
+    }
   }
-  const entries = readFileSync(sessionFile, "utf8").split("\n").flatMap((line) => {
-    try { return line ? [JSON.parse(line)] : [] } catch { return [] }
+  return null
+}
+
+function subagentRecords(turns: Turn[], runs: SubagentRun[], format: TranscriptFormat): SubagentRecord[] {
+  const perTurn = new Map<number, number>()
+  return runs.map((run) => {
+    const launcher = launchingPart(turns, run)
+    const parentTurn = launcher?.turn.number ?? 0
+    const k = (perTurn.get(parentTurn) ?? 0) + 1
+    perTurn.set(parentTurn, k)
+    const file = subagentFile(parentTurn, k, format)
+    if (launcher) launcher.part.record = file
+    return { run, turns: parseTurns(subagentEntries(run), "any"), parentTurn, file }
   })
-  const turns = parseTurns(entries)
+}
+
+export function renderTranscript(sessionFile: string, sessionId: string, outDir = transcriptDir(sessionId), format: TranscriptFormat = "markdown"): RenderResult {
+  mkdirSync(outDir, { recursive: true })
+  const stampFile = path.join(outDir, ".rendered")
+  const countFile = path.join(outDir, ".turns")
+  const runs = subagentRuns(sessionFile)
+  const stamp = [statSync(sessionFile).mtimeMs, ...runs.map((run) => `${run.id}:${run.mtimeMs}`)].join("|")
+  if (existsSync(stampFile) && readFileSync(stampFile, "utf8") === stamp) return { dir: outDir, changed: false, turns: Number(readFileSync(countFile, "utf8") || 0) }
+
+  const turns = parseTurns(parseJsonl(readFileSync(sessionFile, "utf8")))
+  const records = subagentRecords(turns, runs, format)
   let changed = false
   const write = (file: string, content: string) => {
     const target = path.join(outDir, file)
@@ -29,8 +55,9 @@ export function renderTranscript(sessionFile: string, sessionId: string, outDir
     changed = true
   }
   for (const turn of turns) write(turnFile(turn, format), format === "xml" ? renderXml(turn) : renderMarkdown(turn))
-  write(INDEX_FILE, renderIndex(turns, format))
-  writeFileSync(stampFile, mtime)
-  writeFileSync(path.join(outDir, TURN_COUNT_FILE), String(turns.length))
+  for (const record of records) write(record.file, format === "xml" ? renderSubagentXml(record) : renderSubagentMarkdown(record))
+  write("index.md", renderIndex(turns, format, records))
+  writeFileSync(stampFile, stamp)
+  writeFileSync(countFile, String(turns.length))
   return { dir: outDir, changed, turns: turns.length }
 }

package/src/transcript/search.ts

@@ -1,9 +1,13 @@
 import { existsSync } from "node:fs"
 import path from "node:path"
-import type { SearchMode } from "../config/types"
-import { QMD_DIR } from "./constants"
+import type { SearchMode } from "../config"
 import { renderTranscript, transcriptDir } from "./render"
-import type { TranscriptRef } from "./types"
+
+export interface TranscriptRef {
+  mode: SearchMode
+  jsonl: string
+  dir: string
+}
 
 const indexing = new Map<string, Promise<void>>()
 
@@ -11,16 +15,19 @@ async function qmd(cwd: string, args: string[]) {
   await Bun.spawn(["qmd", ...args], { cwd, stdout: "ignore", stderr: "ignore" }).exited
 }
 
+const isIndexed = (dir: string) => existsSync(path.join(dir, ".qmd"))
+
 function indexWithQmd(dir: string) {
-  const previous = indexing.get(dir) ?? Promise.resolve()
-  const next = previous.then(async () => {
-    if (!existsSync(path.join(dir, QMD_DIR))) {
-      await qmd(dir, ["init"])
-      await qmd(dir, ["collection", "add", ".", "--name", "transcript"])
-    }
-    await qmd(dir, ["update"])
-    await qmd(dir, ["embed"])
-  }).catch(() => undefined)
+  const next = (indexing.get(dir) ?? Promise.resolve())
+    .then(async () => {
+      if (!isIndexed(dir)) {
+        await qmd(dir, ["init"])
+        await qmd(dir, ["collection", "add", ".", "--name", "transcript"])
+      }
+      await qmd(dir, ["update"])
+      await qmd(dir, ["embed"])
+    })
+    .catch(() => undefined)
   indexing.set(dir, next)
   return next
 }
@@ -30,51 +37,8 @@ export function prepareTranscript(mode: SearchMode, sessionFile: string, key: st
   if (mode !== "jsonl") {
     try {
       const { changed } = renderTranscript(sessionFile, key, dir, mode === "xml" ? "xml" : "markdown")
-      if (mode === "qmd" && (changed || !existsSync(path.join(dir, QMD_DIR)))) void indexWithQmd(dir)
+      if (mode === "qmd" && (changed || !isIndexed(dir))) void indexWithQmd(dir)
     } catch {}
   }
   return { mode, jsonl: sessionFile, dir }
 }
-
-export function searchGuide(ref: TranscriptRef): string {
-  if (ref.mode === "jsonl") {
-    return [
-      `The full transcript is Claude Code's session file: ${ref.jsonl}`,
-      "It is JSONL, one entry per line. Your tool calls are `tool_use` blocks in `assistant` entries; their output is in the `tool_result` blocks of the `user` entries that follow. It is large: search it narrowly and never read it whole. For example:",
-      `  grep -n 'distinctive text' ${ref.jsonl} | cut -c1-400`,
-      `  jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | "\\(.name) \\(.input | tostring | .[0:200])"' ${ref.jsonl}`,
-    ].join("\n")
-  }
-  const ext = ref.mode === "xml" ? "xml" : "md"
-  const layout = ref.mode === "xml"
-    ? [
-        `The full transcript is a folder with one XML file per turn: ${ref.dir}`,
-        "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
-        "- `turn-0001.xml`, …: one turn each, `<turn n>` with `<user>` (the message), `<said>` (what you wrote while working), `<tool n name>` holding `<call>`, `<input>` and `<output>`, and `<final_reply>`.",
-      ]
-    : [
-        `The full transcript is a folder of markdown files: ${ref.dir}`,
-        "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
-        "- `turn-0001.md`, …: one turn each. `## User` (the message), `### [tool 3/12] Bash: …` for every tool call with `[output of tool 3]` below it, and `## Final reply`.",
-      ]
-  const habits = "Search for more than one phrasing (the exact term, a synonym, a file or function name, an error string) before you conclude something isn't there. Read the whole turn file around a hit: the answer is often a few calls before or after it."
-  if (ref.mode === "markdown" || ref.mode === "xml") {
-    return [
-      ...layout,
-      "To find something:",
-      `  grep -ril 'distinctive words' ${ref.dir}        # which turns mention it`,
-      `  grep -n -i 'distinctive words' ${ref.dir}/*.${ext} | cut -c1-300`,
-      `  then Read ${ref.dir}/turn-NNNN.${ext}`,
-      habits,
-    ].join("\n")
-  }
-  return [
-    ...layout,
-    "It is indexed with qmd. Run qmd from inside that folder:",
-    `  cd ${ref.dir} && qmd query "a natural-language question"   # semantic + keyword, best when you don't know the exact words (5–20s)`,
-    `  cd ${ref.dir} && qmd search "exact words"                 # keyword only, instant`,
-    `  then Read ${ref.dir}/turn-NNNN.md (or qmd get turn-NNNN.md)`,
-    "If qmd isn't ready yet (the index builds in the background), grep the folder instead.",
-    habits,
-  ].join("\n")
-}

package/src/transcript/subagents.ts

@@ -0,0 +1,150 @@
+import { readFileSync, statSync } from "node:fs"
+import path from "node:path"
+import { blocks, clip, contentBlocks, type Message } from "../context/content"
+import { splitTurns } from "../context/fold/turns"
+import { type RecallChunk, recallChunks } from "../context/recall"
+import { listEntries } from "./locate"
+import { sessionMessages } from "./messages"
+import { entryMessages, parseJsonl, type SessionEntry } from "./parse"
+
+export interface SubagentRun {
+  id: string
+  file: string
+  inline: boolean
+  description: string
+  toolUseId: string | null
+  prompt: string
+  started: string
+  mtimeMs: number
+}
+
+const INLINE_ID = "sidechain"
+
+const entryCache = new Map<string, { mtimeMs: number; entries: SessionEntry[] }>()
+const chunkCache = new Map<string, { mtimeMs: number; parentTurn: number; chunks: RecallChunk[] }>()
+
+function mtimeOf(file: string): number | null {
+  try {
+    return statSync(file).mtimeMs
+  } catch {
+    return null
+  }
+}
+
+function readEntries(file: string): SessionEntry[] {
+  const mtimeMs = mtimeOf(file)
+  if (mtimeMs === null) return []
+  const hit = entryCache.get(file)
+  if (hit?.mtimeMs === mtimeMs) return hit.entries
+  const entries = parseJsonl(readFileSync(file, "utf8"))
+  entryCache.set(file, { mtimeMs, entries })
+  return entries
+}
+
+function firstPrompt(entries: SessionEntry[]): string {
+  for (const entry of entries) {
+    if (entry.type !== "user" || !entry.message) continue
+    const text = contentBlocks(entry.message.content)
+      .filter((block) => block.type === "text")
+      .map((block) => String(block.text ?? ""))
+      .join("\n")
+      .trim()
+    if (text) return text
+  }
+  return ""
+}
+
+function readMeta(file: string): { description?: string; toolUseId?: string } {
+  try {
+    return JSON.parse(readFileSync(file.replace(/\.jsonl$/, ".meta.json"), "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+export function subagentsDir(sessionFile: string) {
+  return path.join(path.dirname(sessionFile), path.basename(sessionFile, ".jsonl"), "subagents")
+}
+
+function fileRuns(sessionFile: string): SubagentRun[] {
+  const dir = subagentsDir(sessionFile)
+  return listEntries(dir)
+    .filter((name) => name.startsWith("agent-") && name.endsWith(".jsonl"))
+    .map((name) => {
+      const file = path.join(dir, name)
+      const entries = readEntries(file)
+      const meta = readMeta(file)
+      const prompt = firstPrompt(entries)
+      return {
+        id: name.slice("agent-".length, -".jsonl".length),
+        file,
+        inline: false,
+        description: meta.description ? String(meta.description) : clip(prompt, 80),
+        toolUseId: meta.toolUseId ? String(meta.toolUseId) : null,
+        prompt,
+        started: String(entries[0]?.timestamp ?? ""),
+        mtimeMs: mtimeOf(file) ?? 0,
+      }
+    })
+}
+
+function inlineRuns(sessionFile: string, known: Set<string>): SubagentRun[] {
+  const byAgent = new Map<string, SessionEntry[]>()
+  for (const entry of readEntries(sessionFile)) {
+    if (!entry.isSidechain) continue
+    const id = entry.agentId ?? INLINE_ID
+    byAgent.set(id, [...(byAgent.get(id) ?? []), entry])
+  }
+  return [...byAgent]
+    .filter(([id]) => !known.has(id))
+    .map(([id, entries]) => {
+      const prompt = firstPrompt(entries)
+      return { id, file: sessionFile, inline: true, description: clip(prompt, 80), toolUseId: null, prompt, started: String(entries[0]?.timestamp ?? ""), mtimeMs: mtimeOf(sessionFile) ?? 0 }
+    })
+}
+
+export function subagentRuns(sessionFile: string): SubagentRun[] {
+  const files = fileRuns(sessionFile)
+  const inline = inlineRuns(sessionFile, new Set(files.map((run) => run.id)))
+  return [...files, ...inline].sort((a, b) => a.started.localeCompare(b.started))
+}
+
+export function subagentEntries(run: SubagentRun): SessionEntry[] {
+  const entries = readEntries(run.file)
+  if (!run.inline) return entries
+  return entries.filter((entry) => entry.isSidechain && (entry.agentId ?? INLINE_ID) === run.id)
+}
+
+export function subagentMessages(run: SubagentRun): Message[] {
+  return entryMessages(subagentEntries(run))
+}
+
+function launchedBy(run: SubagentRun, call: { id?: unknown; name?: unknown; prompt?: unknown }): boolean {
+  if (run.toolUseId) return call.id === run.toolUseId
+  return (call.name === "Agent" || call.name === "Task") && String(call.prompt ?? "") === run.prompt
+}
+
+export function parentTurnOf(run: SubagentRun, parentMessages: Message[]): number {
+  const { turns } = splitTurns(parentMessages)
+  const index = turns.findIndex((turn) =>
+    turn
+      .filter((message) => message.role === "assistant")
+      .flatMap(blocks)
+      .some((block) => block.type === "tool_use" && launchedBy(run, { id: block.id, name: block.name, prompt: block.input?.prompt })),
+  )
+  return index + 1
+}
+
+export function subagentChunks(sessionFile: string): RecallChunk[] {
+  const parent = sessionMessages(sessionFile)
+  return subagentRuns(sessionFile).flatMap((run) => {
+    const key = `${run.file}#${run.id}`
+    const parentTurn = parentTurnOf(run, parent)
+    const hit = chunkCache.get(key)
+    if (hit && hit.mtimeMs === run.mtimeMs && hit.parentTurn === parentTurn) return hit.chunks
+    const from = `subagent "${run.description}"`
+    const chunks = recallChunks([...subagentMessages(run), { role: "user", content: "" }], new Map()).map((chunk) => ({ ...chunk, from, turn: parentTurn }))
+    chunkCache.set(key, { mtimeMs: run.mtimeMs, parentTurn, chunks })
+    return chunks
+  })
+}

package/src/cli/claude-settings.ts

@@ -1,42 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs"
-import path from "node:path"
-import type { Settings } from "./types"
-
-export const proxyUrl = (port: number) => `http://127.0.0.1:${port}`
-
-export function withEunoe(settings: Settings, port: number, mode: string): Settings {
-  const next = { ...settings, env: { ...settings.env, ANTHROPIC_BASE_URL: proxyUrl(port) } }
-  return withCompactionOwner(next, mode)
-}
-
-export function withoutEunoe(settings: Settings, port: number): Settings {
-  const next = { ...settings }
-  if (next.env?.ANTHROPIC_BASE_URL === proxyUrl(port)) {
-    const { ANTHROPIC_BASE_URL: _, ...env } = next.env
-    if (Object.keys(env).length > 0) next.env = env
-    else delete next.env
-  }
-  delete next.autoCompactEnabled
-  return next
-}
-
-export function withCompactionOwner(settings: Settings, mode: string): Settings {
-  const next = { ...settings }
-  if (mode === "off") delete next.autoCompactEnabled
-  else next.autoCompactEnabled = false
-  return next
-}
-
-export function editSettings(dirs: string[], edit: (settings: Settings) => Settings): string[] {
-  const touched: string[] = []
-  for (const dir of dirs) {
-    if (!existsSync(dir)) continue
-    const file = path.join(dir, "settings.json")
-    const current: Settings = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {}
-    const next = edit(current)
-    if (JSON.stringify(next) === JSON.stringify(current)) continue
-    writeFileSync(file, JSON.stringify(next, null, 2) + "\n")
-    touched.push(file)
-  }
-  return touched
-}

package/src/cli/commands/install.ts

@@ -1,44 +0,0 @@
-import { existsSync } from "node:fs"
-import path from "node:path"
-import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
-import { paths } from "../../config/constants"
-import { flagValues } from "../args"
-import { editSettings, proxyUrl, withEunoe } from "../claude-settings"
-import { MODE_DESCRIPTIONS } from "../constants"
-import { routedDirs } from "../inspect"
-import * as launchd from "../launchd"
-import type { Command } from "../types"
-import { c, fail, line, listFiles, note, ok, rows, tilde, warn } from "../ui"
-
-export const install: Command = {
-  summary: "Route Claude Code through eunoe and keep it running",
-  usage: "eunoe install [--config-dir <dir>]",
-  details: [
-    "Starts the proxy in the background and points Claude Code at it by setting",
-    "ANTHROPIC_BASE_URL in settings.json. New sessions pick it up; restart running ones.",
-  ],
-  options: [["--config-dir <dir>", "Also manage this Claude config directory (repeatable, remembered)"]],
-  run(args) {
-    const added = flagValues(args, "--config-dir").map((dir) => path.resolve(dir))
-    for (const dir of added) if (!existsSync(dir)) fail(`No such directory: ${tilde(dir)}`)
-    if (added.length) saveConfig({ claudeConfigDirs: [...new Set([...loadConfig().claudeConfigDirs, ...added])] })
-    const config = loadConfig()
-
-    line()
-    if (launchd.supported) {
-      launchd.installAgent([process.execPath, path.join(import.meta.dir, "..", "main.ts"), "serve"], paths.proxyLog)
-      ok(`Proxy running in the background on ${c.cyan(proxyUrl(config.port))}`)
-    } else {
-      warn("No launchd here, so keep the proxy running yourself:")
-      line(`    ${c.cyan("eunoe serve")}`)
-    }
-    const touched = editSettings(claudeConfigDirs(config), (settings) => withEunoe(settings, config.port, config.mode))
-    ok("Claude Code routed through eunoe")
-    listFiles(touched.length ? touched : routedDirs(config).map((dir) => path.join(dir, "settings.json")))
-    line()
-    rows([["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`]])
-    line()
-    note(`New sessions go through eunoe. Restart any that are already running.`)
-    line()
-  },
-}

package/src/cli/constants.ts

@@ -1,29 +0,0 @@
-import { homedir } from "node:os"
-import path from "node:path"
-import type { Mode } from "../config/types"
-import type { OptionRow } from "./types"
-
-export const TAGLINE = "Context management for Claude Code that never forgets what matters."
-
-export const MODE_DESCRIPTIONS: Record<Mode, string> = {
-  compact: "Full context until the window is nearly full, then eunoe's cut",
-  trim: "Every finished turn kept as your message and the final reply",
-  off: "Passthrough. Claude Code compacts on its own",
-}
-
-export const GLOBAL_OPTIONS: OptionRow[] = [
-  ["-h, --help", "Show help for a command"],
-  ["-v, --version", "Show the version"],
-]
-
-export const LAUNCHD_LABEL = "com.chroxify.eunoe"
-export const LAUNCH_AGENT_PLIST = path.join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`)
-
-export const PROBE_TIMEOUT_MS = 800
-export const RECENT_REQUESTS = 200
-export const TYPO_DISTANCE = 2
-
-export const TRANSPARENT_PIXEL = "."
-export const HALF_BLOCKS = " ▀▄█"
-export const OCTANTS = [..." 𜺨𜺫🮂𜴀▘𜴁𜴂𜴃𜴄▝𜴅𜴆𜴇𜴈▀𜴉𜴊𜴋𜴌🯦𜴍𜴎𜴏𜴐𜴑𜴒𜴓𜴔𜴕𜴖𜴗𜴘𜴙𜴚𜴛𜴜𜴝𜴞𜴟🯧𜴠𜴡𜴢𜴣𜴤𜴥𜴦𜴧𜴨𜴩𜴪𜴫𜴬𜴭𜴮𜴯𜴰𜴱𜴲𜴳𜴴𜴵🮅𜺣𜴶𜴷𜴸𜴹𜴺𜴻𜴼𜴽𜴾𜴿𜵀𜵁𜵂𜵃𜵄▖𜵅𜵆𜵇𜵈▌𜵉𜵊𜵋𜵌▞𜵍𜵎𜵏𜵐▛𜵑𜵒𜵓𜵔𜵕𜵖𜵗𜵘𜵙𜵚𜵛𜵜𜵝𜵞𜵟𜵠𜵡𜵢𜵣𜵤𜵥𜵦𜵧𜵨𜵩𜵪𜵫𜵬𜵭𜵮𜵯𜵰𜺠𜵱𜵲𜵳𜵴𜵵𜵶𜵷𜵸𜵹𜵺𜵻𜵼𜵽𜵾𜵿𜶀𜶁𜶂𜶃𜶄𜶅𜶆𜶇𜶈𜶉𜶊𜶋𜶌𜶍𜶎𜶏▗𜶐𜶑𜶒𜶓▚𜶔𜶕𜶖𜶗▐𜶘𜶙𜶚𜶛▜𜶜𜶝𜶞𜶟𜶠𜶡𜶢𜶣𜶤𜶥𜶦𜶧𜶨𜶩𜶪𜶫▂𜶬𜶭𜶮𜶯𜶰𜶱𜶲𜶳𜶴𜶵𜶶𜶷𜶸𜶹𜶺𜶻𜶼𜶽𜶾𜶿𜷀𜷁𜷂𜷃𜷄𜷅𜷆𜷇𜷈𜷉𜷊𜷋𜷌𜷍𜷎𜷏𜷐𜷑𜷒𜷓𜷔𜷕𜷖𜷗𜷘𜷙𜷚▄𜷛𜷜𜷝𜷞▙𜷟𜷠𜷡𜷢▟𜷣▆𜷤𜷥█"]
-export const OCTANT_TERMINALS = ["ghostty"]

package/src/cli/inspect.ts

@@ -1,41 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import path from "node:path"
-import { claudeConfigDirs } from "../config"
-import { paths } from "../config/constants"
-import type { Config } from "../config/types"
-import { HEALTH_PATH } from "../proxy/constants"
-import type { Health } from "../proxy/types"
-import { proxyUrl } from "./claude-settings"
-import { PROBE_TIMEOUT_MS, RECENT_REQUESTS } from "./constants"
-import type { RequestRecord } from "./types"
-
-export async function probe(port: number): Promise<Health | null> {
-  try {
-    const response = await fetch(`${proxyUrl(port)}${HEALTH_PATH}`, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) })
-    return response.ok ? await response.json() as Health : null
-  } catch {
-    return null
-  }
-}
-
-export function routedDirs(config: Config) {
-  return claudeConfigDirs(config).filter((dir) => {
-    try {
-      const settings = JSON.parse(readFileSync(path.join(dir, "settings.json"), "utf8"))
-      return settings.env?.ANTHROPIC_BASE_URL === proxyUrl(config.port)
-    } catch {
-      return false
-    }
-  })
-}
-
-export function recentRequests(limit = RECENT_REQUESTS): RequestRecord[] {
-  if (!existsSync(paths.requests)) return []
-  return readFileSync(paths.requests, "utf8").trim().split("\n").slice(-limit).flatMap((entry) => {
-    try {
-      return [JSON.parse(entry)]
-    } catch {
-      return []
-    }
-  })
-}

package/src/cli/launchd.ts

@@ -1,34 +0,0 @@
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs"
-import path from "node:path"
-import { LAUNCH_AGENT_PLIST as PLIST, LAUNCHD_LABEL } from "./constants"
-
-export const supported = process.platform === "darwin"
-
-export function isInstalled() {
-  return existsSync(PLIST)
-}
-
-export function installAgent(program: string[], logFile: string) {
-  mkdirSync(path.dirname(PLIST), { recursive: true })
-  const args = program.map((arg) => `<string>${arg}</string>`).join("")
-  writeFileSync(PLIST, `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0"><dict>
-  <key>Label</key><string>${LAUNCHD_LABEL}</string>
-  <key>ProgramArguments</key><array>${args}</array>
-  <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
-  <key>StandardOutPath</key><string>${logFile}</string>
-  <key>StandardErrorPath</key><string>${logFile}</string>
-</dict></plist>
-`)
-  Bun.spawnSync(["launchctl", "unload", PLIST])
-  Bun.spawnSync(["launchctl", "load", PLIST])
-}
-
-export function removeAgent() {
-  if (!existsSync(PLIST)) return false
-  Bun.spawnSync(["launchctl", "unload", PLIST])
-  unlinkSync(PLIST)
-  return true
-}

package/src/cli/logo/pixels.ts

@@ -1,34 +0,0 @@
-export const LOGO_KEYS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456"
-
-export const LOGO_PALETTE = ["#fefefd", "#fdfcf1", "#fef7db", "#fef7da", "#fdf7dc", "#fef7d9", "#fdf6d9", "#fef6d6", "#fdf6d7", "#fdf4d5", "#fdf6cf", "#fef4ae", "#fde9a5", "#feec97", "#fde186", "#fddb6b", "#fdd763", "#fdd661", "#fdd55d", "#fcd259", "#fdcd49", "#fdc524", "#f6f5de", "#f5e6b1", "#d7ecc9", "#e2d596", "#e5b93b", "#7ce5d0", "#68dbd4", "#74cdd0", "#52d1cc", "#33c4c9", "#2bc0c7", "#2abcc5", "#29bbc4", "#27bcc5", "#20bccc", "#27bac3", "#24b7bc", "#12b3d0", "#0baccd", "#0fa7b4", "#7f7870", "#0678a5", "#038abb", "#04527e", "#018cd0", "#016b95", "#014b85", "#01417b", "#023d73", "#013a71", "#033b6a", "#023768", "#013367", "#092945", "#002d56", "#071a2c", "#041223"]
-
-export const LOGO_PIXELS = [
-  "..............W4...........a",
-  ".............Xutt..........U",
-  ".........tt...kuut.......uu.",
-  "........tkr...1Yxt4tT....u..",
-  "...XXW..soq...X2Xtst0.......",
-  "..TqssW.xr6...0CJRXs4.......",
-  "..oCCCsW.srrr012S4R1s.1.....",
-  "..kCCPrsV.ttslRSRJCFEB0m....",
-  "...pCPPrqW4W43nJJJJJHCG0....",
-  "...koCPR0sppHEtEILIHHHGhTrq.",
-  "....oCOSSZSFFEFFIIIHHHhhkEp.",
-  "XXX..nyEVPByEEEGGIIIHHLbwLo.",
-  "YrrYYY04WMGFEEggdhIIHHH63Vx.",
-  ".rqnnnxKKLwFifg66hhHHGJ6ujTe",
-  ".ZrpoCNSLKkGfh3355fffB4ejmj.",
-  "..1qpCY1PMLFfg3553hhhh.ihgRw",
-  ".....ZZ2POJGdd653AdcgQQhfe..",
-  ".....ZZPZPJdxjj6vcddcAAffT..",
-  ".CC.YpCE2VhGkjmmfdcddghdT..A",
-  "....Xpp1ZVRVxhhfgddfffTT..Ab",
-  ".....1Z2pC02VxxkxxgnmzA....6",
-  ".......qrp2ewVPMxxmmavvv6..A",
-  "..UU...YXY..PPFkEkkvvaaavA..",
-  ".UUCU......XXPMCkkvalanxavvN",
-  ".UCyUNN..1Yu4PMP055nlalxBavN",
-  "..UU.NN.1uD2PwJ0MP33nlmyBuav",
-  "QyDy3y..uo2RRwFPPPP6nnBBavaa",
-  "DQQQDyy.tB2RVPPPSR4poBBaaB6N",
-]

package/src/cli/ui.ts

@@ -1,91 +0,0 @@
-import { homedir } from "node:os"
-import { TYPO_DISTANCE } from "./constants"
-
-const colorFor = (stream: NodeJS.WriteStream) => Boolean(stream.isTTY) && !process.env.NO_COLOR && process.env.TERM !== "dumb"
-export const useColor = colorFor(process.stdout)
-export const trueColor = /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? "")
-const useColorErr = colorFor(process.stderr)
-
-const paint = (open: number, close: number, enabled = useColor) => (text: string) => (enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text)
-
-export const c = {
-  bold: paint(1, 22),
-  dim: paint(2, 22),
-  italic: paint(3, 23),
-  cyan: paint(36, 39),
-  green: paint(32, 39),
-  yellow: paint(33, 39),
-  red: paint(31, 39),
-  magenta: paint(35, 39),
-}
-
-const errRed = paint(31, 39, useColorErr)
-const errDim = paint(2, 22, useColorErr)
-
-export function line(text = "") {
-  console.log(text)
-}
-
-export function ok(text: string) {
-  console.log(`${c.green("✓")} ${text}`)
-}
-
-export function note(text: string) {
-  console.log(`${c.dim("·")} ${text}`)
-}
-
-export function warn(text: string) {
-  console.log(`${c.yellow("!")} ${text}`)
-}
-
-export function fail(text: string, hint?: string): never {
-  console.error(`${errRed("✗")} ${text}`)
-  if (hint) console.error(`  ${errDim(hint)}`)
-  process.exit(1)
-}
-
-export function listFiles(files: string[]) {
-  for (const file of files) line(`    ${c.dim(tilde(file))}`)
-}
-
-export function rows(entries: Array<[string, string]>, indent = 2) {
-  const width = Math.max(...entries.map(([label]) => label.length))
-  for (const [label, value] of entries) console.log(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
-}
-
-export function tilde(file: string) {
-  const home = homedir()
-  return file.startsWith(home) ? `~${file.slice(home.length)}` : file
-}
-
-export function tokens(count: number) {
-  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(count >= 10_000_000 ? 0 : 1)}M`
-  if (count >= 1_000) return `${(count / 1_000).toFixed(count >= 10_000 ? 0 : 1)}k`
-  return String(count)
-}
-
-export function ago(iso: string) {
-  const seconds = Math.max(0, Math.round((Date.now() - Date.parse(iso)) / 1000))
-  if (seconds < 60) return "just now"
-  if (seconds < 3_600) return `${Math.round(seconds / 60)}m ago`
-  if (seconds < 86_400) return `${Math.round(seconds / 3_600)}h ago`
-  return `${Math.round(seconds / 86_400)}d ago`
-}
-
-export function closest(input: string, options: string[]) {
-  const distance = (a: string, b: string) => {
-    const row = Array.from({ length: b.length + 1 }, (_, i) => i)
-    for (let i = 1; i <= a.length; i += 1) {
-      let previous = row[0]
-      row[0] = i
-      for (let j = 1; j <= b.length; j += 1) {
-        const current = row[j]
-        row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1))
-        previous = current
-      }
-    }
-    return row[b.length]
-  }
-  const [best] = options.map((option) => [option, distance(input, option)] as const).sort((x, y) => x[1] - y[1])
-  return best && best[1] <= TYPO_DISTANCE ? best[0] : null
-}