opencode-miniterm 1.0.0

package/src/render.ts

@@ -0,0 +1,320 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import { gfm, parse, renderToConsole } from "allmark";
+import * as ansi from "./ansi";
+import { config } from "./config";
+import type { State } from "./index";
+
+export function render(state: State, details = false): void {
+	let output = "";
+
+	if (details) {
+		output += "📋 Detailed output from the last run:\n\n";
+	}
+
+	// Only show the last (i.e. active) thinking part
+	// Only show the last (i.e. active) tool use
+	// Only show the last files part between parts
+	let foundPart = false;
+	let foundFiles = false;
+	let foundTodo = false;
+	for (let i = state.accumulatedResponse.length - 1; i >= 0; i--) {
+		const part = state.accumulatedResponse[i];
+		if (!part) continue;
+		if (details) {
+			part.active = true;
+			continue;
+		}
+
+		if (part.title === "thinking") {
+			part.active = !foundPart;
+			foundPart = true;
+		} else if (part.title === "tool") {
+			part.active = !foundPart;
+		} else if (part.title === "files") {
+			part.active = !foundFiles;
+			foundFiles = true;
+		} else if (part.title === "todo") {
+			part.active = !foundTodo;
+			foundTodo = true;
+		} else {
+			foundPart = true;
+			part.active = true;
+		}
+	}
+
+	for (let i = 0; i < state.accumulatedResponse.length; i++) {
+		const part = state.accumulatedResponse[i];
+		if (!part || !part.active) continue;
+		if (!part.text.trim()) continue;
+
+		if (part.title === "thinking") {
+			const partText = details ? part.text.trimStart() : lastThinkingLines(part.text.trimStart());
+			output += `💭 ${ansi.BRIGHT_BLACK}${partText}${ansi.RESET}\n\n`;
+		} else if (part.title === "response") {
+			const doc = parse(part.text.trimStart(), gfm);
+			const partText = renderToConsole(doc);
+			output += `💬 ${partText}\n\n`;
+		} else if (part.title === "tool") {
+			output += part.text + "\n\n";
+		} else if (part.title === "files") {
+			output += part.text + "\n\n";
+		} else if (part.title === "todo") {
+			output += part.text + "\n\n";
+		}
+	}
+
+	if (output) {
+		const lines = wrapText(output, process.stdout.columns || 80);
+
+		// Clear lines that have changed
+		let firstDiff = state.renderedLines.length;
+		for (let i = 0; i < Math.max(state.renderedLines.length, lines.length); i++) {
+			if (state.renderedLines[i] !== lines[i]) {
+				firstDiff = i;
+				break;
+			}
+		}
+		let linesToClear = state.renderedLines.length - firstDiff;
+		clearRenderedLines(state, linesToClear);
+
+		// Write new lines
+		for (let i = firstDiff; i < lines.length; i++) {
+			state.write(lines[i]!);
+			state.write("\n");
+		}
+
+		state.renderedLines = lines;
+	}
+}
+
+function lastThinkingLines(text: string): string {
+	const consoleWidth = process.stdout.columns || 80;
+	const strippedText = ansi.stripAnsiCodes(text);
+
+	let lineCount = 0;
+	let col = 0;
+	const lineBreaks: number[] = [0];
+
+	for (let i = 0; i < strippedText.length; i++) {
+		const char = strippedText[i];
+
+		if (char === "\n") {
+			lineCount++;
+			col = 0;
+			lineBreaks.push(i + 1);
+		} else if (char === "\r") {
+			continue;
+		} else {
+			col++;
+			if (col >= consoleWidth) {
+				lineCount++;
+				col = 0;
+				lineBreaks.push(i);
+			}
+		}
+	}
+
+	if (col > 0) {
+		lineCount++;
+	}
+
+	const startIndex = lineBreaks[Math.max(0, lineBreaks.length - 10)] || 0;
+	return text.slice(startIndex);
+}
+
+function clearRenderedLines(state: State, linesToClear: number): void {
+	if (linesToClear > 0) {
+		state.write(`${ansi.CURSOR_UP(linesToClear)}\x1b[J`);
+	}
+	state.write(ansi.CURSOR_HOME);
+}
+
+export function wrapText(text: string, width: number): string[] {
+	const lines: string[] = [];
+	let currentLine = "";
+	let visibleLength = 0;
+	let i = 0;
+
+	const pushLine = () => {
+		lines.push(currentLine);
+		currentLine = "";
+		visibleLength = 0;
+	};
+
+	const addWord = (word: string, wordVisibleLength: number) => {
+		if (!word || wordVisibleLength === 0) return;
+
+		const wouldFit =
+			visibleLength === 0
+				? wordVisibleLength <= width
+				: visibleLength + 1 + wordVisibleLength <= width;
+
+		if (wouldFit) {
+			if (visibleLength > 0) {
+				currentLine += " ";
+				visibleLength++;
+			}
+			currentLine += word;
+			visibleLength += wordVisibleLength;
+		} else if (visibleLength > 0) {
+			pushLine();
+			currentLine = word;
+			visibleLength = wordVisibleLength;
+		} else if (wordVisibleLength <= width) {
+			currentLine = word;
+			visibleLength = wordVisibleLength;
+		} else {
+			const wordWidth = width;
+			for (let w = 0; w < word.length; ) {
+				let segment = "";
+				let segmentVisible = 0;
+				let segmentStart = w;
+
+				while (w < word.length && segmentVisible < wordWidth) {
+					const char = word[w];
+					if (char === "\x1b" && word[w + 1] === "[") {
+						const ansiMatch = word.slice(w).match(ansi.ANSI_CODE_PATTERN);
+						if (ansiMatch) {
+							segment += ansiMatch[0];
+							w += ansiMatch[0].length;
+						} else {
+							segment += char;
+							w++;
+						}
+					} else {
+						segment += char;
+						segmentVisible++;
+						w++;
+					}
+				}
+
+				if (segment) {
+					if (currentLine) {
+						pushLine();
+					}
+					currentLine = segment;
+					visibleLength = segmentVisible;
+				}
+			}
+		}
+	};
+
+	while (i < text.length) {
+		const char = text[i];
+
+		if (char === "\n") {
+			pushLine();
+			i++;
+		} else if (char === "\r") {
+			i++;
+		} else if (char === " " || char === "\t") {
+			i++;
+		} else {
+			let word = "";
+			let wordVisibleLength = 0;
+
+			while (i < text.length) {
+				const char = text[i];
+				if (char === "\n" || char === "\r" || char === " " || char === "\t") {
+					break;
+				} else if (char === "\x1b" && text[i + 1] === "[") {
+					const ansiMatch = text.slice(i).match(ansi.ANSI_CODE_PATTERN);
+					if (ansiMatch) {
+						word += ansiMatch[0];
+						i += ansiMatch[0].length;
+					} else {
+						word += char;
+						i++;
+					}
+				} else {
+					word += char;
+					wordVisibleLength++;
+					i++;
+				}
+			}
+
+			addWord(word, wordVisibleLength);
+		}
+	}
+
+	if (currentLine || lines.length === 0) {
+		pushLine();
+	}
+
+	return lines;
+}
+
+export function writePrompt(): void {
+	stopAnimation();
+	process.stdout.write(ansi.CURSOR_SHOW);
+	process.stdout.write(`${ansi.BOLD_MAGENTA}# ${ansi.RESET}`);
+}
+
+const ANIMATION_CHARS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇"];
+let animationInterval: ReturnType<typeof setInterval> | null = null;
+
+export function startAnimation(): void {
+	if (animationInterval) return;
+
+	let index = 0;
+	animationInterval = setInterval(() => {
+		process.stdout.write(`\r${ansi.BOLD_MAGENTA}`);
+		process.stdout.write(`${ANIMATION_CHARS[index]}${ansi.RESET}`);
+		index = (index + 1) % ANIMATION_CHARS.length;
+	}, 100);
+}
+
+export function stopAnimation(): void {
+	if (animationInterval) {
+		clearInterval(animationInterval);
+		animationInterval = null;
+	}
+	process.stdout.write(`\r${ansi.CLEAR_LINE}`);
+}
+
+export async function getActiveDisplay(client: OpencodeClient): Promise<string> {
+	let agentName = "";
+	let providerName = "";
+	let modelName = "";
+	try {
+		const [agentsResult, providersResult] = await Promise.all([
+			client.app.agents(),
+			client.config.providers(),
+		]);
+		if (!agentsResult.error) {
+			const agents = agentsResult.data || [];
+			const agent = agents.find((a) => a.name === config.agentID);
+			if (agent) {
+				agentName = agent.name.substring(0, 1).toUpperCase() + agent.name.substring(1);
+			}
+		}
+		if (!providersResult.error) {
+			const providers = providersResult.data?.providers || [];
+			for (const provider of providers) {
+				const models = Object.values(provider.models || {});
+				for (const model of models) {
+					if (provider.id === config.providerID && model.id === config.modelID) {
+						providerName = provider.name;
+						modelName = model.name || model.id;
+						break;
+					}
+				}
+				if (providerName) break;
+			}
+		}
+	} catch (error) {}
+
+	const parts: string[] = [];
+	if (agentName) {
+		parts.push(`${ansi.CYAN}${agentName}${ansi.RESET}`);
+	}
+	if (modelName) {
+		let modelPart = `${ansi.BRIGHT_WHITE}${modelName}${ansi.RESET}`;
+		if (providerName) {
+			modelPart += ` ${ansi.BRIGHT_BLACK}(${providerName})${ansi.RESET}`;
+		}
+		parts.push(modelPart);
+	}
+
+	return parts.join("  ");
+}

package/src/types.ts

@@ -0,0 +1,11 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { Key } from "node:readline";
+import type { State } from "./index";
+
+export interface Command {
+	name: string;
+	description: string;
+	run: (client: OpencodeClient, state: State, input?: string) => Promise<void> | void;
+	handleKey?: (client: OpencodeClient, key: Key, input?: string) => Promise<void> | void;
+	running: boolean;
+}

package/test/render.test.ts

@@ -0,0 +1,390 @@
+import { describe, expect, it, vi } from "bun:test";
+import { type State } from "../src";
+import { render, wrapText } from "../src/render";
+
+describe("render", () => {
+	const createMockState = (overrides?: Partial<State>): State => ({
+		sessionID: "",
+		renderedLines: [],
+		accumulatedResponse: [],
+		allEvents: [],
+		write: vi.fn(),
+		lastFileAfter: new Map(),
+		...overrides,
+	});
+
+	describe("clearRenderedLines", () => {
+		it("should not write escape sequence when renderedLines is empty", () => {
+			const write = vi.fn();
+			const state = createMockState({ renderedLines: [], write });
+
+			render(state);
+
+			expect(write).not.toHaveBeenCalled();
+		});
+
+		it("should write escape sequence to clear lines when renderedLines has content", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				renderedLines: ["line1", "line2", "line3", "line4", "line5"],
+				accumulatedResponse: [{ key: "xxx", title: "response", text: "new content" }],
+				write,
+			});
+
+			render(state);
+
+			expect(write).toHaveBeenCalledWith("\x1b[5A\x1b[J");
+		});
+
+		it("should clear previous accumulated parts", () => {
+			const write = vi.fn();
+			let state = createMockState({ renderedLines: [], accumulatedResponse: [], write });
+
+			state.accumulatedResponse.push({ key: "xxx", title: "thinking", text: "gotta do the thing" });
+			state.accumulatedResponse.push({
+				key: "xxx",
+				title: "thinking",
+				text: "now i know how to do it",
+			});
+
+			render(state);
+
+			const firstOutput = write.mock.calls.map((c) => c[0]).join("");
+			expect(firstOutput).toContain("now i know how to do it");
+
+			write.mockClear();
+
+			state.accumulatedResponse.push({ key: "xxx", title: "response", text: "i've done it" });
+
+			render(state);
+
+			const calls = write.mock.calls.map((c) => c[0]);
+			expect(calls.some((c) => c.includes("\u001B[2A"))).toBe(true);
+			const outputCall = calls.find((c) => c.includes("i've done it"));
+			expect(outputCall).toContain("💬");
+		});
+	});
+
+	describe("thinking parts", () => {
+		it("should render thinking part with thinking indicator and gray text", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [{ key: "xxx", title: "thinking", text: "分析问题" }],
+				write,
+			});
+
+			render(state);
+
+			const output = write.mock.calls.map((c) => c[0]).join("");
+			expect(output).toContain("💭");
+			expect(output).toContain("分析问题");
+		});
+
+		it("should only show thinking indicator for last thinking part", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [
+					{ key: "xxx", title: "thinking", text: "first" },
+					{ key: "xxx", title: "thinking", text: "second" },
+				],
+				write,
+			});
+
+			render(state);
+
+			const output = write.mock.calls.map((c) => c[0]).join("");
+			expect(output).toContain("💭");
+			expect(output).toContain("second");
+			expect(output).not.toMatch(/first.*Thinking/);
+		});
+
+		it("should skip parts with empty text", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [{ key: "xxx", title: "thinking", text: "" }],
+				write,
+			});
+
+			render(state);
+
+			expect(write).not.toHaveBeenCalled();
+		});
+
+		it("should skip null parts", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [null as any, { key: "xxx", title: "response", text: "test" }],
+				write,
+			});
+
+			render(state);
+
+			expect(write).toHaveBeenCalled();
+		});
+	});
+
+	describe("response parts", () => {
+		it("should render response part with response indicator", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [{ key: "xxx", title: "response", text: "Hello world" }],
+				write,
+			});
+
+			render(state);
+
+			const output = write.mock.calls.map((c) => c[0]).join("");
+			expect(output).toContain("💬");
+			expect(output).toContain("Hello world");
+		});
+	});
+
+	describe("tool parts", () => {
+		it("should render tool part without indicator", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [{ key: "xxx", title: "tool", text: "🔧 bash: ls -la" }],
+				write,
+			});
+
+			render(state);
+
+			const output = write.mock.calls.map((c) => c[0]).join("");
+			expect(output).toContain("🔧 bash: ls -la");
+		});
+	});
+
+	describe("files parts", () => {
+		it("should render files part without indicator", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [{ key: "xxx", title: "files", text: "src/index.ts" }],
+				write,
+			});
+
+			render(state);
+
+			const output = write.mock.calls.map((c) => c[0]).join("");
+			expect(output).toContain("src/index.ts");
+		});
+	});
+
+	describe("line counting", () => {
+		it("should count lines correctly for multiline output", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [{ key: "xxx", title: "response", text: "line1\nline2\nline3" }],
+				write,
+			});
+
+			render(state);
+
+			expect(state.renderedLines.length).toBe(4);
+		});
+
+		it("should set renderedLines to empty when output is empty", () => {
+			const state = createMockState({
+				accumulatedResponse: [],
+			});
+
+			render(state);
+
+			expect(state.renderedLines.length).toBe(0);
+		});
+
+		it("should count lines including newlines from part formatting", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [{ key: "xxx", title: "response", text: "A" }],
+				write,
+			});
+
+			render(state);
+
+			expect(state.renderedLines.length).toBe(2);
+		});
+	});
+
+	describe("empty state", () => {
+		it("should not write anything when accumulatedResponse is empty", () => {
+			const write = vi.fn();
+			const state = createMockState({ write });
+
+			render(state);
+
+			expect(write).not.toHaveBeenCalled();
+			expect(state.renderedLines.length).toBe(0);
+		});
+
+		it("should not write anything when all parts have empty text", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [
+					{ key: "xxx", title: "thinking", text: "" },
+					{ key: "xxx", title: "response", text: "" },
+				],
+				write,
+			});
+
+			render(state);
+
+			expect(write).not.toHaveBeenCalled();
+		});
+	});
+
+	describe("multiple parts", () => {
+		it("should render multiple parts in order", () => {
+			const write = vi.fn();
+			const state = createMockState({
+				accumulatedResponse: [
+					{ key: "xxx", title: "thinking", text: "分析中" },
+					{ key: "xxx", title: "tool", text: "🔧 bash: npm test" },
+					{ key: "xxx", title: "response", text: "Test results: 5 passed" },
+				],
+				write,
+			});
+
+			render(state);
+
+			const output = write.mock.calls.map((c) => c[0]).join("");
+			expect(output).not.toContain("💭");
+			expect(output).not.toContain("🔧 bash: npm test");
+			expect(output).toContain("💬");
+			expect(output).toContain("Test results: 5 passed");
+		});
+	});
+});
+
+describe("wrapText", () => {
+	describe("basic wrapping", () => {
+		it("should return single line for text shorter than width", () => {
+			const result = wrapText("hello", 20);
+			expect(result).toEqual(["hello"]);
+		});
+
+		it("should wrap text longer than width", () => {
+			const result = wrapText("hello world this is a long text", 10);
+			expect(result).toEqual(["hello", "world this", "is a long", "text"]);
+		});
+
+		it("should handle text exactly at width", () => {
+			const result = wrapText("1234567890", 10);
+			expect(result).toEqual(["1234567890"]);
+		});
+
+		it("should break long word that exceeds width", () => {
+			const result = wrapText("12345678901", 10);
+			expect(result).toEqual(["1234567890", "1"]);
+		});
+	});
+
+	describe("multiple lines", () => {
+		it("should preserve existing newlines", () => {
+			const result = wrapText("line1\nline2\nline3", 20);
+			expect(result).toEqual(["line1", "line2", "line3"]);
+		});
+
+		it("should wrap lines that are too long", () => {
+			const result = wrapText("very long line1\nshort\nvery long line2", 10);
+			expect(result).toEqual(["very long", "line1", "short", "very long", "line2"]);
+		});
+
+		it("should handle empty lines", () => {
+			const result = wrapText("line1\n\nline3", 20);
+			expect(result).toEqual(["line1", "", "line3"]);
+		});
+	});
+
+	describe("ANSI codes", () => {
+		it("should preserve ANSI codes in output", () => {
+			const result = wrapText("\x1b[31mred\x1b[0m text", 20);
+			expect(result).toEqual(["\x1b[31mred\x1b[0m text"]);
+		});
+
+		it("should not count ANSI codes toward visible width", () => {
+			const result = wrapText("\x1b[31mred\x1b[0m text", 8);
+			expect(result).toEqual(["\x1b[31mred\x1b[0m text"]);
+		});
+
+		it("should handle multiple ANSI codes", () => {
+			const result = wrapText("\x1b[31m\x1b[1mbold red\x1b[0m\x1b[32m green\x1b[0m", 10);
+			expect(result).toEqual(["\x1b[31m\x1b[1mbold red\x1b[0m\x1b[32m", "green\x1b[0m"]);
+		});
+
+		it("should handle ANSI codes at wrap boundary", () => {
+			const result = wrapText("12345\x1b[31m67890\x1b[0m", 10);
+			expect(result).toEqual(["12345\x1b[31m67890\x1b[0m"]);
+		});
+	});
+
+	describe("edge cases", () => {
+		it("should handle empty string", () => {
+			const result = wrapText("", 20);
+			expect(result).toEqual([""]);
+		});
+
+		it("should handle single character", () => {
+			const result = wrapText("a", 20);
+			expect(result).toEqual(["a"]);
+		});
+
+		it("should handle width of 1", () => {
+			const result = wrapText("a b c", 1);
+			expect(result).toEqual(["a", "b", "c"]);
+		});
+
+		it("should handle carriage return characters", () => {
+			const result = wrapText("hello\r\nworld", 20);
+			expect(result).toEqual(["hello", "world"]);
+		});
+
+		it("should handle trailing newline", () => {
+			const result = wrapText("hello\n", 20);
+			expect(result).toEqual(["hello"]);
+		});
+
+		it("should handle multiple trailing newlines", () => {
+			const result = wrapText("hello\n\n", 20);
+			expect(result).toEqual(["hello", ""]);
+		});
+
+		it("should handle leading newline", () => {
+			const result = wrapText("\nhello", 20);
+			expect(result).toEqual(["", "hello"]);
+		});
+	});
+
+	describe("real-world scenarios", () => {
+		it("should wrap thinking output with emoji", () => {
+			const result = wrapText(
+				"💭 Let me analyze this problem step by step to find the best solution",
+				40,
+			);
+			expect(result.length).toBeGreaterThan(1);
+			expect(result[0]).toBe("💭 Let me analyze this problem step by");
+		});
+
+		it("should wrap response output with emoji", () => {
+			const result = wrapText(
+				"💬 Here is the solution:\nWe need to implement the fix by updating the wrapText function",
+				30,
+			);
+			expect(result.length).toBeGreaterThan(1);
+		});
+
+		it("should wrap output with ANSI colors", () => {
+			const result = wrapText(
+				"\x1b[90mThis is gray text\x1b[0m and this is \x1b[31mred\x1b[0m",
+				25,
+			);
+			expect(result[0]).toContain("\x1b[90m");
+			expect(result[0]).toContain("\x1b[0m");
+		});
+
+		it("should handle tool output", () => {
+			const result = wrapText("🔧 Using `bash`\nRunning command to install dependencies", 35);
+			expect(result[0]).toContain("🔧 Using");
+			expect(result[1]).toContain("Running command");
+		});
+	});
+});