@chroxify/eunoe 1.0.0 → 1.2.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/constants.ts

@@ -1,52 +0,0 @@
-import { homedir } from "node:os"
-import path from "node:path"
-import type { Mode, Tunable } 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> = {
-  default: "Recent turns whole, older turns folded; evidence and recall on",
-  compact: "Claude Code as it is, only its compaction replaced",
-  off: "Passthrough; Claude Code compacts on its own",
-}
-
-export const TUNABLE_DESCRIPTIONS: Record<Tunable, string> = {
-  keep: "Turns kept whole at the end, in default mode",
-  budget: "Tokens of older detail that trigger a fold, in default mode",
-  compactAt: "Share of the context window that triggers the cut",
-  keepTurns: "Earlier turns kept after a cut",
-  search: "How transcripts are written for the agent to search",
-  rerank: "Typesafe model that reorders recall, or off",
-}
-
-export const TUNABLE_HINTS: Record<Tunable, string> = {
-  keep: "a whole number, 1 or more",
-  budget: "a token count, 1000 or more",
-  compactAt: "a number above 0, up to 1",
-  keepTurns: "a whole number or all",
-  search: "markdown, xml, jsonl or qmd",
-  rerank: "a model name such as jev-preview, or off",
-}
-
-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 = 5_000
-export const STATUS_WINDOW_MS = 24 * 3_600_000
-export const TYPO_DISTANCE = 2
-export const SHORT_ID_LENGTH = 8
-export const SESSIONS_SHOWN = 5
-
-export const TRANSPARENT_PIXEL = "."
-export const HALF_BLOCKS = " ▀▄█"
-export const OCTANTS = [..." 𜺨𜺫🮂𜴀▘𜴁𜴂𜴃𜴄▝𜴅𜴆𜴇𜴈▀𜴉𜴊𜴋𜴌🯦𜴍𜴎𜴏𜴐𜴑𜴒𜴓𜴔𜴕𜴖𜴗𜴘𜴙𜴚𜴛𜴜𜴝𜴞𜴟🯧𜴠𜴡𜴢𜴣𜴤𜴥𜴦𜴧𜴨𜴩𜴪𜴫𜴬𜴭𜴮𜴯𜴰𜴱𜴲𜴳𜴴𜴵🮅𜺣𜴶𜴷𜴸𜴹𜴺𜴻𜴼𜴽𜴾𜴿𜵀𜵁𜵂𜵃𜵄▖𜵅𜵆𜵇𜵈▌𜵉𜵊𜵋𜵌▞𜵍𜵎𜵏𜵐▛𜵑𜵒𜵓𜵔𜵕𜵖𜵗𜵘𜵙𜵚𜵛𜵜𜵝𜵞𜵟𜵠𜵡𜵢𜵣𜵤𜵥𜵦𜵧𜵨𜵩𜵪𜵫𜵬𜵭𜵮𜵯𜵰𜺠𜵱𜵲𜵳𜵴𜵵𜵶𜵷𜵸𜵹𜵺𜵻𜵼𜵽𜵾𜵿𜶀𜶁𜶂𜶃𜶄𜶅𜶆𜶇𜶈𜶉𜶊𜶋𜶌𜶍𜶎𜶏▗𜶐𜶑𜶒𜶓▚𜶔𜶕𜶖𜶗▐𜶘𜶙𜶚𜶛▜𜶜𜶝𜶞𜶟𜶠𜶡𜶢𜶣𜶤𜶥𜶦𜶧𜶨𜶩𜶪𜶫▂𜶬𜶭𜶮𜶯𜶰𜶱𜶲𜶳𜶴𜶵𜶶𜶷𜶸𜶹𜶺𜶻𜶼𜶽𜶾𜶿𜷀𜷁𜷂𜷃𜷄𜷅𜷆𜷇𜷈𜷉𜷊𜷋𜷌𜷍𜷎𜷏𜷐𜷑𜷒𜷓𜷔𜷕𜷖𜷗𜷘𜷙𜷚▄𜷛𜷜𜷝𜷞▙𜷟𜷠𜷡𜷢▟𜷣▆𜷤𜷥█"]
-export const OCTANT_TERMINALS = ["ghostty"]
-export const START_TIMEOUT_MS = 3_000
-export const START_POLL_MS = 150

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,39 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, 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("")
-  const 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>
-`
-  if (existsSync(PLIST) && readFileSync(PLIST, "utf8") === plist) {
-    Bun.spawnSync(["launchctl", "load", PLIST])
-    return
-  }
-  writeFileSync(PLIST, 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/prompt.ts

@@ -1,91 +0,0 @@
-import { c, useColor } from "./ui"
-
-export interface Choice<T extends string = string> {
-  value: T
-  label?: string
-  hint?: string
-}
-
-export const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY)
-
-function keys(onKey: (key: string) => boolean | void): Promise<void> {
-  return new Promise((resolve) => {
-    const stdin = process.stdin
-    stdin.setRawMode(true)
-    stdin.resume()
-    stdin.setEncoding("utf8")
-    const handler = (chunk: string) => {
-      if (onKey(chunk) === true) {
-        stdin.off("data", handler)
-        stdin.setRawMode(false)
-        stdin.pause()
-        resolve()
-      }
-    }
-    stdin.on("data", handler)
-  })
-}
-
-function render(title: string, choices: Choice[], index: number, width: number) {
-  const lines = [`  ${c.bold(title)}`, ""]
-  for (const [i, choice] of choices.entries()) {
-    const label = (choice.label ?? choice.value).padEnd(width)
-    const marker = i === index ? c.green("●") : c.dim("○")
-    lines.push(`  ${marker} ${i === index ? c.bold(label) : label}${choice.hint ? `  ${c.dim(choice.hint)}` : ""}`)
-  }
-  lines.push("", `  ${c.dim("↑↓ move · enter choose · esc cancel")}`)
-  return lines
-}
-
-export async function select<T extends string>(title: string, choices: Choice<T>[], current?: T): Promise<T | null> {
-  let index = Math.max(0, choices.findIndex((choice) => choice.value === current))
-  const width = Math.max(...choices.map((choice) => (choice.label ?? choice.value).length))
-  let drawn = 0
-  const draw = () => {
-    const lines = render(title, choices, index, width)
-    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
-    process.stdout.write(lines.join("\n") + "\n")
-    drawn = lines.length
-  }
-  let chosen: T | null = null
-  process.stdout.write(useColor ? "\x1b[?25l" : "")
-  draw()
-  await keys((key) => {
-    if (key === "\x1b[A" || key === "k") index = (index + choices.length - 1) % choices.length
-    else if (key === "\x1b[B" || key === "j") index = (index + 1) % choices.length
-    else if (key === "\r" || key === "\n") {
-      chosen = choices[index].value
-      return true
-    } else if (key === "\x1b" || key === "q" || key === "\x03") return true
-    draw()
-  })
-  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
-  process.stdout.write(useColor ? "\x1b[?25h" : "")
-  return chosen
-}
-
-export async function input(title: string, placeholder: string, initial = ""): Promise<string | null> {
-  let value = initial
-  let drawn = 0
-  const draw = () => {
-    const shown = value ? value : c.dim(placeholder)
-    const lines = [`  ${c.bold(title)}`, `  ${c.cyan("›")} ${shown}`, "", `  ${c.dim("enter save · esc cancel")}`]
-    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
-    process.stdout.write(lines.join("\n") + "\n")
-    drawn = lines.length
-  }
-  let result: string | null = null
-  draw()
-  await keys((key) => {
-    if (key === "\r" || key === "\n") {
-      result = value
-      return true
-    }
-    if (key === "\x1b" || key === "\x03") return true
-    if (key === "\x7f" || key === "\b") value = value.slice(0, -1)
-    else if (key >= " " && !key.startsWith("\x1b")) value += key
-    draw()
-  })
-  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
-  return result
-}

package/src/cli/service.ts

@@ -1,33 +0,0 @@
-import path from "node:path"
-import { paths } from "../config/constants"
-import type { Config } from "../config/types"
-import { proxyUrl } from "./claude-settings"
-import { START_POLL_MS, START_TIMEOUT_MS } from "./constants"
-import { probe } from "./inspect"
-import * as launchd from "./launchd"
-import { c, line, ok, warn } from "./ui"
-
-async function waitForProxy(port: number) {
-  const deadline = Date.now() + START_TIMEOUT_MS
-  while (Date.now() < deadline) {
-    if (await probe(port)) return true
-    await Bun.sleep(START_POLL_MS)
-  }
-  return false
-}
-
-export async function startService(config: Config) {
-  if (!launchd.supported) {
-    if (await probe(config.port)) return true
-    warn("No launchd here, so keep the proxy running yourself:")
-    line(`    ${c.cyan("eunoe serve")}`)
-    return false
-  }
-  launchd.installAgent([process.execPath, path.join(import.meta.dir, "main.ts"), "serve"], paths.proxyLog)
-  if (await waitForProxy(config.port)) {
-    ok(`Proxy running in the background on ${c.cyan(proxyUrl(config.port))}`)
-    return true
-  }
-  warn(`The proxy didn't answer on ${proxyUrl(config.port)} yet. Check ${paths.proxyLog}.`)
-  return false
-}