@oh-my-pi/pi-coding-agent 12.7.6 → 12.8.0

package/src/lsp/client.ts

@@ -1,4 +1,4 @@
-import { isEnoent, logger, ptree } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger, ptree, untilAborted } from "@oh-my-pi/pi-utils";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
@@ -157,8 +157,8 @@ const CLIENT_CAPABILITIES = {
  * Returns the parsed message and remaining buffer, or null if incomplete.
  */
 function parseMessage(
-	buffer: Uint8Array,
-): { message: LspJsonRpcResponse | LspJsonRpcNotification; remaining: Uint8Array } | null {
+	buffer: Buffer,
+): { message: LspJsonRpcResponse | LspJsonRpcNotification; remaining: Buffer } | null {
 	// Only decode enough to find the header
 	const headerEndIndex = findHeaderEnd(buffer);
 	if (headerEndIndex === -1) return null;
@@ -173,9 +173,9 @@ function parseMessage(
 
 	if (buffer.length < messageEnd) return null;
 
-	const messageBytes = buffer.slice(messageStart, messageEnd);
+	const messageBytes = buffer.subarray(messageStart, messageEnd);
 	const messageText = new TextDecoder().decode(messageBytes);
-	const remaining = buffer.slice(messageEnd);
+	const remaining = buffer.subarray(messageEnd);
 
 	return {
 		message: JSON.parse(messageText),
@@ -195,26 +195,13 @@ function findHeaderEnd(buffer: Uint8Array): number {
 	return -1;
 }
 
-/**
- * Concatenate two Uint8Arrays efficiently
- */
-function concatBuffers(a: Uint8Array, b: Uint8Array): Uint8Array {
-	const result = new Uint8Array(a.length + b.length);
-	result.set(a);
-	result.set(b, a.length);
-	return result;
-}
-
 async function writeMessage(
 	sink: Bun.FileSink,
 	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
 ): Promise<void> {
 	const content = JSON.stringify(message);
-	const contentBytes = new TextEncoder().encode(content);
-	const header = `Content-Length: ${contentBytes.length}\r\n\r\n`;
-	const fullMessage = new TextEncoder().encode(header + content);
-
-	sink.write(fullMessage);
+	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n`);
+	sink.write(content);
 	await sink.flush();
 }
 
@@ -238,7 +225,7 @@ async function startMessageReader(client: LspClient): Promise<void> {
 			if (done) break;
 
 			// Atomically update buffer before processing
-			const currentBuffer = concatBuffers(client.messageBuffer, value);
+			const currentBuffer: Buffer = Buffer.concat([client.messageBuffer, value]);
 			client.messageBuffer = currentBuffer;
 
 			// Process all complete messages in buffer
@@ -499,7 +486,8 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
  * Ensure a file is opened in the LSP client.
  * Sends didOpen notification if the file is not already tracked.
  */
-export async function ensureFileOpen(client: LspClient, filePath: string): Promise<void> {
+export async function ensureFileOpen(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void> {
+	throwIfAborted(signal);
 	const uri = fileToUri(filePath);
 	const lockKey = `${client.name}:${uri}`;
 
@@ -511,12 +499,13 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
 	// Check if another operation is already opening this file
 	const existingLock = fileOperationLocks.get(lockKey);
 	if (existingLock) {
-		await existingLock;
+		await untilAborted(signal, () => existingLock);
 		return;
 	}
 
 	// Lock and open file
 	const openPromise = (async () => {
+		throwIfAborted(signal);
 		// Double-check after acquiring lock
 		if (client.openFiles.has(uri)) {
 			return;
@@ -525,11 +514,13 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
 		let content: string;
 		try {
 			content = await Bun.file(filePath).text();
+			throwIfAborted(signal);
 		} catch (err) {
 			if (isEnoent(err)) return;
 			throw err;
 		}
 		const languageId = detectLanguageId(filePath);
+		throwIfAborted(signal);
 
 		await sendNotification(client, "textDocument/didOpen", {
 			textDocument: {
@@ -568,7 +559,7 @@ export async function syncContent(
 
 	const existingLock = fileOperationLocks.get(lockKey);
 	if (existingLock) {
-		await existingLock;
+		await untilAborted(signal, () => existingLock);
 	}
 
 	const syncPromise = (async () => {
@@ -631,38 +622,43 @@ export async function notifySaved(client: LspClient, filePath: string, signal?:
  * Refresh a file in the LSP client.
  * Increments version, sends didChange and didSave notifications.
  */
-export async function refreshFile(client: LspClient, filePath: string): Promise<void> {
+export async function refreshFile(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void> {
+	throwIfAborted(signal);
 	const uri = fileToUri(filePath);
 	const lockKey = `${client.name}:${uri}`;
 
 	// Check if another operation is in progress
 	const existingLock = fileOperationLocks.get(lockKey);
 	if (existingLock) {
-		await existingLock;
+		await untilAborted(signal, () => existingLock);
 	}
 
 	// Lock and refresh file
 	const refreshPromise = (async () => {
+		throwIfAborted(signal);
 		const info = client.openFiles.get(uri);
 
 		if (!info) {
-			await ensureFileOpen(client, filePath);
+			await ensureFileOpen(client, filePath, signal);
 			return;
 		}
 
 		let content: string;
 		try {
 			content = await Bun.file(filePath).text();
+			throwIfAborted(signal);
 		} catch (err) {
 			if (isEnoent(err)) return;
 			throw err;
 		}
 		const version = ++info.version;
+		throwIfAborted(signal);
 
 		await sendNotification(client, "textDocument/didChange", {
 			textDocument: { uri, version },
 			contentChanges: [{ text: content }],
 		});
+		throwIfAborted(signal);
 
 		await sendNotification(client, "textDocument/didSave", {
 			textDocument: { uri },
@@ -745,6 +741,7 @@ export async function sendRequest(
 		if (client.pendingRequests.has(id)) {
 			client.pendingRequests.delete(id);
 		}
+		void sendNotification(client, "$/cancelRequest", { id }).catch(() => {});
 		if (timeout) clearTimeout(timeout);
 		cleanup();
 		const reason = signal?.reason instanceof Error ? signal.reason : new ToolAbortError();

package/src/lsp/index.ts

@@ -8,7 +8,7 @@ import { type Theme, theme } from "../modes/theme/theme";
 import lspDescription from "../prompts/tools/lsp.md" with { type: "text" };
 import type { ToolSession } from "../tools";
 import { resolveToCwd } from "../tools/path-utils";
-import { throwIfAborted } from "../tools/tool-errors";
+import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import {
 	ensureFileOpen,
 	getActiveClients,
@@ -308,41 +308,52 @@ function detectProjectType(cwd: string): ProjectType {
 }
 
 /** Run workspace diagnostics command and parse output */
-async function runWorkspaceDiagnostics(cwd: string): Promise<{ output: string; projectType: ProjectType }> {
+async function runWorkspaceDiagnostics(
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<{ output: string; projectType: ProjectType }> {
+	throwIfAborted(signal);
 	const projectType = detectProjectType(cwd);
-
 	if (!projectType.command) {
 		return {
 			output: `Cannot detect project type. Supported: Rust (Cargo.toml), TypeScript (tsconfig.json), Go (go.mod), Python (pyproject.toml)`,
 			projectType,
 		};
 	}
+	const proc = Bun.spawn(projectType.command, {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+		windowsHide: true,
+	});
+	const abortHandler = () => {
+		proc.kill();
+	};
+	if (signal) {
+		signal.addEventListener("abort", abortHandler, { once: true });
+	}
 
 	try {
-		const proc = Bun.spawn(projectType.command, {
-			cwd,
-			stdout: "pipe",
-			stderr: "pipe",
-			windowsHide: true,
-		});
-
 		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
 		await proc.exited;
-
+		throwIfAborted(signal);
 		const combined = (stdout + stderr).trim();
 		if (!combined) {
 			return { output: "No issues found", projectType };
 		}
-
 		// Limit output length
 		const lines = combined.split("\n");
 		if (lines.length > 50) {
 			return { output: `${lines.slice(0, 50).join("\n")}\n... and ${lines.length - 50} more lines`, projectType };
 		}
-
 		return { output: combined, projectType };
 	} catch (e) {
+		if (signal?.aborted) {
+			throw new ToolAbortError();
+		}
 		return { output: `Failed to run ${projectType.command.join(" ")}: ${e}`, projectType };
+	} finally {
+		signal?.removeEventListener("abort", abortHandler);
 	}
 }
 
@@ -871,11 +882,12 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 	async execute(
 		_toolCallId: string,
 		params: LspParams,
-		_signal?: AbortSignal,
+		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<LspToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<LspToolDetails>> {
 		const { action, file, files, line, column, query, new_name, apply, include_declaration } = params;
+		throwIfAborted(signal);
 
 		const config = getConfig(this.session.cwd);
 
@@ -906,7 +918,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			const targets = files?.length ? files : file ? [file] : null;
 			if (!targets) {
 				// No file specified - run workspace diagnostics
-				const result = await runWorkspaceDiagnostics(this.session.cwd);
+				const result = await runWorkspaceDiagnostics(this.session.cwd, signal);
 				return {
 					content: [
 						{
@@ -923,6 +935,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			const allServerNames = new Set<string>();
 
 			for (const target of targets) {
+				throwIfAborted(signal);
 				const resolved = resolveToCwd(target, this.session.cwd);
 				const servers = getServersForFile(config, resolved);
 				if (servers.length === 0) {
@@ -938,6 +951,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				for (const [serverName, serverConfig] of servers) {
 					allServerNames.add(serverName);
 					try {
+						throwIfAborted(signal);
 						if (serverConfig.createClient) {
 							const linterClient = getLinterClient(serverName, serverConfig, this.session.cwd);
 							const diagnostics = await linterClient.lint(resolved);
@@ -946,10 +960,13 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 						}
 						const client = await getOrCreateClient(serverConfig, this.session.cwd);
 						const minVersion = client.diagnosticsVersion;
-						await refreshFile(client, resolved);
-						const diagnostics = await waitForDiagnostics(client, uri, 3000, undefined, minVersion);
+						await refreshFile(client, resolved, signal);
+						const diagnostics = await waitForDiagnostics(client, uri, 3000, signal, minVersion);
 						allDiagnostics.push(...diagnostics);
-					} catch {
+					} catch (err) {
+						if (err instanceof ToolAbortError || signal?.aborted) {
+							throw err;
+						}
 						// Server failed, continue with others
 					}
 				}
@@ -1029,7 +1046,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			const targetFile = resolvedFile;
 
 			if (targetFile) {
-				await ensureFileOpen(client, targetFile);
+				await ensureFileOpen(client, targetFile, signal);
 			}
 
 			const uri = targetFile ? fileToUri(targetFile) : "";
@@ -1043,10 +1060,15 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				// =====================================================================
 
 				case "definition": {
-					const result = (await sendRequest(client, "textDocument/definition", {
-						textDocument: { uri },
-						position,
-					})) as Location | Location[] | LocationLink | LocationLink[] | null;
+					const result = (await sendRequest(
+						client,
+						"textDocument/definition",
+						{
+							textDocument: { uri },
+							position,
+						},
+						signal,
+					)) as Location | Location[] | LocationLink | LocationLink[] | null;
 
 					if (!result) {
 						output = "No definition found";
@@ -1076,11 +1098,16 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				}
 
 				case "references": {
-					const result = (await sendRequest(client, "textDocument/references", {
-						textDocument: { uri },
-						position,
-						context: { includeDeclaration: include_declaration ?? true },
-					})) as Location[] | null;
+					const result = (await sendRequest(
+						client,
+						"textDocument/references",
+						{
+							textDocument: { uri },
+							position,
+							context: { includeDeclaration: include_declaration ?? true },
+						},
+						signal,
+					)) as Location[] | null;
 
 					if (!result || result.length === 0) {
 						output = "No references found";
@@ -1092,10 +1119,15 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				}
 
 				case "hover": {
-					const result = (await sendRequest(client, "textDocument/hover", {
-						textDocument: { uri },
-						position,
-					})) as Hover | null;
+					const result = (await sendRequest(
+						client,
+						"textDocument/hover",
+						{
+							textDocument: { uri },
+							position,
+						},
+						signal,
+					)) as Hover | null;
 
 					if (!result || !result.contents) {
 						output = "No hover information";
@@ -1116,7 +1148,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 								details: { action, serverName, success: false },
 							};
 						}
-						const result = (await sendRequest(client, "workspace/symbol", { query })) as
+						const result = (await sendRequest(client, "workspace/symbol", { query }, signal)) as
 							| SymbolInformation[]
 							| null;
 						if (!result || result.length === 0) {
@@ -1127,9 +1159,14 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 						}
 					} else {
 						// File-based document symbols
-						const result = (await sendRequest(client, "textDocument/documentSymbol", {
-							textDocument: { uri },
-						})) as (DocumentSymbol | SymbolInformation)[] | null;
+						const result = (await sendRequest(
+							client,
+							"textDocument/documentSymbol",
+							{
+								textDocument: { uri },
+							},
+							signal,
+						)) as (DocumentSymbol | SymbolInformation)[] | null;
 
 						if (!result || result.length === 0) {
 							output = "No symbols found";
@@ -1159,11 +1196,16 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 						};
 					}
 
-					const result = (await sendRequest(client, "textDocument/rename", {
-						textDocument: { uri },
-						position,
-						newName: new_name,
-					})) as WorkspaceEdit | null;
+					const result = (await sendRequest(
+						client,
+						"textDocument/rename",
+						{
+							textDocument: { uri },
+							position,
+							newName: new_name,
+						},
+						signal,
+					)) as WorkspaceEdit | null;
 
 					if (!result) {
 						output = "Rename returned no edits";
@@ -1186,7 +1228,12 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 					const reloadMethods = ["rust-analyzer/reloadWorkspace", "workspace/didChangeConfiguration"];
 					for (const method of reloadMethods) {
 						try {
-							await sendRequest(client, method, method.includes("Configuration") ? { settings: {} } : null);
+							await sendRequest(
+								client,
+								method,
+								method.includes("Configuration") ? { settings: {} } : null,
+								signal,
+							);
 							output = `Reloaded ${serverName}`;
 							break;
 						} catch {
@@ -1208,6 +1255,9 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				details: { serverName, action, success: true, request: params },
 			};
 		} catch (err) {
+			if (err instanceof ToolAbortError || signal?.aborted) {
+				throw new ToolAbortError();
+			}
 			const errorMessage = err instanceof Error ? err.message : String(err);
 			return {
 				content: [{ type: "text", text: `LSP error: ${errorMessage}` }],

package/src/mcp/config-writer.ts

@@ -180,3 +180,36 @@ export async function listMCPServers(filePath: string): Promise<string[]> {
 	const config = await readMCPConfigFile(filePath);
 	return Object.keys(config.mcpServers ?? {});
 }
+
+/**
+ * Read the disabled servers list from a config file.
+ */
+export async function readDisabledServers(filePath: string): Promise<string[]> {
+	const config = await readMCPConfigFile(filePath);
+	return Array.isArray(config.disabledServers) ? config.disabledServers : [];
+}
+
+/**
+ * Add or remove a server name from the disabled servers list.
+ */
+export async function setServerDisabled(filePath: string, name: string, disabled: boolean): Promise<void> {
+	const config = await readMCPConfigFile(filePath);
+	const current = new Set(config.disabledServers ?? []);
+
+	if (disabled) {
+		current.add(name);
+	} else {
+		current.delete(name);
+	}
+
+	const updated: MCPConfigFile = {
+		...config,
+		disabledServers: current.size > 0 ? Array.from(current).sort() : undefined,
+	};
+
+	if (!updated.disabledServers) {
+		delete updated.disabledServers;
+	}
+
+	await writeMCPConfigFile(filePath, updated);
+}

package/src/mcp/config.ts

@@ -3,10 +3,13 @@
  *
  * Uses the capability system to load MCP servers from multiple sources.
  */
+
+import { getMCPConfigPath } from "@oh-my-pi/pi-utils/dirs";
 import { mcpCapability } from "../capability/mcp";
 import type { SourceMeta } from "../capability/types";
 import type { MCPServer } from "../discovery";
 import { loadCapability } from "../discovery";
+import { readDisabledServers } from "./config-writer";
 import type { MCPServerConfig } from "./types";
 
 /** Options for loading MCP configs */
@@ -97,12 +100,14 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 		? result.items
 		: result.items.filter(server => server._source.level !== "project");
 
+	// Load user-level disabled servers list
+	const disabledServers = new Set(await readDisabledServers(getMCPConfigPath("user", cwd)));
 	// Convert to legacy format and preserve source metadata
 	const configs: Record<string, MCPServerConfig> = {};
 	const sources: Record<string, SourceMeta> = {};
 	for (const server of servers) {
 		const config = convertToLegacyConfig(server);
-		if (config.enabled === false) {
+		if (config.enabled === false || (server._source.level !== "user" && disabledServers.has(server.name))) {
 			continue;
 		}
 		configs[server.name] = config;

package/src/mcp/types.ts

@@ -89,6 +89,7 @@ export type MCPServerConfig = MCPStdioServerConfig | MCPHttpServerConfig | MCPSs
 /** Root .mcp.json file structure */
 export interface MCPConfigFile {
 	mcpServers?: Record<string, MCPServerConfig>;
+	disabledServers?: string[];
 }
 
 // =============================================================================

package/src/modes/components/custom-editor.ts

@@ -5,6 +5,7 @@ import { Editor, type KeyId, matchesKey, parseKittySequence } from "@oh-my-pi/pi
  */
 export class CustomEditor extends Editor {
 	onEscape?: () => void;
+	shouldBypassAutocompleteOnEscape?: () => boolean;
 	onCtrlC?: () => void;
 	onCtrlD?: () => void;
 	onShiftTab?: () => void;
@@ -124,11 +125,13 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		// Intercept Escape key - but only if autocomplete is NOT active
-		// (let parent handle escape for autocomplete cancellation)
-		if ((matchesKey(data, "escape") || matchesKey(data, "esc")) && this.onEscape && !this.isShowingAutocomplete()) {
-			this.onEscape();
-			return;
+		// Intercept Escape key.
+		// Default behavior keeps autocomplete dismissal, but parent can prioritize global escape handling.
+		if ((matchesKey(data, "escape") || matchesKey(data, "esc")) && this.onEscape) {
+			if (!this.isShowingAutocomplete() || this.shouldBypassAutocompleteOnEscape?.()) {
+				this.onEscape();
+				return;
+			}
 		}
 
 		// Intercept Ctrl+C

package/src/modes/components/settings-defs.ts

@@ -149,9 +149,10 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{
 			value: "auto",
 			label: "Auto",
-			description: "Priority: Exa > Jina > Perplexity > Anthropic > Gemini > Codex > Z.AI",
+			description: "Priority: Exa > Brave > Jina > Perplexity > Anthropic > Gemini > Codex > Z.AI",
 		},
 		{ value: "exa", label: "Exa", description: "Requires EXA_API_KEY" },
+		{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
 		{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
 		{ value: "perplexity", label: "Perplexity", description: "Requires PERPLEXITY_API_KEY" },
 		{ value: "anthropic", label: "Anthropic", description: "Uses Anthropic web search" },

package/src/modes/controllers/command-controller.ts

@@ -334,23 +334,29 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 	}
 
-	async handleChangelogCommand(): Promise<void> {
+	async handleChangelogCommand(showFull = false): Promise<void> {
 		const changelogPath = getChangelogPath();
 		const allEntries = await parseChangelog(changelogPath);
-
+		// Default to showing only the latest 3 versions unless --full is specified
+		// allEntries comes from parseChangelog with newest first, reverse to show oldest->newest
+		const entriesToShow = showFull ? allEntries : allEntries.slice(0, 3);
 		const changelogMarkdown =
-			allEntries.length > 0
-				? allEntries
+			entriesToShow.length > 0
+				? [...entriesToShow]
 						.reverse()
 						.map(e => e.content)
 						.join("\n\n")
 				: "No changelog entries found.";
+		const title = showFull ? "Full Changelog" : "Recent Changes";
+		const hint = showFull
+			? ""
+			: `\n\n${theme.fg("dim", "Use")} ${theme.bold("/changelog full")} ${theme.fg("dim", "to view the complete changelog.")}`;
 
 		this.ctx.chatContainer.addChild(new Spacer(1));
 		this.ctx.chatContainer.addChild(new DynamicBorder());
-		this.ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0));
+		this.ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", title)), 1, 0));
 		this.ctx.chatContainer.addChild(new Spacer(1));
-		this.ctx.chatContainer.addChild(new Markdown(changelogMarkdown, 1, 1, getMarkdownTheme()));
+		this.ctx.chatContainer.addChild(new Markdown(changelogMarkdown + hint, 1, 1, getMarkdownTheme()));
 		this.ctx.chatContainer.addChild(new DynamicBorder());
 		this.ctx.ui.requestRender();
 	}