@chroxify/eunoe 0.0.0-stage → 1.0.0

package/src/cli/commands/settings.ts

@@ -0,0 +1,100 @@
+import { loadConfig, overrides, parseTunable, saveConfig } from "../../config"
+import { DEFAULTS, TUNABLES } from "../../config/constants"
+import type { Tunable } from "../../config/types"
+import { TUNABLE_DESCRIPTIONS, TUNABLE_HINTS } from "../constants"
+import { input, interactive, select } from "../prompt"
+import { sessionArgs, shortId } from "../sessions"
+import type { Command } from "../types"
+import { c, fail, line, ok, rows } from "../ui"
+
+const RESET = "default"
+
+function listSettings() {
+  const config = loadConfig()
+  line()
+  const width = Math.max(...TUNABLES.map((name) => String(config[name]).length))
+  rows(TUNABLES.map((name) => {
+    const value = String(config[name])
+    const changed = config[name] !== DEFAULTS[name]
+    return [name, `${c.bold(value.padEnd(width))}  ${c.dim(TUNABLE_DESCRIPTIONS[name])}${changed ? c.dim(`  (default ${DEFAULTS[name]})`) : ""}`]
+  }))
+  const own = Object.entries(config.sessions).map(([id, settings]) => [id, overrides(settings)] as const).filter(([, values]) => Object.keys(values).length)
+  if (own.length) {
+    line()
+    for (const [id, values] of own) line(`  ${c.cyan(shortId(id))}  ${Object.entries(values).map(([name, value]) => `${name} ${c.bold(String(value))}`).join(c.dim("  ·  "))}`)
+  }
+  line()
+}
+
+function applySetting(name: Tunable, raw: string, ids: string[]) {
+  const config = loadConfig()
+  if (raw === RESET) {
+    if (!ids.length) fail(`\`${RESET}\` only applies with --session`, `eunoe settings set ${name} ${RESET} --session <id>`)
+    const sessions = { ...config.sessions }
+    for (const id of ids) {
+      if (!sessions[id]) continue
+      const { [name]: _, ...rest } = sessions[id]
+      sessions[id] = rest
+    }
+    saveConfig({ sessions })
+    ok(`${name} back to the default (${c.bold(String(config[name]))}) for ${ids.map(shortId).join(", ")}`)
+    return
+  }
+  const value = parseTunable(name, raw)
+  if (value === null) fail(`Not a valid ${name}: ${raw}`, `Expected ${TUNABLE_HINTS[name]}.`)
+  if (ids.length) {
+    saveConfig({ sessions: { ...config.sessions, ...Object.fromEntries(ids.map((id) => [id, { ...config.sessions[id], [name]: value }])) } })
+    ok(`${name} ${c.bold(String(value))} for ${ids.map(shortId).join(", ")}`)
+    if (config.scope === "sessions" && ids.some((id) => !config.sessions[id])) line(`  ${c.dim("eunoe only manages sessions you started it for: eunoe start --session <id>")}`)
+    return
+  }
+  saveConfig({ [name]: value })
+  ok(`${name} ${c.bold(String(value))}`)
+}
+
+async function pickSetting(ids: string[]) {
+  const config = loadConfig()
+  line()
+  const name = await select<Tunable>(ids.length ? `Setting for ${ids.map(shortId).join(", ")}` : "Setting", TUNABLES.map((value) => ({ value, hint: `${String(config[value]).padEnd(12)} ${TUNABLE_DESCRIPTIONS[value]}` })))
+  if (name === null) return
+  const current = ids.length === 1 ? config.sessions[ids[0]]?.[name] ?? config[name] : config[name]
+  const raw = await input(`${name}  ${c.dim(TUNABLE_HINTS[name])}`, `${current}  (current)`)
+  if (raw === null || raw === "") return
+  applySetting(name, raw, ids)
+}
+
+export const settings: Command = {
+  summary: "List or change settings, for every session or just one",
+  usage: "eunoe settings [list | set <key> <value>] [--session <id>]",
+  details: [
+    "Without arguments it opens a picker. Keys:",
+    ...TUNABLES.map((key) => `  ${key.padEnd(10)} ${TUNABLE_DESCRIPTIONS[key]} ${c.dim(`(${TUNABLE_HINTS[key]})`)}`),
+    "",
+    `With --session, the value applies to that session only; \`${RESET}\` removes its own value.`,
+    "Takes effect on the next request; no restart needed.",
+  ],
+  options: [["--session <id>", "Change it for just this session (repeatable; a unique prefix is enough)"]],
+  async run(args) {
+    const words = args.filter((arg, i) => !arg.startsWith("-") && args[i - 1] !== "--session")
+    const ids = sessionArgs(args)
+    const [verb, key, raw] = words
+    if (!verb) {
+      if (interactive) await pickSetting(ids)
+      else listSettings()
+      return
+    }
+    if (verb === "list") {
+      listSettings()
+      return
+    }
+    if (verb !== "set") fail(`Unknown subcommand: ${verb}`, "Use `eunoe settings list` or `eunoe settings set <key> <value>`.")
+    if (!key) {
+      if (interactive) await pickSetting(ids)
+      else fail("set needs a key and a value", "eunoe settings set <key> <value>")
+      return
+    }
+    if (!TUNABLES.includes(key as Tunable)) fail(`Unknown setting: ${key}`, `Choose ${TUNABLES.join(", ")}.`)
+    if (raw === undefined) fail(`${key} needs a value`, `eunoe settings set ${key} <${TUNABLE_HINTS[key as Tunable]}>`)
+    applySetting(key as Tunable, raw, ids)
+  },
+}

package/src/cli/commands/start.ts

@@ -0,0 +1,64 @@
+import { existsSync } from "node:fs"
+import path from "node:path"
+import { claudeConfigDirs, compactionOwner, loadConfig, saveConfig } from "../../config"
+import type { Config } from "../../config/types"
+import { flagValues } from "../args"
+import { editSettings, withEunoe } from "../claude-settings"
+import { MODE_DESCRIPTIONS } from "../constants"
+import { routedDirs } from "../inspect"
+import { startService } from "../service"
+import { isKnown, sessionArgs, shortId } from "../sessions"
+import type { Command } from "../types"
+import { c, fail, line, listFiles, note, ok, rows, tilde } from "../ui"
+
+function scoped(config: Config, ids: string[]): Partial<Config> {
+  if (!ids.length) return { scope: "all" }
+  const managingAll = config.scope === "all" && routedDirs(config).length > 0
+  const sessions = { ...config.sessions }
+  for (const id of ids) {
+    const { mode, ...rest } = sessions[id] ?? {}
+    sessions[id] = mode && mode !== "off" ? { mode, ...rest } : rest
+  }
+  return { scope: managingAll ? "all" : "sessions", sessions }
+}
+
+export const start: Command = {
+  summary: "Route Claude Code through eunoe",
+  usage: "eunoe start [--session <id>] [--config-dir <dir>]",
+  details: [
+    "Starts the background proxy if it isn't running (setting it up the first time)",
+    "and points Claude Code at it through ANTHROPIC_BASE_URL in settings.json.",
+    "New sessions pick it up; restart the ones already running.",
+    "",
+    "With --session, eunoe manages only the sessions you name and passes the rest",
+    "through untouched. Session ids are in Claude Code's /status, or `eunoe status`.",
+  ],
+  options: [
+    ["--session <id>", "Only manage this session (repeatable; a unique prefix is enough)"],
+    ["--config-dir <dir>", "Also manage this Claude config directory (repeatable, remembered)"],
+  ],
+  async 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 ids = sessionArgs(args)
+    saveConfig(scoped(loadConfig(), ids))
+    const config = loadConfig()
+
+    line()
+    await startService(config)
+    const touched = editSettings(claudeConfigDirs(config), (settings) => withEunoe(settings, config.port, compactionOwner(config)))
+    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])}`],
+      ["Sessions", config.scope === "all" ? "all" : `only ${Object.entries(config.sessions).filter(([, own]) => own.mode !== "off").map(([id]) => shortId(id)).join(", ")}`],
+    ])
+    line()
+    const unseen = ids.filter((id) => !isKnown(id))
+    if (unseen.length) note(`Not seen through eunoe yet: ${unseen.map(shortId).join(", ")}. It applies once that session's requests come through; one started before routing needs a restart.`)
+    else note(ids.length ? "Takes effect on the session's next request." : "New sessions go through eunoe. Restart any that are already running.")
+    line()
+  },
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,82 @@
+import path from "node:path"
+import { loadConfig, modeFor, overrides } from "../../config"
+import { paths, RERANK_OFF } from "../../config/constants"
+import { rerankKey } from "../../context/rerank"
+import { seenSessions } from "../../proxy/sessions"
+import { VERSION } from "../../version"
+import { proxyUrl } from "../claude-settings"
+import { MODE_DESCRIPTIONS, SESSIONS_SHOWN } from "../constants"
+import { probe, recentRequests, routedDirs } from "../inspect"
+import * as launchd from "../launchd"
+import { shortId } from "../sessions"
+import { perSession, savedShare, totals, withinWindow } from "../stats"
+import type { Command } from "../types"
+import { ago, c, line, percent, rows, table, tilde, tokens, warn } from "../ui"
+
+const dot = (on: boolean) => (on ? c.green("●") : c.red("○"))
+
+export const status: Command = {
+  summary: "Show what eunoe is doing and saving",
+  usage: "eunoe status",
+  async run() {
+    const config = loadConfig()
+    const health = await probe(config.port)
+    const routed = routedDirs(config)
+    const recent = recentRequests()
+    const today = withinWindow(recent)
+    const stats = perSession(recent)
+    const sum = totals(today)
+
+    line()
+    line(`  ${c.bold("eunoe")} ${c.dim(VERSION)}`)
+    line()
+
+    const recall = config.rerank === RERANK_OFF ? "bm25" : rerankKey() ? `bm25 ${c.dim("→")} ${config.rerank}` : `bm25  ${c.dim(`(${config.rerank} needs a key in ${tilde(paths.typesafeKey)} or TYPESAFE_API_KEY)`)}`
+    rows([
+      ["Proxy", health ? `${dot(true)} running on ${c.cyan(proxyUrl(config.port))}${launchd.isInstalled() ? c.dim("  launchd") : ""}` : `${dot(false)} not running ${c.dim("(eunoe start)")}`],
+      ["Claude Code", routed.length ? `${dot(true)} routed ${c.dim(routed.map((dir) => tilde(path.join(dir, "settings.json"))).join(", "))}` : `${c.dim("○")} not routed ${c.dim("(eunoe start)")}`],
+      ["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`],
+      ["Sessions", config.scope === "all" ? "all" : `only the ones you started it for ${c.dim("(eunoe start --session <id>)")}`],
+      ["Recall", recall],
+    ])
+
+    const sessions = seenSessions().slice(0, SESSIONS_SHOWN)
+    if (sessions.length) {
+      line()
+      line(`  ${c.dim("Sessions")}`)
+      table(sessions.map(([id, session]) => {
+        const active = modeFor(config, id)
+        const own = Object.entries(overrides(config.sessions[id])).map(([name, value]) => `${name} ${value}`).join(" · ")
+        const stat = stats.get(id)
+        const saved = stat ? savedShare(stat.context, stat.plain) : null
+        return [
+          c.cyan(shortId(id)),
+          active === "off" ? c.dim("off") : c.green(active),
+          session.cwd ? tilde(session.cwd) : c.dim("–"),
+          stat?.turns ? c.dim(`${stat.turns} turns`) : "",
+          stat && active !== "off" ? `${c.bold(tokens(stat.context))} ctx` : "",
+          saved !== null && active !== "off" ? (saved > 0 ? c.green(`−${percent(saved)}`) : c.dim("±0")) : "",
+          c.dim(ago(session.lastSeen)),
+          own ? c.dim(own) : "",
+        ]
+      }))
+    }
+
+    if (sum.requests) {
+      const hit = sum.cacheRead + sum.cacheWrite + sum.uncached
+      line()
+      line(`  ${c.dim("Last 24h")}`)
+      rows([
+        ["Requests", `${c.bold(String(sum.requests))}${sum.folds ? `  ${c.dim(`${sum.folds} fold${sum.folds === 1 ? "" : "s"}, last ${ago(sum.lastFold!)}`)}` : ""}`],
+        ["Cache", `${c.bold(tokens(sum.cacheRead))} read  ${c.dim("·")}  ${tokens(sum.cacheWrite)} written  ${c.dim("·")}  ${tokens(sum.uncached)} uncached${hit ? c.dim(`  (${percent(sum.cacheRead / hit)} hit)`) : ""}`],
+        ["Saved", sum.saved > 0 ? `${c.bold(c.green(tokens(sum.saved)))} input tokens not sent  ${c.dim(`(${percent(sum.saved / (sum.sent + sum.saved))} less than plain Claude Code)`)}` : c.dim("no data yet")],
+      ], 4)
+    }
+
+    if (health && health.mode !== config.mode) {
+      line()
+      warn(`The running proxy reports mode ${health.mode}; it switches on its next request.`)
+    }
+    line()
+  },
+}

package/src/cli/commands/stop.ts

@@ -0,0 +1,38 @@
+import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
+import { editSettings, withoutEunoe } from "../claude-settings"
+import { sessionArgs, shortId } from "../sessions"
+import type { Command } from "../types"
+import { line, listFiles, note, ok } from "../ui"
+
+export const stop: Command = {
+  summary: "Send new sessions straight to the API again",
+  usage: "eunoe stop [--session <id>]",
+  details: [
+    "Removes eunoe from Claude Code's settings and hands compaction back to it.",
+    "The proxy stays up for sessions that are already running through it, so they",
+    "keep working until you restart them. `eunoe start` turns it back on.",
+    "",
+    "With --session, only that session is passed through untouched from its next request.",
+  ],
+  options: [["--session <id>", "Stop managing just this session (repeatable; a unique prefix is enough)"]],
+  run(args) {
+    const config = loadConfig()
+    const ids = sessionArgs(args)
+    if (ids.length) {
+      const sessions = { ...config.sessions }
+      for (const id of ids) {
+        if (config.scope === "all") sessions[id] = { ...sessions[id], mode: "off" }
+        else delete sessions[id]
+      }
+      saveConfig({ sessions })
+      ok(`eunoe off for ${ids.map(shortId).join(", ")} from the next request`)
+      return
+    }
+    const touched = editSettings(claudeConfigDirs(config), (settings) => withoutEunoe(settings, config.port))
+    line()
+    ok("Claude Code no longer routed through eunoe")
+    listFiles(touched)
+    note("Sessions already running through eunoe keep using it until restarted.")
+    line()
+  },
+}

package/src/cli/commands/uninstall.ts

@@ -0,0 +1,27 @@
+import { claudeConfigDirs, loadConfig } from "../../config"
+import { editSettings, withoutEunoe } from "../claude-settings"
+import * as launchd from "../launchd"
+import type { Command } from "../types"
+import { c, line, listFiles, note, ok, warn } from "../ui"
+
+export const uninstall: Command = {
+  summary: "Stop eunoe and remove the background proxy",
+  usage: "eunoe uninstall",
+  details: [
+    "Everything `stop` does, then shuts the proxy down and removes its background service.",
+    "Sessions still running through eunoe lose their connection, so restart them first.",
+    "Your config and transcripts in ~/.eunoe are kept.",
+  ],
+  run() {
+    const config = loadConfig()
+    const touched = editSettings(claudeConfigDirs(config), (settings) => withoutEunoe(settings, config.port))
+    line()
+    ok("Claude Code no longer routed through eunoe")
+    listFiles(touched)
+    if (launchd.removeAgent()) ok("Background proxy stopped and removed")
+    else note("No background proxy was installed.")
+    warn(`Restart any Claude Code session that was still using eunoe.`)
+    line(`  ${c.dim("Data kept in")} ~/.eunoe`)
+    line()
+  },
+}

package/src/cli/constants.ts

@@ -0,0 +1,52 @@
+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/help.ts

@@ -0,0 +1,42 @@
+import { VERSION } from "../version"
+import { GLOBAL_OPTIONS, TAGLINE } from "./constants"
+import { withLogo } from "./logo"
+import type { Command } from "./types"
+import { c, line } from "./ui"
+
+export function printHelp(commands: Record<string, Command>) {
+  const width = Math.max(...Object.keys(commands).map((name) => name.length), ...GLOBAL_OPTIONS.map(([flag]) => flag.length))
+  line()
+  for (const row of withLogo([`${c.bold("eunoe")} ${c.dim(VERSION)}`, c.italic(TAGLINE)])) line(row)
+  line()
+  line(`  ${c.dim("Usage")}`)
+  line(`    eunoe ${c.cyan("<command>")} ${c.dim("[options]")}`)
+  line()
+  line(`  ${c.dim("Commands")}`)
+  for (const [name, command] of Object.entries(commands).filter(([, command]) => !command.hidden)) line(`    ${c.cyan(name.padEnd(width))}   ${command.summary}`)
+  line()
+  line(`  ${c.dim("Options")}`)
+  for (const [flag, description] of GLOBAL_OPTIONS) line(`    ${flag.padEnd(width)}   ${description}`)
+  line()
+  line(`  ${c.dim("Run")} eunoe ${c.cyan("<command>")} --help ${c.dim("for details.")} ${c.dim("`ee` works anywhere `eunoe` does.")}`)
+  line()
+}
+
+export function printCommandHelp(name: string, command: Command) {
+  line()
+  line(`  ${c.bold(`eunoe ${name}`)}  ${c.dim(command.summary)}`)
+  line()
+  line(`  ${c.dim("Usage")}`)
+  line(`    ${command.usage}`)
+  if (command.details) {
+    line()
+    for (const detail of command.details) line(`  ${detail}`)
+  }
+  if (command.options) {
+    line()
+    line(`  ${c.dim("Options")}`)
+    const width = Math.max(...command.options.map(([flag]) => flag.length))
+    for (const [flag, description] of command.options) line(`    ${c.cyan(flag.padEnd(width))}   ${description}`)
+  }
+  line()
+}

package/src/cli/inspect.ts

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,39 @@
+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/index.ts

@@ -0,0 +1,89 @@
+import { HALF_BLOCKS, OCTANT_TERMINALS, OCTANTS, TRANSPARENT_PIXEL } from "../constants"
+import { trueColor, useColor } from "../ui"
+import { LOGO_KEYS, LOGO_PALETTE, LOGO_PIXELS } from "./pixels"
+
+type Rgb = [number, number, number]
+type Pixel = Rgb | null
+
+const rgb = (hex: string): Rgb => [1, 3, 5].map((i) => Number.parseInt(hex.slice(i, i + 2), 16)) as Rgb
+
+const toCube = (value: number) => (value < 48 ? 0 : value < 115 ? 1 : Math.min(5, Math.round((value - 35) / 40)))
+
+const MISMATCH = 3 * 255 ** 2
+
+function sgr(color: Rgb, layer: "fg" | "bg") {
+  const base = layer === "fg" ? 38 : 48
+  if (trueColor) return `${base};2;${color.join(";")}`
+  const [r, g, b] = color.map(toCube)
+  return `${base};5;${16 + 36 * r + 6 * g + b}`
+}
+
+function pixel(key: string | undefined): Pixel {
+  if (!key || key === TRANSPARENT_PIXEL) return null
+  return rgb(LOGO_PALETTE[LOGO_KEYS.indexOf(key)])
+}
+
+function distance(a: Pixel, b: Pixel) {
+  if (!a || !b) return a === b ? 0 : MISMATCH
+  return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2
+}
+
+function split(block: Pixel[]): [Pixel, Pixel] {
+  const colors = block.filter((color, i) => block.findIndex((other) => distance(other, color) === 0) === i)
+  if (colors.length <= 2) return [colors[0] ?? null, colors[1] ?? null]
+  let best: [Pixel, Pixel] = [colors[0], colors[1]]
+  let bestError = Number.POSITIVE_INFINITY
+  for (let i = 0; i < colors.length; i += 1) {
+    for (let j = i + 1; j < colors.length; j += 1) {
+      const error = block.reduce((total, color) => total + Math.min(distance(color, colors[i]), distance(color, colors[j])), 0)
+      if (error < bestError) [best, bestError] = [[colors[i], colors[j]], error]
+    }
+  }
+  return best
+}
+
+function dominant(block: Pixel[]): Pixel {
+  const counts = block.map((color) => block.filter((other) => distance(other, color) === 0).length)
+  return block[counts.indexOf(Math.max(...counts))]
+}
+
+function cell(block: Pixel[], glyphs: string[]) {
+  let [fg, bg] = split(block)
+  if (!fg) [fg, bg] = [bg, fg]
+  if (!fg) return " "
+  const mask = block.reduce((bits, color, i) => (distance(color, fg) <= distance(color, bg) ? bits | (1 << i) : bits), 0)
+  const codes = bg ? `${sgr(fg, "fg")};${sgr(bg, "bg")}` : sgr(fg, "fg")
+  return `\x1b[${codes}m${glyphs[mask]}\x1b[0m`
+}
+
+function supportsOctants() {
+  const terminal = `${process.env.TERM_PROGRAM ?? ""} ${process.env.TERM ?? ""}`.toLowerCase()
+  return OCTANT_TERMINALS.some((name) => terminal.includes(name))
+}
+
+function region(x: number, y: number, width: number, height: number): Pixel[] {
+  const block: Pixel[] = []
+  for (let dy = 0; dy < height; dy += 1) for (let dx = 0; dx < width; dx += 1) block.push(pixel(LOGO_PIXELS[y + dy]?.[x + dx]))
+  return block
+}
+
+export function logoLines(): string[] {
+  if (!useColor) return []
+  const octants = supportsOctants()
+  const lines: string[] = []
+  for (let y = 0; y < LOGO_PIXELS.length; y += 4) {
+    let row = ""
+    for (let x = 0; x < LOGO_PIXELS[0].length; x += 2) {
+      row += octants
+        ? cell(region(x, y, 2, 4), OCTANTS)
+        : cell([dominant(region(x, y, 2, 2)), dominant(region(x, y + 2, 2, 2))], [...HALF_BLOCKS])
+    }
+    lines.push(row)
+  }
+  return lines
+}
+
+export function withLogo(text: string[]): string[] {
+  const logo = logoLines()
+  return [...logo.map((row) => `  ${row}`), ...(logo.length ? [""] : []), ...text.map((entry) => `  ${entry}`)]
+}

package/src/cli/logo/pixels.ts

@@ -0,0 +1,34 @@
+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/main.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env bun
+import { VERSION } from "../version"
+import { wantsHelp } from "./args"
+import { commands } from "./commands"
+import { printCommandHelp, printHelp } from "./help"
+import { closest, fail, line } from "./ui"
+
+const [name, ...args] = process.argv.slice(2)
+
+if (!name || name === "help" || name === "-h" || name === "--help") {
+  const topic = name === "help" ? args[0] : undefined
+  if (topic && commands[topic]) printCommandHelp(topic, commands[topic])
+  else printHelp(commands)
+} else if (name === "-v" || name === "--version" || name === "version") {
+  line(VERSION)
+} else if (!commands[name]) {
+  const suggestion = closest(name, Object.keys(commands))
+  fail(`Unknown command: ${name}`, suggestion ? `Did you mean \`eunoe ${suggestion}\`?` : "Run `eunoe --help` to see the commands.")
+} else if (wantsHelp(args)) {
+  printCommandHelp(name, commands[name])
+} else {
+  await commands[name].run(args)
+}