kronk-cli 0.4.0 → 0.5.1

package/README.md

@@ -626,6 +626,46 @@ yellow past 70%, red past 90%. Toggling `/auto`, `/think` or `/steps` updates it
 
 The per-turn usage line still prints after each response; this one is the running picture.
 
+### It follows your terminal's background
+
+That grey is the one colour the whole line depends on, and the sixteen-colour palette has exactly
+one of them — bright black, which most terminals render around `#555`. On a light background it
+reads; on a dark one the status line was the hardest thing on screen to see.
+
+So the palette is chosen per background, from the 256-colour cube: a lighter grey on a dark
+terminal, a darker one on a light terminal, and every other colour shifted the same way. Which
+background you have is settled once, at startup, in this order:
+
+1. `KRONK_THEME`, or `"theme"` in `~/.kronk-cli.json` — `dark` or `light` pins it
+2. `COLORFGBG`, when the terminal exports it
+3. the terminal's own answer to an `OSC 11` background query, waited on for 100 ms
+4. failing all of that, dark — what most terminals ship as
+
+`/theme dark` or `/theme light` switches it mid-session, for when step 3 guessed wrong. `NO_COLOR`
+still turns every escape off, and a terminal that advertises no 256-colour support gets a
+sixteen-colour palette picked the same way.
+
+---
+
+## Markdown in answers
+
+The models write markdown whether or not anything renders it, so an answer used to arrive with the
+punctuation still in your way — `### The letter is a notification`, `**binding**`, backticks around
+every identifier. Those constructs are rendered into the attributes the terminal already has:
+headings lose their hashes and gain bold, emphasis becomes bold or italic, code spans and fenced
+blocks get their own colour and a gutter, lists get a `•`, quotes a `│`, and `---` a rule.
+
+It is a line renderer, not a markdown parser — one bit of state, whether a fenced block is open —
+and anything it does not recognise is left exactly as written. Prose that only looks like markup
+survives: `snake_case`, `3 * 4`, a lone asterisk, `**kwargs` inside backticks.
+
+Two consequences worth knowing:
+
+- **Output appears a line at a time**, not a token at a time, because `**` is bold or two
+  asterisks depending on what follows it. At local speeds that is still a line every half second.
+- **With colour off the bytes are the model's own.** Piped, redirected, or `NO_COLOR` — nothing is
+  rewritten, so anything parsing kronk-cli's output sees exactly what it saw before.
+
 ---
 
 ## REPL commands
@@ -643,6 +683,7 @@ The per-turn usage line still prints after each response; this one is the runnin
 | `/agents` | the sub-agents `task` can delegate to, and what each may touch |
 | `/mcp` | list attached MCP servers and their tools |
 | `/context` | how much of the context window is used |
+| `/theme [dark\|light]` | show or pin the palette, for when the terminal was read wrong |
 | `/compact` | replace the conversation with a summary of itself |
 | `/clear` | reset the conversation, keep the model |
 | `/exit`, `/quit` | quit |
@@ -676,7 +717,9 @@ The per-turn usage line still prints after each response; this one is the runnin
 | `KRONK_WARM` | `true` | `false` skips the boot-time model preload |
 | `KRONK_AUTO_COMPACT` | `true` | `false` disables automatic compaction |
 | `KRONK_COMPACT_AT` | `0.85` | Fraction of the window that triggers compaction |
+| `KRONK_THEME` | `auto` | `dark` or `light` pins the palette; `auto` reads the terminal's background |
 | `NO_COLOR` | — | Any value disables colour |
+| `FORCE_COLOR` | — | `0` disables colour; any other value keeps it on through a pipe |
 
 ### Config file
 
@@ -690,6 +733,7 @@ The per-turn usage line still prints after each response; this one is the runnin
   "maxTokens": 16384,
   "maxSteps": 200,
   "showThinking": false,
+  "theme": "auto",
   "autoCompact": true,
   "compactAt": 0.85,
   "noThink": true,
@@ -1390,6 +1434,9 @@ previous prompt prefix — watch `cached` climb in the usage line.
 | `src/distill.js` | summarizing large tool output in a throwaway context |
 | `src/config.js` | precedence of flags, env, config file |
 | `src/ui.js` | colour, spinner, usage formatting |
+| `src/theme.js` | which palette to print in, and how the background is worked out |
+| `src/markdown.js` | rendering the model's markdown for the terminal, as it streams |
+| `src/prompt.js` | the line reader: opened on the first question, keeping what was typed before it |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kronk-cli",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "A Claude-Code-style terminal agent for local models served by Kronk.",
   "license": "Apache-2.0",
   "type": "module",

package/src/agent.js

@@ -6,6 +6,7 @@ import {
 import { config, shouldPreserveThinking } from './config.js';
 import { forRequest } from './reasoning.js';
 import { c, fmtUsage, spinner, liveLine, toolResultLines } from './ui.js';
+import { markdownStream } from './markdown.js';
 import { compact, isOverflow, report } from './compact.js';
 import { maybeDistill } from './distill.js';
 import {
@@ -125,6 +126,9 @@ export async function runTurn({
     let calls = [];
     let wroteAnything = false;
     let inReasoning = false;
+    // One renderer per step: a fence left open by one answer must not colour
+    // the next one as code.
+    const md = markdownStream();
 
     try {
       for await (const ev of streamChat({
@@ -158,7 +162,10 @@ export async function runTurn({
           if (!stream) continue;
           if (sp) { sp.stop(); sp = null; }
           if (inReasoning) { process.stdout.write(c.grey('\n  ┄─────────┄\n\n')); inReasoning = false; }
-          process.stdout.write(ev.value);
+          // Rendered a line at a time — see src/markdown.js. `text` keeps the
+          // model's own copy: what goes back in the conversation is never the
+          // screen's version of it.
+          process.stdout.write(md.write(ev.value));
           wroteAnything = true;
         }
 
@@ -191,6 +198,9 @@ export async function runTurn({
     }
 
     if (inReasoning) process.stdout.write(c.grey('\n  ┄─────────┄\n'));
+    // The last line has no newline to trigger it: an answer that ends mid-line
+    // would otherwise be held in the renderer and never printed.
+    if (stream) process.stdout.write(md.flush());
     if (wroteAnything) process.stdout.write('\n');
     if (totalUsage) {
       out(fmtUsage(totalUsage, window));

package/src/config.js

@@ -61,6 +61,10 @@ export const config = {
   // Kronk admits a model on its first inference request, not at server start.
   // Pay that cold load at boot rather than on the first typed prompt.
   warm: (process.env.KRONK_WARM ?? String(file.warm ?? 'true')) !== 'false',
+  // 'auto' asks the terminal what colour its background is; 'dark' or 'light'
+  // pins the palette when it answers wrong or cannot answer at all. See
+  // src/theme.js — the value is only ever read there.
+  theme: process.env.KRONK_THEME ?? file.theme ?? 'auto',
   autoCompact: (process.env.KRONK_AUTO_COMPACT ?? String(file.autoCompact ?? 'true')) !== 'false',
   compactAt: Number(process.env.KRONK_COMPACT_AT ?? file.compactAt ?? 0.85),
   // Large tool output is summarized in a throwaway context so the raw text

package/src/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import readline from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
 import { homedir } from 'node:os';
 import { readFile } from 'node:fs/promises';
@@ -8,12 +7,14 @@ import { listModels, listModelDetails, listLoaded, modelLimits, tokenize } from
 import { pickDefault, ensureLoaded } from './boot.js';
 import { runTurn, SYSTEM, SYSTEM_AUTO } from './agent.js';
 import { c, banner, fmtContext, statusLine } from './ui.js';
+import { resolveTheme, theme, useTheme } from './theme.js';
 import { projectContext } from './context.js';
 import { forRequest } from './reasoning.js';
 import { compact, report } from './compact.js';
 import { loadServers, McpHub, reportFailures } from './mcp.js';
 import { resolveSandbox, sandbox } from './tools.js';
 import { parseArgv } from './argv.js';
+import { deferredPrompt } from './prompt.js';
 import { AGENTS } from './subagent.js';
 import { runSetup } from './setup.js';
 
@@ -68,6 +69,8 @@ if (args.help) {
     KRONK_PRESERVE_THINKING
                         false to stop pinning earlier think blocks in the
                         prompt (smaller prompts, cache lost on every turn)
+    KRONK_THEME         dark or light to pin the palette; default auto, which
+                        asks the terminal for its background colour
     KRONK_WARM          false to skip the boot-time model preload
     KRONK_AUTO_COMPACT  false to disable automatic compaction
     KRONK_COMPACT_AT    fraction of the window that triggers it (default 0.85)
@@ -289,6 +292,7 @@ const HELP = `
   ${c.bold('/agents')}          sub-agents you can delegate to with the task tool
   ${c.bold('/mcp')}             list attached MCP servers and their tools
   ${c.bold('/context')}         how much of the context window is used
+  ${c.bold('/theme [d|l]')}     dark or light palette, for when the terminal guessed wrong
   ${c.bold('/compact')}         replace the conversation with a summary of itself
   ${c.bold('/clear')}           reset the conversation
   ${c.bold('/exit')}            quit
@@ -425,7 +429,26 @@ async function main() {
     return;
   }
 
-  const rl = readline.createInterface({ input: stdin, output: stdout, historySize: 500 });
+  // Before readline takes stdin, because settling the palette may mean asking
+  // the terminal for its background colour and reading the reply in raw mode.
+  await resolveTheme({ prefer: config.theme, input: stdin, output: stdout });
+
+  // Not created yet: the interface is opened by the first question, below.
+  // Everything between here and there — the model load, the project scan, the
+  // MCP connections — is time somebody may spend typing, and readline emits
+  // lines whether or not anything is listening. See src/prompt.js.
+  let ac = null;
+  const rl = deferredPrompt({
+    input: stdin,
+    output: stdout,
+    historySize: 500,
+    // Ctrl-C aborts the in-flight request instead of killing the process.
+    onSigint: () => {
+      if (ac) { ac.abort(); ac = null; console.log(c.yellow('\n  interrupted')); }
+      else { console.log(); rl.close(); }
+    },
+  });
+
   await boot();
   const { content, ctx } = await systemMessage(AUTO);
   console.log(banner(config.model, config.baseUrl));
@@ -463,13 +486,6 @@ async function main() {
   // it — so both the status line and the turn read the answer from there.
   const isAuto = () => messages[0].content.startsWith(SYSTEM_AUTO);
 
-  // Ctrl-C aborts the in-flight request instead of killing the process.
-  let ac = null;
-  rl.on('SIGINT', () => {
-    if (ac) { ac.abort(); ac = null; console.log(c.yellow('\n  interrupted')); }
-    else { console.log(); rl.close(); }
-  });
-
   let autoApprove = AUTO_YES;
   const approve = async (name) => {
     if (autoApprove) return true;
@@ -561,6 +577,16 @@ async function main() {
         + `cap ${config.subagentSteps} steps per task\n`));
       continue;
     }
+    if (input === '/theme' || input.startsWith('/theme ')) {
+      // Everything prints through src/ui.js, which reads the palette per call,
+      // so the next line drawn is already in the new one — nothing to redraw.
+      const want = input.slice(6).trim().toLowerCase();
+      const name = { d: 'dark', dark: 'dark', l: 'light', light: 'light' }[want];
+      if (want && !name) { console.log(c.yellow('  /theme dark | /theme light')); continue; }
+      if (name) useTheme({ name });
+      console.log(c.grey(`  ${theme()} palette`));
+      continue;
+    }
     if (input === '/models') { await showModels(); continue; }
     if (input === '/mcp') {
       if (!mcp || !mcp.routes.size) { console.log(c.grey('  no MCP servers attached — start with --mcp')); continue; }

package/src/markdown.js

@@ -0,0 +1,136 @@
+/**
+ * Markdown, rendered for the terminal as it streams.
+ *
+ * The models write markdown whether or not anything is going to render it, so
+ * an answer arrived as `### The letter is a notification` and `**binding**`
+ * with the punctuation left in the reader's way. This turns the handful of
+ * constructs that actually show up in an answer — headings, emphasis, code,
+ * lists, quotes, rules, links — into the attributes a terminal already has.
+ *
+ * Deliberately not a markdown parser. It is a line renderer with one bit of
+ * state, whether a fenced code block is open, which is all that spans lines in
+ * the subset above. Anything it does not recognise is left exactly as written,
+ * which is the only safe answer for text that was never markdown to begin with.
+ *
+ * Line-buffered, because inline emphasis cannot be decided until the line is
+ * whole: `**` is bold or two asterisks depending on what comes next. Output
+ * therefore appears a line at a time rather than a token at a time. With colour
+ * off — piped, redirected, NO_COLOR — nothing is rewritten at all and the bytes
+ * are the model's own.
+ */
+import { c } from './ui.js';
+import { colorsOn } from './theme.js';
+
+const FENCE = /^\s*(?:```|~~~)\s*([\w+-]*)\s*$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const BULLET = /^(\s*)[-*+]\s+(.*)$/;
+const ORDERED = /^(\s*)(\d{1,9})([.)])\s+(.*)$/;
+const QUOTE = /^\s*>\s?(.*)$/;
+const RULE = /^\s*([-*_])(?:\s*\1){2,}\s*$/;
+
+/** How wide a `---` is drawn. Narrow enough to sit inside any terminal. */
+const RULE_WIDTH = 40;
+
+/**
+ * Inline spans, in one pass over the parts that are not code.
+ *
+ * Code first and separately: whatever is between backticks is content, not
+ * markup, and running the emphasis rules over it would eat the asterisks in a
+ * `**kwargs` or a glob.
+ */
+export function renderInline(text) {
+  return text
+    .split(/(`[^`]+`)/)
+    .map((part, i) => {
+      if (i % 2) return c.cyan(part.slice(1, -1));
+      return part
+        // Links before emphasis: the label can contain either.
+        .replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, (_, label, url) => `${c.blue(label)} ${c.grey(url)}`)
+        .replace(/\*\*([^\s*][^*]*?)\*\*/g, (_, s) => c.bold(s))
+        .replace(/__([^\s_][^_]*?)__/g, (_, s) => c.bold(s))
+        .replace(/~~([^\s~][^~]*?)~~/g, (_, s) => c.strike(s))
+        // Emphasis last, and only where the marker is not part of a word:
+        // snake_case identifiers and 3 * 4 must survive unchanged.
+        .replace(/(^|[\s(])\*([^\s*][^*]*?)\*(?=$|[\s).,;:!?])/g, (_, pre, s) => `${pre}${c.italic(s)}`)
+        .replace(/(^|[\s(])_([^\s_][^_]*?)_(?=$|[\s).,;:!?])/g, (_, pre, s) => `${pre}${c.italic(s)}`);
+    })
+    .join('');
+}
+
+/**
+ * One line, given the state carried from the lines before it. Mutates `state`,
+ * which is what a fenced block needs and the only reason state exists.
+ */
+export function renderLine(line, state) {
+  const fence = FENCE.exec(line);
+  if (fence) {
+    if (state.fence) { state.fence = null; return c.grey('  ╰────'); }
+    state.fence = fence[1] || 'code';
+    return c.grey(`  ╭─ ${state.fence}`);
+  }
+  // Inside a fence every character is the code's own — no emphasis, no
+  // reflowing, just a gutter to show where the block runs.
+  if (state.fence) return `${c.grey('  │ ')}${line}`;
+
+  if (RULE.test(line)) return c.grey('─'.repeat(RULE_WIDTH));
+
+  const heading = HEADING.exec(line);
+  if (heading) {
+    const [, hashes, body] = heading;
+    const text = c.bold(renderInline(body));
+    return hashes.length <= 2 ? c.cyan(text) : text;
+  }
+
+  const quote = QUOTE.exec(line);
+  if (quote) return `${c.grey('│ ')}${c.grey(renderInline(quote[1]))}`;
+
+  const bullet = BULLET.exec(line);
+  if (bullet) return `${bullet[1]}${c.grey('•')} ${renderInline(bullet[2])}`;
+
+  const ordered = ORDERED.exec(line);
+  if (ordered) {
+    const [, indent, n, , rest] = ordered;
+    return `${indent}${c.grey(`${n}.`)} ${renderInline(rest)}`;
+  }
+
+  return renderInline(line);
+}
+
+/**
+ * A renderer for streamed text: feed it deltas, write what comes back, and
+ * call `flush` when the stream ends to get the last partial line.
+ *
+ * `enabled` defaults to whether colour is on at all, so the piped and
+ * NO_COLOR paths hand back exactly what the model wrote.
+ */
+export function markdownStream({ enabled = colorsOn() } = {}) {
+  const state = { fence: null };
+  let held = '';
+  return {
+    write(chunk) {
+      if (!enabled) return chunk;
+      held += chunk;
+      let out = '';
+      let at;
+      while ((at = held.indexOf('\n')) !== -1) {
+        out += `${renderLine(held.slice(0, at), state)}\n`;
+        held = held.slice(at + 1);
+      }
+      return out;
+    },
+    flush() {
+      if (!enabled || !held) { const rest = enabled ? '' : held; held = ''; return rest; }
+      const out = renderLine(held, state);
+      held = '';
+      return out;
+    },
+    /** Whether a fenced block is still open — the tail of a truncated answer. */
+    get inCode() { return state.fence !== null; },
+  };
+}
+
+/** The whole thing at once. The streaming path is the one the REPL uses. */
+export function renderMarkdown(text, options) {
+  const md = markdownStream(options);
+  return md.write(text) + md.flush();
+}

package/src/prompt.js

@@ -0,0 +1,79 @@
+/**
+ * The line reader: opened only when something is waiting on a line, and never
+ * dropping one that arrives before then.
+ *
+ * `readline` starts consuming stdin the moment it is created and emits every
+ * line it parses, listener or no listener. Startup is not instant — the model
+ * list, a cold load that can run to tens of seconds, the project scan, the MCP
+ * connections — so creating the interface up front meant every line typed in
+ * that window was emitted into nothing: no echo left, no error, and a prompt
+ * that arrived as though you had typed nothing at all.
+ *
+ * Two things fix that, and both are needed. Creation is deferred to the first
+ * question, which leaves those keystrokes in the terminal's own input buffer
+ * until there is something to read them. And once the interface exists, lines
+ * are queued rather than answered directly by `rl.question`, because a paste
+ * or a fast typist can hand readline several lines in one read and only the
+ * first would have had a listener waiting for it.
+ *
+ * One interface is created and kept, so history, line editing and Ctrl-C are
+ * readline's own, exactly as before.
+ */
+import readline from 'node:readline';
+
+/** What a pending question rejects with when the reader closes under it. */
+export class PromptClosed extends Error {
+  constructor() { super('the prompt was closed'); this.name = 'PromptClosed'; }
+}
+
+export function deferredPrompt({ input, output, historySize = 500, onSigint } = {}) {
+  let rl = null;
+  let closed = false;
+  let waiting = null;              // the question currently unanswered, if any
+  const queued = [];               // lines that arrived with nobody asking
+
+  const open = () => {
+    if (rl) return rl;
+    rl = readline.createInterface({ input, output, historySize });
+    rl.on('line', (line) => {
+      if (waiting) { const w = waiting; waiting = null; w.resolve(line); }
+      else queued.push(line);
+    });
+    rl.on('close', () => {
+      closed = true;
+      if (waiting) { const w = waiting; waiting = null; w.reject(new PromptClosed()); }
+    });
+    // Registered with the interface rather than by the caller, so there is no
+    // moment in which the interface exists and Ctrl-C is unhandled.
+    if (onSigint) rl.on('SIGINT', () => onSigint());
+    return rl;
+  };
+
+  return {
+    /**
+     * Ask, opening the interface if this is the first time. A line that was
+     * typed ahead answers immediately — echoed after the prompt, so the
+     * transcript reads the way it would have if the timing had been kinder.
+     */
+    question(query) {
+      if (closed) return Promise.reject(new PromptClosed());
+      const reader = open();
+      if (queued.length) {
+        const line = queued.shift();
+        output.write(`${query}${line}\n`);
+        return Promise.resolve(line);
+      }
+      // setPrompt rather than a bare write: readline needs to know the prompt
+      // to redraw the line correctly when it is edited.
+      reader.setPrompt(query);
+      reader.prompt();
+      return new Promise((resolve, reject) => { waiting = { resolve, reject }; });
+    },
+    /** Closing one that was never opened is not an error, it is a no-op. */
+    close() { closed = true; rl?.close(); },
+    /** For tests, and for anything that wants to know without opening one. */
+    get open() { return rl !== null; },
+    /** Lines typed ahead that no question has taken yet. */
+    get pending() { return queued.length; },
+  };
+}

package/src/theme.js

@@ -0,0 +1,226 @@
+/**
+ * What colour to print in, given the terminal we were launched from.
+ *
+ * The status line, the context meter and every hint under it were bright black
+ * (SGR 90). On a light background that is a readable grey; on a dark one most
+ * terminals render it around #555, which is a few points of contrast away from
+ * the background it sits on — the line the REPL shows before every prompt was
+ * the hardest thing on screen to read. Bright black is the only grey the
+ * sixteen-colour palette has, so the fix is not a different code but a
+ * different palette per background, chosen from the 256-colour cube.
+ *
+ * Three ways to learn the background, in order of how much we trust them:
+ * what the user said (`KRONK_THEME`, `theme` in ~/.kronk-cli.json), what the
+ * terminal advertises (`COLORFGBG`), and what it answers when asked (OSC 11).
+ * The last one is a round trip over the tty, so it happens once at startup and
+ * never blocks for longer than a blink.
+ */
+
+/**
+ * Palettes, as SGR parameters. Each is chosen for contrast against its own
+ * background, not for fidelity to the sixteen-colour name it replaces: `red`
+ * on a light background is a darker red than on a dark one, and both are still
+ * unmistakably red.
+ *
+ * The `grey`/`dim` pair is the whole point. 245 on dark and 242 on light both
+ * land near 4.5:1 against a typical terminal background, where 90 on dark is
+ * closer to 1.9:1.
+ */
+export const PALETTES = {
+  256: {
+    dark: {
+      dim: '38;5;244', bold: '1', italic: '3', strike: '9',
+      red: '38;5;203', green: '38;5;114', yellow: '38;5;221', blue: '38;5;111',
+      magenta: '38;5;176', cyan: '38;5;116', grey: '38;5;245',
+    },
+    light: {
+      dim: '38;5;244', bold: '1', italic: '3', strike: '9',
+      red: '38;5;160', green: '38;5;28', yellow: '38;5;136', blue: '38;5;26',
+      magenta: '38;5;90', cyan: '38;5;30', grey: '38;5;242',
+    },
+  },
+  // Sixteen colours: no cube to pick from, so the only lever is whether a hue
+  // comes from the normal or the bright half. Light keeps exactly what this
+  // program printed before the palettes existed.
+  16: {
+    dark: {
+      dim: '37', bold: '1', italic: '3', strike: '9',
+      red: '91', green: '92', yellow: '93', blue: '94',
+      magenta: '95', cyan: '96', grey: '37',
+    },
+    light: {
+      dim: '90', bold: '1', italic: '3', strike: '9',
+      red: '31', green: '32', yellow: '33', blue: '34',
+      magenta: '35', cyan: '36', grey: '90',
+    },
+  },
+};
+
+/** Anything we cannot classify is dark: it is what most terminals ship as. */
+export const DEFAULT_THEME = 'dark';
+
+const THEMES = new Set(['dark', 'light']);
+
+/**
+ * How many colours we may use. 0 means print no escapes at all, which is what
+ * NO_COLOR, a dumb terminal, a redirected stdout and `FORCE_COLOR=0` each ask
+ * for; any other FORCE_COLOR overrides the redirect, so a pipe into `less -R`
+ * and the test suite can both see what a terminal would.
+ */
+export function colorDepth(env = process.env, stream = process.stdout) {
+  if (env.NO_COLOR) return 0;
+  if (env.TERM === 'dumb') return 0;
+  if (env.FORCE_COLOR === '0') return 0;
+  if (env.FORCE_COLOR === undefined && !stream?.isTTY) return 0;
+  const term = env.TERM ?? '';
+  if (env.COLORTERM || /-256(color)?\b/.test(term) || /^(alacritty|kitty|wezterm|xterm-ghostty)/.test(term)) {
+    return 256;
+  }
+  return 16;
+}
+
+/**
+ * The background as `COLORFGBG` describes it — `foreground;background`, or
+ * `foreground;bold;background` from rxvt. The background is the last field,
+ * as a palette index: the dark half of the sixteen, plus bright black, means
+ * a dark terminal. `default` is the one honest answer some terminals give and
+ * it tells us nothing, so it stays unclassified rather than guessed at.
+ */
+export function parseColorFgBg(value) {
+  if (typeof value !== 'string') return null;
+  const bg = value.split(';').pop()?.trim();
+  if (!bg || !/^\d+$/.test(bg)) return null;
+  const n = Number(bg);
+  if (n > 15) return null;
+  return [0, 1, 2, 3, 4, 5, 6, 8].includes(n) ? 'dark' : 'light';
+}
+
+/**
+ * The reply to an OSC 11 query: `ESC ] 11 ; rgb:RRRR/GGGG/BBBB`, an optional
+ * alpha component, then BEL or ST. Components are 1 to 4 hex digits wide
+ * depending on the terminal — xterm answers in 16 bits, others in 8.
+ */
+// eslint-disable-next-line no-control-regex -- ESC is what the reply starts with
+const OSC11 = /\x1b\]11;rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})(?:\/[0-9a-f]{1,4})?(?:\x07|\x1b\\)?/i;
+
+/**
+ * The reply found in `buf`: its relative luminance, and where it sat, so the
+ * caller can hand back whatever else was in the buffer. Each component is
+ * scaled by its own width — a short reply is not a near-black one.
+ */
+function matchOsc11(buf) {
+  const m = typeof buf === 'string' ? OSC11.exec(buf) : null;
+  if (!m) return null;
+  const [r, g, b] = m.slice(1, 4).map((h) => parseInt(h, 16) / (16 ** h.length - 1));
+  return {
+    luminance: 0.2126 * r + 0.7152 * g + 0.0722 * b,
+    rest: buf.slice(0, m.index) + buf.slice(m.index + m[0].length),
+  };
+}
+
+/** The relative luminance of an OSC 11 reply, or null if this is not one. */
+export function parseOsc11(reply) {
+  return matchOsc11(reply)?.luminance ?? null;
+}
+
+/** Mid-grey is the boundary; a terminal sitting exactly on it reads as light. */
+export const themeForLuminance = (lum) => (lum >= 0.5 ? 'light' : 'dark');
+
+/**
+ * A theme somebody named, or null for "work it out". `auto` is spelled out
+ * rather than left to an empty value so a config file can turn a forced theme
+ * back off without deleting the key, and a typo falls through to detection
+ * rather than pinning the wrong palette.
+ */
+export const namedTheme = (value) => {
+  const asked = String(value ?? '').trim().toLowerCase();
+  return THEMES.has(asked) ? asked : null;
+};
+
+/** What the environment alone can tell us, or null for "ask the terminal". */
+export function detectTheme(env = process.env) {
+  return namedTheme(env.KRONK_THEME) ?? parseColorFgBg(env.COLORFGBG);
+}
+
+/**
+ * Ask the terminal for its background colour and wait, briefly.
+ *
+ * This puts stdin in raw mode for as long as the answer takes, so it runs
+ * once, before the REPL's readline exists, and only when both ends are a tty.
+ * A terminal that does not implement OSC 11 says nothing at all, which is why
+ * there is a timeout rather than a sentinel to wait for; 100 ms is far longer
+ * than a local round trip and short enough to be invisible.
+ *
+ * Anything read that is not part of the reply is somebody typing ahead, and it
+ * is pushed back onto stdin before this resolves. Without that, a fast typist
+ * — or a script piping commands in — loses whatever landed in the window, and
+ * loses it silently.
+ */
+export function probeBackground({ input = process.stdin, output = process.stdout, timeoutMs = 100 } = {}) {
+  if (!input?.isTTY || !output?.isTTY || typeof input.setRawMode !== 'function') {
+    return Promise.resolve(null);
+  }
+  return new Promise((resolve) => {
+    const wasRaw = input.isRaw;
+    let buf = '';
+    let settled = false;
+    const finish = (value, rest) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      input.off('data', onData);
+      if (!wasRaw) input.setRawMode(false);
+      input.pause();
+      if (rest) input.unshift?.(Buffer.from(rest, 'latin1'));
+      resolve(value);
+    };
+    const onData = (chunk) => {
+      buf += chunk.toString('latin1');
+      const hit = matchOsc11(buf);
+      if (hit) finish(themeForLuminance(hit.luminance), hit.rest);
+      // Whatever this is, it is not the reply and no longer plausibly the
+      // start of one. Stop reading and give it back.
+      else if (buf.length > 64) finish(null, buf);
+    };
+    const timer = setTimeout(() => finish(null, buf), timeoutMs);
+    input.setRawMode(true);
+    input.resume();
+    input.on('data', onData);
+    output.write('\x1b]11;?\x07');
+  });
+}
+
+let depth = colorDepth();
+let active = detectTheme() ?? DEFAULT_THEME;
+
+/** Which palette is in force. Read by the tests and by `/theme`. */
+export const theme = () => active;
+
+/** Depth 0 means every colour helper is the identity function. */
+export const colorsOn = () => depth > 0;
+
+/** Set both explicitly. Tests use it; nothing in the program has to guess. */
+export function useTheme({ name, colors } = {}) {
+  if (THEMES.has(name)) active = name;
+  if (colors !== undefined) depth = colors ? (colors === true ? 256 : colors) : 0;
+  return active;
+}
+
+/**
+ * Settle the palette for this session: what the user asked for, what the
+ * environment said, or failing both what the terminal answers. Startup awaits this once; everything that
+ * prints reads `ansi` per call, so the banner and every later line agree.
+ */
+export async function resolveTheme({ prefer, ...options } = {}) {
+  const known = namedTheme(prefer) ?? detectTheme();
+  if (known) { active = known; return active; }
+  if (depth === 0) return active;              // nothing to colour, don't touch the tty
+  active = (await probeBackground(options)) ?? DEFAULT_THEME;
+  return active;
+}
+
+/** The SGR parameters for a palette entry, or null when colour is off. */
+export function ansi(name) {
+  if (depth === 0) return null;
+  return PALETTES[depth === 256 ? 256 : 16][active][name] ?? null;
+}

package/src/ui.js

@@ -1,16 +1,27 @@
-const on = process.stdout.isTTY && !process.env.NO_COLOR;
-const wrap = (code) => (s) => (on ? `\x1b[${code}m${s}\x1b[0m` : s);
+import { ansi } from './theme.js';
+
+/**
+ * Each colour resolves its escape when it is called, not when this module is
+ * loaded: the background is only known after the terminal has been asked, and
+ * that answer arrives after the first import. See src/theme.js.
+ */
+const wrap = (name) => (s) => {
+  const code = ansi(name);
+  return code ? `\x1b[${code}m${s}\x1b[0m` : s;
+};
 
 export const c = {
-  dim: wrap('2'),
-  bold: wrap('1'),
-  red: wrap('31'),
-  green: wrap('32'),
-  yellow: wrap('33'),
-  blue: wrap('34'),
-  magenta: wrap('35'),
-  cyan: wrap('36'),
-  grey: wrap('90'),
+  dim: wrap('dim'),
+  bold: wrap('bold'),
+  italic: wrap('italic'),
+  strike: wrap('strike'),
+  red: wrap('red'),
+  green: wrap('green'),
+  yellow: wrap('yellow'),
+  blue: wrap('blue'),
+  magenta: wrap('magenta'),
+  cyan: wrap('cyan'),
+  grey: wrap('grey'),
 };
 
 export const banner = (model, url) => `