@lazyingart/agintiflow 0.12.0 → 0.12.2

package/README.md

@@ -67,7 +67,7 @@ aginti
 aginti chat
 ```
 
-Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
+Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. `Ctrl+J` inserts a new line in the colored input panel, Enter sends, arrow keys move through wrapped multiline input, and `Ctrl+A`/`Ctrl+E` jump to the current line start/end. Assistant responses render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, and tables. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
 
 For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSeek v4 pro by default and exposes `apply_patch` as a deterministic workspace tool. It supports exact replacements, Codex-style patch envelopes, and unified diffs, with preflight checks, path guardrails, hashes, and compact per-file diffs. See [docs/patch-tools.md](docs/patch-tools.md).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "type": "module",
   "description": "AgInTiFlow is a resumable Playwright website-control agent with OpenAI-compatible tool calling.",
   "license": "Apache-2.0",

package/scripts/smoke-cli-chat.js

@@ -4,6 +4,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { buildPromptLayout, stripMarkdown } from "../src/interactive-cli.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-cli-chat-"));
@@ -52,6 +53,38 @@ function runCli(args, inputText) {
 }
 
 try {
+  const renderedMarkdown = stripMarkdown(
+    [
+      "**Docker status**",
+      "",
+      "| Check | Result |",
+      "| --- | --- |",
+      "| `/.dockerenv` | **Present** |",
+      "| Hostname | `abc123` |",
+    ].join("\n")
+  );
+  if (renderedMarkdown.includes("**") || renderedMarkdown.includes("| --- |")) {
+    throw new Error("terminal markdown renderer left raw markdown syntax");
+  }
+  if (!renderedMarkdown.includes("Check") || !renderedMarkdown.includes("Present")) {
+    throw new Error("terminal markdown renderer dropped table content");
+  }
+
+  const promptLayout = buildPromptLayout(`${"x".repeat(180)}\nsecond line`, 95, 80, 24);
+  const visibleLengths = promptLayout.renderedRows.map((line) =>
+    line.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").length
+  );
+  if (promptLayout.rows.length < 4 || Math.max(...visibleLengths) > 79) {
+    throw new Error("terminal prompt layout did not wrap long multiline input safely");
+  }
+  if (promptLayout.cursorRow < 0 || promptLayout.cursorColumn < 0) {
+    throw new Error("terminal prompt layout returned an invalid cursor location");
+  }
+  const hugePromptLayout = buildPromptLayout(Array.from({ length: 30 }, (_unused, index) => `line ${index + 1}`).join("\n"), 120, 80, 20);
+  if (hugePromptLayout.renderedRows.length > 12 || !hugePromptLayout.renderedRows.some((line) => line.includes("earlier input row"))) {
+    throw new Error("terminal prompt layout did not bound redraw size for large prompts");
+  }
+
   const result = await runChat("Create notes/interactive.md with a short CLI chat smoke message\n/exit\n");
   const written = await fs.readFile(path.join(tempRoot, "notes/interactive.md"), "utf8");
   if (!written.includes("Created by AgInTiFlow mock mode.")) {
@@ -74,7 +107,7 @@ try {
       {
         ok: true,
         projectRoot: tempRoot,
-        checks: ["interactive-chat", "mock-file-write", "run-status", "resume-latest"],
+        checks: ["markdown-render", "prompt-layout", "interactive-chat", "mock-file-write", "run-status", "resume-latest"],
       },
       null,
       2

package/src/interactive-cli.js

@@ -18,6 +18,9 @@ const ansi = {
   green: "\x1b[32m",
   yellow: "\x1b[33m",
   red: "\x1b[31m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  faint: "\x1b[2m",
   clearLine: "\x1b[2K",
   cursorHide: "\x1b[?25l",
   cursorShow: "\x1b[?25h",
@@ -50,6 +53,7 @@ const SLASH_COMMANDS = [
   "/web",
   "/exit",
 ];
+const promptHistory = [];
 
 function color(value, ...codes) {
   if (!useColor || codes.length === 0) return String(value);
@@ -64,6 +68,39 @@ function label(name, bgCode) {
   return color(` ${name} `, bgCode, ansi.bold);
 }
 
+function terminalWidth() {
+  return Math.max(Number(output.columns) || 80, 40);
+}
+
+function terminalHeight() {
+  return Math.max(Number(output.rows) || 24, 10);
+}
+
+function editorWidth(width = terminalWidth()) {
+  return Math.max(Number(width) - 1, 39);
+}
+
+function promptViewportRows(height = terminalHeight()) {
+  return Math.max(Math.min(Math.floor(Number(height) * 0.42), 10), 4);
+}
+
+function visualLength(value) {
+  return stripAnsi(value).length;
+}
+
+function padVisible(value, width) {
+  const padding = Math.max(width - visualLength(value), 0);
+  return `${value}${" ".repeat(padding)}`;
+}
+
+function panelLine(content = "", bgCode = ansi.systemBg, width = editorWidth()) {
+  const raw = String(content || "");
+  const safeContent = visualLength(raw) > width ? stripAnsi(raw).slice(0, width) : raw;
+  if (!useColor) return padVisible(safeContent, width);
+  const padded = padVisible(safeContent, width).replaceAll(ansi.reset, `${ansi.reset}${bgCode}`);
+  return `${bgCode}${padded}${ansi.reset}`;
+}
+
 function userPrompt() {
   return `\n${label("user>", ansi.userBg)} ${color("|", ansi.userBg)} `;
 }
@@ -90,12 +127,17 @@ function commandSuggestions(line = "") {
   return SLASH_COMMANDS.filter((command) => command.startsWith(trimmed)).slice(0, 8);
 }
 
-function stripMarkdown(text) {
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+export function stripMarkdown(text) {
   const lines = String(text || "").split(/\r?\n/);
   let inFence = false;
   const rendered = [];
 
-  for (const rawLine of lines) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index];
     let line = rawLine;
     if (/^\s*```/.test(line)) {
       inFence = !inFence;
@@ -119,6 +161,12 @@ function stripMarkdown(text) {
       if (/^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line)) {
         continue;
       }
+      const table = parseMarkdownTable(lines, index);
+      if (table) {
+        rendered.push(...renderMarkdownTable(table));
+        index += table.rawLineCount - 1;
+        continue;
+      }
       line = line.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
       line = line.replace(/\*\*([^*]+)\*\*/g, (_, value) => color(value, ansi.bold));
       line = line.replace(/__([^_]+)__/g, (_, value) => color(value, ansi.bold));
@@ -137,6 +185,75 @@ function stripMarkdown(text) {
   return rendered.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
 }
 
+function splitMarkdownTableRow(line = "") {
+  const trimmed = String(line || "").trim();
+  if (!trimmed.includes("|")) return null;
+  const normalized = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  const cells = normalized.split("|").map((cell) => cell.trim());
+  return cells.length >= 2 ? cells : null;
+}
+
+function isMarkdownTableSeparator(line = "") {
+  const cells = splitMarkdownTableRow(line);
+  return Boolean(cells?.length) && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+
+function parseMarkdownTable(lines, startIndex) {
+  const header = splitMarkdownTableRow(lines[startIndex]);
+  if (!header || !isMarkdownTableSeparator(lines[startIndex + 1] || "")) return null;
+  const rows = [];
+  let index = startIndex + 2;
+  while (index < lines.length) {
+    const row = splitMarkdownTableRow(lines[index]);
+    if (!row) break;
+    rows.push(row);
+    index += 1;
+  }
+  return {
+    header,
+    rows,
+    rawLineCount: Math.max(index - startIndex, 2),
+  };
+}
+
+function renderMarkdownTable(table) {
+  const allRows = [table.header, ...table.rows];
+  const columnCount = Math.max(...allRows.map((row) => row.length));
+  const widths = Array.from({ length: columnCount }, (_unused, column) =>
+    Math.min(
+      Math.max(
+        ...allRows.map((row) => visualLength(stripMarkdownInline(row[column] || ""))),
+        3
+      ),
+      36
+    )
+  );
+  const formatRow = (row, header = false) =>
+    widths
+      .map((width, column) => {
+        const value = stripMarkdownInline(row[column] || "");
+        return padVisible(value, width);
+      })
+      .join(color("  │  ", ansi.dim));
+  const separator = widths.map((width) => "─".repeat(width)).join(color("──┼──", ansi.dim));
+  return [
+    color(formatRow(table.header, true), ansi.bold, ansi.cyan),
+    color(separator, ansi.dim),
+    ...table.rows.map((row) => formatRow(row)),
+  ];
+}
+
+function stripMarkdownInline(value = "") {
+  return String(value)
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)")
+    .replace(/\*\*([^*]+)\*\*/g, (_, text) => color(text, ansi.bold))
+    .replace(/__([^_]+)__/g, (_, text) => color(text, ansi.bold))
+    .replace(/`([^`]+)`/g, (_, text) => color(text, ansi.yellow))
+    .replace(/~~([^~]+)~~/g, "$1")
+    .replace(/\*([^*]+)\*/g, "$1")
+    .replace(/_([^_]+)_/g, "$1");
+}
+
 function rolePrefix(name, bgCode) {
   return `${label(name, bgCode)} ${color("|", bgCode)} `;
 }
@@ -183,7 +300,10 @@ async function renderLaunchHeader(packageVersion = "") {
   const title = "AgInTi Flow";
   const subtitle = "web-first agent workspace";
   const version = packageVersion ? `v${packageVersion}` : "";
-  const line = "+--------------------------------------------------+";
+  const width = Math.min(Math.max(terminalWidth() - 2, 58), 82);
+  const top = `╭${"─".repeat(width)}╮`;
+  const mid = `├${"─".repeat(width)}┤`;
+  const bottom = `╰${"─".repeat(width)}╯`;
 
   if (!useColor || process.env.AGINTIFLOW_NO_ANIMATION === "1") {
     console.log(` AgInTiFlow ${packageVersion || ""}`.trim());
@@ -198,11 +318,15 @@ async function renderLaunchHeader(packageVersion = "") {
   output.write(`\r${ansi.clearLine}`);
   output.write(ansi.cursorShow);
 
-  console.log(color(line, "\x1b[38;5;45m"));
-  console.log(`${color("|", "\x1b[38;5;45m")} ${shimmerText(title, 2)} ${color(version.padStart(36 - title.length), ansi.dim)} ${color("|", "\x1b[38;5;45m")}`);
-  console.log(`${color("|", "\x1b[38;5;45m")} ${color(subtitle.padEnd(48), ansi.dim)} ${color("|", "\x1b[38;5;45m")}`);
-  console.log(`${color("|", "\x1b[38;5;45m")} ${color("browser + shell + files + docker + canvas".padEnd(48), ansi.cyan)} ${color("|", "\x1b[38;5;45m")}`);
-  console.log(color(line, "\x1b[38;5;45m"));
+  const border = "\x1b[38;5;45m";
+  const titleLine = `${shimmerText(title, 2)} ${color(version, ansi.dim)}`;
+  const tagline = "browser + shell + files + docker + web search + scouts";
+  console.log(color(top, border));
+  console.log(`${color("│", border)} ${padVisible(titleLine, width - 2)} ${color("│", border)}`);
+  console.log(`${color("│", border)} ${color(padVisible(subtitle, width - 2), ansi.dim)} ${color("│", border)}`);
+  console.log(color(mid, border));
+  console.log(`${color("│", border)} ${color(padVisible(tagline, width - 2), ansi.cyan)} ${color("│", border)}`);
+  console.log(color(bottom, border));
 }
 
 function printHelp() {
@@ -238,24 +362,236 @@ function printHelp() {
   );
 }
 
-function renderPromptBuffer(buffer, previousLineCount = 0) {
-  for (let index = 0; index < previousLineCount; index += 1) {
-    output.write(`\r${ansi.clearLine}`);
-    if (index < previousLineCount - 1) output.write("\x1b[1A");
+function logicalLinesWithOffsets(buffer = "") {
+  const lines = String(buffer).split("\n");
+  let offset = 0;
+  return lines.map((line, index) => {
+    const start = offset;
+    const end = start + line.length;
+    offset = end + 1;
+    return {
+      text: line,
+      start,
+      end,
+      hasNewline: index < lines.length - 1,
+    };
+  });
+}
+
+function promptVisibleWindow(rows, cursorRow, height = terminalHeight()) {
+  const maxRows = promptViewportRows(height);
+  if (rows.length <= maxRows) {
+    return { start: 0, end: rows.length, topHidden: 0, bottomHidden: 0 };
   }
+  const half = Math.floor(maxRows / 2);
+  const start = clamp(cursorRow - half, 0, rows.length - maxRows);
+  const end = start + maxRows;
+  return {
+    start,
+    end,
+    topHidden: start,
+    bottomHidden: rows.length - end,
+  };
+}
 
-  const lines = String(buffer || "").split("\n");
-  const suggestions = commandSuggestions(lines[0] || "");
-  const rendered = [];
-  rendered.push(`${userPrompt().replace(/^\n/, "")}${lines[0] || ""}`);
-  for (const line of lines.slice(1)) {
-    rendered.push(`${promptGutter()}${line}`);
+export function buildPromptLayout(buffer = "", cursor = 0, width = terminalWidth(), height = terminalHeight()) {
+  const safeBuffer = String(buffer || "");
+  const safeCursor = clamp(Number(cursor) || 0, 0, safeBuffer.length);
+  const lineWidth = editorWidth(width);
+  const firstPrefix = " user ";
+  const nextPrefix = "  ... ";
+  const firstInnerWidth = Math.max(lineWidth - firstPrefix.length, 8);
+  const nextInnerWidth = Math.max(lineWidth - nextPrefix.length, 8);
+  const rows = [];
+
+  for (const [lineIndex, line] of logicalLinesWithOffsets(safeBuffer).entries()) {
+    let localOffset = 0;
+    const text = line.text;
+    if (!text) {
+      rows.push({
+        prefix: lineIndex === 0 ? firstPrefix : nextPrefix,
+        text: "",
+        start: line.start,
+        end: line.start,
+        innerWidth: lineIndex === 0 ? firstInnerWidth : nextInnerWidth,
+        lineStart: line.start,
+        lineEnd: line.end,
+        hasNewline: line.hasNewline,
+      });
+      continue;
+    }
+
+    while (localOffset < text.length) {
+      const prefix = lineIndex === 0 && localOffset === 0 ? firstPrefix : nextPrefix;
+      const innerWidth = prefix === firstPrefix ? firstInnerWidth : nextInnerWidth;
+      const chunk = text.slice(localOffset, localOffset + innerWidth);
+      rows.push({
+        prefix,
+        text: chunk,
+        start: line.start + localOffset,
+        end: line.start + localOffset + chunk.length,
+        innerWidth,
+        lineStart: line.start,
+        lineEnd: line.end,
+        hasNewline: line.hasNewline,
+      });
+      localOffset += chunk.length;
+    }
+  }
+
+  if (rows.length === 0) {
+    rows.push({
+      prefix: firstPrefix,
+      text: "",
+      start: 0,
+      end: 0,
+      innerWidth: firstInnerWidth,
+      lineStart: 0,
+      lineEnd: 0,
+      hasNewline: false,
+    });
+  }
+
+  const last = rows[rows.length - 1];
+  if (safeCursor === safeBuffer.length && last.end === safeCursor && last.text.length >= last.innerWidth) {
+    rows.push({
+      prefix: nextPrefix,
+      text: "",
+      start: safeCursor,
+      end: safeCursor,
+      innerWidth: nextInnerWidth,
+      lineStart: safeCursor,
+      lineEnd: safeCursor,
+      hasNewline: false,
+    });
+  }
+
+  let cursorRow = rows.length - 1;
+  let cursorColumn = rows[cursorRow].prefix.length;
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    const next = rows[index + 1];
+    if (safeCursor < row.end) {
+      cursorRow = index;
+      cursorColumn = row.prefix.length + safeCursor - row.start;
+      break;
+    }
+    if (safeCursor === row.end) {
+      if (next && next.start === safeCursor && row.text.length >= row.innerWidth) continue;
+      cursorRow = index;
+      cursorColumn = row.prefix.length + safeCursor - row.start;
+      break;
+    }
   }
+
+  const suggestions = commandSuggestions(safeBuffer.split("\n")[0] || "");
+  const emptyHint = "type a request, /help, Enter to send, Ctrl+J for newline";
+  const visible = promptVisibleWindow(rows, cursorRow, height);
+  const renderedRows = [];
+  let renderedCursorRow = cursorRow - visible.start;
+
+  if (visible.topHidden > 0) {
+    renderedRows.push(panelLine(`  ... ${visible.topHidden} earlier input row${visible.topHidden === 1 ? "" : "s"}`, ansi.systemBg, lineWidth));
+    renderedCursorRow += 1;
+  }
+
+  for (const row of rows.slice(visible.start, visible.end)) {
+    const content = safeBuffer ? `${row.prefix}${row.text}` : `${row.prefix}${emptyHint}`;
+    renderedRows.push(panelLine(content, ansi.userBg, lineWidth));
+  }
+
+  if (visible.bottomHidden > 0) {
+    renderedRows.push(panelLine(`  ... ${visible.bottomHidden} later input row${visible.bottomHidden === 1 ? "" : "s"}`, ansi.systemBg, lineWidth));
+  }
+
   if (suggestions.length > 0) {
-    rendered.push(`${promptGutter()}${color(`suggest: ${suggestions.join("  ")}`, ansi.dim)}`);
+    renderedRows.push(panelLine(` hint  ${suggestions.join("  ")}`, ansi.systemBg, lineWidth));
   }
-  output.write(rendered.join("\n"));
-  return rendered.length;
+
+  return {
+    rows,
+    renderedRows,
+    cursorRow: renderedCursorRow,
+    absoluteCursorRow: cursorRow,
+    cursorColumn: clamp(cursorColumn, 0, editorWidth(width) - 1),
+  };
+}
+
+function cursorLocation(layout, cursor) {
+  for (let index = 0; index < layout.rows.length; index += 1) {
+    const row = layout.rows[index];
+    const next = layout.rows[index + 1];
+    if (cursor < row.end) return { rowIndex: index, column: cursor - row.start };
+    if (cursor === row.end) {
+      if (next && next.start === cursor && row.text.length >= row.innerWidth) continue;
+      return { rowIndex: index, column: cursor - row.start };
+    }
+  }
+  const rowIndex = Math.max(layout.rows.length - 1, 0);
+  const row = layout.rows[rowIndex];
+  return { rowIndex, column: Math.max(row.end - row.start, 0) };
+}
+
+function clearRenderedPrompt(previous) {
+  if (!previous.lineCount) return;
+  const below = previous.lineCount - 1 - previous.cursorRow;
+  if (below > 0) output.write(`\x1b[${below}B`);
+  output.write(`\r${ansi.clearLine}`);
+  for (let index = 1; index < previous.lineCount; index += 1) {
+    output.write(`\x1b[1A\r${ansi.clearLine}`);
+  }
+}
+
+function renderPromptBuffer(buffer, cursor, previous = { lineCount: 0, cursorRow: 0 }) {
+  output.write(ansi.cursorHide);
+  clearRenderedPrompt(previous);
+  const layout = buildPromptLayout(buffer, cursor);
+  output.write(layout.renderedRows.join("\n"));
+  const below = layout.renderedRows.length - 1 - layout.cursorRow;
+  if (below > 0) output.write(`\x1b[${below}A`);
+  output.write(`\r\x1b[${layout.cursorColumn + 1}G`);
+  output.write(ansi.cursorShow);
+  return {
+    lineCount: layout.renderedRows.length,
+    cursorRow: layout.cursorRow,
+  };
+}
+
+function moveToPromptBottom(rendered) {
+  const below = Math.max((rendered?.lineCount || 1) - 1 - (rendered?.cursorRow || 0), 0);
+  if (below > 0) output.write(`\x1b[${below}B`);
+  output.write("\r");
+}
+
+function lineBounds(buffer, cursor) {
+  const safeCursor = clamp(cursor, 0, buffer.length);
+  const start = buffer.lastIndexOf("\n", safeCursor - 1) + 1;
+  const nextNewline = buffer.indexOf("\n", safeCursor);
+  const end = nextNewline === -1 ? buffer.length : nextNewline;
+  return { start, end };
+}
+
+function insertAt(buffer, cursor, text) {
+  return {
+    buffer: `${buffer.slice(0, cursor)}${text}${buffer.slice(cursor)}`,
+    cursor: cursor + text.length,
+  };
+}
+
+function removeBefore(buffer, cursor) {
+  if (cursor <= 0) return { buffer, cursor };
+  return {
+    buffer: `${buffer.slice(0, cursor - 1)}${buffer.slice(cursor)}`,
+    cursor: cursor - 1,
+  };
+}
+
+function removeAt(buffer, cursor) {
+  if (cursor >= buffer.length) return { buffer, cursor };
+  return {
+    buffer: `${buffer.slice(0, cursor)}${buffer.slice(cursor + 1)}`,
+    cursor,
+  };
 }
 
 function createAbortError(message = "Aborted with Ctrl+C") {
@@ -270,34 +606,97 @@ function readTtyPrompt() {
     emitKeypressEvents(input);
     const wasRaw = Boolean(input.isRaw);
     let buffer = "";
-    let renderedLines = 0;
+    let cursor = 0;
+    let rendered = { lineCount: 0, cursorRow: 0 };
+    let preferredColumn = null;
+    let historyIndex = promptHistory.length;
+    let draft = "";
+    let redrawHandle = null;
 
     const cleanup = () => {
+      if (redrawHandle) {
+        clearImmediate(redrawHandle);
+        redrawHandle = null;
+      }
       input.off("keypress", handler);
       if (typeof input.setRawMode === "function") input.setRawMode(wasRaw);
       input.pause();
       output.write(ansi.cursorShow);
     };
 
+    const renderNow = () => {
+      if (redrawHandle) {
+        clearImmediate(redrawHandle);
+        redrawHandle = null;
+      }
+      rendered = renderPromptBuffer(buffer, cursor, rendered);
+    };
+
     const redraw = () => {
-      renderedLines = renderPromptBuffer(buffer, renderedLines);
+      if (redrawHandle) return;
+      redrawHandle = setImmediate(() => {
+        redrawHandle = null;
+        rendered = renderPromptBuffer(buffer, cursor, rendered);
+      });
     };
 
     const submit = () => {
+      renderNow();
+      moveToPromptBottom(rendered);
       cleanup();
       output.write("\n");
+      const saved = buffer.trim();
+      if (saved && promptHistory[promptHistory.length - 1] !== buffer) promptHistory.push(buffer);
       resolve(buffer);
     };
 
+    const setBuffer = (nextBuffer, nextCursor = nextBuffer.length) => {
+      buffer = nextBuffer;
+      cursor = clamp(nextCursor, 0, buffer.length);
+      preferredColumn = null;
+      redraw();
+    };
+
+    const moveVertical = (direction) => {
+      const layout = buildPromptLayout(buffer, cursor);
+      const location = cursorLocation(layout, cursor);
+      const targetRowIndex = location.rowIndex + direction;
+      if (targetRowIndex < 0) {
+        if (promptHistory.length === 0) return;
+        if (historyIndex === promptHistory.length) draft = buffer;
+        historyIndex = Math.max(historyIndex - 1, 0);
+        setBuffer(promptHistory[historyIndex], promptHistory[historyIndex].length);
+        return;
+      }
+      if (targetRowIndex >= layout.rows.length) {
+        if (historyIndex < promptHistory.length - 1) {
+          historyIndex += 1;
+          setBuffer(promptHistory[historyIndex], promptHistory[historyIndex].length);
+        } else if (historyIndex < promptHistory.length) {
+          historyIndex = promptHistory.length;
+          setBuffer(draft, draft.length);
+        }
+        return;
+      }
+      const currentColumn = preferredColumn ?? location.column;
+      const targetRow = layout.rows[targetRowIndex];
+      cursor = targetRow.start + Math.min(currentColumn, targetRow.end - targetRow.start);
+      preferredColumn = currentColumn;
+      redraw();
+    };
+
     const handler = (str = "", key = {}) => {
       if (key.ctrl && key.name === "c") {
+        renderNow();
+        moveToPromptBottom(rendered);
         cleanup();
         output.write("\n");
         reject(createAbortError());
         return;
       }
-      if ((key.ctrl && key.name === "j") || (key.sequence === "\n" && key.name !== "return" && key.name !== "enter")) {
-        buffer += "\n";
+      if ((key.ctrl && key.name === "j") || key.sequence === "\n") {
+        ({ buffer, cursor } = insertAt(buffer, cursor, "\n"));
+        preferredColumn = null;
         redraw();
         return;
       }
@@ -306,7 +705,61 @@ function readTtyPrompt() {
         return;
       }
       if (key.name === "backspace") {
-        buffer = buffer.slice(0, -1);
+        ({ buffer, cursor } = removeBefore(buffer, cursor));
+        preferredColumn = null;
+        redraw();
+        return;
+      }
+      if (key.name === "delete") {
+        ({ buffer, cursor } = removeAt(buffer, cursor));
+        preferredColumn = null;
+        redraw();
+        return;
+      }
+      if (key.name === "left") {
+        cursor = Math.max(cursor - 1, 0);
+        preferredColumn = null;
+        redraw();
+        return;
+      }
+      if (key.name === "right") {
+        cursor = Math.min(cursor + 1, buffer.length);
+        preferredColumn = null;
+        redraw();
+        return;
+      }
+      if (key.name === "up") {
+        moveVertical(-1);
+        return;
+      }
+      if (key.name === "down") {
+        moveVertical(1);
+        return;
+      }
+      if ((key.ctrl && key.name === "a") || key.name === "home") {
+        cursor = lineBounds(buffer, cursor).start;
+        preferredColumn = null;
+        redraw();
+        return;
+      }
+      if ((key.ctrl && key.name === "e") || key.name === "end") {
+        cursor = lineBounds(buffer, cursor).end;
+        preferredColumn = null;
+        redraw();
+        return;
+      }
+      if (key.ctrl && key.name === "u") {
+        const bounds = lineBounds(buffer, cursor);
+        buffer = `${buffer.slice(0, bounds.start)}${buffer.slice(cursor)}`;
+        cursor = bounds.start;
+        preferredColumn = null;
+        redraw();
+        return;
+      }
+      if (key.ctrl && key.name === "k") {
+        const bounds = lineBounds(buffer, cursor);
+        buffer = `${buffer.slice(0, cursor)}${buffer.slice(bounds.end)}`;
+        preferredColumn = null;
         redraw();
         return;
       }
@@ -314,27 +767,32 @@ function readTtyPrompt() {
         const suggestions = commandSuggestions(buffer.split("\n")[0] || "");
         if (suggestions.length === 1) {
           buffer = suggestions[0];
+          cursor = buffer.length;
         }
+        preferredColumn = null;
         redraw();
         return;
       }
       if (key.name === "escape") {
         buffer = "";
+        cursor = 0;
+        preferredColumn = null;
         redraw();
         return;
       }
       if (key.ctrl || key.meta) return;
       if (str && !key.sequence?.startsWith("\x1b")) {
-        buffer += str;
+        const text = str.replace(/\r/g, "");
+        ({ buffer, cursor } = insertAt(buffer, cursor, text));
+        preferredColumn = null;
         redraw();
       }
     };
 
     input.resume();
     input.setRawMode(true);
-    output.write(ansi.cursorHide);
     input.on("keypress", handler);
-    redraw();
+    renderNow();
   });
 }