@oh-my-pi/pi-coding-agent 3.30.0 → 3.32.0

package/src/core/tools/lsp/index.ts

@@ -1,5 +1,5 @@
 import type { Dirent } from "node:fs";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { BunFile } from "bun";
@@ -19,6 +19,7 @@ import {
 	sendRequest,
 	setIdleTimeout,
 	syncContent,
+	WARMUP_TIMEOUT_MS,
 } from "./client";
 import { getLinterClient } from "./clients";
 import { getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
@@ -72,23 +73,36 @@ export interface LspWarmupResult {
 	}>;
 }
 
+/** Options for warming up LSP servers */
+export interface LspWarmupOptions {
+	/** Called when starting to connect to servers */
+	onConnecting?: (serverNames: string[]) => void;
+}
+
 /**
  * Warm up LSP servers for a directory by connecting to all detected servers.
  * This should be called at startup to avoid cold-start delays.
  *
  * @param cwd - Working directory to detect and start servers for
+ * @param options - Optional callbacks for progress reporting
  * @returns Status of each server that was started
  */
-export async function warmupLspServers(cwd: string): Promise<LspWarmupResult> {
+export async function warmupLspServers(cwd: string, options?: LspWarmupOptions): Promise<LspWarmupResult> {
 	const config = await loadConfig(cwd);
 	setIdleTimeout(config.idleTimeoutMs);
 	const servers: LspWarmupResult["servers"] = [];
 	const lspServers = getLspServers(config);
 
-	// Start all detected servers in parallel
+	// Notify caller which servers we're connecting to
+	if (lspServers.length > 0 && options?.onConnecting) {
+		options.onConnecting(lspServers.map(([name]) => name));
+	}
+
+	// Start all detected servers in parallel with a short timeout
+	// Servers that don't respond quickly will be initialized lazily on first use
 	const results = await Promise.allSettled(
 		lspServers.map(async ([name, serverConfig]) => {
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, WARMUP_TIMEOUT_MS);
 			return { name, client, fileTypes: serverConfig.fileTypes };
 		}),
 	);
@@ -136,14 +150,18 @@ async function syncFileContent(
 	content: string,
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
+	signal?: AbortSignal,
 ): Promise<void> {
+	signal?.throwIfAborted();
 	await Promise.allSettled(
 		servers.map(async ([_serverName, serverConfig]) => {
+			signal?.throwIfAborted();
 			if (serverConfig.createClient) {
 				return;
 			}
 			const client = await getOrCreateClient(serverConfig, cwd);
-			await syncContent(client, absolutePath, content);
+			signal?.throwIfAborted();
+			await syncContent(client, absolutePath, content, signal);
 		}),
 	);
 }
@@ -160,14 +178,17 @@ async function notifyFileSaved(
 	absolutePath: string,
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
+	signal?: AbortSignal,
 ): Promise<void> {
+	signal?.throwIfAborted();
 	await Promise.allSettled(
 		servers.map(async ([_serverName, serverConfig]) => {
+			signal?.throwIfAborted();
 			if (serverConfig.createClient) {
 				return;
 			}
 			const client = await getOrCreateClient(serverConfig, cwd);
-			await notifySaved(client, absolutePath);
+			await notifySaved(client, absolutePath, signal);
 		}),
 	);
 }
@@ -227,13 +248,19 @@ function findFileByExtensions(baseDir: string, extensions: string[], maxDepth: n
 	const normalized = extensions.map((ext) => ext.toLowerCase());
 	const search = (dir: string, depth: number): string | null => {
 		if (depth > maxDepth) return null;
-		let entries: Dirent[];
+		const entries: Dirent[] = [];
 		try {
-			entries = Array.from(new Bun.Glob("*").scanSync({ cwd: dir, onlyFiles: false })).map((name) => ({
-				name,
-				isFile: () => !existsSync(path.join(dir, name)) || Bun.file(path.join(dir, name)).type !== "directory",
-				isDirectory: () => existsSync(path.join(dir, name)) && Bun.file(path.join(dir, name)).type === "directory",
-			})) as Dirent[];
+			const names = Array.from(new Bun.Glob("*").scanSync({ cwd: dir, onlyFiles: false }));
+			for (const name of names) {
+				const fullPath = path.join(dir, name);
+				let isDir = false;
+				try {
+					isDir = statSync(fullPath).isDirectory();
+				} catch {
+					continue;
+				}
+				entries.push({ name, isFile: () => !isDir, isDirectory: () => isDir } as Dirent);
+			}
 		} catch {
 			return null;
 		}
@@ -298,9 +325,15 @@ function getServerForWorkspaceAction(config: LspConfig, action: string): [string
 	return null;
 }
 
-async function waitForDiagnostics(client: LspClient, uri: string, timeoutMs = 3000): Promise<Diagnostic[]> {
+async function waitForDiagnostics(
+	client: LspClient,
+	uri: string,
+	timeoutMs = 3000,
+	signal?: AbortSignal,
+): Promise<Diagnostic[]> {
 	const start = Date.now();
 	while (Date.now() - start < timeoutMs) {
+		signal?.throwIfAborted();
 		const diagnostics = client.diagnostics.get(uri);
 		if (diagnostics !== undefined) return diagnostics;
 		await sleep(100);
@@ -440,6 +473,7 @@ async function getDiagnosticsForFile(
 	absolutePath: string,
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
+	signal?: AbortSignal,
 ): Promise<FileDiagnosticsResult | undefined> {
 	if (servers.length === 0) {
 		return undefined;
@@ -453,6 +487,7 @@ async function getDiagnosticsForFile(
 	// Wait for diagnostics from all servers in parallel
 	const results = await Promise.allSettled(
 		servers.map(async ([serverName, serverConfig]) => {
+			signal?.throwIfAborted();
 			// Use custom linter client if configured
 			if (serverConfig.createClient) {
 				const linterClient = getLinterClient(serverName, serverConfig, cwd);
@@ -462,8 +497,9 @@ async function getDiagnosticsForFile(
 
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
+			signal?.throwIfAborted();
 			// Content already synced + didSave sent, just wait for diagnostics
-			const diagnostics = await waitForDiagnostics(client, uri);
+			const diagnostics = await waitForDiagnostics(client, uri, 3000, signal);
 			return { serverName, diagnostics };
 		}),
 	);
@@ -539,6 +575,7 @@ async function formatContent(
 	content: string,
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
+	signal?: AbortSignal,
 ): Promise<string> {
 	if (servers.length === 0) {
 		return content;
@@ -548,6 +585,7 @@ async function formatContent(
 
 	for (const [serverName, serverConfig] of servers) {
 		try {
+			signal?.throwIfAborted();
 			// Use custom linter client if configured
 			if (serverConfig.createClient) {
 				const linterClient = getLinterClient(serverName, serverConfig, cwd);
@@ -556,6 +594,7 @@ async function formatContent(
 
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
+			signal?.throwIfAborted();
 
 			const caps = client.serverCapabilities;
 			if (!caps?.documentFormattingProvider) {
@@ -563,10 +602,15 @@ async function formatContent(
 			}
 
 			// Request formatting (content already synced)
-			const edits = (await sendRequest(client, "textDocument/formatting", {
-				textDocument: { uri },
-				options: DEFAULT_FORMAT_OPTIONS,
-			})) as TextEdit[] | null;
+			const edits = (await sendRequest(
+				client,
+				"textDocument/formatting",
+				{
+					textDocument: { uri },
+					options: DEFAULT_FORMAT_OPTIONS,
+				},
+				signal,
+			)) as TextEdit[] | null;
 
 			if (!edits || edits.length === 0) {
 				return content;
@@ -633,28 +677,29 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 		let formatter: FileFormatResult | undefined;
 		let diagnostics: FileDiagnosticsResult | undefined;
 		try {
-			signal ??= AbortSignal.timeout(10_000);
-			await untilAborted(signal, async () => {
+			const timeoutSignal = AbortSignal.timeout(10_000);
+			const operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+			await untilAborted(operationSignal, async () => {
 				if (useCustomFormatter) {
 					// Custom linters (e.g. Biome CLI) require on-disk input.
 					await writeContent(content);
-					finalContent = await formatContent(dst, content, cwd, customLinterServers);
+					finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
 					formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
 					await writeContent(finalContent);
-					await syncFileContent(dst, finalContent, cwd, lspServers);
+					await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
 				} else {
 					// 1. Sync original content to LSP servers
-					await syncFileContent(dst, content, cwd, lspServers);
+					await syncFileContent(dst, content, cwd, lspServers, operationSignal);
 
 					// 2. Format in-memory via LSP
 					if (enableFormat) {
-						finalContent = await formatContent(dst, content, cwd, lspServers);
+						finalContent = await formatContent(dst, content, cwd, lspServers, operationSignal);
 						formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
 					}
 
 					// 3. If formatted, sync formatted content to LSP servers
 					if (finalContent !== content) {
-						await syncFileContent(dst, finalContent, cwd, lspServers);
+						await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
 					}
 
 					// 4. Write to disk
@@ -662,11 +707,11 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 				}
 
 				// 5. Notify saved to LSP servers
-				await notifyFileSaved(dst, cwd, lspServers);
+				await notifyFileSaved(dst, cwd, lspServers, operationSignal);
 
 				// 6. Get diagnostics from all servers
 				if (enableDiagnostics) {
-					diagnostics = await getDiagnosticsForFile(dst, cwd, servers);
+					diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal);
 				}
 			});
 		} catch {
@@ -1362,11 +1407,3 @@ export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema,
 		},
 	};
 }
-
-export const lspTool = createLspTool({
-	cwd: process.cwd(),
-	hasUI: false,
-	rulebookRules: [],
-	getSessionFile: () => null,
-	getSessionSpawns: () => null,
-});

package/src/core/tools/lsp/rust-analyzer.ts

@@ -1,13 +1,6 @@
 import { sendNotification, sendRequest } from "./client";
 import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types";
-import { fileToUri } from "./utils";
-
-/**
- * Wait for specified milliseconds.
- */
-async function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
+import { fileToUri, sleep } from "./utils";
 
 /**
  * Run flycheck (cargo check) and collect diagnostics.
@@ -19,10 +12,56 @@ async function sleep(ms: number): Promise<void> {
  */
 export async function flycheck(client: LspClient, file?: string): Promise<Diagnostic[]> {
 	const textDocument = file ? { uri: fileToUri(file) } : null;
+
+	const countDiagnostics = (diagnostics: Map<string, Diagnostic[]>): number => {
+		let count = 0;
+		for (const diags of diagnostics.values()) {
+			count += diags.length;
+		}
+		return count;
+	};
+
+	// Capture current diagnostic version before triggering flycheck
+	const initialDiagnosticsVersion = client.diagnosticsVersion;
+	const initialDiagnosticsCount = countDiagnostics(client.diagnostics);
+
 	await sendNotification(client, "rust-analyzer/runFlycheck", { textDocument });
 
-	// Wait for diagnostics to accumulate (2 seconds as per reference)
-	await sleep(2000);
+	// Bounded polling: wait for diagnostics to stabilize or timeout
+	// Poll every 100ms for up to 8 seconds (80 iterations)
+	const pollIntervalMs = 100;
+	const maxPollIterations = 80;
+	const stabilityThreshold = 3; // Consider stable after 3 iterations without change
+	const minStableDurationMs = 2000; // Avoid early exit when diagnostics are re-published unchanged.
+	const startTime = Date.now();
+	let lastDiagnosticsVersion = initialDiagnosticsVersion;
+	let lastDiagnosticsCount = initialDiagnosticsCount;
+	let stableIterations = 0;
+
+	for (let i = 0; i < maxPollIterations; i++) {
+		await sleep(pollIntervalMs);
+
+		const currentDiagnosticsVersion = client.diagnosticsVersion;
+		const currentDiagnosticsCount = countDiagnostics(client.diagnostics);
+
+		// Check if diagnostics have stabilized
+		if (currentDiagnosticsVersion === lastDiagnosticsVersion && currentDiagnosticsCount === lastDiagnosticsCount) {
+			stableIterations++;
+			const elapsedMs = Date.now() - startTime;
+			const countChangedFromStart = currentDiagnosticsCount !== initialDiagnosticsCount;
+			if (
+				currentDiagnosticsVersion !== initialDiagnosticsVersion &&
+				stableIterations >= stabilityThreshold &&
+				(countChangedFromStart || elapsedMs >= minStableDurationMs)
+			) {
+				break;
+			}
+		} else {
+			stableIterations = 0;
+			lastDiagnosticsVersion = currentDiagnosticsVersion;
+			lastDiagnosticsCount = currentDiagnosticsCount;
+		}
+	}
 
 	// Collect all diagnostics from client
 	const allDiags: Diagnostic[] = [];

package/src/core/tools/lsp/types.ts

@@ -403,6 +403,7 @@ export interface LspClient {
 	process: Subprocess;
 	requestId: number;
 	diagnostics: Map<string, Diagnostic[]>;
+	diagnosticsVersion: number;
 	openFiles: Map<string, OpenFile>;
 	pendingRequests: Map<number, PendingRequest>;
 	messageBuffer: Uint8Array;

package/src/core/tools/lsp/utils.ts

@@ -492,7 +492,7 @@ export function extractHoverText(
  * Sleep for the specified number of milliseconds.
  */
 export function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+	return Bun.sleep(ms);
 }
 
 /**