opencode-miniterm 1.0.0

package/src/commands/debug.ts

@@ -0,0 +1,74 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { type State, getLogDir } from "../index";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/debug",
+	description: "Save raw events from the last request to a JSON file",
+	run,
+	running: false,
+};
+
+export default command;
+
+function run(_client: OpencodeClient, state: State): void {
+	if (state.allEvents.length === 0) {
+		console.log("No parts stored yet. Send a message first.");
+		return;
+	}
+
+	// Create a copy of events to modify
+	const eventsCopy = JSON.parse(JSON.stringify(state.allEvents));
+
+	for (let part of eventsCopy) {
+		stripLongStrings(part);
+	}
+
+	// Create debug data with metadata
+	const debugData = {
+		timestamp: new Date().toISOString(),
+		sessionID: state.sessionID,
+		events: eventsCopy,
+		metadata: {
+			command: "/debug",
+			version: "1.0",
+			totalEvents: eventsCopy.length,
+		},
+	};
+
+	// Ensure log dir exists
+	const logDir = getLogDir();
+	mkdirSync(logDir, { recursive: true });
+
+	// Create filename with timestamp
+	const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+	const filename = `debug-${timestamp}.json`;
+	const filepath = join(logDir, filename);
+
+	try {
+		// Write to JSON file
+		writeFileSync(filepath, JSON.stringify(debugData, null, 2));
+		console.log(`✅ Debug data saved in ${logDir}`);
+	} catch (error) {
+		console.error(`❌ Failed to save debug data: ${error}`);
+	}
+
+	console.log();
+}
+
+function stripLongStrings(target: Record<PropertyKey, unknown>): void {
+	for (const prop in target) {
+		if (prop !== "text" && prop !== "delta") {
+			const value = target[prop];
+			if (typeof value === "string") {
+				if (value.length > 255) {
+					target[prop] = value.substring(0, 252) + "...";
+				}
+			} else if (typeof value === "object" && value !== null) {
+				stripLongStrings(value as Record<PropertyKey, unknown>);
+			}
+		}
+	}
+}

package/src/commands/details.ts

@@ -0,0 +1,17 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { State } from "../index";
+import { render } from "../render";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/details",
+	description: "Show all parts from the last request",
+	run,
+	running: false,
+};
+
+export default command;
+
+function run(_client: OpencodeClient, state: State): void {
+	render(state, true);
+}

package/src/commands/diff.ts

@@ -0,0 +1,155 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import { config } from "../config";
+import type { State } from "../index";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/diff",
+	description: "Show file additions and deletions",
+	run,
+	running: false,
+};
+
+export default command;
+
+interface DiffLine {
+	type: "add" | "remove" | "same";
+	line: string;
+	oldIndex?: number;
+	newIndex?: number;
+}
+
+async function run(client: OpencodeClient, state: State): Promise<void> {
+	if (!config.sessionID) {
+		console.log("No active session.\n");
+		return;
+	}
+
+	console.log("Fetching file changes...");
+
+	const result = await client.session.diff({
+		path: { id: config.sessionID },
+	});
+
+	if (result.error) {
+		throw new Error(
+			`Failed to fetch diff (${result.response.status}): ${JSON.stringify(result.error)}`,
+		);
+	}
+
+	const allDiffs = result.data;
+
+	if (!allDiffs || allDiffs.length === 0) {
+		console.log("No file changes found.\n");
+		return;
+	}
+
+	for (const file of allDiffs) {
+		console.log(`\x1b[36;1m${file.file}\x1b[0m`);
+
+		if (!file.before && file.after) {
+			console.log(`\x1b[32m+ new file\x1b[0m\n`);
+			const lines = file.after.split("\n");
+			for (let i = 0; i < lines.length; i++) {
+				console.log(`\x1b[90m${i + 1}\x1b[0m \x1b[32m+ ${lines[i]!}\x1b[0m`);
+			}
+			console.log();
+			continue;
+		}
+
+		if (file.before && !file.after) {
+			console.log(`\x1b[31m- deleted file\x1b[0m\n`);
+			const lines = file.before.split("\n");
+			for (let i = 0; i < lines.length; i++) {
+				console.log(`\x1b[90m${i + 1}\x1b[0m \x1b[31m- ${lines[i]!}\x1b[0m`);
+			}
+			console.log();
+			continue;
+		}
+
+		if (file.before && file.after) {
+			const diff = computeDiff(file.before, file.after);
+			for (const diffLine of diff) {
+				if (diffLine.type === "add") {
+					console.log(`\x1b[90m${diffLine.newIndex! + 1}\x1b[0m \x1b[32m+ ${diffLine.line}\x1b[0m`);
+				} else if (diffLine.type === "remove") {
+					console.log(`\x1b[90m${diffLine.oldIndex! + 1}\x1b[0m \x1b[31m- ${diffLine.line}\x1b[0m`);
+				}
+			}
+			console.log();
+		}
+	}
+}
+
+function computeDiff(before: string, after: string): DiffLine[] {
+	const beforeLines = before.split("\n");
+	const afterLines = after.split("\n");
+
+	const lcs = computeLCS(beforeLines, afterLines);
+
+	const result: DiffLine[] = [];
+	let oldIdx = 0;
+	let newIdx = 0;
+
+	for (const lcsItem of lcs) {
+		while (oldIdx < lcsItem.oldIndex!) {
+			result.push({ type: "remove", line: beforeLines[oldIdx]!, oldIndex: oldIdx });
+			oldIdx++;
+		}
+		while (newIdx < lcsItem.newIndex!) {
+			result.push({ type: "add", line: afterLines[newIdx]!, newIndex: newIdx });
+			newIdx++;
+		}
+		result.push(lcsItem);
+		oldIdx++;
+		newIdx++;
+	}
+
+	while (oldIdx < beforeLines.length) {
+		result.push({ type: "remove", line: beforeLines[oldIdx]!, oldIndex: oldIdx });
+		oldIdx++;
+	}
+	while (newIdx < afterLines.length) {
+		result.push({ type: "add", line: afterLines[newIdx]!, newIndex: newIdx });
+		newIdx++;
+	}
+
+	return result;
+}
+
+function computeLCS(beforeLines: string[], afterLines: string[]): DiffLine[] {
+	const m = beforeLines.length;
+	const n = afterLines.length;
+
+	const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+	for (let i = 1; i <= m; i++) {
+		for (let j = 1; j <= n; j++) {
+			if (beforeLines[i - 1] === afterLines[j - 1]) {
+				dp[i]![j] = dp[i - 1]![j - 1]! + 1;
+			} else {
+				dp[i]![j] = Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
+			}
+		}
+	}
+
+	const result: DiffLine[] = [];
+	let i = m;
+	let j = n;
+
+	while (i > 0 || j > 0) {
+		if (i > 0 && j > 0 && beforeLines[i - 1] === afterLines[j - 1]) {
+			result.unshift({ type: "same", line: beforeLines[i - 1]!, oldIndex: i - 1, newIndex: j - 1 });
+			i--;
+			j--;
+		} else if (j > 0 && (i === 0 || dp[i]![j]! === dp[i]![j - 1]!)) {
+			result.unshift({ type: "add", line: afterLines[j - 1]!, newIndex: j - 1 });
+			j--;
+		} else if (i > 0) {
+			result.unshift({ type: "remove", line: beforeLines[i - 1]!, oldIndex: i - 1 });
+			i--;
+		}
+	}
+
+	return result;
+}

package/src/commands/exit.ts

@@ -0,0 +1,17 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { State } from "../index";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/exit",
+	description: "Exit the application",
+	run,
+	running: false,
+};
+
+export default command;
+
+async function run(_client: OpencodeClient, _state: State): Promise<void> {
+	console.log(`\x1b[90mGoodbye!\x1b[0m`);
+	process.exit(0);
+}

package/src/commands/init.ts

@@ -0,0 +1,35 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import { config, saveConfig } from "../config";
+import type { State } from "../index";
+import { writePrompt } from "../render";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/init",
+	description: "Analyze project and create/update AGENTS.md",
+	run,
+	running: false,
+};
+
+export default command;
+
+async function run(_client: OpencodeClient, _state: State): Promise<void> {
+	if (!config.sessionID) return;
+
+	console.log("Running /init command (analyzing project and creating AGENTS.md)...");
+	const result = await _client.session.init({
+		path: { id: config.sessionID },
+	});
+
+	if (result.error) {
+		throw new Error(
+			`Failed to run /init (${result.response.status}): ${JSON.stringify(result.error)}`,
+		);
+	}
+
+	console.log();
+	console.log(
+		result.data ? "AGENTS.md created/updated successfully." : "No changes made to AGENTS.md.",
+	);
+	console.log();
+}

package/src/commands/kill.ts

@@ -0,0 +1,33 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { State } from "../index";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/kill",
+	description: "Abort a session (e.g. `/kill ses_123`)",
+	run,
+	running: false,
+};
+
+export default command;
+
+async function run(client: OpencodeClient, _state: State, input?: string): Promise<void> {
+	if (!input) {
+		console.log("Usage: /kill <session_id>");
+		console.log();
+		return;
+	}
+
+	const result = await client.session.abort({
+		path: { id: input },
+	});
+
+	if (result.error) {
+		throw new Error(
+			`Failed to abort session (${result.response.status}): ${JSON.stringify(result.error)}`,
+		);
+	}
+
+	console.log(`Session aborted successfully.`);
+	console.log();
+}

package/src/commands/log.ts

@@ -0,0 +1,24 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import { config, saveConfig } from "../config";
+import type { State } from "../index";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/log",
+	description: "Toggle logging of parts to file",
+	run,
+	running: false,
+};
+
+export default command;
+
+export function isLoggingEnabled(): boolean {
+	return config.loggingEnabled;
+}
+
+function run(_client: OpencodeClient, _state: State): void {
+	config.loggingEnabled = !config.loggingEnabled;
+	saveConfig();
+	const status = config.loggingEnabled ? "enabled" : "disabled";
+	console.log(`📝 Logging ${status}\n`);
+}

package/src/commands/models.ts

@@ -0,0 +1,218 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import readline, { type Key } from "node:readline";
+import { config, saveConfig } from "../config";
+import { getActiveDisplay, writePrompt } from "../render";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/models",
+	description: "List and select available models",
+	run,
+	handleKey,
+	running: false,
+};
+
+export default command;
+
+interface ModelInfo {
+	providerID: string;
+	providerName: string;
+	modelID: string;
+	modelName: string;
+}
+
+let modelList: ModelInfo[] = [];
+let selectedModelIndex = 0;
+let modelListLineCount = 0;
+let modelSearchString = "";
+let modelFilteredIndices: number[] = [];
+
+async function run(client: OpencodeClient): Promise<void> {
+	const result = await client.config.providers();
+
+	if (result.error) {
+		throw new Error(
+			`Failed to fetch models (${result.response.status}): ${JSON.stringify(result.error)}`,
+		);
+	}
+
+	const providers = result.data?.providers || [];
+
+	modelList = [];
+	for (const provider of providers) {
+		const models = Object.values(provider.models || {});
+		for (const model of models) {
+			modelList.push({
+				providerID: provider.id,
+				providerName: provider.name,
+				modelID: model.id,
+				modelName: model.name || model.id,
+			});
+		}
+	}
+
+	modelList.sort(
+		(a, b) =>
+			a.providerName.localeCompare(b.providerName) || a.modelName.localeCompare(b.modelName),
+	);
+
+	modelSearchString = "";
+	updateModelFilter();
+
+	command.running = true;
+
+	renderModelList();
+}
+
+async function handleKey(client: OpencodeClient, key: Key, str?: string) {
+	switch (key.name) {
+		case "up": {
+			if (selectedModelIndex === 0) {
+				selectedModelIndex = modelFilteredIndices.length - 1;
+			} else {
+				selectedModelIndex--;
+			}
+			renderModelList();
+			return;
+		}
+		case "down": {
+			if (selectedModelIndex === modelFilteredIndices.length - 1) {
+				selectedModelIndex = 0;
+			} else {
+				selectedModelIndex++;
+			}
+			renderModelList();
+			return;
+		}
+		case "escape": {
+			clearModelList();
+			process.stdout.write("\x1b[?25h");
+			command.running = false;
+			modelList = [];
+			selectedModelIndex = 0;
+			modelListLineCount = 0;
+			modelSearchString = "";
+			modelFilteredIndices = [];
+			readline.cursorTo(process.stdout, 0);
+			readline.clearScreenDown(process.stdout);
+			writePrompt();
+			return;
+		}
+		case "return": {
+			modelListLineCount++;
+			clearModelList();
+			process.stdout.write("\x1b[?25h");
+			const selectedIndex = modelFilteredIndices[selectedModelIndex];
+			const selected = selectedIndex !== undefined ? modelList[selectedIndex] : undefined;
+			command.running = false;
+			modelList = [];
+			selectedModelIndex = 0;
+			modelListLineCount = 0;
+			modelSearchString = "";
+			modelFilteredIndices = [];
+			readline.cursorTo(process.stdout, 0);
+			readline.clearScreenDown(process.stdout);
+			if (selected) {
+				config.providerID = selected.providerID;
+				config.modelID = selected.modelID;
+				saveConfig();
+				const activeDisplay = await getActiveDisplay(client);
+				console.log(activeDisplay);
+				console.log();
+			}
+			writePrompt();
+			return;
+		}
+		case "backspace": {
+			modelSearchString = modelSearchString.slice(0, -1);
+			updateModelFilter();
+			selectedModelIndex = 0;
+			renderModelList();
+			return;
+		}
+	}
+
+	if (str && str.length === 1) {
+		modelSearchString += str;
+		updateModelFilter();
+		selectedModelIndex = 0;
+		renderModelList();
+		return;
+	}
+}
+
+function clearModelList() {
+	process.stdout.write("\x1b[?25l");
+	if (modelListLineCount > 0) {
+		process.stdout.write(`\x1b[${modelListLineCount}A`);
+	}
+	readline.cursorTo(process.stdout, 0);
+	readline.clearScreenDown(process.stdout);
+}
+
+function renderModelList(): void {
+	clearModelList();
+
+	const grouped = new Map<string, { models: typeof modelList; startIndices: number[] }>();
+	let currentIndex = 0;
+	for (const model of modelList) {
+		const existing = grouped.get(model.providerName);
+		if (existing) {
+			existing.models.push(model);
+			existing.startIndices.push(currentIndex);
+		} else {
+			grouped.set(model.providerName, { models: [model], startIndices: [currentIndex] });
+		}
+		currentIndex++;
+	}
+
+	modelListLineCount = 0;
+	if (modelSearchString) {
+		console.log(`  \x1b[90mFilter: \x1b[0m\x1b[33m${modelSearchString}\x1b[0m`);
+		modelListLineCount++;
+	}
+
+	for (const [providerName, data] of grouped) {
+		const filteredModelsWithIndices = data.models
+			.map((model, i) => ({ model, globalIndex: data.startIndices[i]! }))
+			.filter(({ globalIndex }) => modelFilteredIndices.includes(globalIndex));
+
+		if (filteredModelsWithIndices.length === 0) continue;
+
+		console.log(`  \x1b[36;1m${providerName}\x1b[0m`);
+		modelListLineCount++;
+
+		for (let i = 0; i < filteredModelsWithIndices.length; i++) {
+			const { model, globalIndex } = filteredModelsWithIndices[i]!;
+			const filteredIndex = modelFilteredIndices.indexOf(globalIndex);
+			const isSelected = filteredIndex === selectedModelIndex;
+			const isActive = model.providerID === config.providerID && model.modelID === config.modelID;
+			const prefix = isSelected ? "  >" : "   -";
+			const name = isSelected ? `\x1b[33;1m${model.modelName}\x1b[0m` : model.modelName;
+			const status = isActive ? " (active)" : "";
+
+			console.log(`${prefix} ${name}${status}`);
+			modelListLineCount++;
+		}
+	}
+}
+
+function updateModelFilter(): void {
+	if (!modelSearchString) {
+		modelFilteredIndices = modelList.map((_, i) => i);
+	} else {
+		const search = modelSearchString.toLowerCase();
+		modelFilteredIndices = modelList
+			.map((model, i) => ({ model, index: i }))
+			.filter(({ model }) => model.modelName.toLowerCase().includes(search))
+			.map(({ index }) => index);
+	}
+	if (modelFilteredIndices.length > 0) {
+		selectedModelIndex = modelFilteredIndices.indexOf(
+			modelList.findIndex(
+				(m) => m.providerID === config.providerID && m.modelID === config.modelID,
+			),
+		);
+		if (selectedModelIndex === -1) selectedModelIndex = 0;
+	}
+}

package/src/commands/new.ts

@@ -0,0 +1,42 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import { config, saveConfig } from "../config";
+import type { State } from "../index";
+import { updateSessionTitle } from "../index";
+import { getActiveDisplay } from "../render";
+import type { Command } from "../types";
+
+let command: Command = {
+	name: "/new",
+	description: "Create a new session",
+	run,
+	running: false,
+};
+
+export default command;
+
+async function run(client: OpencodeClient, state: State): Promise<void> {
+	state.sessionID = await createSession(client);
+	config.sessionID = state.sessionID;
+	saveConfig();
+
+	await updateSessionTitle();
+
+	const activeDisplay = await getActiveDisplay(client);
+	console.log(activeDisplay);
+	console.log(`Created new session`);
+	console.log();
+}
+
+async function createSession(client: OpencodeClient): Promise<string> {
+	const result = await client.session.create({
+		body: {},
+	});
+
+	if (result.error) {
+		throw new Error(
+			`Failed to create session (${result.response.status}): ${JSON.stringify(result.error)}`,
+		);
+	}
+
+	return result.data.id;
+}

package/src/commands/page.ts

@@ -0,0 +1,78 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { Key } from "node:readline";
+import type { State } from "../index";
+import { wrapText } from "../render";
+import type { Command } from "../types";
+
+let currentPageIndex = 0;
+let pages: string[] = [];
+
+let command: Command = {
+	name: "/page",
+	description: "Show detailed output page by page",
+	run,
+	handleKey,
+	running: false,
+};
+
+export default command;
+
+function run(client: OpencodeClient, state: State): void {
+	pages = [];
+
+	for (const part of state.accumulatedResponse) {
+		if (!part || !part.text.trim()) continue;
+
+		if (part.title === "thinking") {
+			pages.push(`💭 \x1b[90m${part.text.trimStart()}\x1b[0m`);
+		} else if (part.title === "response") {
+			pages.push(`💬 ${part.text.trimStart()}`);
+		} else if (part.title === "tool") {
+			pages.push(part.text);
+		} else if (part.title === "files") {
+			pages.push(part.text);
+		}
+	}
+
+	if (pages.length === 0) {
+		console.log("\n\x1b[90mNo parts to display yet.\x1b[0m\n");
+		return;
+	}
+
+	currentPageIndex = 0;
+	command.running = true;
+
+	displayPage();
+}
+
+function handleKey(client: OpencodeClient, key: Key, _input?: string): void {
+	if (key.name === "space") {
+		currentPageIndex++;
+		if (currentPageIndex >= pages.length) {
+			command.running = false;
+			process.stdout.write("\x1b[?25h");
+			process.stdout.write("\x1b[2K\r\n");
+		} else {
+			displayPage();
+		}
+	} else if (key.name === "escape") {
+		command.running = false;
+		process.stdout.write("\x1b[?25h");
+		console.log("\n\x1b[90mCancelled\x1b[0m\n");
+	}
+}
+
+function displayPage(): void {
+	let page = pages[currentPageIndex]!;
+	if (process.stdout.columns) {
+		page = wrapText(page, process.stdout.columns).join("\n");
+	}
+	const footer = `\n\n\x1b[90m--- Part ${currentPageIndex + 1} of ${pages.length}; press SPACE to advance or ESC to cancel ---\x1b[0m`;
+
+	if (currentPageIndex > 0) {
+		process.stdout.write("\x1b[2K\r");
+		process.stdout.write(page + footer);
+	} else {
+		process.stdout.write(page + footer);
+	}
+}