@chroxify/eunoe 0.1.0 → 1.1.0

package/src/cli/commands/settings.ts

@@ -0,0 +1,119 @@
+import { DEFAULTS, overrides, parseTunable, readConfig, saveConfig, TUNABLES, type Tunable } from "../../config"
+import type { Command } from "../command"
+import { sessionArgs, shortId } from "../sessions"
+import { input, interactive, select } from "../terminal/prompt"
+import { c, fail, line, ok, rows } from "../terminal/ui"
+
+const 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",
+  turnCap: "A kept turn larger than this many tokens is folded at once, live turn excepted; or off",
+  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",
+}
+
+const HINTS: Record<Tunable, string> = {
+  keep: "a whole number, 1 or more",
+  budget: "a token count, 1000 or more",
+  turnCap: "a token count, 1000 or more, or off",
+  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",
+}
+
+const RESET = "default"
+
+const forSessions = (ids: string[]) => ids.map(shortId).join(", ")
+
+function listSettings() {
+  const config = readConfig()
+  line()
+  const width = Math.max(...TUNABLES.map((name) => String(config[name]).length))
+  rows(
+    TUNABLES.map((name) => {
+      const changed = config[name] !== DEFAULTS[name]
+      return [name, `${c.bold(String(config[name]).padEnd(width))}  ${c.dim(DESCRIPTIONS[name])}${changed ? c.dim(`  (default ${DEFAULTS[name]})`) : ""}`]
+    }),
+  )
+  const own = Object.entries(config.sessions)
+    .map(([id, session]) => [id, overrides(session)] as const)
+    .filter(([, values]) => Object.keys(values).length > 0)
+  if (own.length > 0) {
+    line()
+    for (const [id, values] of own) {
+      const shown = Object.entries(values).map(([name, value]) => `${name} ${c.bold(String(value))}`)
+      line(`  ${c.cyan(shortId(id))}  ${shown.join(c.dim("  ·  "))}`)
+    }
+  }
+  line()
+}
+
+function resetSetting(name: Tunable, ids: string[]) {
+  const config = readConfig()
+  if (ids.length === 0) 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 ${forSessions(ids)}`)
+}
+
+function applySetting(name: Tunable, raw: string, ids: string[]) {
+  if (raw === RESET) return resetSetting(name, ids)
+  const config = readConfig()
+  const value = parseTunable(name, raw)
+  if (value === null) fail(`Not a valid ${name}: ${raw}`, `Expected ${HINTS[name]}.`)
+  if (ids.length === 0) {
+    saveConfig({ [name]: value })
+    ok(`${name} ${c.bold(String(value))}`)
+    return
+  }
+  saveConfig({ sessions: { ...config.sessions, ...Object.fromEntries(ids.map((id) => [id, { ...config.sessions[id], [name]: value }])) } })
+  ok(`${name} ${c.bold(String(value))} for ${forSessions(ids)}`)
+  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>")}`)
+}
+
+async function pickSetting(ids: string[]) {
+  const config = readConfig()
+  line()
+  const name = await select<Tunable>(
+    ids.length > 0 ? `Setting for ${forSessions(ids)}` : "Setting",
+    TUNABLES.map((value) => ({ value, hint: `${String(config[value]).padEnd(12)} ${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(HINTS[name])}`, `${current}  (current)`)
+  if (raw) 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)} ${DESCRIPTIONS[key]} ${c.dim(`(${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)"]],
+  run(args) {
+    const [verb, key, raw] = args.filter((arg, i) => !arg.startsWith("-") && args[i - 1] !== "--session")
+    const ids = sessionArgs(args)
+    if (verb === "list" || (!verb && !interactive)) return listSettings()
+    if (verb && verb !== "set") fail(`Unknown subcommand: ${verb}`, "Use `eunoe settings list` or `eunoe settings set <key> <value>`.")
+    if (!key) {
+      if (!interactive) fail("set needs a key and a value", "eunoe settings set <key> <value>")
+      return pickSetting(ids)
+    }
+    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} <${HINTS[key as Tunable]}>`)
+    applySetting(key as Tunable, raw, ids)
+  },
+}

package/src/cli/commands/start.ts

@@ -0,0 +1,73 @@
+import { existsSync } from "node:fs"
+import path from "node:path"
+import { type Config, claudeConfigDirs, compactionOwner, readConfig, saveConfig } from "../../config"
+import type { Command } from "../command"
+import { editSettings, withEunoe } from "../proxy/claude-settings"
+import { routedDirs } from "../proxy/inspect"
+import { startService } from "../proxy/service"
+import { clearWatch } from "../proxy/watch"
+import { isKnown, sessionArgs, shortId } from "../sessions"
+import { flagValues } from "../terminal/args"
+import { c, fail, line, listFiles, note, ok, rows, tilde } from "../terminal/ui"
+import { MODE_DESCRIPTIONS } from "./mode"
+
+function scoped(config: Config, ids: string[]): Partial<Config> {
+  if (ids.length === 0) 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 }
+}
+
+function managedSessions(config: Config): string {
+  if (config.scope === "all") return "all"
+  const ids = Object.entries(config.sessions)
+    .filter(([, own]) => own.mode !== "off")
+    .map(([id]) => shortId(id))
+  return `only ${ids.join(", ")}`
+}
+
+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 > 0) saveConfig({ claudeConfigDirs: [...new Set([...readConfig().claudeConfigDirs, ...added])] })
+    const ids = sessionArgs(args)
+    saveConfig(scoped(readConfig(), ids))
+    const config = readConfig()
+
+    line()
+    if (!(await startService(config))) fail("Claude Code was left alone because the proxy isn't up.", "Nothing is routed through a proxy that can't answer. Fix the proxy and run `eunoe start` again.")
+    clearWatch()
+    const touched = editSettings(claudeConfigDirs(config), (settings) => withEunoe(settings, config.port, compactionOwner(config)))
+    ok("Claude Code routed through eunoe")
+    listFiles(touched.length > 0 ? touched : routedDirs(config).map((dir) => path.join(dir, "settings.json")))
+    line()
+    rows([
+      ["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`],
+      ["Sessions", managedSessions(config)],
+    ])
+    line()
+    const unseen = ids.filter((id) => !isKnown(id))
+    if (unseen.length > 0) 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 > 0 ? "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

@@ -1,48 +1,125 @@
 import path from "node:path"
-import { loadConfig } from "../../config"
+import { type Config, modeFor, overrides, readConfig } from "../../config"
+import { paths } from "../../config/paths"
+import { rerankKey } from "../../context/recall/rerank"
+import type { Health } from "../../proxy/server"
+import { seenSessions } from "../../proxy/sessions"
 import { VERSION } from "../../version"
-import { proxyUrl } from "../claude-settings"
-import { MODE_DESCRIPTIONS } from "../constants"
-import { probe, recentRequests, routedDirs } from "../inspect"
-import * as launchd from "../launchd"
-import type { Command } from "../types"
-import { ago, c, line, rows, tilde, tokens, warn } from "../ui"
+import type { Command } from "../command"
+import { BLOCKING_LIMIT_ENV, proxyUrl, readSettings } from "../proxy/claude-settings"
+import { probe, RECENT_REQUESTS, type RequestRecord, recentRequests, routedDirs, runsStaleCode } from "../proxy/inspect"
+import * as launchd from "../proxy/launchd"
+import { PROXY_AGENT } from "../proxy/service"
+import { perSession, type SessionStats, savedShare, type Totals, totals, withinWindow } from "../proxy/stats"
+import { readWatch } from "../proxy/watch"
+import { shortId } from "../sessions"
+import { ago, c, line, percent, plural, rows, table, tilde, tokens, warn } from "../terminal/ui"
+import { MODE_DESCRIPTIONS } from "./mode"
+
+const dot = (on: boolean) => (on ? c.green("●") : c.red("○"))
+
+const settingsFiles = (dirs: string[]) => dirs.map((dir) => tilde(path.join(dir, "settings.json"))).join(", ")
+
+function summary(title: string, sum: Totals) {
+  const hit = sum.cacheRead + sum.cacheWrite + sum.uncached
+  const folds = sum.folds && sum.lastFold ? `  ${c.dim(`${plural(sum.folds, "fold")}, last ${ago(sum.lastFold)}`)}` : ""
+  const hitRate = hit ? c.dim(`  (${percent(sum.cacheRead / hit)} hit)`) : ""
+  const 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")
+  line()
+  line(`  ${title}`)
+  rows(
+    [
+      ["Requests", `${c.bold(String(sum.requests))}${folds}`],
+      ["Cache", `${c.bold(tokens(sum.cacheRead))} read  ${c.dim("·")}  ${tokens(sum.cacheWrite)} written  ${c.dim("·")}  ${tokens(sum.uncached)} uncached${hitRate}`],
+      ["Saved", saved],
+    ],
+    4,
+  )
+}
+
+function recallLine(config: Config, recent: RequestRecord[]) {
+  if (config.rerank === "off") return "bm25"
+  if (!rerankKey()) return `bm25  ${c.dim(`(${config.rerank} needs a key in ${tilde(paths.typesafeKey)} or TYPESAFE_API_KEY)`)}`
+  const last = recent.findLast((r) => r.reranked || r.rerankError)
+  if (last?.rerankError) return `bm25  ${c.yellow(`(${config.rerank} failing: ${last.rerankError.replace(/^[^:]+: /, "")}, last ${ago(last.ts)})`)}`
+  return `bm25 ${c.dim("→")} ${config.rerank}`
+}
+
+function sessionRow(config: Config, stats: Map<string, SessionStats>, [id, session]: ReturnType<typeof seenSessions>[number]) {
+  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 managed = active !== "off"
+  const saved = stat ? savedShare(stat.context, stat.plain) : null
+  return [
+    c.cyan(shortId(id)),
+    managed ? c.green(active) : c.dim("off"),
+    session.cwd ? tilde(session.cwd) : c.dim("–"),
+    stat?.turns ? c.dim(`${stat.turns} turns`) : "",
+    stat && managed ? `${c.bold(tokens(stat.context))} ctx${stat.fixed ? c.dim(` (${tokens(stat.fixed)} fixed)`) : ""}` : "",
+    saved !== null && managed ? (saved > 0 ? c.green(`−${percent(saved)}`) : c.dim("±0")) : "",
+    c.dim(ago(session.lastSeen)),
+    own ? c.dim(own) : "",
+  ]
+}
+
+function sessionsTable(config: Config, stats: Map<string, SessionStats>) {
+  const sessions = seenSessions().slice(0, 5)
+  if (sessions.length === 0) return
+  line()
+  line(`  ${c.dim("Sessions")}`)
+  table(sessions.map((entry) => sessionRow(config, stats, entry)))
+}
+
+function warnings(config: Config, health: Health | null, routed: string[], recent: RequestRecord[]) {
+  const notes: string[] = []
+  const watch = readWatch()
+  if (watch.paused.length > 0)
+    notes.push(`The proxy stopped answering ${watch.pausedAt ? ago(watch.pausedAt) : ""}, so Claude Code was sent straight to the API. Routing comes back by itself once the proxy does; ${c.bold("eunoe start")} forces it.`)
+  if (health && health.mode !== config.mode) notes.push(`The running proxy reports mode ${health.mode}; it switches on its next request.`)
+  if (health && runsStaleCode(health)) notes.push(`The proxy is running older code than what's installed. ${c.bold("eunoe start")} restarts it.`)
+  const unguarded = config.mode !== "off" ? routed.filter((dir) => readSettings(dir).env?.[BLOCKING_LIMIT_ENV] === undefined) : []
+  if (unguarded.length > 0) notes.push(`Claude Code can still refuse to send near a full window in ${settingsFiles(unguarded)}. ${c.bold("eunoe start")} fixes it.`)
+  const missed = recent.filter((r) => r.overflow || r.fit === "over")
+  const lastMissed = missed.at(-1)
+  if (lastMissed) notes.push(`${missed.length} request${missed.length === 1 ? "" : "s"} didn't fit the window on the first try, last ${ago(lastMissed.ts)}. Details in ${tilde(paths.requests)}.`)
+  for (const text of notes) {
+    line()
+    warn(text)
+  }
+}
 
 export const status: Command = {
-  summary: "Show what eunoe is doing",
+  summary: "Show what eunoe is doing and saving",
   usage: "eunoe status",
   async run() {
-    const config = loadConfig()
+    const config = readConfig()
     const health = await probe(config.port)
     const routed = routedDirs(config)
-    const recent = recentRequests()
+    const all = recentRequests(Number.POSITIVE_INFINITY)
+    const recent = all.slice(-RECENT_REQUESTS)
+    const sum = totals(withinWindow(recent))
+    const allTime = totals(all)
 
     line()
     line(`  ${c.bold("eunoe")} ${c.dim(VERSION)}`)
     line()
     rows([
-      ["Proxy", health ? `${c.green("●")} running on ${c.cyan(proxyUrl(config.port))}` : `${c.red("○")} not running`],
-      ["Claude Code", routed.length ? `${c.green("●")} routed through eunoe` : `${c.dim("○")} not routed ${c.dim("(eunoe install)")}`],
+      ["Proxy", health ? `${dot(true)} running on ${c.cyan(proxyUrl(config.port))}${launchd.isInstalled(PROXY_AGENT) ? c.dim("  launchd") : ""}` : `${dot(false)} not running ${c.dim("(eunoe start)")}`],
+      ["Claude Code", routed.length > 0 ? `${dot(true)} routed ${c.dim(settingsFiles(routed))}` : `${c.dim("○")} not routed ${c.dim("(eunoe start)")}`],
       ["Mode", `${c.bold(config.mode)}  ${c.dim(MODE_DESCRIPTIONS[config.mode])}`],
-      ["Search", `${config.search} transcripts`],
-      ["Background", launchd.isInstalled() ? "launchd agent" : c.dim("none")],
+      ["Sessions", config.scope === "all" ? "all" : `only the ones you started it for ${c.dim("(eunoe start --session <id>)")}`],
+      ["Recall", recallLine(config, recent)],
     ])
-    for (const dir of routed) line(`  ${" ".repeat(13)}${c.dim(tilde(path.join(dir, "settings.json")))}`)
-
-    if (recent.length) {
-      const sum = (key: string) => recent.reduce((total, entry) => total + (entry[key] ?? 0), 0)
-      const compactions = recent.filter((entry) => entry.compacted)
-      line()
-      line(`  ${c.dim(`Last ${recent.length} requests`)}`)
-      rows([
-        ["Cache", `${c.bold(tokens(sum("cacheRead")))} read  ·  ${tokens(sum("cacheWrite"))} written  ·  ${tokens(sum("uncached"))} uncached`],
-        ["Cuts", compactions.length ? `${compactions.length}, last ${ago(compactions.at(-1)!.ts)}` : c.dim("none yet")],
-      ])
-    }
-    if (health && health.mode !== config.mode) {
-      line()
-      warn(`The running proxy reports mode ${health.mode}; it switches on its next request.`)
-    }
+
+    sessionsTable(config, perSession(recent))
+
+    if (sum.requests) summary(c.dim("Last 24h"), sum)
+    if (allTime.requests > sum.requests) summary(`${c.dim("All time")}  ${c.dim(`since ${new Date(all[0].ts).toLocaleDateString()}`)}`, allTime)
+
+    warnings(config, health, routed, recent)
     line()
   },
 }

package/src/cli/commands/stop.ts

@@ -1,16 +1,40 @@
-import { loadConfig } from "../../config"
-import { routedDirs } from "../inspect"
-import * as launchd from "../launchd"
-import type { Command } from "../types"
-import { fail, note, ok } from "../ui"
+import { claudeConfigDirs, readConfig, saveConfig } from "../../config"
+import type { Command } from "../command"
+import { editSettings, withoutEunoe } from "../proxy/claude-settings"
+import { clearWatch } from "../proxy/watch"
+import { sessionArgs, shortId } from "../sessions"
+import { line, listFiles, note, ok } from "../terminal/ui"
 
 export const stop: Command = {
-  summary: "Stop the background proxy",
-  usage: "eunoe stop",
-  details: ["Sessions still pointed at the proxy will fail until restarted, so run `eunoe uninstall` first."],
-  run() {
-    if (routedDirs(loadConfig()).length) fail("Claude Code is still routed through eunoe", "Run `eunoe uninstall` first, then restart your sessions.")
-    if (launchd.removeAgent()) ok("Background proxy stopped")
-    else note("The proxy isn't running as a background service.")
+  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 = readConfig()
+    const ids = sessionArgs(args)
+    if (ids.length > 0) {
+      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))
+    clearWatch()
+    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

@@ -1,25 +1,25 @@
-import { claudeConfigDirs, loadConfig, saveConfig } from "../../config"
-import { editSettings, withoutEunoe } from "../claude-settings"
-import type { Command } from "../types"
-import { c, line, listFiles, note, ok } from "../ui"
+import { claudeConfigDirs, readConfig } from "../../config"
+import type { Command } from "../command"
+import { editSettings, withoutEunoe } from "../proxy/claude-settings"
+import { removeService } from "../proxy/service"
+import { clearWatch } from "../proxy/watch"
+import { c, line, listFiles, note, ok, warn } from "../terminal/ui"
 
 export const uninstall: Command = {
-  summary: "Send new sessions straight to the API again",
+  summary: "Stop eunoe and remove the background proxy",
   usage: "eunoe uninstall",
-  details: [
-    "Removes eunoe from Claude Code's settings and hands compaction back to it.",
-    "The proxy keeps running as a passthrough, so sessions already pointed at it",
-    "keep working. Run `eunoe stop` once they have been restarted.",
-  ],
+  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 config = readConfig()
     const touched = editSettings(claudeConfigDirs(config), (settings) => withoutEunoe(settings, config.port))
-    saveConfig({ mode: "off" })
+    clearWatch()
     line()
     ok("Claude Code no longer routed through eunoe")
     listFiles(touched)
-    note("The proxy stays up as a passthrough for sessions still using it.")
-    line(`  ${c.dim("Once they're restarted:")} ${c.cyan("eunoe stop")}`)
+    if (removeService()) 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/commands/watch.ts

@@ -0,0 +1,16 @@
+import { readConfig } from "../../config"
+import type { Command } from "../command"
+import { runWatch } from "../proxy/watch"
+import { line } from "../terminal/ui"
+
+export const watch: Command = {
+  summary: "Check the proxy once and unroute Claude Code while it is down",
+  usage: "eunoe watch",
+  details: ["`eunoe start` schedules this in the background. When the proxy stops answering, Claude Code goes straight to the API; when it is back, routing returns."],
+  hidden: true,
+  async run() {
+    const step = await runWatch(readConfig())
+    for (const dir of step.pause) line(`eunoe watch  proxy down, routing removed from ${dir}`)
+    for (const dir of step.resume) line(`eunoe watch  proxy back, routing restored in ${dir}`)
+  },
+}

package/src/cli/logo/art.ts

@@ -0,0 +1,99 @@
+export const HALF_BLOCKS = " ▀▄█"
+export const OCTANTS = [
+  ..." 𜺨𜺫🮂𜴀▘𜴁𜴂𜴃𜴄▝𜴅𜴆𜴇𜴈▀𜴉𜴊𜴋𜴌🯦𜴍𜴎𜴏𜴐𜴑𜴒𜴓𜴔𜴕𜴖𜴗𜴘𜴙𜴚𜴛𜴜𜴝𜴞𜴟🯧𜴠𜴡𜴢𜴣𜴤𜴥𜴦𜴧𜴨𜴩𜴪𜴫𜴬𜴭𜴮𜴯𜴰𜴱𜴲𜴳𜴴𜴵🮅𜺣𜴶𜴷𜴸𜴹𜴺𜴻𜴼𜴽𜴾𜴿𜵀𜵁𜵂𜵃𜵄▖𜵅𜵆𜵇𜵈▌𜵉𜵊𜵋𜵌▞𜵍𜵎𜵏𜵐▛𜵑𜵒𜵓𜵔𜵕𜵖𜵗𜵘𜵙𜵚𜵛𜵜𜵝𜵞𜵟𜵠𜵡𜵢𜵣𜵤𜵥𜵦𜵧𜵨𜵩𜵪𜵫𜵬𜵭𜵮𜵯𜵰𜺠𜵱𜵲𜵳𜵴𜵵𜵶𜵷𜵸𜵹𜵺𜵻𜵼𜵽𜵾𜵿𜶀𜶁𜶂𜶃𜶄𜶅𜶆𜶇𜶈𜶉𜶊𜶋𜶌𜶍𜶎𜶏▗𜶐𜶑𜶒𜶓▚𜶔𜶕𜶖𜶗▐𜶘𜶙𜶚𜶛▜𜶜𜶝𜶞𜶟𜶠𜶡𜶢𜶣𜶤𜶥𜶦𜶧𜶨𜶩𜶪𜶫▂𜶬𜶭𜶮𜶯𜶰𜶱𜶲𜶳𜶴𜶵𜶶𜶷𜶸𜶹𜶺𜶻𜶼𜶽𜶾𜶿𜷀𜷁𜷂𜷃𜷄𜷅𜷆𜷇𜷈𜷉𜷊𜷋𜷌𜷍𜷎𜷏𜷐𜷑𜷒𜷓𜷔𜷕𜷖𜷗𜷘𜷙𜷚▄𜷛𜷜𜷝𜷞▙𜷟𜷠𜷡𜷢▟𜷣▆𜷤𜷥█",
+]
+
+export const KEYS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456"
+
+export const 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 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/logo/index.ts

@@ -1,6 +1,5 @@
-import { HALF_BLOCKS, OCTANT_TERMINALS, OCTANTS, TRANSPARENT_PIXEL } from "../constants"
-import { trueColor, useColor } from "../ui"
-import { LOGO_KEYS, LOGO_PALETTE, LOGO_PIXELS } from "./pixels"
+import { trueColor, useColor } from "../terminal/ui"
+import { HALF_BLOCKS, KEYS, OCTANTS, PALETTE, PIXELS } from "./art"
 
 type Rgb = [number, number, number]
 type Pixel = Rgb | null
@@ -9,8 +8,6 @@ const rgb = (hex: string): Rgb => [1, 3, 5].map((i) => Number.parseInt(hex.slice
 
 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(";")}`
@@ -19,12 +16,12 @@ function sgr(color: Rgb, layer: "fg" | "bg") {
 }
 
 function pixel(key: string | undefined): Pixel {
-  if (!key || key === TRANSPARENT_PIXEL) return null
-  return rgb(LOGO_PALETTE[LOGO_KEYS.indexOf(key)])
+  if (!key || key === ".") return null
+  return rgb(PALETTE[KEYS.indexOf(key)])
 }
 
 function distance(a: Pixel, b: Pixel) {
-  if (!a || !b) return a === b ? 0 : MISMATCH
+  if (!a || !b) return a === b ? 0 : 3 * 255 ** 2
   return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2
 }
 
@@ -57,26 +54,23 @@ function cell(block: Pixel[], glyphs: string[]) {
 }
 
 function supportsOctants() {
-  const terminal = `${process.env.TERM_PROGRAM ?? ""} ${process.env.TERM ?? ""}`.toLowerCase()
-  return OCTANT_TERMINALS.some((name) => terminal.includes(name))
+  return `${process.env.TERM_PROGRAM ?? ""} ${process.env.TERM ?? ""}`.toLowerCase().includes("ghostty")
 }
 
 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]))
+  for (let dy = 0; dy < height; dy += 1) for (let dx = 0; dx < width; dx += 1) block.push(pixel(PIXELS[y + dy]?.[x + dx]))
   return block
 }
 
-export function logoLines(): string[] {
+function logoLines(): string[] {
   if (!useColor) return []
   const octants = supportsOctants()
   const lines: string[] = []
-  for (let y = 0; y < LOGO_PIXELS.length; y += 4) {
+  for (let y = 0; y < 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])
+    for (let x = 0; x < 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)
   }
@@ -85,5 +79,5 @@ export function logoLines(): string[] {
 
 export function withLogo(text: string[]): string[] {
   const logo = logoLines()
-  return [...logo.map((row) => `  ${row}`), ...(logo.length ? [""] : []), ...text.map((entry) => `  ${entry}`)]
+  return [...logo.map((row) => `  ${row}`), ...(logo.length > 0 ? [""] : []), ...text.map((entry) => `  ${entry}`)]
 }

package/src/cli/main.ts

@@ -1,9 +1,9 @@
 #!/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"
+import { wantsHelp } from "./terminal/args"
+import { printCommandHelp, printHelp } from "./terminal/help"
+import { closest, fail, line } from "./terminal/ui"
 
 const [name, ...args] = process.argv.slice(2)