opencode-miniterm 1.0.11 → 1.0.12

package/bun.lock

@@ -5,7 +5,7 @@
     "": {
       "name": "opencode-miniterm",
       "dependencies": {
-        "@opencode-ai/sdk": "^1.2.15",
+        "@opencode-ai/sdk": "^1.2.24",
         "allmark": "^1.0.2",
       },
       "devDependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-miniterm",
-	"version": "1.0.11",
+	"version": "1.0.12",
 	"description": "A small front-end terminal UI for OpenCode",
 	"main": "src/index.ts",
 	"bin": {
@@ -9,7 +9,6 @@
 	"scripts": {
 		"dev": "bun src/index.ts",
 		"test": "bun test",
-		"test:tmux": "bun test/tmux-readline.test.ts",
 		"check": "tsgo --noEmit"
 	},
 	"keywords": [

package/src/ansi.ts

@@ -5,7 +5,6 @@ export const CLEAR_SCREEN_UP = "\x1b[2A";
 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 DISABLE_LINE_WRAP = "\x1b[?7l";
 export const ENABLE_LINE_WRAP = "\x1b[?7h";
 export const RESET = "\x1b[0m";

package/src/index.ts

@@ -182,34 +182,50 @@ let completionCycling = false;
 let lastSpaceTime = 0;
 let currentInputBuffer: string | null = null;
 
-let count = 0;
+let oldInputBuffer = "";
 let oldWrappedRows = 0;
 let oldCursorRow = 0;
 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);
-
-	// Ensure the cursor is at the end of the old input
-	if (cursorPosition < inputBuffer.length) {
-		readline.moveCursor(process.stdout, 0, oldWrappedRows - oldCursorRow);
-	}
-
-	// Clear the old input
 	if (oldWrappedRows > 0) {
+		if (cursorPosition < inputBuffer.length) {
+			readline.moveCursor(process.stdout, 0, oldWrappedRows - oldCursorRow);
+		}
 		readline.moveCursor(process.stdout, 0, -oldWrappedRows);
 	}
+
+	// Find the position where the input has changed (i.e. where the user has
+	// typed something)
+	let start = 0;
+	let currentCol = 2;
+	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++;
+		}
+		currentCol++;
+		start++;
+	}
+
+	// Clear the old, changed, input
+	readline.moveCursor(process.stdout, currentCol, 0);
 	readline.clearScreenDown(process.stdout);
-	readline.cursorTo(process.stdout, 2);
 
-	// Write the prompt
-	writePrompt();
+	if (start === 0) {
+		writePrompt();
+	}
 
-	// Write the new input buffer
+	// Write the changes from the new input buffer
 	let renderExtent = Math.max(cursorPosition + 1, inputBuffer.length);
-	let currentCol = 2;
-	let newWrappedRows = 0;
-	for (let i = 0; i < renderExtent; i++) {
+	for (let i = start; i < renderExtent; i++) {
 		if (currentCol >= consoleWidth) {
 			process.stdout.write("\n");
 			currentCol = 0;
@@ -221,14 +237,15 @@ function renderLine(): void {
 		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);
 
+	oldInputBuffer = inputBuffer;
 	oldWrappedRows = newWrappedRows;
 	oldCursorRow = newCursorRow;
 }

package/src/render.ts

@@ -1,5 +1,6 @@
 import type { OpencodeClient } from "@opencode-ai/sdk";
 import { gfm, parse, renderToConsole } from "allmark";
+import readline from "node:readline";
 import * as ansi from "./ansi";
 import { config } from "./config";
 import type { State } from "./index";
@@ -138,9 +139,10 @@ function lastThinkingLines(text: string): string {
 
 function clearRenderedLines(state: State, linesToClear: number): void {
 	if (linesToClear > 0) {
-		state.write(`${ansi.CURSOR_UP(linesToClear)}\x1b[J`);
+		readline.moveCursor(process.stdout, 0, -1 * linesToClear);
+		readline.clearScreenDown(process.stdout);
 	}
-	state.write(ansi.CURSOR_HOME);
+	readline.cursorTo(process.stdout, 0);
 }
 
 export function wrapText(text: string, width: number): string[] {
@@ -301,7 +303,7 @@ export function startAnimation(startTime?: number): void {
 		const elapsedText = formatDuration(elapsed);
 
 		process.stdout.write(
-			`\r${ansi.BOLD_MAGENTA}${ANIMATION_CHARS[index]} ${ansi.RESET}${ansi.BRIGHT_BLACK}Running for ${elapsedText}${ansi.RESET}`,
+			`\r${ansi.BOLD_MAGENTA}${ANIMATION_CHARS[index]} ${ansi.RESET}${ansi.BRIGHT_BLACK}Running for ${elapsedText}${ansi.RESET}    `,
 		);
 		index = (index + 1) % ANIMATION_CHARS.length;
 	}, 100);

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);
-});