ubume 0.1.0

package/src/ui/input/inputBuffer.ts

@@ -0,0 +1,203 @@
+import type { WrappedTextRow } from "../render/textLayout.js";
+import { getTextWidth, normalizeLineBreaks, wrapTextRows } from "../render/textLayout.js";
+import { sanitizeTerminalInput } from "../../core/terminal/terminalSanitize.js";
+
+export type WrappedInputRow = WrappedTextRow;
+
+export interface InputViewport {
+  rows: WrappedInputRow[];
+  visibleRows: WrappedInputRow[];
+  cursorRow: number;
+  cursorColumn: number;
+  scrollRow: number;
+}
+
+function isHighSurrogate(code: number): boolean {
+  return code >= 0xd800 && code <= 0xdbff;
+}
+
+function isLowSurrogate(code: number): boolean {
+  return code >= 0xdc00 && code <= 0xdfff;
+}
+
+const LEAKED_SGR_MOUSE_PATTERN = /(?:\x1b)?\[<\d+;\d+;\d+[Mm]/g;
+
+export function normalizeInputText(text: string): string {
+  if (!text) return "";
+  // Strip out leaked SGR mouse coordinates that might have been emitted by
+  // the terminal without their ESC prefix (swallowed by readline).
+  const withoutMouse = text.replace(LEAKED_SGR_MOUSE_PATTERN, "");
+  return normalizeLineBreaks(sanitizeTerminalInput(withoutMouse));
+}
+
+export function stripMouseEscapes(input: string): string {
+  return input.replace(LEAKED_SGR_MOUSE_PATTERN, "");
+}
+
+export function normalizeCursorOffset(text: string, cursorOffset: number): number {
+  const safeCursor = Math.max(0, Math.min(cursorOffset, text.length));
+
+  if (
+    safeCursor > 0
+    && safeCursor < text.length
+    && isHighSurrogate(text.charCodeAt(safeCursor - 1))
+    && isLowSurrogate(text.charCodeAt(safeCursor))
+  ) {
+    return safeCursor - 1;
+  }
+
+  return safeCursor;
+}
+
+// ─── Cursor movement ─────────────────────────────────────────────────────────
+
+export function moveCursorLeft(text: string, cursorOffset: number): number {
+  const safeCursor = normalizeCursorOffset(text, cursorOffset);
+  if (safeCursor <= 0) return 0;
+
+  let nextCursor = safeCursor - 1;
+  if (nextCursor > 0 && isLowSurrogate(text.charCodeAt(nextCursor)) && isHighSurrogate(text.charCodeAt(nextCursor - 1))) {
+    nextCursor -= 1;
+  }
+
+  return nextCursor;
+}
+
+export function moveCursorRight(text: string, cursorOffset: number): number {
+  const safeCursor = normalizeCursorOffset(text, cursorOffset);
+  if (safeCursor >= text.length) return text.length;
+
+  if (
+    isHighSurrogate(text.charCodeAt(safeCursor))
+    && safeCursor + 1 < text.length
+    && isLowSurrogate(text.charCodeAt(safeCursor + 1))
+  ) {
+    return safeCursor + 2;
+  }
+
+  return safeCursor + 1;
+}
+
+// ─── Text mutations ───────────────────────────────────────────────────────────
+
+export function insertInputText(params: {
+  value: string;
+  cursorOffset: number;
+  text: string;
+}): { value: string; cursorOffset: number } {
+  const value = normalizeInputText(params.value);
+  const safeCursor = normalizeCursorOffset(value, params.cursorOffset);
+  const insertedText = normalizeInputText(params.text);
+  return {
+    value: value.slice(0, safeCursor) + insertedText + value.slice(safeCursor),
+    cursorOffset: safeCursor + insertedText.length,
+  };
+}
+
+export function deleteInputBackward(params: {
+  value: string;
+  cursorOffset: number;
+}): { value: string; cursorOffset: number } {
+  const value = normalizeInputText(params.value);
+  const safeCursor = normalizeCursorOffset(value, params.cursorOffset);
+  
+  if (safeCursor <= 0) {
+    return { value, cursorOffset: 0 };
+  }
+
+  const previousCursor = moveCursorLeft(value, safeCursor);
+  return {
+    value: value.slice(0, previousCursor) + value.slice(safeCursor),
+    cursorOffset: previousCursor,
+  };
+}
+
+export function deleteInputForward(params: {
+  value: string;
+  cursorOffset: number;
+}): { value: string; cursorOffset: number } {
+  const value = normalizeInputText(params.value);
+  const safeCursor = normalizeCursorOffset(value, params.cursorOffset);
+
+  if (safeCursor >= value.length) {
+    return { value, cursorOffset: safeCursor };
+  }
+
+  const nextCursor = moveCursorRight(value, safeCursor);
+  return {
+    value: value.slice(0, safeCursor) + value.slice(nextCursor),
+    cursorOffset: safeCursor,
+  };
+}
+
+// ─── Viewport ────────────────────────────────────────────────────────────────
+
+export function wrapInputRows(text: string, width: number): WrappedInputRow[] {
+  return wrapTextRows(normalizeInputText(text), width);
+}
+
+export function locateCursor(rows: WrappedInputRow[], cursorOffset: number) {
+  const safeCursor = Math.max(0, cursorOffset);
+
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index]!;
+    if (safeCursor <= row.end) {
+      const relative = Math.max(0, Math.min(safeCursor, row.end) - row.start);
+      return {
+        row: index,
+        column: getTextWidth(row.text.slice(0, relative)),
+      };
+    }
+  }
+
+  const lastRow = rows[rows.length - 1]!;
+  return {
+    row: rows.length - 1,
+    column: getTextWidth(lastRow.text),
+  };
+}
+
+export function clampScrollToCursor(
+  scrollRow: number,
+  cursorRow: number,
+  visibleRowCount: number,
+  totalRowCount = cursorRow + 1,
+): number {
+  const safeVisibleRows = Math.max(1, visibleRowCount);
+  const maxScroll = Math.max(0, totalRowCount - safeVisibleRows);
+  let nextScrollRow = Math.max(0, Math.min(scrollRow, maxScroll));
+
+  if (cursorRow < nextScrollRow) {
+    nextScrollRow = cursorRow;
+  }
+
+  if (cursorRow >= nextScrollRow + safeVisibleRows) {
+    nextScrollRow = cursorRow - safeVisibleRows + 1;
+  }
+
+  return Math.max(0, Math.min(nextScrollRow, maxScroll));
+}
+
+export function createInputViewport(params: {
+  text: string;
+  cursorOffset: number;
+  width: number;
+  maxVisibleRows: number;
+  scrollRow?: number;
+}): InputViewport {
+  const rows = wrapInputRows(params.text, params.width);
+  const cursor = locateCursor(rows, params.cursorOffset);
+  const nextScrollRow = clampScrollToCursor(params.scrollRow ?? 0, cursor.row, params.maxVisibleRows, rows.length);
+
+  return {
+    rows,
+    visibleRows: rows.slice(nextScrollRow, nextScrollRow + Math.max(1, params.maxVisibleRows)),
+    cursorRow: cursor.row,
+    cursorColumn: cursor.column,
+    scrollRow: nextScrollRow,
+  };
+}
+
+export function getComposerBodyWidth(totalWidth: number): number {
+  return Math.max(4, totalWidth - 4);
+}

package/src/ui/input/pastedContent.ts

@@ -0,0 +1,75 @@
+export const LARGE_PASTE_THRESHOLD = 1_000;
+
+export const PASTED_CONTENT_PATTERN = /\[Pasted Content ([\d,]+) chars\](?:\u2063[\uFE00-\uFE09]+\u2063)?/g;
+export const IMAGE_ATTACHMENT_PATTERN = /\[Image: ([^\]\n]+)\](?:\u2063[\uFE00-\uFE09]+\u2063)?/g;
+const ATOMIC_CONTENT_PATTERN = /(?:\[Pasted Content [\d,]+ chars\]|\[Image: [^\]\n]+\])(?:\u2063[\uFE00-\uFE09]+\u2063)?/g;
+
+let nextPasteId = 1;
+
+export function countCharacters(value: string): number {
+  return Array.from(value).length;
+}
+
+export function createPastedContentLabel(value: string): string {
+  return `[Pasted Content ${countCharacters(value).toLocaleString("en-US")} chars]`;
+}
+
+function encodeInvisibleId(value: number): string {
+  return String(value).split("").map((digit) => String.fromCharCode(0xFE00 + Number(digit))).join("");
+}
+
+export function createAtomicContentToken(label: string): string {
+  const id = encodeInvisibleId(nextPasteId++);
+  return `${label}\u2063${id}\u2063`;
+}
+
+export function createPastedContentToken(value: string): string {
+  return createAtomicContentToken(createPastedContentLabel(value));
+}
+
+export function isLargePaste(value: string): boolean {
+  return countCharacters(value) >= LARGE_PASTE_THRESHOLD;
+}
+
+export type PastedContentRegistry = Map<string, string[]>;
+
+export function expandPastedContent(value: string, registry: PastedContentRegistry): string {
+  const offsets = new Map<string, number>();
+  return value.replace(PASTED_CONTENT_PATTERN, (label) => {
+    const values = registry.get(label);
+    const offset = offsets.get(label) ?? 0;
+    offsets.set(label, offset + 1);
+    return values?.[offset] ?? label;
+  });
+}
+
+export function findPastedContentSpan(value: string, cursor: number) {
+  ATOMIC_CONTENT_PATTERN.lastIndex = 0;
+  for (const match of value.matchAll(ATOMIC_CONTENT_PATTERN)) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    if (cursor >= start && cursor <= end) return { start, end };
+  }
+  return null;
+}
+
+export function moveAcrossPastedContent(value: string, cursor: number, direction: "left" | "right"): number | null {
+  const span = findPastedContentSpan(value, cursor);
+  if (!span) return null;
+  if (direction === "left" && cursor > span.start) return span.start;
+  if (direction === "right" && cursor < span.end) return span.end;
+  return null;
+}
+
+export function deleteAdjacentPastedContent(value: string, cursor: number, direction: "backward" | "forward") {
+  ATOMIC_CONTENT_PATTERN.lastIndex = 0;
+  for (const match of value.matchAll(ATOMIC_CONTENT_PATTERN)) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    const adjacent = direction === "backward" ? cursor === end : cursor === start;
+    if (adjacent || (cursor > start && cursor < end)) {
+      return { value: value.slice(0, start) + value.slice(end), cursorOffset: start };
+    }
+  }
+  return null;
+}

package/src/ui/input/rawArrowKeys.ts

@@ -0,0 +1,28 @@
+export type ArrowDirection = "up" | "down" | "left" | "right";
+export type HorizontalArrowDirection = "left" | "right";
+
+const ESC = String.fromCharCode(27);
+
+const FINAL_BYTE_DIRECTIONS: Record<string, ArrowDirection> = {
+  A: "up",
+  B: "down",
+  C: "right",
+  D: "left",
+};
+
+// CSI form (`ESC [ C`, `ESC [ 1;5C`) and SS3/application-cursor form (`ESC O C`).
+// Terminals emit either depending on DECCKM, and modifier presses add parameters.
+// Kitty encodes arrows the same way; its CSI-u codepoint space does not cover them.
+const ARROW_PATTERN = new RegExp(`${ESC}(?:\\[[0-9;]*|O)([ABCD])`);
+
+/** Resolve an arrow key from a raw stdin chunk, or null when it holds none. */
+export function getArrowDirection(raw: string): ArrowDirection | null {
+  const finalByte = ARROW_PATTERN.exec(raw)?.[1];
+  return finalByte ? FINAL_BYTE_DIRECTIONS[finalByte] ?? null : null;
+}
+
+/** Horizontal-only variant for menus that ignore vertical movement. */
+export function getHorizontalArrowDirection(raw: string): HorizontalArrowDirection | null {
+  const direction = getArrowDirection(raw);
+  return direction === "left" || direction === "right" ? direction : null;
+}

package/src/ui/input/slashCommands.ts

@@ -0,0 +1,43 @@
+export interface SlashCommandSuggestion {
+  cmd: string;
+  desc: string;
+  aliases?: readonly string[];
+}
+
+export const SLASH_COMMANDS = [
+  { cmd: "/help", desc: "Show available commands" },
+  { cmd: "/clear", desc: "Clear chat and cancel active run" },
+  { cmd: "/resume", desc: "Resume a previous conversation" },
+  { cmd: "/providers", desc: "Open AI provider picker", aliases: ["/provider"] },
+  { cmd: "/model", desc: "Change active model" },
+  { cmd: "/models", desc: "Open model picker" },
+  { cmd: "/mode", desc: "Change execution mode" },
+  { cmd: "/route", desc: "Show active chat route" },
+  { cmd: "/backend", desc: "Change active backend" },
+  { cmd: "/reasoning", desc: "Change reasoning level" },
+  { cmd: "/plan", desc: "Show or toggle session plan mode" },
+  { cmd: "/settings", desc: "Open the settings picker", aliases: ["/setting"] },
+  { cmd: "/status", desc: "Show effective runtime configuration" },
+  { cmd: "/permissions", desc: "Inspect or update permissions and sandbox controls" },
+  { cmd: "/runtime", desc: "Compatibility runtime policy controls" },
+  { cmd: "/themes", desc: "Open visual theme picker" },
+  { cmd: "/verbose", desc: "Toggle verbose mode (detailed processing info)" },
+  { cmd: "/auth", desc: "Manage authentication" },
+  { cmd: "/workspace", desc: "Show the locked workspace" },
+  { cmd: "/copy", desc: "Copy the full conversation transcript to clipboard" },
+  { cmd: "/paste-image", desc: "Attach the image currently on the clipboard" },
+  { cmd: "/update", desc: "Check for updates and install the latest Ubume" },
+  { cmd: "/exit", desc: "Quit the application" },
+] as const satisfies readonly SlashCommandSuggestion[];
+
+export type CommandSuggestion = (typeof SLASH_COMMANDS)[number];
+
+function matchesPrefix(suggestion: SlashCommandSuggestion, prefix: string): boolean {
+  if (suggestion.cmd.startsWith(prefix)) return true;
+  return suggestion.aliases?.some((alias) => alias.startsWith(prefix)) ?? false;
+}
+
+export function getSlashCommandSuggestions(prefix: string): readonly CommandSuggestion[] {
+  const normalized = prefix.toLowerCase();
+  return SLASH_COMMANDS.filter((command) => matchesPrefix(command, normalized)).slice(0, 5);
+}

package/src/ui/input/useStdinRawModeLease.ts

@@ -0,0 +1,23 @@
+import { useEffect } from "react";
+import { useStdin } from "ink";
+
+/**
+ * Hold one raw-mode reference for the lifetime of the mounted tree.
+ *
+ * Ink refcounts raw-mode consumers (useFocus / active useInput). When the last
+ * consumer unmounts and a replacement mounts in the same commit — e.g. the
+ * composer moving between AppShell and TranscriptShell on overlay exit — Ink
+ * removes and re-adds its 'readable' stdin listener. Two such cycles in one
+ * tick, combined with a raw 'data' listener (BottomComposer's key sniffer),
+ * make Node/Bun streams switch stdin to flowing mode, after which 'readable'
+ * never fires and Ink stops receiving input entirely (no keys, no Ctrl+C).
+ * Keeping the count above zero at the root prevents the listener churn.
+ */
+export function useStdinRawModeLease(): void {
+  const { isRawModeSupported, setRawMode } = useStdin();
+  useEffect(() => {
+    if (!isRawModeSupported) return;
+    setRawMode(true);
+    return () => setRawMode(false);
+  }, [isRawModeSupported, setRawMode]);
+}