opencode-miniterm 1.0.14 → 1.0.15

package/src/index.ts

@@ -1,89 +1,28 @@
 #!/usr/bin/env bun
 
-import { createOpencodeClient, createOpencodeServer } from "@opencode-ai/sdk";
-import type { Event, FileDiff, Part, Todo, ToolPart } from "@opencode-ai/sdk";
-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, { type Key } from "node:readline";
+import { createOpencodeServer } from "@opencode-ai/sdk";
+import readline from "node:readline";
 import * as ansi from "./ansi";
-import agentsCommand from "./commands/agents";
-import debugCommand from "./commands/debug";
-import detailsCommand from "./commands/details";
-import diffCommand from "./commands/diff";
-import exitCommand from "./commands/exit";
-import initCommand from "./commands/init";
-import logCommand, { isLoggingEnabled } from "./commands/log";
-import modelsCommand from "./commands/models";
-import newCommand from "./commands/new";
-import pageCommand from "./commands/page";
-import quitCommand from "./commands/quit";
-import runCommand from "./commands/run";
-import sessionsCommand from "./commands/sessions";
-import undoCommand from "./commands/undo";
 import { config, loadConfig, saveConfig } from "./config";
-import { getActiveDisplay, render, startAnimation, stopAnimation, writePrompt } from "./render";
-
-const SERVER_URL = "http://127.0.0.1:4096";
-const AUTH_USERNAME = process.env.OPENCODE_SERVER_USERNAME || "opencode";
-const AUTH_PASSWORD = process.env.OPENCODE_SERVER_PASSWORD || "";
-
-const SLASH_COMMANDS = [
-	initCommand,
-	agentsCommand,
-	modelsCommand,
-	sessionsCommand,
-	newCommand,
-	undoCommand,
-	detailsCommand,
-	diffCommand,
-	debugCommand,
-	logCommand,
-	pageCommand,
-	exitCommand,
-	quitCommand,
-	runCommand,
-];
+import { handleKeyPress, loadSessionHistory } from "./input";
+import { getActiveDisplay, updateSessionTitle, writePrompt } from "./render";
+import { createClient, createSession, startEventListener, validateSession } from "./server";
+import type { State } from "./types";
 
 let server: Awaited<ReturnType<typeof createOpencodeServer>> | undefined;
-let client: ReturnType<typeof createOpencodeClient>;
-
-let processing = true;
-let retryInterval: ReturnType<typeof setInterval> | null = null;
-let isRequestActive = false;
-
-interface AccumulatedPart {
-	key: string;
-	title: "thinking" | "response" | "tool" | "files" | "todo";
-	text: string;
-	active?: boolean;
-	durationMs?: number;
-}
-
-export interface State {
-	sessionID: string;
-	renderedLines: string[];
-	accumulatedResponse: AccumulatedPart[];
-	allEvents: Event[];
-	write: (text: string) => void;
-	lastFileAfter: Map<string, string>;
-}
-
-export { updateSessionTitle, setTerminalTitle };
 
 let state: State = {
+	// @ts-ignore This will get set
+	client: null,
 	sessionID: "",
 	renderedLines: [],
 	accumulatedResponse: [],
 	allEvents: [],
-	write: (text) => process.stdout.write(text),
 	lastFileAfter: new Map(),
+	write: (text) => process.stdout.write(text),
+	shutdown,
 };
 
-let logFile: Awaited<ReturnType<typeof open>> | null = null;
-let logFilePath: string | null = null;
-
 // ====================
 // MAIN ENTRY POINT
 // ====================
@@ -101,15 +40,7 @@ async function main() {
 	}
 
 	const cwd = process.cwd();
-	client = createOpencodeClient({
-		baseUrl: SERVER_URL,
-		headers: AUTH_PASSWORD
-			? {
-					Authorization: `Basic ${Buffer.from(`${AUTH_USERNAME}:${AUTH_PASSWORD}`).toString("base64")}`,
-				}
-			: undefined,
-		directory: cwd,
-	});
+	state.client = createClient(cwd);
 
 	process.on("SIGINT", () => {
 		process.stdout.write("\n");
@@ -120,8 +51,8 @@ async function main() {
 		let isNewSession = false;
 
 		const initialSessionID = config.sessionIDs[cwd];
-		if (!initialSessionID || !(await validateSession(initialSessionID))) {
-			state.sessionID = await createSession();
+		if (!initialSessionID || !(await validateSession(state, initialSessionID))) {
+			state.sessionID = await createSession(state);
 			isNewSession = true;
 			config.sessionIDs[cwd] = state.sessionID;
 			saveConfig();
@@ -129,15 +60,15 @@ async function main() {
 			state.sessionID = initialSessionID;
 		}
 
-		startEventListener();
+		startEventListener(state);
 
-		await updateSessionTitle();
+		await updateSessionTitle(state);
 
-		history = await loadSessionHistory();
+		await loadSessionHistory(state);
 
 		process.stdout.write(`${ansi.CLEAR_SCREEN_UP}${ansi.CLEAR_FROM_CURSOR}`);
 		process.stdout.write(ansi.CURSOR_HOME);
-		const activeDisplay = await getActiveDisplay(client);
+		const activeDisplay = await getActiveDisplay(state.client);
 		console.log(activeDisplay);
 		if (!isNewSession) {
 			console.log("Resumed last session");
@@ -145,7 +76,7 @@ async function main() {
 		console.log();
 		console.log(`${ansi.BRIGHT_BLACK}Ask anything...${ansi.RESET}\n`);
 
-		const rl = readline.createInterface({
+		const _rl = readline.createInterface({
 			input: process.stdin,
 			output: undefined,
 		});
@@ -157,7 +88,7 @@ async function main() {
 		process.stdout.write(ansi.DISABLE_LINE_WRAP);
 
 		process.stdin.on("keypress", async (str, key) => {
-			handleKeyPress(str, key);
+			handleKeyPress(state, str, key);
 		});
 
 		writePrompt();
@@ -168,760 +99,6 @@ async function main() {
 	}
 }
 
-// ====================
-// HANDLE INPUT
-// ====================
-
-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 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);
-	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.cursorTo(process.stdout, currentCol);
-	readline.clearScreenDown(process.stdout);
-
-	// Write the prompt if this is a fresh buffer
-	if (start === 0) {
-		readline.cursorTo(process.stdout, 0);
-		writePrompt();
-		readline.cursorTo(process.stdout, 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) {
-			process.stdout.write("\n");
-			currentCol = 0;
-			newWrappedRows++;
-		}
-		if (i < inputBuffer.length) {
-			process.stdout.write(inputBuffer[i]!);
-		}
-		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;
-}
-
-async function handleKeyPress(str: string, key: Key) {
-	if (key.ctrl && key.name === "c") {
-		process.stdout.write("\n");
-		shutdown();
-		return;
-	}
-
-	for (let command of SLASH_COMMANDS) {
-		if (command.running && command.handleKey) {
-			await command.handleKey(client, key, str);
-			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;
-		}
-		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;
-		}
-	}
-
-	completionCycling = false;
-	completions = [];
-	renderLine();
-}
-
-async function handleTab(): Promise<void> {
-	const potentialCompletions = await getCompletions(inputBuffer);
-
-	if (potentialCompletions.length === 0) {
-		completionCycling = false;
-		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();
-	}
-}
-
-async function getCompletions(text: string): Promise<string[]> {
-	if (text.startsWith("/")) {
-		return ["/help", ...SLASH_COMMANDS.map((c) => c.name)].filter((cmd) => cmd.startsWith(text));
-	}
-
-	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));
-	}
-
-	return [];
-}
-
-async function acceptInput(): Promise<void> {
-	process.stdout.write("\n");
-
-	const input = inputBuffer.trim();
-
-	oldInputBuffer = "";
-	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}`,
-					);
-				}
-				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;
-						}
-					}
-				}
-				return;
-			}
-
-			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);
-			}
-		}
-	}
-}
-
-// ====================
-// SERVER COMMUNICATION
-// ====================
-
-async function createSession(): Promise<string> {
-	const result = await client.session.create({
-		body: {},
-	});
-
-	if (result.error) {
-		if (result.response.status === 401 && !AUTH_PASSWORD) {
-			throw new Error(
-				"Server requires authentication. Set OPENCODE_SERVER_PASSWORD environment variable.",
-			);
-		}
-		throw new Error(
-			`Failed to create session (${result.response.status}): ${JSON.stringify(result.error)}`,
-		);
-	}
-
-	return result.data.id;
-}
-
-async function validateSession(sessionID: string): Promise<boolean> {
-	try {
-		const result = await client.session.get({
-			path: { id: sessionID },
-		});
-		return !result.error && result.response.status === 200;
-	} catch {
-		return false;
-	}
-}
-
-async function updateSessionTitle(): Promise<void> {
-	try {
-		const result = await client.session.get({
-			path: { id: state.sessionID },
-		});
-		if (!result.error && result.data?.title) {
-			setTerminalTitle(result.data.title);
-		} else {
-			setTerminalTitle(state.sessionID.substring(0, 8));
-		}
-	} catch {
-		setTerminalTitle(state.sessionID.substring(0, 8));
-	}
-}
-
-async function loadSessionHistory(): Promise<string[]> {
-	try {
-		const result = await client.session.messages({
-			path: { id: state.sessionID },
-		});
-		if (result.error || !result.data) {
-			return [];
-		}
-
-		const history: string[] = [];
-		for (const msg of result.data) {
-			if (msg.info.role === "user") {
-				const textParts = msg.parts
-					.filter((p: Part) => p.type === "text")
-					.map((p: Part) => (p as any).text || "")
-					.filter(Boolean);
-				const text = textParts.join("").trim();
-				if (text && !text.startsWith("/")) {
-					history.push(text);
-				}
-			}
-		}
-		return history;
-	} catch {
-		return [];
-	}
-}
-
-async function startEventListener(): Promise<void> {
-	try {
-		const { stream } = await client.event.subscribe({
-			onSseError: (error) => {
-				console.error(
-					`\n${ansi.RED}Connection error:${ansi.RESET}`,
-					error instanceof Error ? error.message : String(error),
-				);
-			},
-		});
-
-		for await (const event of stream) {
-			try {
-				await processEvent(event);
-			} catch (error) {
-				console.error(
-					`\n${ansi.RED}Event processing error:${ansi.RESET}`,
-					error instanceof Error ? error.message : String(error),
-				);
-			}
-		}
-	} catch (error) {
-		console.error(
-			`\n${ansi.RED}Failed to connect to event stream:${ansi.RESET}`,
-			error instanceof Error ? error.message : String(error),
-		);
-	}
-}
-
-async function sendMessage(sessionID: string, message: string) {
-	processing = false;
-	state.accumulatedResponse = [];
-	state.allEvents = [];
-	state.renderedLines = [];
-
-	await createLogFile();
-
-	await writeToLog(`User: ${message}\n\n`);
-
-	const requestStartTime = Date.now();
-
-	try {
-		const result = await client.session.prompt({
-			path: { id: sessionID },
-			body: {
-				model: {
-					providerID: config.providerID,
-					modelID: config.modelID,
-				},
-				parts: [{ type: "text", text: message }],
-			},
-		});
-
-		if (result.error) {
-			throw new Error(
-				`Failed to send message (${result.response.status}): ${JSON.stringify(result.error)}`,
-			);
-		}
-
-		// Play a chime when request is completed
-		process.stdout.write("\x07");
-
-		stopAnimation();
-
-		const duration = Date.now() - requestStartTime;
-		const durationText = formatDuration(duration);
-		console.log(`  ${ansi.BRIGHT_BLACK}Completed in ${durationText}${ansi.RESET}\n`);
-
-		writePrompt();
-	} catch (error: any) {
-		throw error;
-	} finally {
-		await closeLogFile();
-	}
-}
-
-// ====================
-// EVENT PROCESSING
-// ====================
-
-async function processEvent(event: Event): Promise<void> {
-	if (retryInterval && event.type !== "session.status") {
-		clearInterval(retryInterval);
-		retryInterval = null;
-	}
-
-	state.allEvents.push(event);
-
-	switch (event.type) {
-		case "message.part.updated": {
-			const part = event.properties.part;
-			const delta = event.properties.delta;
-			if (part) {
-				await processPart(part);
-			}
-			if (delta !== undefined && part) {
-				processDelta(part.id, delta);
-			}
-			break;
-		}
-
-		// @ts-ignore this definitely exists
-		case "message.part.delta": {
-			// @ts-ignore
-			const partID = event.properties.partID;
-			// @ts-ignore
-			const delta = event.properties.delta;
-			if (partID !== undefined && delta !== undefined) {
-				processDelta(partID, delta);
-			}
-			break;
-		}
-
-		case "session.diff": {
-			const diff = event.properties.diff;
-			if (diff && diff.length > 0) {
-				await processDiff(diff);
-			}
-			break;
-		}
-
-		case "session.idle":
-		case "session.status":
-			if (event.type === "session.status" && event.properties.status.type === "idle") {
-				stopAnimation();
-				isRequestActive = false;
-				process.stdout.write(ansi.CURSOR_SHOW);
-				if (retryInterval) {
-					clearInterval(retryInterval);
-					retryInterval = null;
-				}
-				writePrompt();
-			}
-			if (event.type === "session.status" && event.properties.status.type === "retry") {
-				const message = event.properties.status.message;
-				const retryTime = event.properties.status.next;
-				const sessionID = event.properties.sessionID;
-				console.error(`\n\n  ${ansi.RED}Error:${ansi.RESET} ${message}`);
-				console.error(`  ${ansi.BRIGHT_BLACK}Session:${ansi.RESET} ${sessionID}`);
-				if (retryTime) {
-					if (retryInterval) {
-						clearInterval(retryInterval);
-					}
-					const retryDate = new Date(retryTime);
-
-					let lastSeconds = Math.max(0, Math.ceil((retryDate.getTime() - Date.now()) / 1000));
-					console.error(`  ${ansi.BRIGHT_BLACK}Retrying in ${lastSeconds}s...${ansi.RESET}`);
-
-					retryInterval = setInterval(() => {
-						const remaining = Math.max(0, Math.ceil((retryDate.getTime() - Date.now()) / 1000));
-						if (remaining !== lastSeconds) {
-							process.stdout.write(
-								`\r  ${ansi.BRIGHT_BLACK}Retrying in ${remaining}s...${ansi.RESET}`,
-							);
-							lastSeconds = remaining;
-						}
-						if (remaining === 0) {
-							if (retryInterval) {
-								clearInterval(retryInterval);
-								retryInterval = null;
-							}
-						}
-					}, 100);
-				}
-			}
-			break;
-
-		case "session.updated": {
-			const session = event.properties.info;
-			if (session && session.id === state.sessionID && session.title) {
-				setTerminalTitle(session.title);
-			}
-			break;
-		}
-
-		case "todo.updated": {
-			const todos = event.properties.todos;
-			if (todos) {
-				await processTodos(todos);
-			}
-
-			break;
-		}
-
-		default:
-			break;
-	}
-}
-
-async function processPart(part: Part): Promise<void> {
-	switch (part.type) {
-		case "step-start":
-			processStepStart();
-			break;
-
-		case "reasoning":
-			processReasoning(part);
-			break;
-
-		case "text":
-			if (processing) {
-				processText(part);
-			}
-			break;
-
-		case "step-finish":
-			break;
-
-		case "tool":
-			processToolUse(part);
-			break;
-
-		default:
-			break;
-	}
-}
-
-function processStepStart() {
-	processing = true;
-}
-
-async function processReasoning(part: Part) {
-	processing = true;
-	let thinkingPart = findLastPart(part.id);
-	if (!thinkingPart) {
-		thinkingPart = { key: part.id, title: "thinking", text: (part as any).text || "" };
-		state.accumulatedResponse.push(thinkingPart);
-	} else {
-		thinkingPart.text = (part as any).text || "";
-	}
-
-	const text = (part as any).text || "";
-	const cleanText = ansi.stripAnsiCodes(text.trimStart());
-	await writeToLog(`Thinking:\n\n${cleanText}\n\n`);
-
-	render(state);
-}
-
-async function processText(part: Part) {
-	let responsePart = findLastPart(part.id);
-	if (!responsePart) {
-		responsePart = { key: part.id, title: "response", text: (part as any).text || "" };
-		state.accumulatedResponse.push(responsePart);
-	} else {
-		responsePart.text = (part as any).text || "";
-	}
-
-	const text = (part as any).text || "";
-	const cleanText = ansi.stripAnsiCodes(text.trimStart());
-	await writeToLog(`Response:\n\n${cleanText}\n\n`);
-
-	render(state);
-}
-
-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"] ||
-		toolPart.state.input["path"] ||
-		toolPart.state.input["include"] ||
-		toolPart.state.input["pattern"] ||
-		// TODO: more state.input props?
-		"...";
-	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;
-	} else {
-		state.accumulatedResponse.push({ key: part.id, title: "tool", text: toolText });
-	}
-
-	const cleanToolText = ansi.stripAnsiCodes(toolText);
-	await writeToLog(`$ ${cleanToolText}\n\n`);
-
-	render(state);
-}
-
-function processDelta(partID: string, delta: string) {
-	let responsePart = findLastPart(partID);
-	if (responsePart) {
-		responsePart.text += delta;
-	}
-
-	render(state);
-}
-
-async function processDiff(diff: FileDiff[]) {
-	const parts: string[] = [];
-	for (const file of diff) {
-		const newAfter = file.after ?? "";
-		const oldAfter = state.lastFileAfter.get(file.file);
-		if (newAfter !== oldAfter) {
-			const statusIcon = !file.before ? "A" : !file.after ? "D" : "M";
-			const addStr = file.additions > 0 ? `${ansi.GREEN}+${file.additions}${ansi.RESET}` : "";
-			const delStr = file.deletions > 0 ? `${ansi.RED}-${file.deletions}${ansi.RESET}` : "";
-			const stats = [addStr, delStr].filter(Boolean).join(" ");
-			const line = `${ansi.BLUE}${statusIcon}${ansi.RESET} ${file.file} ${stats}`;
-			parts.push(line);
-
-			state.lastFileAfter.set(file.file, newAfter);
-		}
-	}
-
-	if (parts.length > 0) {
-		state.accumulatedResponse.push({ key: "diff", title: "files", text: parts.join("\n") });
-
-		const diffText = ansi.stripAnsiCodes(parts.join("\n"));
-		await writeToLog(`${diffText}\n\n`);
-
-		render(state);
-	}
-}
-
-async function processTodos(todos: Todo[]) {
-	let todoListText = "Todo:\n";
-
-	for (let todo of todos) {
-		let todoText = "";
-		if (todo.status === "completed") {
-			todoText += "- [✓] ";
-		} else {
-			todoText += "- [ ] ";
-		}
-		todoText += todo.content;
-		todoListText += todoText + "\n";
-	}
-
-	state.accumulatedResponse.push({ key: "todo", title: "files", text: todoListText });
-
-	const cleanTodoText = ansi.stripAnsiCodes(todoListText);
-	await writeToLog(`${cleanTodoText}\n`);
-
-	render(state);
-}
-
-function findLastPart(title: string) {
-	for (let i = state.accumulatedResponse.length - 1; i >= 0; i--) {
-		const part = state.accumulatedResponse[i];
-		if (part?.key === title) {
-			return part;
-		}
-	}
-}
-
 function shutdown() {
 	if (process.stdin.setRawMode) {
 		process.stdin.setRawMode(false);
@@ -934,141 +111,4 @@ function shutdown() {
 	process.exit(0);
 }
 
-// ====================
-// USER INTERFACE
-// ====================
-
-function setTerminalTitle(sessionName: string): void {
-	process.stdout.write(`\x1b]0;OC | ${sessionName}\x07`);
-}
-
-function findPreviousWordBoundary(text: string, pos: number): number {
-	if (pos <= 0) return 0;
-
-	let newPos = pos;
-
-	while (newPos > 0 && /\s/.test(text[newPos - 1]!)) {
-		newPos--;
-	}
-
-	while (newPos > 0 && !/\s/.test(text[newPos - 1]!)) {
-		newPos--;
-	}
-
-	return newPos;
-}
-
-function findNextWordBoundary(text: string, pos: number): number {
-	if (pos >= text.length) return text.length;
-
-	let newPos = pos;
-
-	while (newPos < text.length && !/\s/.test(text[newPos]!)) {
-		newPos++;
-	}
-
-	while (newPos < text.length && /\s/.test(text[newPos]!)) {
-		newPos++;
-	}
-
-	return newPos;
-}
-
-function formatDuration(ms: number): string {
-	if (ms < 1000) {
-		return `${ms}ms`;
-	}
-	const seconds = ms / 1000;
-	if (seconds < 60) {
-		return `${seconds.toFixed(1)}s`;
-	}
-	const minutes = Math.floor(seconds / 60);
-	const remainingSeconds = Math.round(seconds % 60);
-	if (minutes < 60) {
-		return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
-	}
-	const hours = Math.floor(minutes / 60);
-	const remainingMinutes = minutes % 60;
-	return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
-}
-
-// ====================
-// LOGGING
-// ====================
-
-export function getLogDir(): string {
-	const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-	return `${homeDir}/.local/share/opencode-miniterm/log`;
-}
-
-async function createLogFile(): Promise<void> {
-	if (!isLoggingEnabled()) {
-		return;
-	}
-
-	const logDir = getLogDir();
-	await mkdir(logDir, { recursive: true });
-
-	const now = new Date();
-	const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
-	const filename = `${timestamp}.txt`;
-	logFilePath = `${logDir}/${filename}`;
-
-	try {
-		logFile = await open(logFilePath, "w");
-	} catch (error) {
-		console.error("Failed to create log file:", error);
-		logFile = null;
-		logFilePath = null;
-	}
-}
-
-async function closeLogFile(): Promise<void> {
-	if (logFile) {
-		try {
-			await logFile.close();
-		} catch (error) {
-			console.error("Failed to close log file:", error);
-		}
-		logFile = null;
-		logFilePath = null;
-	}
-}
-
-async function writeToLog(text: string): Promise<void> {
-	if (logFile && isLoggingEnabled()) {
-		try {
-			await logFile.write(text);
-		} catch (error) {
-			console.error("Failed to write to log file:", error);
-		}
-	}
-}
-
-// ====================
-// UTILITIES
-// ====================
-
-async function getFileCompletions(pattern: string): Promise<string[]> {
-	try {
-		const files: string[] = [];
-		for await (const file of glob(pattern)) {
-			if (
-				!file.startsWith("node_modules/") &&
-				!file.startsWith(".git/") &&
-				!file.startsWith("dist/") &&
-				!file.startsWith("build/")
-			) {
-				const isDir = await stat(file)
-					.then((s) => s.isDirectory())
-					.catch(() => false);
-				files.push(isDir ? file + "/" : file);
-			}
-		}
-		return files.sort();
-	} catch {
-		return [];
-	}
-}
-
 main().catch(console.error);