opencode-miniterm 1.0.4 → 1.0.6

package/src/index.ts

@@ -6,7 +6,7 @@ import { mkdir } from "node:fs/promises";
 import { glob } from "node:fs/promises";
 import { stat } from "node:fs/promises";
 import { open } from "node:fs/promises";
-import readline from "node:readline";
+import readline, { type Key } from "node:readline";
 import * as ansi from "./ansi";
 import agentsCommand from "./commands/agents";
 import debugCommand from "./commands/debug";
@@ -46,6 +46,7 @@ const SLASH_COMMANDS = [
 	runCommand,
 ];
 
+let server: Awaited<ReturnType<typeof createOpencodeServer>> | undefined;
 let client: ReturnType<typeof createOpencodeClient>;
 
 let processing = true;
@@ -92,7 +93,6 @@ async function main() {
 
 	console.log(`\n${ansi.BRIGHT_BLACK}Connecting to OpenCode server...${ansi.RESET}\n`);
 
-	let server: Awaited<ReturnType<typeof createOpencodeServer>> | undefined;
 	try {
 		server = await createOpencodeServer();
 	} catch {
@@ -112,10 +112,8 @@ async function main() {
 	});
 
 	process.on("SIGINT", () => {
-		console.log("\nShutting down...");
-		saveConfig();
-		server?.close();
-		process.exit(0);
+		process.stdout.write("\n");
+		shutdown();
 	});
 
 	try {
@@ -135,12 +133,11 @@ async function main() {
 
 		await updateSessionTitle();
 
-		const sessionHistory = await loadSessionHistory();
-
-		const activeDisplay = await getActiveDisplay(client);
+		history = await loadSessionHistory();
 
 		process.stdout.write(`${ansi.CLEAR_SCREEN_UP}${ansi.CLEAR_FROM_CURSOR}`);
 		process.stdout.write(ansi.CURSOR_HOME);
+		const activeDisplay = await getActiveDisplay(client);
 		console.log(activeDisplay);
 		if (!isNewSession) {
 			console.log("Resumed last session");
@@ -150,311 +147,327 @@ async function main() {
 
 		const rl = readline.createInterface({
 			input: process.stdin,
-			output: process.stdout,
+			output: undefined,
 		});
 
 		readline.emitKeypressEvents(process.stdin);
 		if (process.stdin.setRawMode) {
 			process.stdin.setRawMode(true);
 		}
+		process.stdout.write(ansi.DISABLE_LINE_WRAP);
 
-		let inputBuffer = "";
-		let cursorPosition = 0;
-		let completions: string[] = [];
-		let history: string[] = sessionHistory;
-		let historyIndex = history.length;
-		let selectedCompletion = 0;
-		let showCompletions = false;
-		let completionCycling = false;
-		let lastSpaceTime = 0;
-		let currentInputBuffer: string | null = null;
-
-		const getCompletions = async (text: string): Promise<string[]> => {
-			if (text.startsWith("/")) {
-				return ["/help", ...SLASH_COMMANDS.map((c) => c.name)].filter((cmd) =>
-					cmd.startsWith(text),
-				);
-			}
+		process.stdin.on("keypress", async (str, key) => {
+			handleKeyPress(str, key);
+		});
 
-			const atMatch = text.match(/(@[^\s]*)$/);
-			if (atMatch) {
-				const prefix = atMatch[0]!;
-				const searchPattern = prefix.slice(1);
-				const pattern = searchPattern.includes("/")
-					? searchPattern + "*"
-					: "**/" + searchPattern + "*";
-				const files = await getFileCompletions(pattern);
-				return files.map((file: string) => text.replace(/@[^\s]*$/, "@" + file));
-			}
+		writePrompt();
+	} catch (error: any) {
+		console.error("Error:", error.message);
+		server?.close();
+		process.exit(1);
+	}
+}
 
-			return [];
-		};
-
-		let oldWrappedRows = 0;
-		const renderLine = (): void => {
-			const consoleWidth = process.stdout.columns || 80;
-			const totalLength = 2 + inputBuffer.length + 1;
-			const wrappedRows = Math.floor(totalLength / consoleWidth);
-			readline.cursorTo(process.stdout, 0);
-			if (oldWrappedRows > 0) {
-				readline.moveCursor(process.stdout, 0, -oldWrappedRows);
-			}
-			readline.clearScreenDown(process.stdout);
-			oldWrappedRows = wrappedRows;
+// ====================
+// HANDLE INPUT
+// ====================
 
-			writePrompt();
-			process.stdout.write(inputBuffer);
+let inputBuffer = "";
+let cursorPosition = 0;
+let completions: string[] = [];
+let history: string[] = [];
+let historyIndex = history.length;
+let selectedCompletion = 0;
+let completionCycling = false;
+let lastSpaceTime = 0;
+let currentInputBuffer: string | null = null;
+
+let oldWrappedRows = 0;
+function renderLine(): void {
+	const consoleWidth = process.stdout.columns || 80;
+
+	readline.cursorTo(process.stdout, 0);
+	if (oldWrappedRows > 0) {
+		readline.moveCursor(process.stdout, 0, -oldWrappedRows);
+	}
+	readline.clearScreenDown(process.stdout);
 
-			const totalPosition = 2 + cursorPosition;
-			const targetRow = Math.floor(totalPosition / consoleWidth);
-			const targetCol = totalPosition % consoleWidth;
+	writePrompt();
 
-			const endCol = (2 + inputBuffer.length) % consoleWidth;
-			const endRow = Math.floor((2 + inputBuffer.length) / consoleWidth);
+	let currentCol = 2;
+	let row = 0;
+	for (let i = 0; i < inputBuffer.length; i++) {
+		if (currentCol >= consoleWidth) {
+			process.stdout.write("\n");
+			currentCol = 0;
+			row++;
+		}
+		process.stdout.write(inputBuffer[i]!);
+		currentCol++;
+	}
+	oldWrappedRows = row;
+
+	let targetRow = 0;
+	let targetCol = 0;
+	let pos = 2;
+	for (let i = 0; i < cursorPosition; i++) {
+		if (pos >= consoleWidth) {
+			targetRow++;
+			pos = 0;
+		}
+		pos++;
+	}
+	targetCol = pos;
 
-			const deltaCol = targetCol - endCol;
-			let deltaRow = targetRow - endRow;
-			if (deltaCol !== 0 && endCol === 0) {
-				deltaRow += 1;
-			}
+	readline.cursorTo(process.stdout, 0);
+	if (targetRow > 0) {
+		process.stdout.write(`\x1b[${targetRow}B`);
+	}
+	readline.cursorTo(process.stdout, targetCol);
+}
 
-			readline.moveCursor(process.stdout, deltaCol, deltaRow);
-		};
+async function handleKeyPress(str: string, key: Key) {
+	if (key.ctrl && key.name === "c") {
+		process.stdout.write("\n");
+		shutdown();
+		return;
+	}
 
-		const handleTab = async (): Promise<void> => {
-			const potentialCompletions = await getCompletions(inputBuffer);
+	for (let command of SLASH_COMMANDS) {
+		if (command.running && command.handleKey) {
+			await command.handleKey(client, key, str);
+			return;
+		}
+	}
 
-			if (potentialCompletions.length === 0) {
-				completionCycling = false;
-				return;
+	switch (key.name) {
+		case "up": {
+			if (historyIndex === history.length) {
+				currentInputBuffer = inputBuffer;
 			}
-
-			if (!completionCycling) {
-				completions = potentialCompletions;
-				selectedCompletion = 0;
-				completionCycling = true;
-				inputBuffer = completions[0]!;
+			if (history.length > 0) {
+				if (historyIndex > 0) {
+					historyIndex--;
+					inputBuffer = history[historyIndex]!;
+				} else {
+					historyIndex = Math.max(-1, historyIndex - 1);
+					inputBuffer = "";
+				}
 				cursorPosition = inputBuffer.length;
 				renderLine();
-			} else {
-				selectedCompletion = (selectedCompletion + 1) % completions.length;
-				inputBuffer = completions[selectedCompletion]!;
+			}
+			return;
+		}
+		case "down": {
+			if (history.length > 0) {
+				if (historyIndex < history.length - 1) {
+					historyIndex++;
+					inputBuffer = history[historyIndex]!;
+				} else {
+					historyIndex = history.length;
+					inputBuffer = currentInputBuffer || "";
+					currentInputBuffer = null;
+				}
 				cursorPosition = inputBuffer.length;
 				renderLine();
 			}
-		};
+			return;
+		}
+		case "tab": {
+			if (!completionCycling) {
+				await handleTab();
+			}
+			if (completionCycling && completions.length > 0) {
+				await handleTab();
+			}
+			return;
+		}
+		case "escape": {
+			if (isRequestActive) {
+				if (state.sessionID) {
+					client.session.abort({ path: { id: state.sessionID } }).catch(() => {});
+				}
+				stopAnimation();
+				process.stdout.write(ansi.CURSOR_SHOW);
+				process.stdout.write(`\r  ${ansi.BRIGHT_BLACK}Cancelled request${ansi.RESET}\n`);
+				writePrompt();
+				isRequestActive = false;
+			} else {
+				inputBuffer = "";
+				cursorPosition = 0;
+				currentInputBuffer = null;
+				renderLine();
+			}
+			return;
+		}
+		case "return": {
+			await acceptInput();
+			return;
+		}
+		case "backspace": {
+			if (cursorPosition > 0) {
+				inputBuffer = inputBuffer.slice(0, cursorPosition - 1) + inputBuffer.slice(cursorPosition);
+				cursorPosition--;
+				currentInputBuffer = null;
+			}
+			break;
+		}
+		case "delete": {
+			if (cursorPosition < inputBuffer.length) {
+				inputBuffer = inputBuffer.slice(0, cursorPosition) + inputBuffer.slice(cursorPosition + 1);
+				currentInputBuffer = null;
+			}
+			break;
+		}
+		case "left": {
+			if (key.meta) {
+				cursorPosition = findPreviousWordBoundary(inputBuffer, cursorPosition);
+			} else if (cursorPosition > 0) {
+				cursorPosition--;
+			}
+			break;
+		}
+		case "right": {
+			if (key.meta) {
+				cursorPosition = findNextWordBoundary(inputBuffer, cursorPosition);
+			} else if (cursorPosition < inputBuffer.length) {
+				cursorPosition++;
+			}
+			break;
+		}
+		default: {
+			if (str === " ") {
+				const now = Date.now();
+				if (
+					now - lastSpaceTime < 500 &&
+					cursorPosition > 0 &&
+					inputBuffer[cursorPosition - 1] === " "
+				) {
+					inputBuffer =
+						inputBuffer.slice(0, cursorPosition - 1) + ". " + inputBuffer.slice(cursorPosition);
+					cursorPosition += 1;
+				} else {
+					inputBuffer =
+						inputBuffer.slice(0, cursorPosition) + str + inputBuffer.slice(cursorPosition);
+					cursorPosition += str.length;
+				}
+				lastSpaceTime = now;
+			} else if (str) {
+				inputBuffer =
+					inputBuffer.slice(0, cursorPosition) + str + inputBuffer.slice(cursorPosition);
+				cursorPosition += str.length;
+			}
+			currentInputBuffer = null;
+		}
+	}
 
-		const acceptInput = async (): Promise<void> => {
-			process.stdout.write("\n");
+	completionCycling = false;
+	completions = [];
+	renderLine();
+}
 
-			const input = inputBuffer.trim();
+async function handleTab(): Promise<void> {
+	const potentialCompletions = await getCompletions(inputBuffer);
 
-			inputBuffer = "";
-			cursorPosition = 0;
-			showCompletions = false;
-			completionCycling = false;
-			completions = [];
-			currentInputBuffer = null;
+	if (potentialCompletions.length === 0) {
+		completionCycling = false;
+		return;
+	}
 
-			if (input) {
-				if (history[history.length - 1] !== input) {
-					history.push(input);
-				}
-				historyIndex = history.length;
-				try {
-					if (input === "/help") {
-						const maxCommandLength = Math.max(...SLASH_COMMANDS.map((c) => c.name.length));
-						for (const cmd of SLASH_COMMANDS) {
-							const padding = " ".repeat(maxCommandLength - cmd.name.length + 2);
-							console.log(
-								`  ${ansi.BRIGHT_WHITE}${cmd.name}${ansi.RESET}${padding}${ansi.BRIGHT_BLACK}${cmd.description}${ansi.RESET}`,
-							);
-						}
-						console.log();
-						return;
-					} else if (input.startsWith("/")) {
-						const parts = input.match(/(\/[^\s]+)\s*(.*)/)!;
-						if (parts) {
-							const commandName = parts[1];
-							const extra = parts[2]?.trim();
-							for (let command of SLASH_COMMANDS) {
-								if (command.name === commandName) {
-									await command.run(client, state, extra);
-									return;
-								}
-							}
-						}
-						return;
-					}
+	if (!completionCycling) {
+		completions = potentialCompletions;
+		selectedCompletion = 0;
+		completionCycling = true;
+		inputBuffer = completions[0]!;
+		cursorPosition = inputBuffer.length;
+		renderLine();
+	} else {
+		selectedCompletion = (selectedCompletion + 1) % completions.length;
+		inputBuffer = completions[selectedCompletion]!;
+		cursorPosition = inputBuffer.length;
+		renderLine();
+	}
+}
 
-					isRequestActive = true;
-					process.stdout.write(ansi.CURSOR_HIDE);
-					startAnimation();
-					if (isLoggingEnabled()) {
-						console.log(`📝 ${ansi.BRIGHT_BLACK}Logging to ${getLogDir()}\n${ansi.RESET}`);
-					}
-					await sendMessage(state.sessionID, input);
-					isRequestActive = false;
-				} catch (error: any) {
-					isRequestActive = false;
-					if (error.message !== "Request cancelled") {
-						stopAnimation();
-						console.error("Error:", error.message);
-					}
-				}
-			}
+async function getCompletions(text: string): Promise<string[]> {
+	if (text.startsWith("/")) {
+		return ["/help", ...SLASH_COMMANDS.map((c) => c.name)].filter((cmd) => cmd.startsWith(text));
+	}
 
-			if (!SLASH_COMMANDS.find((c) => c.running)) {
-				writePrompt();
-			}
-		};
+	const atMatch = text.match(/(@[^\s]*)$/);
+	if (atMatch) {
+		const prefix = atMatch[0]!;
+		const searchPattern = prefix.slice(1);
+		const pattern = searchPattern.includes("/") ? searchPattern + "*" : "**/" + searchPattern + "*";
+		const files = await getFileCompletions(pattern);
+		return files.map((file: string) => text.replace(/@[^\s]*$/, "@" + file));
+	}
 
-		process.stdin.on("keypress", async (str, key) => {
-			for (let command of SLASH_COMMANDS) {
-				if (command.running && command.handleKey) {
-					await command.handleKey(client, key, str);
-					return;
-				}
-			}
+	return [];
+}
 
-			switch (key.name) {
-				case "up": {
-					if (historyIndex === history.length) {
-						currentInputBuffer = inputBuffer;
-					}
-					if (history.length > 0) {
-						if (historyIndex > 0) {
-							historyIndex--;
-							inputBuffer = history[historyIndex]!;
-						} else {
-							historyIndex = Math.max(-1, historyIndex - 1);
-							inputBuffer = "";
-						}
-						cursorPosition = inputBuffer.length;
-						renderLine();
-					}
-					return;
-				}
-				case "down": {
-					if (history.length > 0) {
-						if (historyIndex < history.length - 1) {
-							historyIndex++;
-							inputBuffer = history[historyIndex]!;
-						} else {
-							historyIndex = history.length;
-							inputBuffer = currentInputBuffer || "";
-							currentInputBuffer = null;
-						}
-						cursorPosition = inputBuffer.length;
-						renderLine();
-					}
-					return;
-				}
-				case "tab": {
-					if (!completionCycling) {
-						await handleTab();
-					}
-					if (completionCycling && completions.length > 0) {
-						await handleTab();
-					}
-					return;
-				}
-				case "escape": {
-					if (isRequestActive) {
-						if (state.sessionID) {
-							client.session.abort({ path: { id: state.sessionID } }).catch(() => {});
-						}
-						stopAnimation();
-						process.stdout.write(ansi.CURSOR_SHOW);
-						process.stdout.write(`\r  ${ansi.BRIGHT_BLACK}Cancelled request${ansi.RESET}\n`);
-						writePrompt();
-						isRequestActive = false;
-					} else {
-						inputBuffer = "";
-						cursorPosition = 0;
-						currentInputBuffer = null;
-						renderLine();
-					}
-					return;
-				}
-				case "return": {
-					await acceptInput();
-					return;
-				}
-				case "backspace": {
-					if (cursorPosition > 0) {
-						inputBuffer =
-							inputBuffer.slice(0, cursorPosition - 1) + inputBuffer.slice(cursorPosition);
-						cursorPosition--;
-						currentInputBuffer = null;
-					}
-					break;
-				}
-				case "delete": {
-					if (cursorPosition < inputBuffer.length) {
-						inputBuffer =
-							inputBuffer.slice(0, cursorPosition) + inputBuffer.slice(cursorPosition + 1);
-						currentInputBuffer = null;
-					}
-					break;
-				}
-				case "left": {
-					if (key.meta) {
-						cursorPosition = findPreviousWordBoundary(inputBuffer, cursorPosition);
-					} else if (cursorPosition > 0) {
-						cursorPosition--;
-					}
-					break;
-				}
-				case "right": {
-					if (key.meta) {
-						cursorPosition = findNextWordBoundary(inputBuffer, cursorPosition);
-					} else if (cursorPosition < inputBuffer.length) {
-						cursorPosition++;
-					}
-					break;
+async function acceptInput(): Promise<void> {
+	process.stdout.write("\n");
+
+	const input = inputBuffer.trim();
+
+	inputBuffer = "";
+	cursorPosition = 0;
+	completionCycling = false;
+	completions = [];
+	currentInputBuffer = null;
+
+	if (input) {
+		if (history[history.length - 1] !== input) {
+			history.push(input);
+		}
+		historyIndex = history.length;
+		try {
+			if (input === "/help") {
+				process.stdout.write("\n");
+				const maxCommandLength = Math.max(...SLASH_COMMANDS.map((c) => c.name.length));
+				for (const cmd of SLASH_COMMANDS) {
+					const padding = " ".repeat(maxCommandLength - cmd.name.length + 2);
+					console.log(
+						`  ${ansi.BRIGHT_WHITE}${cmd.name}${ansi.RESET}${padding}${ansi.BRIGHT_BLACK}${cmd.description}${ansi.RESET}`,
+					);
 				}
-				default: {
-					if (str) {
-						if (str === " ") {
-							const now = Date.now();
-							if (
-								now - lastSpaceTime < 500 &&
-								cursorPosition > 0 &&
-								inputBuffer[cursorPosition - 1] === " "
-							) {
-								inputBuffer =
-									inputBuffer.slice(0, cursorPosition - 1) +
-									". " +
-									inputBuffer.slice(cursorPosition);
-								cursorPosition += 1;
-							} else {
-								inputBuffer =
-									inputBuffer.slice(0, cursorPosition) + str + inputBuffer.slice(cursorPosition);
-								cursorPosition += str.length;
-							}
-							lastSpaceTime = now;
-						} else {
-							inputBuffer =
-								inputBuffer.slice(0, cursorPosition) + str + inputBuffer.slice(cursorPosition);
-							cursorPosition += str.length;
+				console.log();
+				writePrompt();
+				return;
+			} else if (input.startsWith("/")) {
+				const parts = input.match(/(\/[^\s]+)\s*(.*)/)!;
+				if (parts) {
+					const commandName = parts[1];
+					const extra = parts[2]?.trim();
+					for (let command of SLASH_COMMANDS) {
+						if (command.name === commandName) {
+							process.stdout.write("\n");
+							await command.run(client, state, extra);
+							writePrompt();
+							return;
 						}
-						currentInputBuffer = null;
 					}
 				}
+				return;
 			}
 
-			showCompletions = false;
-			completionCycling = false;
-			completions = [];
-			renderLine();
-		});
-
-		writePrompt();
-	} catch (error: any) {
-		console.error("Error:", error.message);
-		server?.close();
-		process.exit(1);
+			isRequestActive = true;
+			process.stdout.write("\n");
+			process.stdout.write(ansi.CURSOR_HIDE);
+			startAnimation();
+			if (isLoggingEnabled()) {
+				console.log(`📝 ${ansi.BRIGHT_BLACK}Logging to ${getLogDir()}\n${ansi.RESET}`);
+			}
+			await sendMessage(state.sessionID, input);
+			isRequestActive = false;
+		} catch (error: any) {
+			isRequestActive = false;
+			if (error.message !== "Request cancelled") {
+				stopAnimation();
+				console.error("Error:", error.message);
+			}
+		}
 	}
 }
 
@@ -604,11 +617,6 @@ async function sendMessage(sessionID: string, message: string) {
 		console.log(`  ${ansi.BRIGHT_BLACK}Completed in ${durationText}${ansi.RESET}\n`);
 
 		writePrompt();
-
-		// HACK:
-		setTimeout(() => {
-			readline.cursorTo(process.stdout, 2);
-		}, 200);
 	} catch (error: any) {
 		throw error;
 	} finally {
@@ -672,7 +680,6 @@ async function processEvent(event: Event): Promise<void> {
 					retryInterval = null;
 				}
 				writePrompt();
-				readline.cursorTo(process.stdout, 2);
 			}
 			if (event.type === "session.status" && event.properties.status.type === "retry") {
 				const message = event.properties.status.message;
@@ -799,7 +806,7 @@ async function processToolUse(part: Part) {
 	const toolPart = part as ToolPart;
 	const toolName = toolPart.tool || "unknown";
 	const toolInput = toolPart.state.input["description"] || toolPart.state.input["filePath"] || {};
-	const toolText = `${ansi.BRIGHT_BLACK}$${ansi.RESET} ${toolName}: ${ansi.BRIGHT_BLACK}${toolInput}${ansi.RESET}`;
+	const toolText = `$ ${toolName}: ${ansi.BRIGHT_BLACK}${toolInput}${ansi.RESET}`;
 
 	if (state.accumulatedResponse[state.accumulatedResponse.length - 1]?.title === "tool") {
 		state.accumulatedResponse[state.accumulatedResponse.length - 1]!.text = toolText;
@@ -883,6 +890,18 @@ function findLastPart(title: string) {
 	}
 }
 
+function shutdown() {
+	if (process.stdin.setRawMode) {
+		process.stdin.setRawMode(false);
+	}
+	process.stdin.destroy();
+	process.stdout.write(ansi.ENABLE_LINE_WRAP);
+	saveConfig();
+	server?.close();
+	console.log(`\n${ansi.BRIGHT_BLACK}Goodbye!${ansi.RESET}`);
+	process.exit(0);
+}
+
 // ====================
 // USER INTERFACE
 // ====================