feat(input): collapse pasted text into [Pasted #N · M lines] placeholders

Before this, pasting 200 lines of code shoved 200 rendered lines into
the input box — the TUI got pushed off-screen and the user couldn't
see what they were sending. Detect paste-shaped useInput ticks (any
newline, or 100+ chars in one tick, since typed input doesn't arrive
that way) and replace the content with a compact placeholder while
stashing the original in a side map. Submit expands placeholders back
to real text before the agent sees them.

Author: halfaipg

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "codebase-cli",
-	"version": "2.0.0-pre.37",
+	"version": "2.0.0-pre.38",
 	"description": "Codebase CLI — a TypeScript coding agent on the pi-mono runtime. OAuth-aware, any LLM provider, single install.",
 	"keywords": [
 		"ai",

src/ui/Input.tsx

@@ -4,11 +4,14 @@ import { logInputEvent } from "./debug-input.js";
 import {
 	backspace,
 	deleteForward,
+	expandPastes,
 	initialInputState,
 	insertChar,
+	insertPaste,
 	killToEnd,
 	killToStart,
 	killWordBack,
+	looksLikePaste,
 	moveEnd,
 	moveLeft,
 	moveRight,
@@ -287,7 +290,7 @@ export function Input({
 			// registry's not-found path surface the typo.
 			const trimmed = state.buffer.trim();
 			if (trimmed.length > 0) {
-				onSubmit(trimmed);
+				onSubmit(expandPastes(trimmed, state.pastedContents));
 				setState(initialInputState());
 				setSuggestionIdx(0);
 				setHistoryIdx(-1);
@@ -360,7 +363,7 @@ export function Input({
 				setPathIdx(0);
 				lastAtTokenRef.current = null;
 			}
-			setState(insertChar(state, input));
+			setState(looksLikePaste(input) ? insertPaste(state, input) : insertChar(state, input));
 		}
 	});
 

src/ui/input-state.test.ts

@@ -2,12 +2,16 @@ import { describe, expect, it } from "vitest";
 import {
 	backspace,
 	deleteForward,
+	expandPastes,
+	formatPastePlaceholder,
 	initialInputState,
 	insertChar,
+	insertPaste,
 	killToEnd,
 	killToStart,
 	killWordBack,
 	killWordForward,
+	looksLikePaste,
 	moveEnd,
 	moveLeft,
 	moveRight,
@@ -214,3 +218,101 @@ describe("undo", () => {
 		expect(s.buffer).toBe("");
 	});
 });
+
+describe("paste detection (looksLikePaste)", () => {
+	it("returns false for a single typed character", () => {
+		expect(looksLikePaste("a")).toBe(false);
+	});
+
+	it("returns false for a short typed run", () => {
+		expect(looksLikePaste("hello world")).toBe(false);
+	});
+
+	it("returns true for any input containing a newline", () => {
+		// Typed \\<Enter> is handled by the key.return branch in Input.tsx,
+		// not the printable-text path — so a \\n landing here is paste.
+		expect(looksLikePaste("a\nb")).toBe(true);
+	});
+
+	it("returns true for a long single-line paste with no newlines", () => {
+		expect(looksLikePaste("x".repeat(120))).toBe(true);
+	});
+
+	it("returns false for a single newline alone (not really a paste signal)", () => {
+		// Edge case: a 1-char input with just \\n. Treated as paste under
+		// our heuristic which is conservative — fine for safety, the
+		// resulting placeholder just reads "0 lines" worth.
+		expect(looksLikePaste("\n")).toBe(true);
+	});
+});
+
+describe("formatPastePlaceholder", () => {
+	it("renders line count for multi-line content", () => {
+		const text = "line1\nline2\nline3";
+		expect(formatPastePlaceholder(1, text)).toBe("[Pasted #1 · 3 lines]");
+	});
+
+	it("renders char count for single-line content", () => {
+		const text = "x".repeat(250);
+		expect(formatPastePlaceholder(7, text)).toBe("[Pasted #7 · 250 chars]");
+	});
+
+	it("uses unique ids", () => {
+		const a = formatPastePlaceholder(1, "x");
+		const b = formatPastePlaceholder(2, "x");
+		expect(a).not.toBe(b);
+	});
+});
+
+describe("insertPaste + expandPastes", () => {
+	it("inserts a placeholder, stores content, and round-trips on expand", () => {
+		const code = "function foo() {\n  return 42;\n}";
+		const s = insertPaste(initialInputState(), code);
+		// Buffer contains only the placeholder, not the 32-char code body.
+		expect(s.buffer).toBe("[Pasted #1 · 3 lines]");
+		expect(s.pastedContents[1]?.content).toBe(code);
+		expect(s.pastedContents[1]?.lines).toBe(3);
+		expect(s.nextPasteId).toBe(2);
+		// Submit path expands it back.
+		expect(expandPastes(s.buffer, s.pastedContents)).toBe(code);
+	});
+
+	it("supports text typed around a placeholder", () => {
+		let s = initialInputState();
+		for (const ch of "explain: ") s = insertChar(s, ch);
+		s = insertPaste(s, "alpha\nbeta\ngamma");
+		for (const ch of " thanks") s = insertChar(s, ch);
+		expect(s.buffer).toBe("explain: [Pasted #1 · 3 lines] thanks");
+		expect(expandPastes(s.buffer, s.pastedContents)).toBe("explain: alpha\nbeta\ngamma thanks");
+	});
+
+	it("assigns unique ids when multiple pastes happen in one buffer", () => {
+		let s = insertPaste(initialInputState(), "first paste");
+		for (const ch of " · then ") s = insertChar(s, ch);
+		s = insertPaste(s, "second\npaste\nhere");
+		expect(s.pastedContents[1]?.content).toBe("first paste");
+		expect(s.pastedContents[2]?.content).toBe("second\npaste\nhere");
+		expect(expandPastes(s.buffer, s.pastedContents)).toBe("first paste · then second\npaste\nhere");
+	});
+
+	it("leaves unrecognized placeholder-shaped text alone", () => {
+		// User literally typed something matching the pattern. We have no
+		// id for it; expand should leave it untouched rather than corrupt it.
+		const text = "see also [Pasted #999 · 5 lines]";
+		expect(expandPastes(text, {})).toBe(text);
+	});
+
+	it("silently drops orphaned placeholders when content was edited away", () => {
+		const s = insertPaste(initialInputState(), "to be deleted");
+		// User selected and removed the placeholder somehow; buffer is empty
+		// but pastedContents still has the entry. expandPastes on empty buffer
+		// just yields empty.
+		expect(expandPastes("", s.pastedContents)).toBe("");
+	});
+
+	it("insertPaste with empty content is a no-op", () => {
+		const before = initialInputState();
+		const after = insertPaste(before, "");
+		expect(after).toEqual(before);
+	});
+});

src/ui/input-state.ts

@@ -18,19 +18,98 @@
 
 export type Action = "type" | "kill" | "yank" | "delete" | "move" | "undo" | "init";
 
+export interface PastedContent {
+	id: number;
+	content: string;
+	lines: number;
+}
+
 export interface InputState {
 	buffer: string;
 	cursor: number;
 	killRing: string[];
 	undoStack: Array<{ buffer: string; cursor: number }>;
 	lastAction: Action;
+	/** Map of paste id → original content for placeholder expansion at submit. */
+	pastedContents: Record<number, PastedContent>;
+	/** Monotonic counter; next paste in this buffer gets this id. */
+	nextPasteId: number;
 }
 
 const MAX_UNDO = 100;
 const MAX_KILL_RING = 60;
 
 export function initialInputState(): InputState {
-	return { buffer: "", cursor: 0, killRing: [], undoStack: [], lastAction: "init" };
+	return {
+		buffer: "",
+		cursor: 0,
+		killRing: [],
+		undoStack: [],
+		lastAction: "init",
+		pastedContents: {},
+		nextPasteId: 1,
+	};
+}
+
+/**
+ * A useInput tick is a paste rather than a keystroke when it contains a
+ * newline (typed `\<Enter>` is handled in the key.return branch, not as
+ * printable text — so any `\n` here came from the OS paste buffer) or
+ * when it's substantially longer than a normal keystroke / IME chunk.
+ */
+export function looksLikePaste(input: string): boolean {
+	return input.includes("\n") || input.length >= 100;
+}
+
+const PASTE_PLACEHOLDER_RE = /\[Pasted #(\d+) · \d+ (?:lines|chars)\]/g;
+
+/**
+ * Render the placeholder shown in the visible buffer when text is pasted.
+ * Multi-line pastes use a line count; single-line long pastes show char
+ * count — different signals for what the user's eye expects to track.
+ */
+export function formatPastePlaceholder(id: number, content: string): string {
+	const lines = content.split("\n").length;
+	if (lines > 1) return `[Pasted #${id} · ${lines} lines]`;
+	return `[Pasted #${id} · ${content.length} chars]`;
+}
+
+/**
+ * Stash pasted content under a fresh id and insert a placeholder at the
+ * cursor. The buffer stays short and readable; the real text re-inflates
+ * at submit via expandPastes(). Pastes follow normal insertChar undo
+ * snapshots — Ctrl-Z will pop the placeholder *and* the side entry stays
+ * in pastedContents, harmless because nothing will reference it.
+ */
+export function insertPaste(state: InputState, content: string): InputState {
+	if (!content) return state;
+	const id = state.nextPasteId;
+	const placeholder = formatPastePlaceholder(id, content);
+	const inserted = insertChar(state, placeholder);
+	return {
+		...inserted,
+		pastedContents: {
+			...state.pastedContents,
+			[id]: { id, content, lines: content.split("\n").length },
+		},
+		nextPasteId: id + 1,
+	};
+}
+
+/**
+ * Replace `[Pasted #N · ...]` placeholders with their original content.
+ * Called at submit time so the agent sees the real text. Orphaned ids
+ * (placeholder deleted out of the buffer) are silently dropped — only
+ * the ones still present in the buffer expand. Placeholders we don't
+ * recognize (e.g. user typed something that matches the pattern) pass
+ * through unchanged so we don't corrupt their literal input.
+ */
+export function expandPastes(buffer: string, pastedContents: Record<number, PastedContent>): string {
+	return buffer.replace(PASTE_PLACEHOLDER_RE, (match, idStr) => {
+		const id = Number.parseInt(idStr, 10);
+		const entry = pastedContents[id];
+		return entry ? entry.content : match;
+	});
 }
 
 export function setBuffer(state: InputState, buffer: string): InputState {