talon-agent 4.3.1 → 4.3.3

package/src/frontend/terminal/input/history.ts

@@ -0,0 +1,64 @@
+import { cloneParts, partsText, type InputPart } from "./parts.js";
+
+const MAX_HISTORY_ITEMS = 100;
+
+/**
+ * In-process prompt history. Keeping this out of the persistent stores avoids
+ * creating a second plaintext transcript while still giving terminal users
+ * the expected Up/Down workflow.
+ */
+export class PromptHistory {
+  private readonly entries: InputPart[][] = [];
+  private cursor = 0;
+  private draft: InputPart[] | null = null;
+
+  constructor(private readonly maxItems = MAX_HISTORY_ITEMS) {}
+
+  add(parts: readonly InputPart[]): void {
+    const text = partsText(parts);
+    if (!text) return;
+
+    const latest = this.entries.at(-1);
+    if (!latest || partsText(latest) !== text) {
+      this.entries.push(cloneParts(parts));
+      if (this.entries.length > this.maxItems) this.entries.shift();
+    }
+    this.resetNavigation();
+  }
+
+  move(
+    direction: "previous" | "next",
+    current: readonly InputPart[],
+  ): InputPart[] | undefined {
+    if (this.entries.length === 0) return undefined;
+
+    if (direction === "previous") {
+      if (this.cursor === this.entries.length) {
+        this.draft = cloneParts(current);
+      }
+      if (this.cursor > 0) this.cursor--;
+      return cloneParts(this.entries[this.cursor]!);
+    }
+
+    if (this.cursor === this.entries.length) return undefined;
+    if (this.cursor < this.entries.length - 1) {
+      this.cursor++;
+      return cloneParts(this.entries[this.cursor]!);
+    }
+
+    this.cursor = this.entries.length;
+    return cloneParts(this.draft ?? [{ type: "text", content: "" }]);
+  }
+
+  /** Preserve an edited recalled prompt as the current draft. */
+  detach(parts: readonly InputPart[]): void {
+    if (this.cursor === this.entries.length) return;
+    this.cursor = this.entries.length;
+    this.draft = cloneParts(parts);
+  }
+
+  resetNavigation(): void {
+    this.cursor = this.entries.length;
+    this.draft = null;
+  }
+}

package/src/frontend/terminal/input/keys.ts

@@ -0,0 +1,143 @@
+/**
+ * Key dispatch — one handler per control code. Anything not in the table is
+ * either a stray control character (dropped) or a printable one (typed).
+ */
+
+import { ensureTrailingText, lastPart } from "./parts.js";
+import { redraw } from "./render.js";
+import { clearInput, fullText, submitInput, type InputState } from "./state.js";
+
+/**
+ * Handles the key at `chunk[i]`. Returns the index of the last byte it
+ * consumed, so a multi-byte escape sequence can skip its tail.
+ */
+type KeyHandler = (state: InputState, chunk: string, i: number) => number;
+
+function insertText(state: InputState, text: string): void {
+  ensureTrailingText(state.parts).content += text;
+  state.history.detach(state.parts);
+  redraw(state);
+}
+
+function navigateHistory(
+  state: InputState,
+  direction: "previous" | "next",
+): void {
+  const recalled = state.history.move(direction, state.parts);
+  if (!recalled) return;
+  state.parts = recalled;
+  redraw(state);
+}
+
+function onCtrlC(): number {
+  process.stdout.write("\n\x1b[?2004l");
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  process.exit(0);
+}
+
+function onCtrlU(state: InputState, _chunk: string, i: number): number {
+  clearInput(state);
+  redraw(state);
+  return i;
+}
+
+function onEnter(state: InputState, _chunk: string, i: number): number {
+  if (fullText(state)) {
+    submitInput(state);
+  } else {
+    process.stdout.write("\n");
+    redraw(state);
+  }
+  return i;
+}
+
+function onBackspace(state: InputState, _chunk: string, i: number): number {
+  const parts = state.parts;
+  const last = lastPart(parts);
+  if (last.type === "text" && last.content.length > 0) {
+    // Delete last char from text
+    last.content = last.content.slice(0, -1);
+  } else if (last.type === "text" && last.content === "" && parts.length > 1) {
+    // Empty trailing text — remove it, then remove the paste before it
+    parts.pop();
+    parts.pop();
+    // Ensure we always have at least one text part
+    if (parts.length === 0) parts.push({ type: "text", content: "" });
+    ensureTrailingText(parts);
+  } else if (last.type === "paste") {
+    // Remove the paste block
+    parts.pop();
+    if (parts.length === 0) parts.push({ type: "text", content: "" });
+    ensureTrailingText(parts);
+  }
+  state.history.detach(parts);
+  redraw(state);
+  return i;
+}
+
+function onEscape(state: InputState, chunk: string, i: number): number {
+  if (i + 1 < chunk.length && chunk[i + 1] === "[") {
+    // CSI escape sequence. Up/Down navigate history; the rest are
+    // ignored until cursor editing is implemented.
+    let end = i + 2;
+    while (end < chunk.length && chunk.charCodeAt(end) < 0x40) end++;
+    const final = chunk[end];
+    if (final === "A") navigateHistory(state, "previous");
+    if (final === "B") navigateHistory(state, "next");
+    return end;
+  }
+  if (
+    i + 2 < chunk.length &&
+    chunk[i + 1] === "O" &&
+    (chunk[i + 2] === "A" || chunk[i + 2] === "B")
+  ) {
+    // Some terminals use application-cursor sequences (ESC O A/B).
+    navigateHistory(state, chunk[i + 2] === "A" ? "previous" : "next");
+    return i + 2;
+  }
+  if (state.pendingResolve) {
+    // Bare Escape during waitForInput — cancel
+    const resolve = state.pendingResolve;
+    state.pendingResolve = null;
+    clearInput(state);
+    process.stdout.write("\n");
+    resolve("");
+  }
+  return i;
+}
+
+function onTab(state: InputState, _chunk: string, i: number): number {
+  insertText(state, "  ");
+  return i;
+}
+
+/** Control code → handler. Enter and Backspace each answer to two codes. */
+export const KEY_HANDLERS: Record<number, KeyHandler> = Object.assign(
+  Object.create(null),
+  {
+    0x03: onCtrlC, // Ctrl+C
+    0x15: onCtrlU, // Ctrl+U
+    0x0d: onEnter, // Enter (CR)
+    0x0a: onEnter, // Enter (LF)
+    0x7f: onBackspace, // Backspace (DEL)
+    0x08: onBackspace, // Backspace (BS)
+    0x1b: onEscape, // Escape / CSI
+    0x09: onTab, // Tab
+  },
+);
+
+/** Normal (non-paste) input: dispatch each key in the chunk. */
+export function handleKeyChunk(state: InputState, chunk: string): void {
+  for (let i = 0; i < chunk.length; i++) {
+    const code = chunk.charCodeAt(i);
+    const handler = KEY_HANDLERS[code];
+    if (handler) {
+      i = handler(state, chunk, i);
+      continue;
+    }
+    if (code < 0x20) continue;
+
+    // Printable char
+    insertText(state, chunk[i]!);
+  }
+}

package/src/frontend/terminal/input/parts.ts

@@ -0,0 +1,33 @@
+/**
+ * Input parts — the ordered list of typed text segments and collapsed paste
+ * blocks that makes up the current line.
+ */
+
+export type InputPart =
+  { type: "text"; content: string } | { type: "paste"; content: string };
+type TextPart = Extract<InputPart, { type: "text" }>;
+export type PastePart = Extract<InputPart, { type: "paste" }>;
+
+export function cloneParts(parts: readonly InputPart[]): InputPart[] {
+  return parts.map((part) => ({ ...part }));
+}
+
+export function partsText(parts: readonly InputPart[]): string {
+  return parts
+    .map((part) => part.content)
+    .join("\n")
+    .trim();
+}
+
+export function lastPart(parts: InputPart[]): InputPart {
+  return parts[parts.length - 1]!;
+}
+
+/** Ensure the last part is a text part (for typing into). */
+export function ensureTrailingText(parts: InputPart[]): TextPart {
+  const last = lastPart(parts);
+  if (last.type === "text") return last;
+  const t: TextPart = { type: "text", content: "" };
+  parts.push(t);
+  return t;
+}

package/src/frontend/terminal/input/paste.ts

@@ -0,0 +1,53 @@
+/** Bracketed paste — accumulate between the start/end markers, then collapse. */
+
+import { ensureTrailingText } from "./parts.js";
+import { redraw } from "./render.js";
+import type { InputState } from "./state.js";
+
+const PASTE_COLLAPSE_LINES = 3;
+const PASTE_COLLAPSE_CHARS = 150;
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+
+function handlePasteComplete(state: InputState, text: string): void {
+  const lineCount = text.split("\n").length;
+  if (lineCount >= PASTE_COLLAPSE_LINES || text.length > PASTE_COLLAPSE_CHARS) {
+    // Collapse into a paste part
+    state.parts.push({ type: "paste", content: text });
+  } else {
+    // Short paste — inline into current text part
+    ensureTrailingText(state.parts).content += text.replace(/\n/g, " ");
+  }
+  state.history.detach(state.parts);
+  redraw(state);
+}
+
+/**
+ * Feed a stdin chunk to the paste accumulator. Returns true when the chunk
+ * belonged to a paste (started one, continued one, or finished one) and so
+ * must not reach the key dispatcher.
+ */
+export function consumePasteChunk(state: InputState, chunk: string): boolean {
+  if (chunk.includes(PASTE_START)) {
+    state.inPaste = true;
+    state.pasteAccum = chunk.split(PASTE_START).slice(1).join(PASTE_START);
+    if (state.pasteAccum.includes(PASTE_END)) {
+      state.inPaste = false;
+      handlePasteComplete(state, state.pasteAccum.split(PASTE_END)[0]!);
+      state.pasteAccum = "";
+    }
+    return true;
+  }
+  if (state.inPaste) {
+    if (chunk.includes(PASTE_END)) {
+      state.pasteAccum += chunk.split(PASTE_END)[0]!;
+      state.inPaste = false;
+      handlePasteComplete(state, state.pasteAccum);
+      state.pasteAccum = "";
+    } else {
+      state.pasteAccum += chunk;
+    }
+    return true;
+  }
+  return false;
+}

package/src/frontend/terminal/input/render.ts

@@ -0,0 +1,42 @@
+/** Drawing — rewrite the prompt line(s) in place. */
+
+import pc from "picocolors";
+import type { PastePart } from "./parts.js";
+import type { InputState } from "./state.js";
+
+function pasteTag(p: PastePart): string {
+  const lines = p.content.split("\n").length;
+  return lines > 1
+    ? `[Pasted ~${lines} lines]`
+    : `[Pasted ${p.content.length} chars]`;
+}
+
+/**
+ * Track how many visual rows the last render occupied.
+ * Move up to the first row, clear to end of screen, rewrite.
+ */
+export function redraw(state: InputState): void {
+  const cols = process.stdout.columns || 80;
+
+  // Build display string and measure visible length (strip ANSI)
+  let display = state.promptStr;
+  let visLen = 4; // "  ❯ " = 4 visible chars
+  for (const p of state.parts) {
+    if (p.type === "text") {
+      display += p.content;
+      visLen += p.content.length;
+    } else {
+      const tag = pasteTag(p);
+      display += pc.dim(tag);
+      visLen += tag.length;
+    }
+  }
+
+  // Move cursor to start of the previous render, clear to end of screen
+  if (state.prevRows > 1) {
+    process.stdout.write(`\x1b[${state.prevRows - 1}A`); // move up
+  }
+  process.stdout.write(`\r\x1b[J${display}\x1b[?25h`); // col 0, clear to EOS, write, show cursor
+
+  state.prevRows = Math.max(1, Math.ceil(visLen / cols));
+}

package/src/frontend/terminal/input/state.ts

@@ -0,0 +1,60 @@
+/**
+ * Input state — everything the keypress, paste and render modules share,
+ * lifted out of the `createInput` closure.
+ */
+
+import { PromptHistory } from "./history.js";
+import { partsText, type InputPart } from "./parts.js";
+
+export type InputState = {
+  readonly promptStr: string;
+  lineCallback: ((text: string) => void) | null;
+  pendingResolve: ((value: string) => void) | null;
+  paused: boolean;
+  /** Input is an ordered list of parts. */
+  parts: InputPart[];
+  readonly history: PromptHistory;
+  /** Bracketed paste accumulation. */
+  inPaste: boolean;
+  pasteAccum: string;
+  /** How many visual rows the last render occupied. */
+  prevRows: number;
+};
+
+export function createInputState(promptStr: string): InputState {
+  return {
+    promptStr,
+    lineCallback: null,
+    pendingResolve: null,
+    paused: false,
+    parts: [{ type: "text", content: "" }],
+    history: new PromptHistory(),
+    inPaste: false,
+    pasteAccum: "",
+    prevRows: 1,
+  };
+}
+
+export function fullText(state: InputState): string {
+  return partsText(state.parts);
+}
+
+export function clearInput(state: InputState): void {
+  state.parts = [{ type: "text", content: "" }];
+  state.history.resetNavigation();
+}
+
+export function submitInput(state: InputState): void {
+  const text = fullText(state);
+  if (!state.pendingResolve) state.history.add(state.parts);
+  clearInput(state);
+  process.stdout.write("\n");
+
+  if (state.pendingResolve) {
+    const resolve = state.pendingResolve;
+    state.pendingResolve = null;
+    resolve(text);
+    return;
+  }
+  if (state.lineCallback) state.lineCallback(text);
+}