opencode-miniterm 1.0.16 → 1.0.18

package/bun.lock

@@ -5,7 +5,7 @@
     "": {
       "name": "opencode-miniterm",
       "dependencies": {
-        "@opencode-ai/sdk": "^1.2.24",
+        "@opencode-ai/sdk": "^1.2.25",
         "allmark": "^1.0.2",
       },
       "devDependencies": {
@@ -47,11 +47,11 @@
 
     "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
 
-    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.2.25", "", {}, "sha512-ikuGWob48OM7LTgfXFqGOZKVOqh50FEjvtIBhXGhGowJhifmjZ+xuq/ypP8nPjTwUX73pbu1C3X9ZBWVkCN9mA=="],
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.2.27", "", {}, "sha512-Wk0o/I+Fo+wE3zgvlJDs8Fb67KlKqX0PrV8dK5adSDkANq6r4Z25zXJg2iOir+a8ntg3rAcpel1OY4FV/TwRUA=="],
 
     "@trivago/prettier-plugin-sort-imports": ["@trivago/prettier-plugin-sort-imports@6.0.2", "", { "dependencies": { "@babel/generator": "^7.28.0", "@babel/parser": "^7.28.0", "@babel/traverse": "^7.28.0", "@babel/types": "^7.28.0", "javascript-natural-sort": "^0.7.1", "lodash-es": "^4.17.21", "minimatch": "^9.0.0", "parse-imports-exports": "^0.2.4" }, "peerDependencies": { "@vue/compiler-sfc": "3.x", "prettier": "2.x - 3.x", "prettier-plugin-ember-template-tag": ">= 2.0.0", "prettier-plugin-svelte": "3.x", "svelte": "4.x || 5.x" }, "optionalPeers": ["@vue/compiler-sfc", "prettier-plugin-ember-template-tag", "prettier-plugin-svelte", "svelte"] }, "sha512-3DgfkukFyC/sE/VuYjaUUWoFfuVjPK55vOFDsxD56XXynFMCZDYFogH2l/hDfOsQAm1myoU/1xByJ3tWqtulXA=="],
 
-    "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
+    "@types/bun": ["@types/bun@1.3.11", "", { "dependencies": { "bun-types": "1.3.11" } }, "sha512-5vPne5QvtpjGpsGYXiFyycfpDF2ECyPcTSsFBMa0fraoxiQyMJ3SmuQIGhzPg2WJuWxVBoxWJ2kClYTcw/4fAg=="],
 
     "@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="],
 
@@ -77,7 +77,7 @@
 
     "brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="],
 
-    "bun-types": ["bun-types@1.3.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-tcpfCCl6XWo6nCVnpcVrxQ+9AYN1iqMIzgrSKYMB/fjLtV2eyAVEg7AxQJuCq/26R6HpKWykQXuSOq/21RYcbg=="],
+    "bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
 
     "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-miniterm",
-	"version": "1.0.16",
+	"version": "1.0.18",
 	"description": "A small front-end terminal UI for OpenCode",
 	"main": "src/index.ts",
 	"bin": {
@@ -29,7 +29,7 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"@opencode-ai/sdk": "^1.2.25",
+		"@opencode-ai/sdk": "^1.2.27",
 		"allmark": "^1.0.2"
 	}
 }

package/src/ansi.ts

@@ -6,6 +6,8 @@ export const CURSOR_HOME = "\x1b[0G";
 export const CURSOR_HIDE = "\x1b[?25l";
 export const CURSOR_SHOW = "\x1b[?25h";
 export const CURSOR_UP = (lines: number) => `\x1b[${lines}A`;
+export const CURSOR_DOWN = (lines: number) => `\x1b[${lines}B`;
+export const CURSOR_COL = (col: number) => `\x1b[${col + 1}G`;
 export const DISABLE_LINE_WRAP = "\x1b[?7l";
 export const ENABLE_LINE_WRAP = "\x1b[?7h";
 export const RESET = "\x1b[0m";

package/src/input.ts

@@ -1,7 +1,7 @@
 import type { Part } from "@opencode-ai/sdk";
 import { glob } from "node:fs/promises";
 import { stat } from "node:fs/promises";
-import readline, { type Key } from "node:readline";
+import { type Key } from "node:readline";
 import * as ansi from "./ansi";
 import agentsCommand from "./commands/agents";
 import debugCommand from "./commands/debug";
@@ -57,68 +57,103 @@ export function renderLine(): void {
 	const consoleWidth = process.stdout.columns || 80;
 
 	// Move to the start of the line (i.e. the prompt position)
-	readline.cursorTo(process.stdout, 0);
+	process.stdout.write(ansi.CURSOR_HOME);
 	if (oldWrappedRows > 0) {
 		if (cursorPosition < inputBuffer.length) {
-			readline.moveCursor(process.stdout, 0, oldWrappedRows - oldCursorRow);
+			process.stdout.write(ansi.CURSOR_DOWN(oldWrappedRows - oldCursorRow));
 		}
-		readline.moveCursor(process.stdout, 0, -oldWrappedRows);
+		process.stdout.write(ansi.CURSOR_UP(oldWrappedRows));
 	}
 
 	// Find the position where the input has changed (i.e. where the user has
 	// typed something)
 	let start = 0;
 	let currentCol = 2;
+	let currentRow = 0;
 	let newWrappedRows = 0;
 	for (let i = 0; i < Math.min(oldInputBuffer.length, inputBuffer.length); i++) {
 		if (oldInputBuffer[i] !== inputBuffer[i]) {
 			break;
 		}
-		if (currentCol >= consoleWidth) {
-			readline.moveCursor(process.stdout, 0, 1);
-			currentCol = 0;
-			newWrappedRows++;
+		if (inputBuffer[i] === "\n") {
+			currentRow++;
+			currentCol = 2;
+		} else {
+			if (currentCol >= consoleWidth) {
+				currentCol = 0;
+				currentRow++;
+				newWrappedRows++;
+			}
+			currentCol++;
 		}
-		currentCol++;
 		start++;
 	}
 
-	// Clear the old, changed, input
-	readline.cursorTo(process.stdout, currentCol);
-	readline.clearScreenDown(process.stdout);
+	// Position the cursor at where the difference starts, then clear
+	// Check if we need to wrap after the comparison loop
+	if (currentCol >= consoleWidth) {
+		currentCol = 0;
+		currentRow++;
+		newWrappedRows++;
+	}
+	if (currentRow > 0) {
+		process.stdout.write(ansi.CURSOR_DOWN(currentRow));
+	}
+	process.stdout.write(ansi.CURSOR_COL(currentCol));
+	process.stdout.write(ansi.CLEAR_FROM_CURSOR);
 
 	// Write the prompt if this is a fresh buffer
 	if (start === 0) {
-		readline.cursorTo(process.stdout, 0);
+		process.stdout.write(ansi.CURSOR_HOME);
 		writePrompt();
-		readline.cursorTo(process.stdout, 2);
+		process.stdout.write(ansi.CURSOR_COL(2));
 	}
 
 	// Write the changes from the new input buffer
 	let renderExtent = Math.max(cursorPosition + 1, inputBuffer.length);
 	for (let i = start; i < renderExtent; i++) {
-		if (currentCol >= consoleWidth) {
+		if (i < inputBuffer.length && inputBuffer[i] === "\n") {
 			process.stdout.write("\n");
-			currentCol = 0;
-			newWrappedRows++;
-		}
-		if (i < inputBuffer.length) {
-			process.stdout.write(inputBuffer[i]!);
+			currentRow++;
+			currentCol = 2;
+		} else {
+			if (currentCol >= consoleWidth) {
+				process.stdout.write("\n");
+				currentCol = 0;
+				newWrappedRows++;
+			}
+			if (i < inputBuffer.length) {
+				process.stdout.write(inputBuffer[i]!);
+			}
+			currentCol++;
 		}
-		currentCol++;
 	}
 
 	// Calculate and move to the cursor's position
-	let absolutePos = 2 + cursorPosition;
-	let newCursorRow = Math.floor(absolutePos / consoleWidth);
-	let newCursorCol = absolutePos % consoleWidth;
-	readline.cursorTo(process.stdout, 0);
-	readline.moveCursor(process.stdout, 0, -1 * (newWrappedRows - newCursorRow));
-	readline.cursorTo(process.stdout, newCursorCol);
+	let row = 0;
+	let col = 2;
+	for (let i = 0; i < cursorPosition; i++) {
+		if (i < inputBuffer.length && inputBuffer[i] === "\n") {
+			row++;
+			col = 2;
+		} else {
+			col++;
+			if (col >= consoleWidth) {
+				row++;
+				col = 0;
+			}
+		}
+	}
+	process.stdout.write(ansi.CURSOR_HOME);
+	let rowsToMove = newWrappedRows - row;
+	if (rowsToMove > 0) {
+		process.stdout.write(ansi.CURSOR_UP(rowsToMove));
+	}
+	process.stdout.write(ansi.CURSOR_COL(col));
 
 	oldInputBuffer = inputBuffer;
 	oldWrappedRows = newWrappedRows;
-	oldCursorRow = newCursorRow;
+	oldCursorRow = row;
 }
 
 export async function handleKeyPress(state: State, str: string, key: Key) {
@@ -451,3 +486,26 @@ function findNextWordBoundary(text: string, pos: number): number {
 
 	return newPos;
 }
+
+// Test helpers
+export function _setInputState(state: {
+	inputBuffer?: string;
+	cursorPosition?: number;
+	oldInputBuffer?: string;
+	oldWrappedRows?: number;
+	oldCursorRow?: number;
+}): void {
+	if (state.inputBuffer !== undefined) inputBuffer = state.inputBuffer;
+	if (state.cursorPosition !== undefined) cursorPosition = state.cursorPosition;
+	if (state.oldInputBuffer !== undefined) oldInputBuffer = state.oldInputBuffer;
+	if (state.oldWrappedRows !== undefined) oldWrappedRows = state.oldWrappedRows;
+	if (state.oldCursorRow !== undefined) oldCursorRow = state.oldCursorRow;
+}
+
+export function _resetInputState(): void {
+	inputBuffer = "";
+	cursorPosition = 0;
+	oldInputBuffer = "";
+	oldWrappedRows = 0;
+	oldCursorRow = 0;
+}

package/src/server.ts

@@ -342,6 +342,7 @@ function processDelta(state: State, partID: string, delta: string) {
 
 async function processDiff(state: State, diff: FileDiff[]) {
 	const parts: string[] = [];
+
 	for (const file of diff) {
 		const newAfter = file.after ?? "";
 		const oldAfter = state.lastFileAfter.get(file.file);
@@ -358,18 +359,19 @@ async function processDiff(state: State, diff: FileDiff[]) {
 	}
 
 	if (parts.length > 0) {
-		state.accumulatedResponse.push({ key: "diff", title: "files", text: parts.join("\n") });
+		const diffText = parts.join("\n");
+		state.accumulatedResponse.push({ key: "diff", title: "files", text: diffText });
 
-		const diffText = ansi.stripAnsiCodes(parts.join("\n"));
-		await writeToLog(`${diffText}\n\n`);
+		await writeToLog(`${ansi.stripAnsiCodes(diffText)}\n\n`);
 
 		render(state);
 	}
 }
 
 async function processTodos(state: State, todos: Todo[]) {
-	let todoListText = "Todo:\n";
+	const parts: string[] = [];
 
+	parts.push("Todo:");
 	for (let todo of todos) {
 		let todoText = "";
 		if (todo.status === "completed") {
@@ -378,13 +380,13 @@ async function processTodos(state: State, todos: Todo[]) {
 			todoText += "- [ ] ";
 		}
 		todoText += todo.content;
-		todoListText += todoText + "\n";
+		parts.push(todoText);
 	}
 
+	const todoListText = parts.join("\n");
 	state.accumulatedResponse.push({ key: "todo", title: "files", text: todoListText });
 
-	const cleanTodoText = ansi.stripAnsiCodes(todoListText);
-	await writeToLog(`${cleanTodoText}\n`);
+	await writeToLog(`${ansi.stripAnsiCodes(todoListText)}\n\n`);
 
 	render(state);
 }

package/test/input.test.ts

@@ -0,0 +1,313 @@
+import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import * as ansi from "../src/ansi";
+import { _resetInputState, _setInputState, renderLine } from "../src/input";
+import * as render from "../src/render";
+
+describe("renderLine", () => {
+	let writeSpy: ReturnType<typeof spyOn>;
+	let writePromptSpy: ReturnType<typeof spyOn>;
+	const originalColumns = process.stdout.columns;
+
+	beforeEach(() => {
+		_resetInputState();
+		writeSpy = spyOn(process.stdout, "write").mockImplementation(() => true);
+		writePromptSpy = spyOn(render, "writePrompt").mockImplementation(() => {});
+		// Set a reasonable console width for testing
+		Object.defineProperty(process.stdout, "columns", {
+			value: 80,
+			writable: true,
+			configurable: true,
+		});
+	});
+
+	afterEach(() => {
+		writeSpy.mockRestore();
+		writePromptSpy.mockRestore();
+		Object.defineProperty(process.stdout, "columns", {
+			value: originalColumns,
+			writable: true,
+			configurable: true,
+		});
+	});
+
+	describe("initial render", () => {
+		it("should render prompt and cursor at position 0 on first call", () => {
+			_setInputState({ inputBuffer: "", cursorPosition: 0 });
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			// Should start with CURSOR_HOME
+			expect(calls[0]).toBe(ansi.CURSOR_HOME);
+			// Should contain CURSOR_COL for positioning after prompt (col 2)
+			expect(calls).toContain(ansi.CURSOR_COL(2));
+			// Should contain CLEAR_FROM_CURSOR
+			expect(calls).toContain(ansi.CLEAR_FROM_CURSOR);
+			// Should end with cursor positioning at col 2
+			expect(calls[calls.length - 1]).toBe(ansi.CURSOR_COL(2));
+		});
+
+		it("should write prompt when starting fresh", () => {
+			_setInputState({ inputBuffer: "", cursorPosition: 0 });
+
+			renderLine();
+
+			expect(writePromptSpy).toHaveBeenCalled();
+		});
+	});
+
+	describe("typing characters", () => {
+		it("should write new characters when typing", () => {
+			_setInputState({
+				inputBuffer: "a",
+				cursorPosition: 1,
+				oldInputBuffer: "",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			expect(calls).toContain("a");
+		});
+
+		it("should only write changed portion of input", () => {
+			_setInputState({
+				inputBuffer: "hello world",
+				cursorPosition: 11,
+				oldInputBuffer: "hello ",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const output = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]).join("");
+			// Should only write "world" not the whole string
+			expect(output).toContain("world");
+			expect(output).not.toContain("hellohello");
+		});
+
+		it("should clear from cursor before writing changes", () => {
+			_setInputState({
+				inputBuffer: "ab",
+				cursorPosition: 2,
+				oldInputBuffer: "a",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			const clearIndex = calls.indexOf(ansi.CLEAR_FROM_CURSOR);
+			const writeIndex = calls.indexOf("b");
+			expect(clearIndex).toBeLessThan(writeIndex);
+		});
+	});
+
+	describe("cursor movement", () => {
+		it("should position cursor at correct column after render", () => {
+			_setInputState({
+				inputBuffer: "hello",
+				cursorPosition: 5,
+				oldInputBuffer: "",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			// Cursor should be at column 7 (prompt "❯ " = 2 chars + 5 chars typed)
+			expect(calls).toContain(ansi.CURSOR_COL(7));
+		});
+
+		it("should move cursor up when old content was multiple rows", () => {
+			_setInputState({
+				inputBuffer: "x",
+				cursorPosition: 1,
+				oldInputBuffer: "",
+				oldWrappedRows: 2,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			expect(calls).toContain(ansi.CURSOR_UP(2));
+		});
+	});
+
+	describe("line wrapping", () => {
+		it("should handle content that wraps to next line", () => {
+			Object.defineProperty(process.stdout, "columns", {
+				value: 10,
+				writable: true,
+				configurable: true,
+			});
+
+			_setInputState({
+				inputBuffer: "helloworld",
+				cursorPosition: 10,
+				oldInputBuffer: "",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			// Should have a newline when wrapping
+			expect(calls).toContain("\n");
+		});
+
+		it("should calculate correct cursor position when wrapped", () => {
+			Object.defineProperty(process.stdout, "columns", {
+				value: 10,
+				writable: true,
+				configurable: true,
+			});
+
+			_setInputState({
+				inputBuffer: "helloworld",
+				cursorPosition: 10,
+				oldInputBuffer: "",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			// Absolute position 12 (2 prompt + 10 chars), row 1, col 2
+			expect(calls).toContain(ansi.CURSOR_COL(2));
+		});
+	});
+
+	describe("backspace/delete", () => {
+		it("should clear and rewrite when deleting characters", () => {
+			_setInputState({
+				inputBuffer: "he",
+				cursorPosition: 2,
+				oldInputBuffer: "hel",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			// Should clear from cursor
+			expect(calls).toContain(ansi.CLEAR_FROM_CURSOR);
+		});
+	});
+
+	describe("state tracking", () => {
+		it("should update old state after render", () => {
+			_setInputState({
+				inputBuffer: "test",
+				cursorPosition: 4,
+				oldInputBuffer: "",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			// After render, calling again should recognize no changes
+			writeSpy.mockClear();
+			renderLine();
+
+			const output = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]).join("");
+			// Should not write "test" again since nothing changed
+			expect(output).not.toContain("test");
+		});
+	});
+
+	describe("control sequences", () => {
+		it("should use CURSOR_HOME to move to start", () => {
+			_setInputState({ inputBuffer: "hi", cursorPosition: 2 });
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			const homeCount = calls.filter((c: string) => c === ansi.CURSOR_HOME).length;
+			expect(homeCount).toBeGreaterThanOrEqual(1);
+		});
+
+		it("should use CLEAR_FROM_CURSOR to clear content", () => {
+			_setInputState({
+				inputBuffer: "changed",
+				cursorPosition: 7,
+				oldInputBuffer: "old",
+				oldWrappedRows: 0,
+				oldCursorRow: 0,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			expect(calls).toContain(ansi.CLEAR_FROM_CURSOR);
+		});
+
+		it("should use CURSOR_COL for horizontal positioning", () => {
+			_setInputState({ inputBuffer: "abc", cursorPosition: 3 });
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			// Should have CURSOR_COL calls for positioning
+			const hasColCodes = calls.some(
+				(c: string) => typeof c === "string" && c.match(/^\x1b\[\d+G$/),
+			);
+			expect(hasColCodes).toBe(true);
+		});
+
+		it("should not emit CURSOR_UP(0) which would move up 1 line", () => {
+			_setInputState({ inputBuffer: "x", cursorPosition: 1 });
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+			// CURSOR_UP(0) produces "\x1b[0A" which terminals interpret as "move up 1"
+			// We should not emit this - only emit CURSOR_UP when rows > 0
+			expect(calls).not.toContain(ansi.CURSOR_UP(0));
+		});
+
+		it("should not move cursor during comparison loop (only calculate position)", () => {
+			// With 10-char width, prompt takes 2 chars, so 8 chars fit on first line
+			// Typing the 10th char when 9 chars already exist should not move cursor down
+			// during the comparison loop, only position at the end
+			Object.defineProperty(process.stdout, "columns", {
+				value: 10,
+				writable: true,
+				configurable: true,
+			});
+
+			_setInputState({
+				inputBuffer: "abcdefghij",
+				cursorPosition: 10,
+				oldInputBuffer: "abcdefghi",
+				oldWrappedRows: 1,
+				oldCursorRow: 1,
+			});
+
+			renderLine();
+
+			const calls = writeSpy.mock.calls.map((c: [string, ...unknown[]]) => c[0]);
+
+			// Should have CURSOR_UP to get to top
+			expect(calls).toContain(ansi.CURSOR_UP(1));
+
+			// Should NOT have CURSOR_DOWN during comparison (would be between UP and CLEAR)
+			const upIndex = calls.indexOf(ansi.CURSOR_UP(1));
+			const clearIndex = calls.indexOf(ansi.CURSOR_UP(1));
+			const downAfterUp = calls
+				.slice(upIndex, clearIndex)
+				.some((c: string) => c === ansi.CURSOR_DOWN(1));
+			expect(downAfterUp).toBe(false);
+		});
+	});
+});

package/test/README.md

@@ -1,164 +0,0 @@
-# Tmux Readline Tests
-
-This directory contains tmux-based integration tests for the readline functionality of opencode-miniterm.
-
-## Overview
-
-The `tmux-readline.test.ts` script uses tmux to simulate real terminal interactions with the application, testing:
-
-- **Input Editing**: Character insertion, backspace, delete key
-- **Cursor Navigation**: Left/right arrow keys, word boundaries (Meta+left/right)
-- **History Navigation**: Up/down arrow through command history
-- **Tab Completion**: Slash commands (`/`) and file references (`@`)
-- **Smart Features**: Double-space to period conversion
-- **Escape Key**: Clearing input and canceling requests
-
-## Running the Tests
-
-```bash
-# Run all tmux readline tests
-bun run test:tmux
-
-# Or run directly
-bun test/tmux-readline.test.ts
-```
-
-## How It Works
-
-The test script:
-
-1. **Sets up a tmux session** - Creates a detached tmux session for testing
-2. **Starts the application** - Launches opencode-miniterm in the tmux session
-3. **Sends keystrokes** - Simulates user input using `tmux send-keys`
-4. **Captures output** - Uses `tmux capture-pane` to read terminal state
-5. **Verifies behavior** - Checks that the output matches expected results
-6. **Cleans up** - Kills the tmux session after tests complete
-
-## Test Cases
-
-### Input Editing
-
-- **Character insertion**: Typing "hello" should insert characters correctly
-- **Backspace**: Deleting characters before the cursor
-- **Delete key**: Deleting character at the cursor position
-
-### Cursor Navigation
-
-- **Left arrow**: Moving cursor left one character
-- **Right arrow**: Moving cursor right one character
-- **Meta+Left**: Jumping to previous word boundary
-- **Meta+Right**: Jumping to next word boundary
-
-### History Navigation
-
-- **Up arrow**: Navigating backward through command history
-- **Down arrow**: Navigating forward through command history
-
-### Tab Completion
-
-- **Slash commands**: Tab after `/` shows available commands
-- **File references**: Tab after `@` completes file paths
-
-### Smart Features
-
-- **Double space**: Two spaces within 500ms converts to period + space
-
-### Escape Key
-
-- **Clear input**: Escape clears the current input buffer
-
-## Requirements
-
-- **tmux**: Must be installed on your system (`brew install tmux` on macOS)
-- **Bun**: Must have bun installed to run the tests
-- **opencode-miniterm**: Must be able to run the application
-
-## Troubleshooting
-
-### Tests fail with "Expected prompt to contain X"
-
-The test might be running too fast. Increase `WAIT_MS` at the top of the test file.
-
-### Tests hang or timeout
-
-The application might be stuck in a command menu. Press `Escape` or `C-c` in the tmux session to recover.
-
-### tmux session already exists
-
-The script automatically kills existing test sessions. If you see errors, manually run:
-
-```bash
-tmux kill-session -t opencode-test
-```
-
-### Tests don't start
-
-Ensure tmux is installed and working:
-
-```bash
-tmux -V
-tmux new-session -d -s test
-tmux kill-session -t test
-```
-
-## Adding New Tests
-
-To add a new test:
-
-1. Create an async test function that:
-   - Clears input with `await clearInput()`
-   - Sends keystrokes with `await sendKeys("key")`
-   - Waits for processing with `await sleep(ms)`
-   - Captures output with `await capturePane()`
-   - Asserts behavior with `assertPromptContains()` or `assertContains()`
-   - Throws errors with descriptive messages
-
-2. Register the test in `runAllTests()`:
-   ```typescript
-   await runTest("Your test name", testYourFunction);
-   ```
-
-### Example Test
-
-```typescript
-async function testYourFeature(): Promise<void> {
-	await clearInput();
-	await sendKeys("test");
-	await sendKeys("Enter");
-	await sleep(1000);
-
-	const output = await capturePane();
-	if (!assertContains(output, "expected text")) {
-		throw new Error(`Expected output to contain 'expected text'`);
-	}
-}
-```
-
-## Command Menu Tests
-
-For examples of testing the interactive command menus (agents, models, sessions), see `tmux-menu-examples.ts`. This file demonstrates:
-
-- How to enter command menus (`/agents`, `/models`, `/sessions`)
-- How to navigate menu options (Up, Down)
-- How to filter/search within menus
-- How to select items (Enter)
-- How to cancel menus (Escape)
-- How to verify the results
-
-## Key Constants
-
-- `TMUX_SESSION`: "opencode-test" - The tmux session name
-- `TMUX_WINDOW`: "readline-test" - The tmux window name
-- `WAIT_MS`: 100 - Default wait time between keystrokes
-- `APP_PATH`: Path to the application entry point
-
-## Helper Functions
-
-- `setupTmux()` / `teardownTmux()`: Create/destroy test environment
-- `startApp()` / `stopApp()`: Start/stop the application
-- `sendKeys(keys)`: Send keystrokes to tmux (e.g., "C-c", "Enter", "M-Left")
-- `capturePane()`: Get current terminal output
-- `clearInput()`: Clear the current input line
-- `assertContains(output, expected)`: Check if output contains text
-- `assertPromptContains(text, expected)`: Check if prompt contains text
-- `stripAnsi(text)`: Remove ANSI escape codes from text

package/test/tmux-menu-examples.ts

@@ -1,119 +0,0 @@
-// Example: How to add command menu tests
-// This file contains examples for testing the interactive command menus
-import { $ } from "bun";
-
-const TMUX_SESSION = "opencode-test-menu";
-
-async function testAgentMenu(): Promise<void> {
-	console.log("Testing agent menu navigation");
-
-	// Start with /agents command
-	await $`tmux send-keys -t ${TMUX_SESSION} "/agents" Enter`;
-	await sleep(500);
-
-	// Send some filter text
-	await $`tmux send-keys -t ${TMUX_SESSION} "code"`;
-	await sleep(100);
-
-	// Navigate up
-	await $`tmux send-keys -t ${TMUX_SESSION} Up`;
-	await sleep(100);
-
-	// Navigate down
-	await $`tmux send-keys -t ${TMUX_SESSION} Down`;
-	await sleep(100);
-
-	// Clear filter
-	await $`tmux send-keys -t ${TMUX_SESSION} C-u`;
-	await sleep(100);
-
-	// Cancel with escape
-	await $`tmux send-keys -t ${TMUX_SESSION} Escape`;
-	await sleep(100);
-
-	// Verify we're back at prompt
-	const output = await capturePane();
-	if (!assertPromptContains(output, "#")) {
-		throw new Error("Should be back at prompt");
-	}
-}
-
-async function testModelMenu(): Promise<void> {
-	console.log("Testing model menu navigation");
-
-	await $`tmux send-keys -t ${TMUX_SESSION} "/models" Enter`;
-	await sleep(500);
-
-	// Navigate through options
-	await $`tmux send-keys -t ${TMUX_SESSION} Down`;
-	await sleep(100);
-	await $`tmux send-keys -t ${TMUX_SESSION} Down`;
-	await sleep(100);
-
-	// Select a model
-	await $`tmux send-keys -t ${TMUX_SESSION} Enter`;
-	await sleep(200);
-
-	// Verify selection worked
-	const output = await capturePane();
-	if (!assertContains(output, "Model changed")) {
-		throw new Error("Model should be changed");
-	}
-}
-
-async function testSessionMenu(): Promise<void> {
-	console.log("Testing session menu navigation");
-
-	await $`tmux send-keys -t ${TMUX_SESSION} "/sessions" Enter`;
-	await sleep(500);
-
-	// Test pagination
-	await $`tmux send-keys -t ${TMUX_SESSION} Down`;
-	await sleep(100);
-	await $`tmux send-keys -t ${TMUX_SESSION} Down`;
-	await sleep(100);
-
-	// Select a session
-	await $`tmux send-keys -t ${TMUX_SESSION} Enter`;
-	await sleep(200);
-
-	// Verify we're using the selected session
-	const output = await capturePane();
-	if (!assertContains(output, "Session loaded")) {
-		throw new Error("Session should be loaded");
-	}
-}
-
-// Note: These are example tests that would need to be integrated
-// into the main tmux-readline.test.ts file. They demonstrate:
-// 1. How to enter command menus (/agents, /models, /sessions)
-// 2. How to navigate menu options (Up, Down)
-// 3. How to filter/search within menus
-// 4. How to select items (Enter)
-// 5. How to cancel menus (Escape)
-// 6. How to verify the results
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function capturePane(): Promise<string> {
-	const result = await $`tmux capture-pane -t ${TMUX_SESSION} -p`.quiet();
-	return result.stdout.toString();
-}
-
-function assertPromptContains(text: string, expected: string): boolean {
-	const lines = text.split("\n");
-	for (const line of lines) {
-		if (line.includes("#")) {
-			return line.includes(expected);
-		}
-	}
-	return false;
-}
-
-function assertContains(output: string, expected: string): boolean {
-	return output.includes(expected);
-}
-
-export {};

package/test/tmux-readline.test.ts

@@ -1,518 +0,0 @@
-#!/usr/bin/env bun
-import { $ } from "bun";
-
-const TMUX_SESSION = "opencode-test";
-const TMUX_WINDOW = "readline-test";
-const APP_PATH = "/Users/andrewjk/Source/opencode-miniterm/src/index.ts";
-const WAIT_MS = 80;
-
-interface TestResult {
-	name: string;
-	passed: boolean;
-	output: string;
-	expected: string;
-	error?: string;
-}
-
-const results: TestResult[] = [];
-
-async function setupTmux(): Promise<void> {
-	try {
-		await $`tmux kill-session -t ${TMUX_SESSION}`.quiet();
-	} catch {
-		// Session might not exist
-	}
-
-	await $`tmux new-session -d -s ${TMUX_SESSION} -n ${TMUX_WINDOW}`;
-	await sleep(300);
-}
-
-async function teardownTmux(): Promise<void> {
-	await $`tmux kill-session -t ${TMUX_SESSION}`.quiet();
-}
-
-async function startApp(): Promise<void> {
-	await $`tmux send-keys -t ${TMUX_SESSION} "cd /Users/andrewjk/Source/opencode-miniterm && bun run ${APP_PATH}" Enter`;
-	await sleep(3000);
-}
-
-async function stopApp(): Promise<void> {
-	await $`tmux send-keys -t ${TMUX_SESSION} C-c`;
-	await sleep(200);
-}
-
-async function sendKeys(keys: string): Promise<void> {
-	await $`tmux send-keys -t ${TMUX_SESSION} ${keys}`.quiet();
-	await sleep(WAIT_MS);
-}
-
-async function capturePane(): Promise<string> {
-	const result = await $`tmux capture-pane -t ${TMUX_SESSION} -p`.quiet();
-	const text = result.stdout.toString();
-	return text;
-}
-
-async function clearInput(): Promise<void> {
-	// Send Enter to execute/clear current input
-	await sendKeys("Enter");
-	await sleep(500);
-	// Send Escape to cancel any active state
-	await sendKeys("Escape");
-	await sleep(100);
-	// Send Ctrl+U to clear from cursor to start
-	await sendKeys("C-u");
-	await sleep(100);
-	// Send Ctrl+K to clear from cursor to end
-	await sendKeys("C-k");
-	await sleep(100);
-}
-
-async function sleep(ms: number): Promise<void> {
-	await new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function stripAnsi(text: string): string {
-	return text.replace(/\x1b\[[0-9;]*m/g, "").replace(/\x1b\[[0-9;]*[ABCDEFGJKLM]/g, "");
-}
-
-function extractPromptLine(text: string): string {
-	const lines = text.split("\n");
-	let lastPromptIndex = -1;
-
-	// Find the LAST prompt line (with #)
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
-		if (line && line.includes("#")) {
-			lastPromptIndex = i;
-		}
-	}
-
-	if (lastPromptIndex === -1) {
-		return "";
-	}
-
-	// Collect the prompt line and its wrapped continuations
-	const promptLine = lines[lastPromptIndex]!;
-	const afterPrompt = promptLine.substring(promptLine.indexOf("#") + 1).trim();
-
-	const promptLines: string[] = [afterPrompt];
-	for (let j = lastPromptIndex + 1; j < lines.length; j++) {
-		const nextLine = lines[j];
-		if (!nextLine) {
-			break;
-		}
-		const trimmed = nextLine.trim();
-		// Stop if we hit another prompt or an empty line
-		if (nextLine.includes("#") || trimmed === "") {
-			break;
-		}
-		promptLines.push(trimmed);
-	}
-
-	return stripAnsi(promptLines.join(" "));
-}
-
-function assertContains(output: string, expected: string): boolean {
-	const stripped = stripAnsi(output);
-	return stripped.includes(expected);
-}
-
-function assertPromptContains(text: string, expected: string): boolean {
-	const promptLine = extractPromptLine(text);
-	return promptLine.includes(expected);
-}
-
-async function runTest(name: string, testFn: () => Promise<void>): Promise<void> {
-	console.log(`Running: ${name}`);
-	try {
-		await testFn();
-		results.push({
-			name,
-			passed: true,
-			output: "",
-			expected: "",
-		});
-		console.log(`✓ ${name}`);
-	} catch (error) {
-		results.push({
-			name,
-			passed: false,
-			output: (error as Error).message,
-			expected: "",
-			error: (error as Error).stack,
-		});
-		console.error(`✗ ${name}`);
-		console.error(`  Error: ${(error as Error).message}`);
-	}
-}
-
-async function testCharacterInsertion(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("h");
-	await sendKeys("e");
-	await sendKeys("l");
-	await sendKeys("l");
-	await sendKeys("o");
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "hello")) {
-		throw new Error(`Expected prompt to contain 'hello', got: ${extractPromptLine(output)}`);
-	}
-}
-
-async function testBackspace(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("hello");
-	await sendKeys("Space");
-	await sendKeys("world");
-	await sendKeys("C-h");
-	await sendKeys("C-h");
-	await sendKeys("C-h");
-	await sendKeys("C-h");
-	await sendKeys("C-h");
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "hello")) {
-		throw new Error(`Expected prompt to contain 'hello', got: ${extractPromptLine(output)}`);
-	}
-}
-
-async function testDelete(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("hello");
-	await sendKeys("Left");
-	await sendKeys("Left");
-	await sendKeys("Delete");
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "helo")) {
-		throw new Error(`Expected prompt to contain 'helo', got: ${extractPromptLine(output)}`);
-	}
-}
-
-async function testLeftArrow(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("test");
-	await sendKeys("Left");
-	await sendKeys("Left");
-	await sendKeys("X");
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "teXst")) {
-		throw new Error(`Expected prompt to contain 'teXst', got: ${extractPromptLine(output)}`);
-	}
-}
-
-async function testRightArrow(): Promise<void> {
-	await clearInput();
-	await sleep(200);
-	await sendKeys("test");
-	await sleep(150);
-	await sendKeys("Left");
-	await sleep(150);
-	await sendKeys("Left");
-	await sleep(150);
-	await sendKeys("Right");
-	await sleep(150);
-	await sendKeys("Right");
-	await sleep(150);
-	await sendKeys("X");
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "tesXt") && !assertPromptContains(output, "testX")) {
-		throw new Error(
-			`Expected prompt to contain 'tesXt' or 'testX', got: ${extractPromptLine(output)}`,
-		);
-	}
-}
-
-async function testTabCompletionSlashCommands(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("/");
-	await sleep(200);
-	await sendKeys("Tab");
-	await sleep(500);
-
-	const output = await capturePane();
-	const stripped = stripAnsi(output);
-	if (!stripped.includes("/") && !stripped.includes("/help") && !stripped.includes("commands")) {
-		throw new Error(
-			`Expected output to contain command completions, got: ${stripped.substring(0, 200)}`,
-		);
-	}
-}
-
-async function testTabCompletionFileRef(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("@");
-	await sleep(100);
-	await sendKeys("src/");
-	await sleep(100);
-	await sendKeys("Tab");
-	await sleep(300);
-
-	const output = await capturePane();
-	const stripped = stripAnsi(output);
-	if (!stripped.includes("src/")) {
-		throw new Error(`Expected output to contain 'src/', got: ${stripped.substring(0, 200)}`);
-	}
-}
-
-async function testHistoryUpArrow(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-
-	// Add some commands to history
-	await sendKeys("first command");
-	await sendKeys("Enter");
-	await sleep(1000);
-
-	await sendKeys("second command");
-	await sendKeys("Enter");
-	await sleep(1000);
-
-	await clearInput();
-	await sleep(100);
-	await sendKeys("Up");
-	await sleep(100);
-	await sendKeys("Up");
-	await sleep(100);
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "first command")) {
-		throw new Error(
-			`Expected prompt to contain 'first command', got: ${extractPromptLine(output)}`,
-		);
-	}
-}
-
-async function testHistoryDownArrow(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-
-	await sendKeys("test history");
-	await sendKeys("Enter");
-	await sleep(1000);
-
-	await clearInput();
-	await sleep(100);
-	await sendKeys("Up");
-	await sleep(100);
-	await sendKeys("Down");
-	await sleep(100);
-
-	const output = await capturePane();
-	const promptLine = extractPromptLine(output);
-	if (promptLine.includes("test history")) {
-		throw new Error(`Expected prompt to be empty after down arrow, got: ${promptLine}`);
-	}
-}
-
-async function testEscapeClearsInput(): Promise<void> {
-	await clearInput();
-	await sleep(200);
-	await sendKeys("test");
-	await sleep(100);
-	await sendKeys("Escape");
-	await sleep(300);
-
-	const output = await capturePane();
-	const promptLine = extractPromptLine(output);
-	// Escape should clear input or cancel active request
-	if (
-		promptLine &&
-		promptLine.includes("test") &&
-		!promptLine.includes("test ") &&
-		promptLine.trim() !== ""
-	) {
-		// Input still has "test" - escape might not have cleared it, but this is okay if it cancels a request
-		// Just mark as pass since the key was processed
-	}
-}
-
-async function testDoubleSpaceToPeriod(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("hello");
-	await sleep(100);
-	await sendKeys("Space");
-	await sleep(100);
-	await sendKeys("Space");
-	await sleep(700);
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "hello.")) {
-		throw new Error(`Expected prompt to contain 'hello.', got: ${extractPromptLine(output)}`);
-	}
-}
-
-async function testMetaLeftWordNavigation(): Promise<void> {
-	await clearInput();
-	await sleep(200);
-	await sendKeys("hello world test");
-	await sleep(200);
-
-	// Try to send Alt+b using different methods
-	await $`tmux send-keys -t ${TMUX_SESSION} 'M-b'`.quiet();
-	await sleep(200);
-	await $`tmux send-keys -t ${TMUX_SESSION} 'M-b'`.quiet();
-	await sleep(200);
-	await sendKeys("X");
-
-	const output = await capturePane();
-	const promptLine = extractPromptLine(output);
-	// Check if cursor moved by verifying X is not at the end
-	if (promptLine && promptLine.endsWith("testX")) {
-		// Cursor didn't move, try to skip this test or mark as partial pass
-		console.log("  (Meta key not recognized, test skipped)");
-	} else if (
-		!assertPromptContains(output, "X world test") &&
-		!assertPromptContains(output, "hello worldX test") &&
-		!assertPromptContains(output, "hello world testX")
-	) {
-		throw new Error(`Unexpected prompt: ${promptLine}`);
-	}
-}
-
-async function testMetaRightWordNavigation(): Promise<void> {
-	await clearInput();
-	await sleep(100);
-	await sendKeys("hello");
-	await sendKeys("Space");
-	await sleep(100);
-
-	// Use Alt+f instead of M-Right for better compatibility
-	await $`tmux send-keys -t ${TMUX_SESSION} M-f`.quiet();
-	await sleep(100);
-	await sendKeys("X");
-
-	const output = await capturePane();
-	if (!assertPromptContains(output, "hello X")) {
-		throw new Error(`Expected prompt to contain 'hello X', got: ${extractPromptLine(output)}`);
-	}
-}
-
-async function testMultiLineBackspaceToSingleLine(): Promise<void> {
-	await clearInput();
-	await sleep(200);
-
-	// Type a command that will produce output above the prompt
-	await sendKeys("echo test");
-	await sendKeys("Enter");
-	await sleep(1000);
-
-	// Capture state before multi-line input - we should have output above
-	const outputBefore = await capturePane();
-	const linesBefore = outputBefore.split("\n");
-
-	// Find the line with our output (should contain "test" or similar)
-	const outputLineIndex = linesBefore.findIndex(
-		(line) => line.includes("test") && !line.includes("#"),
-	);
-	if (outputLineIndex === -1) {
-		throw new Error("Could not find output line before typing multi-line input");
-	}
-
-	const outputLineBefore = linesBefore[outputLineIndex]!;
-
-	// Type enough text to span multiple lines
-	await sendKeys(
-		"This is a very long line of text that should wrap to the next line when typed in the terminal",
-	);
-	await sleep(200);
-
-	// Press backspace multiple times to reduce to single line
-	for (let i = 0; i < 40; i++) {
-		await sendKeys("C-h");
-		await sleep(30);
-	}
-
-	await sleep(300);
-	const outputAfter = await capturePane();
-	const linesAfter = outputAfter.split("\n");
-
-	// Find the output line after backspace
-	const outputLineIndexAfter = linesAfter.findIndex(
-		(line) => line.includes("test") && !line.includes("#"),
-	);
-
-	if (outputLineIndexAfter === -1) {
-		throw new Error(`Output line was cleared! Before: '${outputLineBefore}'`);
-	}
-
-	const outputLineAfter = linesAfter[outputLineIndexAfter]!;
-
-	// Verify the output line is still there and not modified
-	if (!outputLineAfter.includes("test")) {
-		throw new Error(
-			`Output line was modified or cleared! Before: '${outputLineBefore}', After: '${outputLineAfter}'`,
-		);
-	}
-
-	// Also verify the output hasn't been corrupted with extra characters from the prompt
-	const strippedBefore = stripAnsi(outputLineBefore);
-	const strippedAfter = stripAnsi(outputLineAfter);
-	if (strippedBefore !== strippedAfter) {
-		throw new Error(
-			`Output line content changed! Before: '${strippedBefore}', After: '${strippedAfter}'`,
-		);
-	}
-}
-
-async function runAllTests(): Promise<void> {
-	console.log("Setting up tmux test environment...");
-	await setupTmux();
-	await startApp();
-
-	console.log("\nRunning readline tests...\n");
-
-	await runTest("Character insertion", testCharacterInsertion);
-	await runTest("Backspace deletion", testBackspace);
-	await runTest("Delete key", testDelete);
-	await runTest("Left arrow navigation", testLeftArrow);
-	await runTest("Right arrow navigation", testRightArrow);
-	await runTest("Tab completion - slash commands", testTabCompletionSlashCommands);
-	await runTest("Tab completion - file references", testTabCompletionFileRef);
-	await runTest("History navigation - up arrow", testHistoryUpArrow);
-	await runTest("History navigation - down arrow", testHistoryDownArrow);
-	await runTest("Escape clears input", testEscapeClearsInput);
-	await runTest("Double space to period", testDoubleSpaceToPeriod);
-	await runTest("Word navigation - Meta+Left", testMetaLeftWordNavigation);
-	await runTest("Word navigation - Meta+Right", testMetaRightWordNavigation);
-	await runTest("Multi-line backspace to single line", testMultiLineBackspaceToSingleLine);
-
-	await stopApp();
-	await teardownTmux();
-
-	console.log("\n" + "=".repeat(60));
-	console.log("Test Results:");
-	console.log("=".repeat(60));
-
-	const passed = results.filter((r) => r.passed).length;
-	const failed = results.filter((r) => !r.passed).length;
-
-	results.forEach((result) => {
-		const icon = result.passed ? "✓" : "✗";
-		console.log(`${icon} ${result.name}`);
-		if (!result.passed) {
-			console.log(`  ${result.output}`);
-		}
-	});
-
-	console.log("=".repeat(60));
-	console.log(`Total: ${results.length} | Passed: ${passed} | Failed: ${failed}`);
-	console.log("=".repeat(60));
-
-	process.exit(failed > 0 ? 1 : 0);
-}
-
-runAllTests().catch((error) => {
-	console.error("Fatal error:", error);
-	process.exit(1);
-});