@hncode/hncode 0.4.1 → 0.5.0

package/src/btw-panel.js

@@ -0,0 +1,224 @@
+// The /btw box — a bordered panel docked ABOVE the composer, the way kimi's
+// BtwPanelComponent is (see its `mount`, which adds the panel to
+// `btwPanelContainer` and sets `editor.connectedAbove = true`).
+//
+// Why a docked box rather than a full-screen panel: the side conversation is
+// something you have WHILE working, and the composer stays the place you type. In
+// kimi the composer input IS the way to ask a follow-up — `sendUserInput` feeds the
+// same panel — so the box sits directly above it and the editor is where you keep
+// typing. A full-screen takeover hides the conversation being asked about, which is
+// precisely the context a side question is about.
+//
+// Shape, matching kimi's renderer:
+//
+//   ╭ BTW ─ Esc close ─────────────────────────────╮
+//   │ Q: what does the --retries flag do?          │
+//   │ The `--retries` flag controls how many…      │
+//   │                                              │
+//   │ Q: and the timeout flag?                     │
+//   │ It sets how long a run may take…             │
+//   ╰──────────────────────────────────────────────╯
+//
+// Differences from kimi, all deliberate:
+//   * turns are held in the SESSION side thread, not here, so /btw clear and the
+//     accumulated view have one source of truth;
+//   * the height cap is a fraction of the terminal (kimi: a third) but the panel
+//     GROWS to the largest size it has needed, so it does not jitter on every token.
+
+import { visualWidth } from './term.js';
+import { C } from './colors.js';
+
+/** Rows kimi reserves as the floor for the box, so it is never a one-line sliver. */
+export const MIN_PANEL_LINES = 3;
+
+/**
+ * The box's height in rows, given the terminal height.
+ *
+ * Mirrors kimi's `collapsedBodyLimit`: at most a THIRD of the terminal, at least
+ * MIN_PANEL_LINES. Returns the TOTAL rows the box occupies (borders included), and
+ * 0 when there is nothing to show so the caller can skip it entirely.
+ */
+export function btwPanelHeight(state, terminalRows, width) {
+  const panel = state && state.btwPanel;
+  if (!panel || !panel.turns || !panel.turns.length) return 0;
+  const rows = Number.isFinite(terminalRows) && terminalRows > 0 ? terminalRows : 24;
+  // At most a THIRD of the terminal (kimi's rule), floor of MIN_PANEL_LINES, and the
+  // rest of the screen keeps the transcript visible.
+  const maxBody = Math.max(MIN_PANEL_LINES, Math.floor(rows / 3)) - 1;
+  const inner = Math.max(1, (width | 0) - 4);
+  const needed = btwBodyLines(panel, inner);
+  // `_btwMinBody` grows monotonically, like kimi's `minBodyLines`: a box that shrank
+  // as a streamed answer reflowed would make the screen jump on most tokens.
+  const mark = Math.max(Number(panel._btwMinBody) || 0, needed);
+  if (panel && typeof panel === 'object') panel._btwMinBody = mark;
+  const want = Math.max(1, Math.min(maxBody, mark));
+  return want + 2;   // the two border rows
+}
+
+/**
+ * How many content rows the box has ever needed.
+ *
+ * kimi keeps `minBodyLines` and grows it monotonically for the same reason: a box
+ * that resized on every streamed token would make the whole screen jump. Seeding it
+ * from this means the height only ever changes when the CONTENT needs more room.
+ */
+export function btwBodyLines(panel, width) {
+  if (!panel || !panel.turns || !panel.turns.length) return 0;
+  let n = 0;
+  for (const t of panel.turns) {
+    if (n > 0) n += 1;                       // the blank line between turns
+    n += wrapCount(`Q: ${t.prompt}`, width);
+    const answer = String(t.answer || '');
+    if (answer.trim()) {
+      for (const line of answer.split('\n')) n += Math.max(1, wrapCount(line, width));
+    } else if (t.thinking && t.thinking.trim()) {
+      n += 1;                                 // the thinking preview
+    } else if (!t.error) {
+      n += 1;                                 // "Waiting for answer…"
+    }
+    if (t.error) n += wrapCount(t.error, width);
+    // The blinking caret row. It MUST be counted here or the box is one row short and
+    // the last content line is clipped off.
+    if (t.phase === 'running') n += 1;
+  }
+  return n;
+}
+
+/** How many display rows a string needs at `width`. Never returns 0. */
+function wrapCount(text, width) {
+  const w = Math.max(1, width);
+  const s = String(text == null ? '' : text);
+  if (!s.length) return 1;
+  let rows = 0;
+  for (const line of s.split('\n')) {
+    const vis = visualWidth(line);
+    rows += Math.max(1, Math.ceil(vis / w));
+  }
+  return rows;
+}
+
+/** Clip a string to `width` display columns, adding `…` when it was cut. */
+function clip(text, width) {
+  const s = String(text == null ? '' : text);
+  if (visualWidth(s) <= width) return s;
+  let out = '';
+  let w = 0;
+  for (const ch of s) {
+    const cw = visualWidth(ch);
+    if (w + cw > Math.max(0, width - 1)) break;
+    out += ch;
+    w += cw;
+  }
+  return out + '…';
+}
+
+/**
+ * Render the box: `{ lines }`, one entry per SCREEN row including the borders.
+ *
+ * `state.btwScroll` counts rows up from the bottom of the content, as an offset from
+ * the tail — the same convention the transcript uses, so ↑/↓ can share the code.
+ */
+export function renderBtwPanel(state, width, opts = {}) {
+  const panel = state && state.btwPanel;
+  if (!panel || !panel.turns || !panel.turns.length) return [];
+  const w = Math.max(8, width | 0);
+  const inner = Math.max(1, w - 4);          // '│ ' + content + ' │'
+  const terminalRows = opts.terminalRows;
+  const height = btwPanelHeight(state, terminalRows, w);
+  const bodyRows = Math.max(1, height - 2);
+
+  // ---- the content rows, in order ----
+  const content = [];
+  for (let i = 0; i < panel.turns.length; i++) {
+    const t = panel.turns[i];
+    // Every entry is a `{ l, color }` ROW. The blank separator between turns must be
+    // one too: a bare '' pushed in its place rendered as `undefined` because the
+    // renderer reads `row.l`.
+    if (i > 0) content.push({ l: '', color: C.white });
+    for (const l of wrapLine(`Q: ${t.prompt}`, inner)) content.push({ l, color: C.cyan });
+    const answer = String(t.answer || '');
+    if (answer.trim()) {
+      for (const raw of answer.split('\n')) {
+        // A blank line inside an answer stays blank; otherwise each line is wrapped on
+        // its own so a long paragraph does not reflow into the previous one.
+        if (!raw.trim()) { content.push({ l: '', color: C.white }); continue; }
+        for (const l of wrapLine(raw, inner)) content.push({ l, color: C.white });
+      }
+    } else if (t.thinking && t.thinking.trim()) {
+      content.push({ l: clip(`  …${t.thinking.trim().split('\n').slice(-1)[0]}`, inner), color: C.gray });
+    } else if (!t.error) {
+      content.push({ l: 'Waiting for answer…', color: C.gray });
+    }
+    if (t.error) for (const l of wrapLine(t.error, inner)) content.push({ l, color: C.red });
+    if (t.phase === 'running') content.push({ l: '▍', color: C.gray });
+  }
+
+  // ---- scroll: offset from the tail, like the transcript ----
+
+  // ---- scroll: offset from the tail, like the transcript ----
+  const maxTop = Math.max(0, content.length - bodyRows);
+  const scroll = Math.max(0, Math.min(maxTop, Number(state.btwScroll) || 0));
+  const start = Math.max(0, content.length - bodyRows - scroll);
+  const shown = content.slice(start, start + bodyRows);
+  while (shown.length < bodyRows) shown.push({ l: '', color: C.white });
+
+  // ---- the frame ----
+  const out = [];
+  const hint = maxTop > 0 ? 'Esc close · ↑↓ scroll ' : 'Esc close ';
+  const title = ' BTW ';
+  const head = `${title}${'─'.repeat(Math.max(1, w - 2 - visualWidth(title) - visualWidth(hint) - 1))} ${hint}`;
+  // Every border segment is painted on its own, so the interior can carry the text
+  // colour while the frame keeps the border colour. Painting the whole line and
+  // patch-substituting the corners (as an earlier version did) left the colour escape
+  // codes embedded in the output.
+  out.push(col('╭', C.border) + col(fitBorder(head, w - 2), C.border) + col('╮', C.border));
+  for (const row of shown) {
+    const padded = row.l + ' '.repeat(Math.max(0, inner - visualWidth(row.l)));
+    out.push(col('│', C.border) + ' ' + col(padded, row.color) + ' ' + col('│', C.border));
+  }
+  const above = start > 0 ? `▲ ${start} more` : '';
+  const below = scroll > 0 ? `▼ ${scroll} more` : '';
+  const tailHint = [above, below].filter(Boolean).join('  ') || 'Esc close';
+  // The bottom border reads `╰─ Esc close ─────…────╯`: the hint sits in the middle of
+  // the rule. The two corners take a column each, so the MIDDLE segment must be exactly
+  // `w - 2` wide — `─ ` + hint + ` ` + fill.
+  const foot = clip(tailHint, Math.max(1, w - 6));
+  const mid = `─ ${foot} `;
+  const footFill = Math.max(0, w - 2 - visualWidth(mid));
+  out.push(col('╰', C.border) + col(mid + '─'.repeat(footFill), C.border) + col('╯', C.border));
+  return out;
+}
+
+/** Paint `s`, resetting after it so the next segment starts clean. */
+function col(s, color) {
+  return color ? color + s + C.reset : s;
+}
+
+
+/** Pad or clip a border segment to exactly `width` columns. */
+function fitBorder(s, width) {
+  const w = Math.max(0, width);
+  if (visualWidth(s) === w) return s;
+  if (visualWidth(s) > w) return clip(s, w);
+  return s + '─'.repeat(w - visualWidth(s));
+}
+
+/** Wrap one logical line into display rows of at most `width` columns. */
+export function wrapLine(text, width) {
+  const w = Math.max(1, width);
+  const s = String(text == null ? '' : text);
+  if (!s.length) return [''];
+  const out = [];
+  let cur = '';
+  let curW = 0;
+  for (const ch of s) {
+    const cw = visualWidth(ch);
+    if (curW + cw > w) { out.push(cur); cur = ''; curW = 0; }
+    cur += ch;
+    curW += cw;
+  }
+  out.push(cur);
+  return out;
+}
+
+

package/src/cache.js

@@ -29,7 +29,7 @@ export const MAX_BREAKPOINTS = 4;
 export const MIN_CACHEABLE_TOKENS = 1024;
 
 export function supportsCaching(protocol) {
-  return protocol === 'anthropic' || protocol === 'openai';
+  return protocol === 'anthropic' || protocol === 'openai' || protocol === 'responses';
 }
 
 // Index (into `messages`) of the last message that belongs to the STABLE prefix.
@@ -125,6 +125,7 @@ export function withOpenAiCache(body, opts = {}) {
 export function applyPromptCache(protocol, body, opts = {}) {
   if (!opts.enabled) return body;
   if (protocol === 'anthropic') return withAnthropicCache(body, opts);
-  if (protocol === 'openai') return withOpenAiCache(body, opts);
+  // Responses API accepts the same stable `prompt_cache_key` as chat/completions.
+  if (protocol === 'openai' || protocol === 'responses') return withOpenAiCache(body, opts);
   return body;
 }

package/src/cell-buffer.js

@@ -0,0 +1,173 @@
+// A minimal retained-mode cell layer, modelled on OpenTUI's OptimizedBuffer.
+//
+// WHY THIS EXISTS
+// ---------------
+// The picker used to be painted as a finished ANSI STRING assigned over a whole
+// frame row (`lines[row] = boxRow`). That is not an overlay, it is a replacement:
+// every column the card's padding happened to occupy was erased, so the transcript
+// beside the card disappeared — a row of `11111111111111` rendered as
+// `        |111111|`.
+//
+// OpenTUI gets this right because it never builds strings. It keeps a 2-D buffer of
+// cells, paints the dialog into its OWN buffer, and composites that buffer onto the
+// scene with `drawFrameBuffer`. The rule that makes it work is in `blendCells`:
+//
+//     const preserveChar = (charIsDefaultSpace and destNotZero and
+//                           destNotDefaultSpace and destWidthIsOne);
+//     const finalChar = if (preserveChar) destCell.char else overlayCell.char;
+//
+// An overlay cell that is a BLANK SPACE does not overwrite what is underneath — it
+// keeps the destination's character. That single rule is the difference between a
+// floating window and a full-screen takeover.
+//
+// hncode still renders its body as ANSI strings (rewriting all of it would be a much
+// larger change), so this module does one job: turn a row of that text into cells,
+// composite an overlay row onto it cell-by-cell using OpenTUI's rule, and turn the
+// result back into an ANSI string. Zero dependencies, like the rest of hncode.
+
+import { charWidth } from './term.js';
+
+// A cell in a layer. `blank` marks a cell the overlay does not paint — the equivalent
+// of OpenTUI's DEFAULT_SPACE_CHAR combined with a transparent alpha. Those cells
+// defer to whatever is underneath instead of erasing it.
+export function cell(ch, style, blank = false) {
+  return { ch, style: style || '', blank };
+}
+
+const RESET = '\x1b[0m';
+
+/**
+ * The cell that follows a double-width glyph, occupying its second column.
+ *
+ * A terminal does not advance one column per CHARACTER, it advances one column per
+ * DISPLAY CELL. `你好` is two characters but eight columns; `😀` is one character and
+ * two columns. A layer indexed by character therefore drifts out of step with the
+ * screen as soon as it contains anything wide, and every glyph after it lands one
+ * or more columns to the left of where the terminal will actually draw it — which is
+ * how backdrop text ended up showing through the middle of an opaque dialog.
+ *
+ * The continuation cell holds an empty `ch`, so rendering emits the wide glyph once
+ * and the terminal supplies the second column itself. This is the same accounting
+ * OpenTUI does with `encodedCharWidth`.
+ */
+const WIDE_CONT = { ch: '', style: '', blank: false, cont: true };
+
+/** A cell that defers to the layer below it. */
+export const BLANK = cell(' ', '', true);
+
+/**
+ * Split an ANSI string into cells, ONE PER DISPLAY COLUMN.
+ *
+ * A wide (CJK) glyph is ONE cell followed by a continuation cell spanning its second
+ * column, so `cells.length` always equals `visualWidth(str)` and index N is always
+ * screen column N. Indexing by code point instead — which this used to do — silently
+ * desynchronised the layer from the screen for any row containing wide text: the
+ * layer came out shorter than the columns it had to cover, so the tail of the row was
+ * never overwritten and the transcript underneath showed through the dialog.
+ *
+ * Zero-width characters (combining marks, joiners) occupy no column and are dropped.
+ */
+export function parseCells(s) {
+  const str = String(s == null ? '' : s);
+  const cells = [];
+  let style = '';
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] === '\x1b') {
+      const m = /^\x1b\[[0-9;?]*[a-zA-Z]/.exec(str.slice(i))
+        || /^\x1b\[[0-9;?]* [a-zA-Z]/.exec(str.slice(i));
+      if (m) {
+        // A reset ends the current style rather than becoming part of the next one. Both
+        // spellings matter: `renderCells` emits `\x1b[0m`, but a row that came from
+        // elsewhere — a shell escape, a plugin, a hand-built string — can carry the bare
+        // `\x1b[m`, and treating that as an ordinary attribute left the old style attached
+        // to the next cell. The stale `48;…` then survived every later edit and the row
+        // never quite matched itself.
+        if (m[0] === '\x1b[0m' || m[0] === '\x1b[m') style = '';
+        else style += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    const cp = str.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const step = cp > 0xffff ? 2 : 1;
+    const cw = charWidth(ch);
+    if (cw === 0) { i += step; continue; }        // combining mark: no column of its own
+    cells.push(cell(ch, style));
+    if (cw === 2) cells.push({ ...WIDE_CONT, style });  // its second column
+    i += step;
+  }
+  return cells;
+}
+
+/**
+ * Render cells back to an ANSI string.
+ *
+ * A RESET is emitted before each new style run, so the output is IDEMPOTENT: parsing
+ * it again reproduces exactly the styles it came from. Without the reset the codes
+ * accumulate — a row that was dimmed, re-parsed and re-rendered grew a fresh `\x1b[2m`
+ * on every pass, and after a few frames a cell's "style" was hundreds of repeated
+ * escape codes. That is invisible in a stripped-text check and eventually slows the
+ * whole render path down.
+ */
+export function renderCells(cells) {
+  let out = '';
+  let cur = null;
+  for (const c of cells) {
+    // A wide glyph's continuation cell carries no character of its own: the glyph
+    // before it already occupies both columns on screen, so emitting anything here
+    // would shift the rest of the row one column to the right.
+    if (c.cont) continue;
+    if (c.style !== cur) {
+      // Close the previous run before opening the next, so neither leaks into the other.
+      out += c.style === '' ? RESET : RESET + c.style;
+      cur = c.style;
+    }
+    out += c.ch;
+  }
+  return out;
+}
+
+/**
+ * OpenTUI's `blendCells`, reduced to the one rule that matters here.
+ *
+ * An overlay cell that is BLANK keeps the destination's character — and, since the
+ * destination has already been dimmed by the time the layer goes on top, that
+ * character arrives dimmed. Everything else in the overlay is opaque and wins.
+ */
+export function blendCell(overlay, dest) {
+  if (!overlay.blank) return overlay;
+  // A continuation cell belongs to the wide glyph in the cell before it. If the
+  // overlay put a wide glyph here, that glyph owns both columns, so the
+  // destination's second half must not survive independently of the first.
+  if (overlay.cont) return overlay;
+  if (dest && dest.ch && dest.ch !== ' ' && !dest.cont) return dest;
+  return overlay;
+}
+
+/**
+ * Composite an overlay row onto a base row at column `destX`, cell by cell, using
+ * `blendCell`. This is `drawFrameBuffer` for a single row.
+ *
+ * `overlay` is a cell array (build one with `parseCells` and mark the cells that must
+ * stay transparent with `BLANK`), or a plain string for the common case of an opaque
+ * overlay. The base row is a string and is never mutated — each call parses its own
+ * copy, so compositing several rows cannot make one bleed into the next.
+ */
+export function drawFrameBuffer(baseRow, overlay, destX) {
+  const base = parseCells(baseRow);
+  const layer = typeof overlay === 'string' ? parseCells(overlay) : overlay;
+  for (let i = 0; i < layer.length; i++) {
+    const at = destX + i;
+    if (at < 0) continue;
+    if (at >= base.length) {
+      // Past the end of the base row: pad so the overlay still lands.
+      while (base.length < at) base.push(BLANK);
+      base.push(blendCell(layer[i], null));
+      continue;
+    }
+    base[at] = blendCell(layer[i], base[at]);
+  }
+  return renderCells(base);
+}

package/src/ci.js

@@ -49,7 +49,7 @@ export function isValidFormat(f) {
 //   files     — files the run wrote/edited (from tool ARGS, best-effort)
 //   error     — a fatal error message, when the run failed outright
 //   stopped   — the turn was interrupted
-export function buildResult({ reply, toolCalls, files, error, stopped, durationMs, model, sessionId }) {
+export function buildResult({ reply, toolCalls, files, error, stopped, durationMs, model, sessionId, timedOut }) {
   const hasReply = typeof reply === 'string' && reply.trim().length > 0;
   const ok = !error && !stopped && hasReply;
   const result = {
@@ -63,6 +63,9 @@ export function buildResult({ reply, toolCalls, files, error, stopped, durationM
   };
   if (error) result.error = String(error);
   if (stopped) result.stopped = true;
+  // `--timeout <seconds>` tripped: distinct from a user interrupt so a caller can
+  // tell "the model was too slow" from "someone pressed Esc" (both set stopped).
+  if (timedOut) result.timedOut = true;
   return result;
 }