@visual-z/xeno 0.8.3 → 0.9.0

package/src/tui/style.ts

@@ -1,208 +0,0 @@
-/**
- * SGR composition for markdown.
- *
- * Terminals do not keep attributes across a newline, and the differential
- * renderer rewrites by line (`src/tui/render.ts`). A wrap-the-whole-string
- * helper would leave only the first row with an open code, so a later
- * rewrite of row 2 paints in the default style. Every output row therefore
- * carries its own open and close.
- *
- * Identity emits no ESC bytes: `-p` and pipes parse the transcript, and a
- * CSI in that stream is a parse error waiting for a script (D17, same
- * reason `createPalette(false)` exists).
- *
- * Colours are data: createStyle reads token → SGR params. Hard-coding a
- * CSI colour here would be a colour the theme cannot reach.
- */
-
-export interface Attrs {
-  readonly bold: boolean;
-  readonly italic: boolean;
-  readonly dim: boolean;
-  readonly code: boolean;
-  readonly heading: boolean;
-  readonly link: boolean;
-  /** Optional: tool diffs and exit codes. Absent keeps markdown Attrs unchanged. */
-  readonly red?: boolean;
-  readonly green?: boolean;
-  readonly yellow?: boolean;
-  readonly thinking?: boolean;
-  readonly tool?: boolean;
-  readonly result?: boolean;
-  readonly error?: boolean;
-  readonly status?: boolean;
-  readonly prompt?: boolean;
-  readonly selected?: boolean;
-}
-
-export const PLAIN_ATTRS: Attrs = {
-  bold: false,
-  italic: false,
-  dim: false,
-  code: false,
-  heading: false,
-  link: false,
-};
-
-export interface Style {
-  open(attrs: Attrs): string;
-  close(attrs: Attrs): string;
-  token?(name: string, text: string): string;
-}
-
-/**
- * Token → SGR colour params. Same names as core/theme.ts; duplicated so
- * tui never imports core. Empty string is the terminal default.
- */
-export type ColorTokens = {
-  readonly text: string;
-  readonly thinkingText: string;
-  readonly toolTitle: string;
-  readonly toolOutput: string;
-  readonly error: string;
-  readonly toolDiffAdded: string;
-  readonly toolDiffRemoved: string;
-  readonly status: string;
-  readonly prompt: string;
-  readonly selectedBg: string;
-  readonly muted: string;
-  readonly warning: string;
-  readonly mdHeading: string;
-  readonly mdCode: string;
-  readonly mdLink: string;
-};
-
-/**
- * Must stay in lockstep with core/theme.ts dark builtin: terminal slots only,
- * no truecolor, no background, no SGR faint for muted text.
- */
-export const DEFAULT_COLORS: ColorTokens = {
-  "text": "",
-  "thinkingText": "95",
-  "toolTitle": "",
-  "toolOutput": "37",
-  "error": "91",
-  "toolDiffAdded": "92",
-  "toolDiffRemoved": "91",
-  "status": "37",
-  "prompt": "",
-  "selectedBg": "",
-  "muted": "37",
-  "warning": "93",
-  "mdHeading": "94",
-  "mdCode": "96",
-  "mdLink": "94"
-};
-
-function anyAttr(a: Attrs, color: string): boolean {
-  return (
-    a.bold ||
-    a.italic ||
-    a.dim ||
-    a.code ||
-    a.heading ||
-    a.link ||
-    a.red === true ||
-    a.green === true ||
-    a.yellow === true ||
-    a.thinking === true ||
-    a.tool === true ||
-    a.result === true ||
-    a.error === true ||
-    a.status === true ||
-    a.prompt === true ||
-    a.selected === true ||
-    color.length > 0
-  );
-}
-
-function pickColor(attrs: Attrs, colors: ColorTokens): string {
-  if (attrs.selected === true) return colors.selectedBg;
-  if (attrs.prompt === true) return colors.prompt;
-  if (attrs.status === true) return colors.status;
-  if (attrs.thinking === true) return colors.thinkingText;
-  if (attrs.error === true) return colors.error;
-  if (attrs.red === true) return colors.toolDiffRemoved;
-  if (attrs.green === true) return colors.toolDiffAdded;
-  if (attrs.yellow === true) return colors.warning;
-  if (attrs.tool === true) return colors.toolTitle;
-  if (attrs.result === true) return colors.toolOutput;
-  if (attrs.code) return colors.mdCode;
-  if (attrs.heading) return colors.mdHeading;
-  if (attrs.link) return colors.mdLink;
-  if (attrs.dim) return colors.muted;
-  return colors.text;
-}
-
-/** Full reset, not a stacked 22/23/24. Nested closes would drop a wrapping attr on wrap. */
-const RESET = "\x1b[0m";
-
-export const IDENTITY: Style = {
-  open: () => "",
-  close: () => "",
-};
-
-/**
- * Build a Style from theme tokens. `enabled` is the NO_COLOR / non-tty gate:
- * a themed Style that still emits ESC in a pipe is the same class of bug as
- * createPalette(true) on stdout that is not a tty.
- */
-export function createStyle(colors: { readonly [token: string]: string }, enabled = true): Style {
-  if (!enabled) return IDENTITY;
-  const tokens: ColorTokens = {
-    text: colors["text"] ?? "",
-    thinkingText: colors["thinkingText"] ?? "",
-    toolTitle: colors["toolTitle"] ?? "",
-    toolOutput: colors["toolOutput"] ?? "",
-    error: colors["error"] ?? "",
-    toolDiffAdded: colors["toolDiffAdded"] ?? "",
-    toolDiffRemoved: colors["toolDiffRemoved"] ?? "",
-    status: colors["status"] ?? "",
-    prompt: colors["prompt"] ?? "",
-    selectedBg: colors["selectedBg"] ?? "",
-    muted: colors["muted"] ?? "",
-    warning: colors["warning"] ?? "",
-    mdHeading: colors["mdHeading"] ?? "",
-    mdCode: colors["mdCode"] ?? "",
-    mdLink: colors["mdLink"] ?? "",
-  };
-  return {
-    token(name, text) {
-      const color = colors[name];
-      return color ? `\x1b[${color}m${text}${RESET}` : text;
-    },
-    open(attrs) {
-      const color = pickColor(attrs, tokens);
-      if (!anyAttr(attrs, color)) return "";
-      const params: string[] = [];
-      if (attrs.bold || attrs.heading) params.push("1");
-      if (attrs.italic) params.push("3");
-      if (attrs.link) params.push("4");
-      if (color.length > 0) params.push(...color.split(";"));
-      const dim = attrs.dim ? "\x1b[2m" : "";
-      return dim + (params.length > 0 ? `\x1b[${params.join(";")}m` : "");
-    },
-    close(attrs) {
-      const color = pickColor(attrs, tokens);
-      return anyAttr(attrs, color) ? RESET : "";
-    },
-  };
-}
-
-export const ANSI: Style = createStyle(DEFAULT_COLORS);
-
-export function withDim(base: Style): Style {
-  return {
-    open(attrs) {
-      return base.open({ ...attrs, dim: true });
-    },
-    close(attrs) {
-      return base.close({ ...attrs, dim: true });
-    },
-  };
-}
-
-export function paint(text: string, attrs: Attrs, style: Style): string {
-  if (text.length === 0) return text;
-  return style.open(attrs) + text + style.close(attrs);
-}

package/src/tui/ui/atomic-draft.ts

@@ -1,121 +0,0 @@
-import { TextareaRenderable, type OptimizedBuffer, type KeyEvent } from "@opentui/core";
-
-/** D20: the native editor owns text and undo; this adapter only protects registered ASCII tokens.
- * Offsets in OpenTUI are terminal cells, while app projections use UTF-16. Resolve token starts
- * through the native buffer, so wide glyphs, combining marks, tabs and newlines stay its concern.
- * Native virtual extmarks in 0.5.14 subtract one on left navigation and do not expand word or
- * selection deletion; use one range policy for every edit rather than patching their internals.
- */
-export interface DraftAtom { readonly start: number; readonly end: number }
-
-export class AtomicDraftArea extends TextareaRenderable {
-  atoms: ((text: string) => readonly DraftAtom[]) | undefined;
-  onRendered: (() => void) | undefined;
-  private killed = "";
-
-  get textCursor(): number { return this.editBuffer.getTextRange(0, this.cursorOffset).length; }
-
-  private ranges(): DraftAtom[] {
-    const text = this.plainText;
-    return (this.atoms?.(text) ?? []).map(atom => {
-      // Every token starts with one ASCII character. The first native prefix containing it
-      // ends exactly one cell after its start, irrespective of the preceding Unicode text.
-      let low = 0, high = text.length * Math.max(2, this.editBuffer.getTabWidth()) + 1;
-      while (low < high) {
-        const middle = Math.floor((low + high) / 2);
-        if (this.editBuffer.getTextRange(0, middle).length > atom.start) high = middle;
-        else low = middle + 1;
-      }
-      const start = Math.max(0, low - 1);
-      return { start, end: start + atom.end - atom.start };
-    });
-  }
-
-  private snap(direction = 0): void {
-    if (this.hasSelection()) return;
-    const cursor = this.cursorOffset;
-    const atom = this.ranges().find(range => cursor > range.start && cursor < range.end);
-    if (!atom) return;
-    this.editorView.setCursorByOffset(direction < 0 ? atom.start : direction > 0 ? atom.end :
-      cursor - atom.start < atom.end - cursor ? atom.start : atom.end);
-    this.requestRender();
-  }
-
-  private move(action: () => boolean, direction: number): boolean {
-    const result = action(); this.snap(direction); return result;
-  }
-  override moveCursorLeft(options?: { select?: boolean }): boolean { return this.move(() => super.moveCursorLeft(options), -1); }
-  override moveCursorRight(options?: { select?: boolean }): boolean { return this.move(() => super.moveCursorRight(options), 1); }
-  override moveCursorUp(options?: { select?: boolean }): boolean { return this.move(() => super.moveCursorUp(options), 0); }
-  override moveCursorDown(options?: { select?: boolean }): boolean { return this.move(() => super.moveCursorDown(options), 0); }
-  override moveWordBackward(options?: { select?: boolean }): boolean { return this.move(() => super.moveWordBackward(options), -1); }
-  override moveWordForward(options?: { select?: boolean }): boolean { return this.move(() => super.moveWordForward(options), 1); }
-  override gotoVisualLineHome(options?: { select?: boolean }): boolean { return this.move(() => super.gotoVisualLineHome(options), -1); }
-  override gotoVisualLineEnd(options?: { select?: boolean }): boolean { return this.move(() => super.gotoVisualLineEnd(options), 1); }
-  override setCursor(row: number, col: number): void { super.setCursor(row, col); this.snap(); }
-
-  private erase(start: number, end: number, kill = false): boolean {
-    if (start > end) [start, end] = [end, start];
-    if (start === end) return true;
-    for (const atom of this.ranges()) {
-      if (atom.start < end && atom.end > start) { start = Math.min(start, atom.start); end = Math.max(end, atom.end); }
-    }
-    if (kill) this.killed = this.editBuffer.getTextRange(start, end);
-    const a = this.editBuffer.offsetToPosition(start), b = this.editBuffer.offsetToPosition(end);
-    if (!a || !b) return false;
-    this.clearSelection();
-    this.editBuffer.deleteRange(a.row, a.col, b.row, b.col);
-    this.requestRender();
-    return true;
-  }
-  override deleteSelection(): boolean {
-    const selection = this.getSelection();
-    return selection ? this.erase(selection.start, selection.end) : false;
-  }
-  override deleteCharBackward(): boolean {
-    if (this.hasSelection()) return this.deleteSelection();
-    const atom = this.ranges().find(range => this.cursorOffset > range.start && this.cursorOffset <= range.end);
-    return atom ? this.erase(atom.start, atom.end) : super.deleteCharBackward();
-  }
-  override deleteChar(): boolean {
-    if (this.hasSelection()) return this.deleteSelection();
-    const atom = this.ranges().find(range => this.cursorOffset >= range.start && this.cursorOffset < range.end);
-    return atom ? this.erase(atom.start, atom.end) : super.deleteChar();
-  }
-  override deleteWordBackward(): boolean {
-    if (this.hasSelection()) return this.deleteSelection();
-    return this.erase(this.editBuffer.getPrevWordBoundary().offset, this.cursorOffset, true);
-  }
-  override deleteWordForward(): boolean {
-    if (this.hasSelection()) return this.deleteSelection();
-    return this.erase(this.cursorOffset, this.editBuffer.getNextWordBoundary().offset, true);
-  }
-  override deleteToLineStart(): boolean {
-    const cursor = this.editBuffer.getCursorPosition();
-    return cursor.col ? this.erase(this.editBuffer.getLineStartOffset(cursor.row), cursor.offset, true) : super.deleteToLineStart();
-  }
-  override deleteToLineEnd(): boolean {
-    const end = this.editBuffer.getEOL().offset;
-    return end > this.cursorOffset ? this.erase(this.cursorOffset, end, true) : super.deleteToLineEnd();
-  }
-  override insertText(text: string): void {
-    if (this.hasSelection()) this.deleteSelection();
-    this.snap(); super.insertText(text);
-  }
-  override insertChar(char: string): void {
-    if (this.hasSelection()) this.deleteSelection();
-    this.snap(); super.insertChar(char);
-  }
-  override newLine(): boolean {
-    if (this.hasSelection()) this.deleteSelection();
-    this.snap(); return super.newLine();
-  }
-  override handleKeyPress(event: KeyEvent): boolean {
-    if (event.ctrl && event.name === "y" && this.killed) { this.insertText(this.killed); return true; }
-    return super.handleKeyPress(event);
-  }
-  clearKilledText(): void { this.killed = ""; }
-  override render(buffer: OptimizedBuffer, deltaTime: number): void {
-    this.snap(); super.render(buffer, deltaTime); this.onRendered?.();
-  }
-}

package/src/tui/ui/canvas.ts

@@ -1,96 +0,0 @@
-/**
- * Rows of styled segments drawn straight into the frame buffer.
- *
- * Chrome (input box edges, top bar, sidebar, greeting, completion list)
- * changes often and never needs wrapping or selection, so it skips the text
- * layout machinery: setting a TextRenderable's content re-measures the node
- * and dirties Yoga, even for an identical string (OpenTUI 0.5.14,
- * TextBufferRenderable). A Canvas only stores rows and requests a frame;
- * the activity glyph is read at paint time, so a spinner tick touches no
- * node at all (docs/tasks/refactor-tui-dock-layout.md DoD 9).
- */
-import { Renderable, TextAttributes, type OptimizedBuffer, type RenderContext, type RenderableOptions, type RGBA } from "@opentui/core";
-import type { UiColors } from "./colors.ts";
-import type { Role } from "./edge.ts";
-import type { Line } from "./status.ts";
-import { displayWidth } from "../width.ts";
-
-export interface CanvasOptions extends RenderableOptions<Canvas> {
-  readonly colors: UiColors;
-  /** The current activity glyph for `spin` segments. */
-  readonly glyph?: () => string;
-}
-
-export function roleColor(colors: UiColors, role: Role): RGBA {
-  switch (role) {
-    case "text": return colors.text;
-    case "muted": return colors.muted;
-    case "edge": return colors.edge;
-    case "line": return colors.line;
-    case "accent": return colors.accent;
-    case "success": return colors.success;
-    case "error": return colors.error;
-    case "warning": return colors.warning;
-    case "reasoning": return colors.reasoning;
-    case "code": return colors.code;
-  }
-}
-
-export class Canvas extends Renderable {
-  private rows: readonly Line[] = [];
-  private colors: UiColors;
-  private readonly glyph: () => string;
-
-  constructor(ctx: RenderContext, options: CanvasOptions) {
-    super(ctx, options);
-    this.colors = options.colors;
-    this.glyph = options.glyph ?? (() => "●");
-  }
-
-  get lines(): readonly Line[] { return this.rows; }
-  /** Plain text of what is drawn (tests, /debug). */
-  get text(): string { return this.rows.map(row => row.map(seg => seg.spin ? this.glyph() : seg.text).join("")).join("\n"); }
-
-  /** Store new rows; an identical set requests nothing. */
-  setRows(rows: readonly Line[]): void {
-    if (sameRows(rows, this.rows)) return;
-    this.rows = rows;
-    this.requestRender();
-  }
-
-  setColors(colors: UiColors): void { this.colors = colors; this.requestRender(); }
-
-  protected override renderSelf(buffer: OptimizedBuffer): void {
-    const x0 = this.screenX, y0 = this.screenY, width = this.width, height = this.height;
-    for (let row = 0; row < Math.min(height, this.rows.length); row++) {
-      // Rows scrolled above the buffer must be skipped here: the native drawText
-      // clamps a negative row to 0, where the scissor (the scroll viewport) lets it through.
-      const y = y0 + row;
-      if (y < 0 || y >= buffer.height) continue;
-      let x = x0;
-      for (const seg of this.rows[row]!) {
-        const text = seg.spin ? this.glyph() : seg.text;
-        if (!text) continue;
-        const w = seg.spin ? 1 : displayWidth(text);
-        if (x - x0 + w > width) break;
-        const attributes = (seg.bold ? TextAttributes.BOLD : 0) | (seg.italic ? TextAttributes.ITALIC : 0);
-        buffer.drawText(text, x, y, roleColor(this.colors, seg.role), undefined, attributes);
-        x += w;
-      }
-    }
-  }
-}
-
-function sameRows(a: readonly Line[], b: readonly Line[]): boolean {
-  if (a === b) return true;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i]!, y = b[i]!;
-    if (x.length !== y.length) return false;
-    for (let j = 0; j < x.length; j++) {
-      const p = x[j]!, q = y[j]!;
-      if (p.text !== q.text || p.role !== q.role || p.bold !== q.bold || p.italic !== q.italic || p.spin !== q.spin) return false;
-    }
-  }
-  return true;
-}

package/src/tui/ui/colors.ts

@@ -1,70 +0,0 @@
-/**
- * The view's colour vocabulary, as OpenTUI colours ready to draw with.
- *
- * Built-in appearances come from the terminal's own palette (ink.ts): the
- * background is never painted and body text is the terminal's foreground.
- * A custom theme file supplies explicit colours instead. `src/tui` may not
- * import core, so the app maps its Theme into this record (apps/ui/theme.ts).
- *
- * Colour carries a stable role: one accent for navigation, success/error
- * only for logged outcomes (D11), warning for things waiting on the user.
- */
-import { RGBA } from "@opentui/core";
-import { terminalInks, type InkSet, type InkSpec } from "./ink.ts";
-
-export interface UiColors {
-  /** The terminal default unless a custom theme sets one explicitly. */
-  readonly background: RGBA;
-  readonly text: RGBA;
-  readonly muted: RGBA;
-  /** The input box border. */
-  readonly edge: RGBA;
-  /** Rules, separators and scrollbar tracks. */
-  readonly line: RGBA;
-  readonly accent: RGBA;
-  readonly success: RGBA;
-  readonly error: RGBA;
-  readonly warning: RGBA;
-  readonly reasoning: RGBA;
-  readonly code: RGBA;
-  /** Mouse-selected text (feat-tui-copy-selection). */
-  readonly selectionBg: RGBA;
-  readonly selectionFg: RGBA;
-}
-
-const cache = new Map<string, RGBA>();
-function cached(key: string, make: () => RGBA): RGBA {
-  let value = cache.get(key);
-  if (!value) { value = make(); cache.set(key, value); }
-  return value;
-}
-
-export function inkColor(spec: InkSpec): RGBA {
-  switch (spec.kind) {
-    case "default": return cached("default:fg", () => RGBA.defaultForeground());
-    case "index": return cached(`index:${spec.index}`, () => RGBA.fromIndex(spec.index));
-    case "rgb": return rgba(spec.hex);
-  }
-}
-
-/** The terminal's own background: SGR 49, so transparency and blur survive. */
-export const TERMINAL_BACKGROUND: RGBA = RGBA.defaultBackground();
-/** Nothing at all (OpenTUI skips the cell's background). */
-export const CLEAR: RGBA = RGBA.fromValues(0, 0, 0, 0);
-
-export function colorsFromInks(inks: InkSet): UiColors {
-  return {
-    background: inks.background.kind === "default" ? TERMINAL_BACKGROUND : inkColor(inks.background),
-    text: inkColor(inks.text), muted: inkColor(inks.muted), edge: inkColor(inks.edge), line: inkColor(inks.line),
-    accent: inkColor(inks.accent), success: inkColor(inks.success), error: inkColor(inks.error),
-    warning: inkColor(inks.warning), reasoning: inkColor(inks.reasoning), code: inkColor(inks.code),
-    selectionBg: inkColor(inks.selectionBg), selectionFg: inkColor(inks.selectionFg),
-  };
-}
-
-/** Before the terminal answers (or when it never does). */
-export const FALLBACK_COLORS: UiColors = colorsFromInks(terminalInks(null, "dark"));
-
-export function rgba(hex: string): RGBA {
-  return cached(`hex:${hex}`, () => RGBA.fromHex(hex));
-}