@visual-z/xeno 0.1.0

package/src/tui/exhaustive.ts

@@ -0,0 +1,14 @@
+/**
+ * Exhaustiveness for discriminated unions.
+ *
+ * Copied rather than imported from core: tui may not import src/ outside
+ * itself, and the boundary checker exists to keep that true. The two copies
+ * must stay one function; if they drift, the newer union is the one that
+ * will fail to compile first.
+ */
+export function assertNever(value: never, context: string): never {
+  throw new Error(
+    `${context}: unhandled variant ${JSON.stringify(value)} -- ` +
+      "a union gained a member without every switch over it being updated",
+  );
+}

package/src/tui/fuzzy.ts

@@ -0,0 +1,75 @@
+/**
+ * Subsequence fuzzy matching with a stable rank.
+ *
+ * Consecutive hits and word-start hits score better (pi-tui's scheme,
+ * lower is better). Ties keep the original index: an unstable sort would
+ * reshuffle the select list between two renders, and Enter would confirm
+ * a different item than the one under the cursor.
+ */
+
+export interface FuzzyMatch {
+  readonly text: string;
+  readonly score: number;
+  readonly index: number;
+}
+
+/**
+ * Lower is better. `null` if `query` is not a subsequence of `text`.
+ * Case-insensitive. Empty query matches with score 0.
+ */
+export function fuzzyMatch(text: string, query: string): number | null {
+  if (query.length === 0) return 0;
+  return score(text, query);
+}
+
+export function fuzzyFilter(candidates: readonly string[], query: string): string[] {
+  if (query.length === 0) return [...candidates];
+  const ranked: FuzzyMatch[] = [];
+  for (let index = 0; index < candidates.length; index++) {
+    const text = candidates[index]!;
+    const s = score(text, query);
+    if (s === null) continue;
+    ranked.push({ text, score: s, index });
+  }
+  ranked.sort((a, b) => a.score - b.score || a.index - b.index);
+  return ranked.map((r) => r.text);
+}
+
+/**
+ * Leftmost greedy subsequence, scored like pi-tui:
+ * consecutive run bonus, word-boundary bonus, later-match penalty.
+ * Walks code points so a CJK query cannot land on a UTF-16 half-unit.
+ */
+function score(text: string, query: string): number | null {
+  const t = [...text.toLowerCase()];
+  const q = [...query.toLowerCase()];
+  if (q.length > t.length) return null;
+
+  let qi = 0;
+  let total = 0;
+  let last = -1;
+  let consecutive = 0;
+
+  for (let i = 0; i < t.length && qi < q.length; i++) {
+    if (t[i] !== q[qi]) continue;
+    const prev = i === 0 ? "" : t[i - 1]!;
+    const boundary = i === 0 || /[\s\-_./:]/.test(prev);
+
+    if (last === i - 1) {
+      consecutive++;
+      total -= consecutive * 5;
+    } else {
+      consecutive = 0;
+      if (last >= 0) total += (i - last - 1) * 2;
+    }
+    if (boundary) total -= 10;
+    total += i * 0.1;
+
+    last = i;
+    qi++;
+  }
+
+  if (qi < q.length) return null;
+  if (q.join("") === t.join("")) total -= 100;
+  return total;
+}

package/src/tui/host.ts

@@ -0,0 +1,223 @@
+/**
+ * Adapter between xeno's tiny Terminal (columns/rows/write) and pi's TUI.
+ *
+ * Vendor is copied unmodified (D19). Anything we need to change — a stub
+ * terminal for tests, thinking-coloured editor borders, wrapping a string[]
+ * as a Component — lives here so the next recopy does not wipe it.
+ */
+import type { Terminal as SimpleTerminal } from "./terminal.ts";
+import type { Style } from "./style.ts";
+import { IDENTITY, PLAIN_ATTRS, paint, type Attrs } from "./style.ts";
+import {
+  Container,
+  Markdown,
+  ProcessTerminal,
+  Text as PiText,
+  type Component,
+  type DefaultTextStyle,
+  type EditorTheme,
+  type MarkdownTheme,
+  type SelectListTheme,
+  type Terminal,
+  type TUI,
+  TuiMainScreen,
+  stripTerminalSequences,
+} from "../vendor/pi-tui/index.ts";
+
+export { Container, Markdown, PiText };
+export type { TuiMainScreen };
+
+/**
+ * Wraps the injectible {columns, rows, write} terminal tests already use.
+ * Tests inject a silent terminal; the application uses ProcessTerminal.
+ */
+export class AdapterTerminal implements Terminal {
+  private readonly inner: SimpleTerminal;
+  constructor(inner: SimpleTerminal) {
+    this.inner = inner;
+  }
+
+  start(_onInput: (data: string) => void, _onResize: () => void): void {}
+  stop(): void {}
+  async drainInput(_maxMs?: number, _idleMs?: number): Promise<void> {}
+  write(data: string): void {
+    this.inner.write(data);
+  }
+  get columns(): number {
+    return this.inner.columns;
+  }
+  get rows(): number {
+    return this.inner.rows;
+  }
+  get kittyProtocolActive(): boolean {
+    return false;
+  }
+  moveBy(lines: number): void {
+    if (lines < 0) this.write(`\x1b[${-lines}A`);
+    else if (lines > 0) this.write(`\x1b[${lines}B`);
+  }
+  hideCursor(): void {
+    this.write("\x1b[?25l");
+  }
+  showCursor(): void {
+    this.write("\x1b[?25h");
+  }
+  clearLine(): void {
+    this.write("\x1b[2K");
+  }
+  clearFromCursor(): void {
+    this.write("\x1b[J");
+  }
+  clearScreen(): void {
+    this.write("\x1b[2J\x1b[H");
+  }
+  setTitle(_title: string): void {}
+  setProgress(_active: boolean): void {}
+}
+
+/** TuiMainScreen without ProcessTerminal — tests inject a FakeTerminal. */
+export function createInteractiveTui(term?: SimpleTerminal, showHardwareCursor = true): TuiMainScreen {
+  return new TuiMainScreen(term ? new AdapterTerminal(term) : new ProcessTerminal(), showHardwareCursor);
+}
+
+/**
+ * Vendor Editor.render only reads tui.terminal.rows. A full TuiMainScreen
+ * would write on construct; a silent stub keeps `new Editor().render()` a
+ * unit test.
+ */
+export function stubTui(rows = 24, columns = 80): TUI {
+  return new TuiMainScreen(new AdapterTerminal({ columns, rows, write() {} }), false);
+}
+
+export function identitySelectListTheme(): SelectListTheme {
+  return {
+    selectedPrefix: (text) => text,
+    selectedText: (text) => text,
+    description: (text) => text,
+    scrollInfo: (text) => text,
+    noMatch: (text) => text,
+  };
+}
+
+export function identityEditorTheme(): EditorTheme {
+  return {
+    borderColor: (text) => text,
+    selectList: identitySelectListTheme(),
+  };
+}
+
+/**
+ * Border colour follows the thinking level, which is pi's cue that the
+ * next turn will spend a different budget. Uncoloured when the style
+ * emits no SGR (IDENTITY / NO_COLOR) so a pipe cannot pick up CSI.
+ */
+export function thinkingBorderColor(level: string, colored: boolean, style?: Style): (s: string) => string {
+  if (!colored) return (s) => s;
+  if (style?.token) return (s) => style.token!(`thinking${level[0]?.toUpperCase()}${level.slice(1)}`, s);
+  const code =
+    level === "max" || level === "xhigh" ? "35" :
+    level === "high" ? "33" :
+    level === "medium" ? "36" :
+    level === "low" ? "32" :
+    "90";
+  return (s) => `\x1b[${code}m${s}\x1b[0m`;
+}
+
+function wrapAttr(style: Style, attrs: Attrs): (text: string) => string {
+  return (text) => paint(text, attrs, style);
+}
+
+export function defaultTextStyleFrom(style: Style): DefaultTextStyle {
+  return { color: (text) => paint(text, PLAIN_ATTRS, style) };
+}
+
+/**
+ * Vendor Markdown may emit OSC 8 even when the theme is identity. IDENTITY
+ * is the -p / NO_COLOR gate: those bytes must not leak into a pipe.
+ */
+export function renderMarkdownLines(text: string, width: number, style: Style): string[] {
+  const md = new Markdown(text, 0, 0, markdownThemeFromStyle(style), defaultTextStyleFrom(style));
+  const lines = md.render(Math.max(0, width));
+  // Vendor pads every row to `width` for backgrounds we do not use. Trailing
+  // spaces would change tool-view snapshots and a pipe's visible payload.
+  const trimmed = lines.map((line) => line.replace(/[ \t]+$/, ""));
+  return style === IDENTITY ? trimmed.map(stripTerminalSequences) : trimmed;
+}
+
+/** Activity-area assistant text: pi's Markdown, themed from our Style. */
+export function assistantMarkdown(text: string, style: Style): Component {
+  return new MarkdownBlock(text, style);
+}
+
+/** Keep Pi's parse/layout cache alive across keystrokes and streaming deltas. */
+export class MarkdownBlock implements Component {
+  private readonly markdown: Markdown;
+  private readonly style: Style;
+  private text: string;
+  constructor(text: string, style: Style) {
+    this.text = text;
+    this.style = style;
+    this.markdown = new Markdown(text, 0, 0, markdownThemeFromStyle(style), defaultTextStyleFrom(style));
+  }
+  setText(text: string): void {
+    if (text === this.text) return;
+    this.text = text;
+    this.markdown.setText(text);
+  }
+  invalidate(): void { this.markdown.invalidate(); }
+  render(width: number): string[] {
+    if (width <= 0) return [""];
+    const lines = this.markdown.render(Math.max(1, width)).map((line) => line.trimEnd());
+    return this.style === IDENTITY ? lines.map(stripTerminalSequences) : lines;
+  }
+}
+
+export function markdownThemeFromStyle(style: Style): MarkdownTheme {
+  const plain = style.open(PLAIN_ATTRS) === "" && style === IDENTITY;
+  if (plain) {
+    return {
+      heading: (t) => t,
+      link: (t) => t,
+      linkUrl: (t) => t,
+      code: (t) => t,
+      codeBlock: (t) => t,
+      codeBlockBorder: (t) => t,
+      quote: (t) => t,
+      quoteBorder: (t) => t,
+      hr: (t) => t,
+      listBullet: (t) => t,
+      bold: (t) => t,
+      italic: (t) => t,
+      strikethrough: (t) => t,
+      underline: (t) => t,
+    };
+  }
+  return {
+    heading: wrapAttr(style, { ...PLAIN_ATTRS, heading: true, bold: true }),
+    link: wrapAttr(style, { ...PLAIN_ATTRS, link: true }),
+    linkUrl: wrapAttr(style, { ...PLAIN_ATTRS, link: true, dim: true }),
+    code: wrapAttr(style, { ...PLAIN_ATTRS, code: true }),
+    codeBlock: wrapAttr(style, { ...PLAIN_ATTRS, code: true }),
+    codeBlockBorder: wrapAttr(style, { ...PLAIN_ATTRS, dim: true }),
+    quote: wrapAttr(style, { ...PLAIN_ATTRS, dim: true }),
+    quoteBorder: wrapAttr(style, { ...PLAIN_ATTRS, dim: true }),
+    hr: wrapAttr(style, { ...PLAIN_ATTRS, dim: true }),
+    listBullet: wrapAttr(style, { ...PLAIN_ATTRS, dim: true }),
+    bold: wrapAttr(style, { ...PLAIN_ATTRS, bold: true }),
+    italic: wrapAttr(style, { ...PLAIN_ATTRS, italic: true }),
+    strikethrough: (t) => t,
+    underline: (t) => t,
+  };
+}
+
+/** Lift a render(width) → string[] into pi's Component (needs invalidate). */
+export class Lines implements Component {
+  private readonly paint: (width: number) => string[];
+  constructor(paint: (width: number) => string[]) {
+    this.paint = paint;
+  }
+  invalidate(): void {}
+  render(width: number): string[] {
+    return this.paint(width);
+  }
+}

package/src/tui/input.ts

@@ -0,0 +1,69 @@
+/** Pi owns decoding. Encoding exists only for programmatic actions and legacy tests. */
+import { KeybindingsManager, TUI_KEYBINDINGS, type KeybindingsConfig } from "../vendor/pi-tui/keybindings.ts";
+import { matchesKey, parseKey, type KeyId } from "../vendor/pi-tui/keys.ts";
+import { formatTuiKey, type Key } from "./keys.ts";
+
+export function keyMatches(data: string, chord: string): boolean {
+  return matchesKey(data, chord.replace("pageup", "pageUp").replace("pagedown", "pageDown") as KeyId);
+}
+
+export function inputKey(data: string): Key | null {
+  const parsed = parseKey(data);
+  if (parsed === undefined) return data.startsWith("\x1b") ? null : { type: "char", grapheme: data };
+  const parts = parsed.toLowerCase().split("+");
+  const name = parts.pop()!;
+  const mods = { ctrl: parts.includes("ctrl"), alt: parts.includes("alt"), shift: parts.includes("shift") };
+  switch (name) {
+    case "enter": return mods.alt ? { type: "alt", key: "\r" } : { type: "enter", shift: mods.shift };
+    case "tab": return { type: "tab", shift: mods.shift };
+    case "escape": return { type: "escape" };
+    case "backspace": if (!mods.alt && !mods.ctrl) return { type: "backspace" }; break;
+    case "up": case "down": case "left": case "right": case "home": case "end":
+    case "delete": case "pageup": case "pagedown": return { type: name, mods };
+  }
+  if (mods.ctrl) return { type: "ctrl", key: name, shift: mods.shift };
+  if (mods.alt) return { type: "alt", key: name };
+  return { type: "char", grapheme: data };
+}
+
+export function encodeKey(key: Key): string {
+  if (key.type === "char") return key.grapheme;
+  return encodeChord(formatTuiKey(key));
+}
+
+export function encodeChord(chord: string): string {
+  const parts = chord.split("+");
+  const name = parts.pop()!;
+  const ctrl = parts.includes("ctrl");
+  const alt = parts.includes("alt");
+  const shift = parts.includes("shift");
+  const modifier = 1 + (shift ? 1 : 0) + (alt ? 2 : 0) + (ctrl ? 4 : 0);
+  const arrow: Record<string, string> = { up: "A", down: "B", right: "C", left: "D", home: "H", end: "F" };
+  const suffix = arrow[name];
+  if (suffix) return modifier === 1 ? `\x1b[${suffix}` : `\x1b[1;${modifier}${suffix}`;
+  if (name === "escape") return "\x1b";
+  if (name === "tab") return shift ? "\x1b[Z" : "\t";
+  if (name === "backspace") return `${alt ? "\x1b" : ""}\x7f`;
+  const code = name === "enter" ? 13 : name === "space" ? 32 : name.codePointAt(0)!;
+  if (name === "delete" || name === "pageup" || name === "pagedown") {
+    const num = name === "delete" ? 3 : name === "pageup" ? 5 : 6;
+    return `\x1b[${num}${modifier === 1 ? "" : `;${modifier}`}~`;
+  }
+  if (shift || (ctrl && alt)) return `\x1b[${code};${modifier}u`;
+  if (ctrl) return String.fromCharCode(code & 31);
+  return `${alt ? "\x1b" : ""}${String.fromCodePoint(code)}`;
+}
+
+const INPUT_ACTIONS: Record<string, string> = {
+  "editor.submit": "tui.input.submit", "editor.newLine": "tui.input.newLine", "editor.complete": "tui.input.tab",
+};
+
+/** Translate existing settings names once, without translating terminal bytes. */
+export function editorBindings(byAction: Readonly<Record<string, readonly string[]>>): KeybindingsManager {
+  const config: KeybindingsConfig = {};
+  for (const [action, chords] of Object.entries(byAction)) {
+    const id = INPUT_ACTIONS[action] ?? `tui.${action}`;
+    if (id in TUI_KEYBINDINGS) config[id] = [...chords] as KeyId[];
+  }
+  return new KeybindingsManager(TUI_KEYBINDINGS, config);
+}