@oh-my-pi/pi-coding-agent 14.2.0 → 14.3.0

package/src/internal-urls/pi-protocol.ts

@@ -45,7 +45,6 @@ export class PiProtocolHandler implements ProtocolHandler {
 			content,
 			contentType: "text/markdown",
 			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: "pi://",
 		};
 	}
 
@@ -78,7 +77,6 @@ export class PiProtocolHandler implements ProtocolHandler {
 			content,
 			contentType: "text/markdown",
 			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: `pi://${normalized}`,
 		};
 	}
 }

package/src/lsp/client.ts

@@ -211,11 +211,19 @@ async function writeMessage(
 	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
 ): Promise<void> {
 	const content = JSON.stringify(message);
-	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n`);
-	sink.write(content);
+	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n${content}`);
 	await sink.flush();
 }
 
+function queueWriteMessage(
+	client: LspClient,
+	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
+): Promise<void> {
+	const write = client.writeQueue.catch(() => {}).then(() => writeMessage(client.proc.stdin, message));
+	client.writeQueue = write.catch(() => {});
+	return write;
+}
+
 // =============================================================================
 // Message Reader
 // =============================================================================
@@ -382,7 +390,7 @@ async function sendResponse(
 	};
 
 	try {
-		await writeMessage(client.proc.stdin, response);
+		await queueWriteMessage(client, response);
 	} catch (err) {
 		logger.error("LSP failed to respond.", { method, error: String(err) });
 	}
@@ -461,6 +469,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			messageBuffer: new Uint8Array(0),
 			isReading: false,
 			lastActivity: Date.now(),
+			writeQueue: Promise.resolve(),
 			activeProgressTokens: new Set(),
 			projectLoaded,
 			resolveProjectLoaded,
@@ -475,7 +484,14 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 
 			// Reject any pending requests — the server is gone, they will never complete.
 			if (client.pendingRequests.size > 0) {
-				const stderr = proc.peekStderr().trim();
+				// Strip informational log lines (e.g. marksman's [INF]/[DBG] prefix)
+				// — they are startup noise, not actionable errors.
+				const rawStderr = proc.peekStderr().trim();
+				const stderr = rawStderr
+					.split("\n")
+					.filter(line => !/^\[\d{2}:\d{2}:\d{2} (?:INF|DBG|VRB)\]/.test(line))
+					.join("\n")
+					.trim();
 				const code = proc.exitCode;
 				const err = new Error(
 					stderr ? `LSP server exited (code ${code}): ${stderr}` : `LSP server exited unexpectedly (code ${code})`,
@@ -848,7 +864,7 @@ export async function sendRequest(
 	});
 
 	// Write request
-	writeMessage(client.proc.stdin, request).catch(err => {
+	queueWriteMessage(client, request).catch(err => {
 		if (timeout) clearTimeout(timeout);
 		client.pendingRequests.delete(id);
 		cleanup();
@@ -868,7 +884,7 @@ export async function sendNotification(client: LspClient, method: string, params
 	};
 
 	client.lastActivity = Date.now();
-	await writeMessage(client.proc.stdin, notification);
+	await queueWriteMessage(client, notification);
 }
 
 /**

package/src/lsp/defaults.json

@@ -857,7 +857,8 @@
 		"rootMarkers": [
 			".marksman.toml",
 			".git"
-		]
+		],
+		"warmupTimeoutMs": 15000
 	},
 	"texlab": {
 		"command": "texlab",

package/src/lsp/index.ts

@@ -40,6 +40,7 @@ import {
 	type LspParams,
 	type LspToolDetails,
 	lspSchema,
+	type Position,
 	type PublishedDiagnostics,
 	type ServerConfig,
 	type SymbolInformation,
@@ -262,6 +263,10 @@ function getLspServerForFile(config: LspConfig, filePath: string): [string, Serv
 	return servers.length > 0 ? servers[0] : null;
 }
 
+function isProjectAwareLspServer(serverConfig: ServerConfig): boolean {
+	return !serverConfig.createClient && !serverConfig.isLinter;
+}
+
 const DIAGNOSTIC_MESSAGE_LIMIT = 50;
 const SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 3000;
 const BATCH_DIAGNOSTICS_WAIT_TIMEOUT_MS = 400;
@@ -278,6 +283,21 @@ function limitDiagnosticMessages(messages: string[]): string[] {
 const LOCATION_CONTEXT_LINES = 1;
 const REFERENCE_CONTEXT_LIMIT = 50;
 
+const REFERENCES_RETRY_COUNT = 2;
+const REFERENCES_RETRY_DELAY_MS = 250;
+
+function comparePosition(a: Position, b: Position): number {
+	return a.line === b.line ? a.character - b.character : a.line - b.line;
+}
+
+function rangeContainsPosition(range: Location["range"], position: Position): boolean {
+	return comparePosition(range.start, position) <= 0 && comparePosition(position, range.end) <= 0;
+}
+
+function isOnlyQueriedDeclaration(locations: Location[], uri: string, position: Position): boolean {
+	return locations.length === 1 && locations[0]?.uri === uri && rangeContainsPosition(locations[0].range, position);
+}
+
 function normalizeLocationResult(result: Location | Location[] | LocationLink | LocationLink[] | null): Location[] {
 	if (!result) return [];
 	const raw = Array.isArray(result) ? result : [result];
@@ -560,6 +580,10 @@ async function getDiagnosticsForFile(
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
 			throwIfAborted(signal);
+			if (isProjectAwareLspServer(serverConfig)) {
+				await waitForProjectLoaded(client, signal);
+				throwIfAborted(signal);
+			}
 			// Content already synced + didSave sent, wait for fresh diagnostics
 			const minVersion = minVersions?.get(serverName);
 			const expectedDocumentVersion = expectedDocumentVersions?.get(serverName);
@@ -1220,6 +1244,10 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 							continue;
 						}
 						const client = await getOrCreateClient(serverConfig, this.session.cwd);
+						if (isProjectAwareLspServer(serverConfig)) {
+							await waitForProjectLoaded(client, signal);
+							throwIfAborted(signal);
+						}
 						const minVersion = client.diagnosticsVersion;
 						await refreshFile(client, resolved, signal);
 						const expectedDocumentVersion = client.openFiles.get(uri)?.version;
@@ -1512,16 +1540,31 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 					break;
 				}
 				case "references": {
-					const result = (await sendRequest(
-						client,
-						"textDocument/references",
-						{
-							textDocument: { uri },
-							position,
-							context: { includeDeclaration: true },
-						},
-						signal,
-					)) as Location[] | null;
+					let result: Location[] | null = null;
+					for (let attempt = 0; attempt <= REFERENCES_RETRY_COUNT; attempt++) {
+						result = (await sendRequest(
+							client,
+							"textDocument/references",
+							{
+								textDocument: { uri },
+								position,
+								context: { includeDeclaration: true },
+							},
+							signal,
+						)) as Location[] | null;
+
+						const locations = result ?? [];
+						if (!isProjectAwareLspServer(serverConfig) || attempt === REFERENCES_RETRY_COUNT) {
+							break;
+						}
+						if (locations.length > 0 && !isOnlyQueriedDeclaration(locations, uri, position)) {
+							break;
+						}
+
+						await waitForProjectLoaded(client, signal);
+						throwIfAborted(signal);
+						await untilAborted(signal, () => Bun.sleep(REFERENCES_RETRY_DELAY_MS));
+					}
 
 					if (!result || result.length === 0) {
 						output = "No references found";

package/src/lsp/types.ts

@@ -411,6 +411,8 @@ export interface LspClient {
 	isReading: boolean;
 	serverCapabilities?: LspServerCapabilities;
 	lastActivity: number;
+	/** Serializes outbound JSON-RPC writes to the server process. */
+	writeQueue: Promise<void>;
 	/** Tracks active work-done progress tokens from the server */
 	activeProgressTokens: Set<string | number>;
 	/** Resolves when the server's initial project loading completes (or after timeout) */

package/src/modes/acp/acp-agent.ts

@@ -39,11 +39,14 @@ import {
 } from "@agentclientprotocol/sdk";
 import type { Model } from "@oh-my-pi/pi-ai";
 import { logger, VERSION } from "@oh-my-pi/pi-utils";
+import { disableProvider, enableProvider } from "../../capability";
+import { Settings } from "../../config/settings";
 import type { ExtensionUIContext } from "../../extensibility/extensions";
 import { runExtensionCompact } from "../../extensibility/extensions/compact-handler";
 import { loadSlashCommands } from "../../extensibility/slash-commands";
 import { MCPManager } from "../../mcp/manager";
 import type { MCPServerConfig } from "../../mcp/types";
+import { loadAllExtensions } from "../../modes/components/extensions/state-manager";
 import { theme } from "../../modes/theme/theme";
 import type { AgentSession, AgentSessionEvent } from "../../session/agent-session";
 import {
@@ -379,8 +382,79 @@ export class AcpAgent implements Agent {
 		}
 	}
 
-	async extMethod(_method: string, _params: { [key: string]: unknown }): Promise<{ [key: string]: unknown }> {
-		throw new Error("ACP extension methods are not implemented");
+	async extMethod(method: string, params: { [key: string]: unknown }): Promise<{ [key: string]: unknown }> {
+		switch (method) {
+			case "omp/sessions/listAll": {
+				const limit = typeof params.limit === "number" ? Math.max(1, Math.min(5000, params.limit as number)) : 1000;
+				const sessions = await SessionManager.listAll();
+				const sorted = sessions.sort((l, r) => r.modified.getTime() - l.modified.getTime()).slice(0, limit);
+				return {
+					sessions: sorted.map(s => this.#toSessionInfo(s)),
+					total: sessions.length,
+				};
+			}
+			case "omp/projects/list": {
+				const sessions = await SessionManager.listAll();
+				const buckets = new Map<
+					string,
+					{ cwd: string; sessionCount: number; lastActivityAt: number; lastTitle: string }
+				>();
+				for (const s of sessions) {
+					if (!s.cwd) continue;
+					const ts = s.modified.getTime();
+					const existing = buckets.get(s.cwd);
+					if (existing) {
+						existing.sessionCount += 1;
+						if (ts > existing.lastActivityAt) {
+							existing.lastActivityAt = ts;
+							existing.lastTitle = s.title ?? "";
+						}
+					} else {
+						buckets.set(s.cwd, {
+							cwd: s.cwd,
+							sessionCount: 1,
+							lastActivityAt: ts,
+							lastTitle: s.title ?? "",
+						});
+					}
+				}
+				const projects = Array.from(buckets.values()).sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+				return { projects, totalSessions: sessions.length };
+			}
+			case "omp/chats/byCwd": {
+				const cwd = typeof params.cwd === "string" ? (params.cwd as string) : undefined;
+				if (!cwd) throw new Error("cwd required");
+				const limit = typeof params.limit === "number" ? Math.max(1, Math.min(500, params.limit as number)) : 100;
+				const sessions = await SessionManager.list(cwd);
+				const sorted = sessions.sort((l, r) => r.modified.getTime() - l.modified.getTime()).slice(0, limit);
+				return { sessions: sorted.map(s => this.#toSessionInfo(s)) };
+			}
+			case "omp/usage": {
+				const [firstRecord] = this.#sessions.values();
+				const target = firstRecord?.session ?? this.#initialSession;
+				const reports = await target.fetchUsageReports();
+				return { reports: reports ?? [] };
+			}
+			case "omp/extensions": {
+				const cwd = typeof params.cwd === "string" ? (params.cwd as string) : undefined;
+				const sm = await Settings.init();
+				const disabledIds = (sm.get("disabledExtensions") as string[] | undefined) ?? [];
+				const extensions = await loadAllExtensions(cwd, disabledIds);
+				return { extensions: extensions as unknown as Array<{ [key: string]: unknown }> };
+			}
+			case "omp/extensions/toggle": {
+				const providerId = params.providerId;
+				if (typeof providerId !== "string") throw new Error("providerId required");
+				if (params.enabled === false) {
+					disableProvider(providerId);
+					return { enabled: false };
+				}
+				enableProvider(providerId);
+				return { enabled: true };
+			}
+			default:
+				throw new Error(`Unknown ACP ext method: ${method}`);
+		}
 	}
 
 	async extNotification(_method: string, _params: { [key: string]: unknown }): Promise<void> {}

package/src/modes/components/assistant-message.ts

@@ -1,8 +1,7 @@
 import type { AssistantMessage, ImageContent, Usage } from "@oh-my-pi/pi-ai";
 import { Container, Image, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@oh-my-pi/pi-tui";
-import { formatNumber, logger } from "@oh-my-pi/pi-utils";
+import { formatNumber } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
-import { hasPendingMermaid, prerenderMermaid } from "../../modes/theme/mermaid-cache";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { resolveImageOptions } from "../../tools/render-utils";
 
@@ -12,7 +11,6 @@ import { resolveImageOptions } from "../../tools/render-utils";
 export class AssistantMessageComponent extends Container {
 	#contentContainer: Container;
 	#lastMessage?: AssistantMessage;
-	#prerenderInFlight = false;
 	#toolImagesByCallId = new Map<string, ImageContent[]>();
 	#usageInfo?: Usage;
 
@@ -85,34 +83,6 @@ export class AssistantMessageComponent extends Container {
 			this.#contentContainer.addChild(new Text(theme.fg("toolOutput", `[Image: ${image.mimeType}]`), 1, 0));
 		}
 	}
-	#triggerMermaidPrerender(message: AssistantMessage): void {
-		if (!TERMINAL.imageProtocol || this.#prerenderInFlight) return;
-
-		// Check if any text content has pending mermaid blocks
-		const hasPending = message.content.some(c => c.type === "text" && c.text.trim() && hasPendingMermaid(c.text));
-		if (!hasPending) return;
-
-		this.#prerenderInFlight = true;
-
-		// Fire off background prerender
-		void (async () => {
-			try {
-				for (const content of message.content) {
-					if (content.type === "text" && content.text.trim() && hasPendingMermaid(content.text)) {
-						prerenderMermaid(content.text);
-					}
-				}
-			} catch (error) {
-				logger.warn("Background mermaid prerender failed", {
-					error: error instanceof Error ? error.message : String(error),
-				});
-			} finally {
-				this.#prerenderInFlight = false;
-				// Invalidate to re-render with cached images
-				this.invalidate();
-			}
-		})();
-	}
 
 	updateContent(message: AssistantMessage): void {
 		this.#lastMessage = message;
@@ -120,9 +90,6 @@ export class AssistantMessageComponent extends Container {
 		// Clear content container
 		this.#contentContainer.clear();
 
-		// Trigger background mermaid pre-rendering if needed
-		this.#triggerMermaidPrerender(message);
-
 		const hasVisibleContent = message.content.some(
 			c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()),
 		);

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

@@ -136,7 +136,7 @@ export class HookEditorComponent extends Container {
 		const editorCmd = getEditorCommand();
 		if (!editorCmd) return;
 
-		const currentText = this.#editor.getText();
+		const currentText = this.#editor.getExpandedText();
 		try {
 			this.#tui.stop();
 			const result = await openInEditor(editorCmd, currentText);