@oh-my-pi/pi-coding-agent 13.19.0 → 14.0.3

package/src/ipy/executor.ts

@@ -299,6 +299,48 @@ async function writePreludeCache(state: PreludeCacheState, helpers: PreludeHelpe
 	}
 }
 
+function isPythonTestEnvironment(): boolean {
+	return Bun.env.BUN_ENV === "test" || Bun.env.NODE_ENV === "test";
+}
+
+function getPreludeIntrospectionOptions(
+	options: KernelSessionExecutionOptions = {},
+): Pick<KernelExecuteOptions, "signal" | "timeoutMs"> {
+	return {
+		signal: options.signal,
+		timeoutMs: requireRemainingTimeoutMs(options.deadlineMs),
+	};
+}
+
+async function cachePreludeDocs(
+	cwd: string,
+	docs: PreludeHelper[],
+	cacheState?: PreludeCacheState | null,
+): Promise<PreludeHelper[]> {
+	cachedPreludeDocs = docs;
+	if (!isPythonTestEnvironment() && docs.length > 0) {
+		const state = cacheState ?? (await buildPreludeCacheState(cwd));
+		await writePreludeCache(state, docs);
+	}
+	return docs;
+}
+
+async function ensurePreludeDocsLoaded(
+	kernel: PythonKernel,
+	cwd: string,
+	options: KernelSessionExecutionOptions = {},
+	cacheState?: PreludeCacheState | null,
+): Promise<PreludeHelper[]> {
+	if (cachedPreludeDocs && cachedPreludeDocs.length > 0) {
+		return cachedPreludeDocs;
+	}
+	const docs = await kernel.introspectPrelude(getPreludeIntrospectionOptions(options));
+	if (docs.length === 0) {
+		throw new Error("Python prelude helpers unavailable");
+	}
+	return cachePreludeDocs(cwd, docs, cacheState);
+}
+
 function startCleanupTimer(): void {
 	if (cleanupTimer) return;
 	cleanupTimer = setInterval(() => {
@@ -366,16 +408,15 @@ export async function warmPythonEnvironment(
 	useSharedGateway?: boolean,
 	sessionFile?: string,
 ): Promise<{ ok: boolean; reason?: string; docs: PreludeHelper[] }> {
-	const isTestEnv = Bun.env.BUN_ENV === "test" || Bun.env.NODE_ENV === "test";
 	let cacheState: PreludeCacheState | null = null;
 	try {
-		await logger.timeAsync("warmPython:ensureKernelAvailable", () => ensureKernelAvailable(cwd));
+		await logger.time("warmPython:ensureKernelAvailable", ensureKernelAvailable, cwd);
 	} catch (err: unknown) {
 		const reason = err instanceof Error ? err.message : String(err);
 		cachedPreludeDocs = [];
 		return { ok: false, reason, docs: [] };
 	}
-	if (!isTestEnv) {
+	if (!isPythonTestEnvironment()) {
 		try {
 			cacheState = await buildPreludeCacheState(cwd);
 			const cached = await readPreludeCache(cacheState);
@@ -393,17 +434,17 @@ export async function warmPythonEnvironment(
 	}
 	const resolvedSessionId = sessionId ?? `session:${cwd}`;
 	try {
-		const docs = await logger.timeAsync("warmPython:withKernelSession", () =>
-			withKernelSession(resolvedSessionId, cwd, async kernel => kernel.introspectPrelude(), {
+		const docs = await logger.time(
+			"warmPython:withKernelSession",
+			withKernelSession,
+			resolvedSessionId,
+			cwd,
+			kernel => ensurePreludeDocsLoaded(kernel, cwd, { useSharedGateway, sessionFile }, cacheState),
+			{
 				useSharedGateway,
 				sessionFile,
-			}),
+			},
 		);
-		cachedPreludeDocs = docs;
-		if (!isTestEnv && docs.length > 0) {
-			const state = cacheState ?? (await buildPreludeCacheState(cwd));
-			await writePreludeCache(state, docs);
-		}
 		return { ok: true, docs };
 	} catch (err: unknown) {
 		const reason = err instanceof Error ? err.message : String(err);
@@ -461,7 +502,7 @@ async function createKernelSession(
 
 	let kernel: PythonKernel;
 	try {
-		kernel = await logger.timeAsync("createKernelSession:PythonKernel.start", () => PythonKernel.start(startOptions));
+		kernel = await logger.time("createKernelSession:PythonKernel.start", PythonKernel.start, startOptions);
 	} catch (err) {
 		if (!isRetry && isResourceExhaustionError(err)) {
 			await recoverFromResourceExhaustion();
@@ -541,7 +582,7 @@ async function withKernelSession<T>(
 		if (options.signal?.aborted) {
 			throw new PythonExecutionCancelledError(isTimedOutCancellation(options.signal.reason, options.signal));
 		}
-		session = await logger.timeAsync("kernel:createKernelSession", createKernelSession, sessionId, cwd, options);
+		session = await logger.time("kernel:createKernelSession", createKernelSession, sessionId, cwd, options);
 		kernelSessions.set(sessionId, session);
 		startCleanupTimer();
 	}
@@ -549,18 +590,18 @@ async function withKernelSession<T>(
 	const run = async (): Promise<T> => {
 		session!.lastUsedAt = Date.now();
 		if (session!.dead || !session!.kernel.isAlive()) {
-			await logger.timeAsync("kernel:restartKernelSession", restartKernelSession, session!, cwd, options);
+			await logger.time("kernel:restartKernelSession", restartKernelSession, session!, cwd, options);
 		}
 		try {
-			const result = await logger.timeAsync("kernel:withSession:handler", handler, session!.kernel);
+			const result = await logger.time("kernel:withSession:handler", handler, session!.kernel);
 			session!.restartCount = 0;
 			return result;
 		} catch (err) {
 			if (!session!.dead && session!.kernel.isAlive()) {
 				throw err;
 			}
-			await logger.timeAsync("kernel:restartKernelSession", restartKernelSession, session!, cwd, options);
-			const result = await logger.timeAsync("kernel:postRestart:handler", handler, session!.kernel);
+			await logger.time("kernel:restartKernelSession", restartKernelSession, session!, cwd, options);
+			const result = await logger.time("kernel:postRestart:handler", handler, session!.kernel);
 			session!.restartCount = 0;
 			return result;
 		}

package/src/ipy/gateway-coordinator.ts

@@ -313,9 +313,9 @@ async function killGateway(pid: number, context: string): Promise<void> {
 export async function acquireSharedGateway(cwd: string): Promise<AcquireResult | null> {
 	try {
 		return await withGatewayLock(async () => {
-			const existingInfo = await logger.timeAsync("acquireSharedGateway:readInfo", () => readGatewayInfo());
+			const existingInfo = await logger.time("acquireSharedGateway:readInfo", readGatewayInfo);
 			if (existingInfo) {
-				if (await logger.timeAsync("acquireSharedGateway:isAlive", () => isGatewayAlive(existingInfo))) {
+				if (await logger.time("acquireSharedGateway:isAlive", isGatewayAlive, existingInfo)) {
 					localGatewayUrl = existingInfo.url;
 					isCoordinatorInitialized = true;
 					logger.debug("Reusing global Python gateway", { url: existingInfo.url });
@@ -329,8 +329,10 @@ export async function acquireSharedGateway(cwd: string): Promise<AcquireResult |
 				await clearGatewayInfo();
 			}
 
-			const { url, pid, pythonPath, venvPath } = await logger.timeAsync("acquireSharedGateway:startGateway", () =>
-				startGatewayProcess(cwd),
+			const { url, pid, pythonPath, venvPath } = await logger.time(
+				"acquireSharedGateway:startGateway",
+				startGatewayProcess,
+				cwd,
 			);
 			const info: GatewayInfo = {
 				url,

package/src/ipy/kernel.ts

@@ -421,8 +421,10 @@ export class PythonKernel {
 	}
 
 	static async start(options: KernelStartOptions): Promise<PythonKernel> {
-		const availability = await logger.timeAsync("PythonKernel.start:availabilityCheck", () =>
-			checkPythonKernelAvailability(options.cwd),
+		const availability = await logger.time(
+			"PythonKernel.start:availabilityCheck",
+			checkPythonKernelAvailability,
+			options.cwd,
 		);
 		if (!availability.ok) {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
@@ -443,14 +445,21 @@ export class PythonKernel {
 		for (let attempt = 0; attempt < 2; attempt += 1) {
 			throwIfAborted(startupSignal, "Python kernel startup aborted");
 			try {
-				const sharedResult = await logger.timeAsync("PythonKernel.start:acquireSharedGateway", () =>
-					acquireSharedGateway(options.cwd),
+				const sharedResult = await logger.time(
+					"PythonKernel.start:acquireSharedGateway",
+					acquireSharedGateway,
+					options.cwd,
 				);
 				if (!sharedResult) {
 					throw new Error("Shared Python gateway unavailable");
 				}
-				const kernel = await logger.timeAsync("PythonKernel.start:startWithSharedGateway", () =>
-					PythonKernel.#startWithSharedGateway(sharedResult.url, options.cwd, options.env, startup),
+				const kernel = await logger.time(
+					"PythonKernel.start:startWithSharedGateway",
+					PythonKernel.#startWithSharedGateway,
+					sharedResult.url,
+					options.cwd,
+					options.env,
+					startup,
 				);
 				return kernel;
 			} catch (err) {
@@ -538,13 +547,16 @@ export class PythonKernel {
 	): Promise<PythonKernel> {
 		const startupSignal = combineAbortSignal(startup, undefined, "Python kernel startup aborted");
 		throwIfAborted(startupSignal, "Python kernel startup aborted");
-		const createResponse = await logger.timeAsync("startWithSharedGateway:createKernel", () =>
-			fetch(`${gatewayUrl}/api/kernels`, {
+		const createResponse = await logger.time(
+			"startWithSharedGateway:createKernel",
+			fetch,
+			`${gatewayUrl}/api/kernels`,
+			{
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify({ name: "python3" }),
 				signal: startupSignal,
-			}),
+			},
 		);
 
 		if (!createResponse.ok) {
@@ -557,35 +569,44 @@ export class PythonKernel {
 			);
 		}
 
-		const kernelInfo = await logger.timeAsync(
+		const kernelInfo = (await logger.time(
 			"startWithSharedGateway:parseJson",
-			() => createResponse.json() as Promise<{ id: string }>,
-		);
+			createResponse.json.bind(createResponse),
+		)) as { id: string };
 		const kernelId = kernelInfo.id;
 
 		const kernel = new PythonKernel(Snowflake.next(), kernelId, gatewayUrl, Snowflake.next(), "omp", true);
 
 		try {
-			await logger.timeAsync("startWithSharedGateway:connectWS", () => kernel.#connectWebSocket(startup));
-			await logger.timeAsync("startWithSharedGateway:initEnv", () =>
-				kernel.#initializeKernelEnvironment(cwd, env, startup),
+			await logger.time("startWithSharedGateway:connectWS", kernel.#connectWebSocket.bind(kernel), startup);
+			await logger.time(
+				"startWithSharedGateway:initEnv",
+				kernel.#initializeKernelEnvironment.bind(kernel),
+				cwd,
+				env,
+				startup,
 			);
 			const preludeOptions = getStartupExecuteOptions(startup);
-			const preludeResult = await logger.timeAsync("startWithSharedGateway:prelude", () =>
-				kernel.execute(PYTHON_PRELUDE, {
+			const preludeResult = await logger.time(
+				"startWithSharedGateway:prelude",
+				kernel.execute.bind(kernel),
+				PYTHON_PRELUDE,
+				{
 					...preludeOptions,
 					silent: true,
 					storeHistory: false,
-				}),
+				},
 			);
 			throwIfStartupExecutionFailed(
 				preludeResult,
 				preludeOptions.signal,
 				"Failed to initialize Python kernel prelude",
 			);
-			await logger.timeAsync("startWithSharedGateway:loadModules", () =>
-				loadPythonModules(kernel, { cwd, signal: startup.signal, deadlineMs: startup.deadlineMs }),
-			);
+			await logger.time("startWithSharedGateway:loadModules", loadPythonModules, kernel, {
+				cwd,
+				signal: startup.signal,
+				deadlineMs: startup.deadlineMs,
+			});
 			return kernel;
 		} catch (err: unknown) {
 			await kernel.shutdown({ timeoutMs: getStartupCleanupTimeoutMs(startup.deadlineMs) });
@@ -927,11 +948,13 @@ export class PythonKernel {
 		return promise;
 	}
 
-	async introspectPrelude(): Promise<PreludeHelper[]> {
+	async introspectPrelude(options: Pick<KernelExecuteOptions, "signal" | "timeoutMs"> = {}): Promise<PreludeHelper[]> {
 		let output = "";
 		const result = await this.execute(PRELUDE_INTROSPECTION_SNIPPET, {
 			silent: false,
 			storeHistory: false,
+			signal: options.signal,
+			timeoutMs: options.timeoutMs,
 			onChunk: text => {
 				output += text;
 			},

package/src/ipy/runtime.ts

@@ -6,7 +6,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { $env, getPythonEnvDir } from "@oh-my-pi/pi-utils";
+import { $env, $which, getPythonEnvDir } from "@oh-my-pi/pi-utils";
 
 const DEFAULT_ENV_ALLOWLIST = new Set([
 	"PATH",
@@ -210,7 +210,7 @@ export function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string
 		};
 	}
 
-	const pythonPath = Bun.which("python") ?? Bun.which("python3");
+	const pythonPath = $which("python") ?? $which("python3");
 	if (!pythonPath) {
 		throw new Error("Python executable not found on PATH");
 	}

package/src/lsp/client.ts

@@ -3,11 +3,11 @@ import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
 import type {
-	Diagnostic,
 	LspClient,
 	LspJsonRpcNotification,
 	LspJsonRpcRequest,
 	LspJsonRpcResponse,
+	PublishDiagnosticsParams,
 	ServerConfig,
 	WorkspaceEdit,
 } from "./types";
@@ -130,7 +130,7 @@ const CLIENT_CAPABILITIES = {
 		},
 		publishDiagnostics: {
 			relatedInformation: true,
-			versionSupport: false,
+			versionSupport: true,
 			tagSupport: { valueSet: [1, 2] },
 			codeDescriptionSupport: true,
 			dataSupport: true,
@@ -261,8 +261,11 @@ async function startMessageReader(client: LspClient): Promise<void> {
 				} else if ("method" in message) {
 					// Server notification
 					if (message.method === "textDocument/publishDiagnostics" && message.params) {
-						const params = message.params as { uri: string; diagnostics: Diagnostic[] };
-						client.diagnostics.set(params.uri, params.diagnostics);
+						const params = message.params as PublishDiagnosticsParams;
+						client.diagnostics.set(params.uri, {
+							diagnostics: params.diagnostics,
+							version: params.version ?? null,
+						});
 						client.diagnosticsVersion += 1;
 					}
 				}

package/src/lsp/clients/lsp-linter-client.ts

@@ -77,14 +77,14 @@ export class LspLinterClient implements LinterClient {
 		const timeoutMs = 3000;
 		const start = Date.now();
 		while (Date.now() - start < timeoutMs) {
-			const diagnostics = client.diagnostics.get(uri);
-			if (diagnostics !== undefined) {
-				return diagnostics;
+			const publishedDiagnostics = client.diagnostics.get(uri);
+			if (publishedDiagnostics !== undefined) {
+				return publishedDiagnostics.diagnostics;
 			}
 			await Bun.sleep(100);
 		}
 
-		return client.diagnostics.get(uri) ?? [];
+		return client.diagnostics.get(uri)?.diagnostics ?? [];
 	}
 
 	dispose(): void {

package/src/lsp/config.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { isRecord, logger } from "@oh-my-pi/pi-utils";
+import { $which, isRecord, logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { getConfigDirPaths } from "../config";
 import { getPreloadedPluginRoots } from "../discovery/helpers";
@@ -197,6 +197,21 @@ const LOCAL_BIN_PATHS: Array<{ markers: string[]; binDir: string }> = [
 	{ markers: ["go.mod", "go.sum"], binDir: "bin" },
 ];
 
+const WINDOWS_LOCAL_EXECUTABLE_EXTENSIONS = [".exe", ".cmd", ".bat"] as const;
+
+function resolveLocalCommand(basePath: string): string | null {
+	if (fs.existsSync(basePath)) return basePath;
+	if (process.platform !== "win32") return null;
+
+	// Package managers write Windows launchers with executable suffixes in node_modules/.bin.
+	for (const extension of WINDOWS_LOCAL_EXECUTABLE_EXTENSIONS) {
+		const candidate = `${basePath}${extension}`;
+		if (fs.existsSync(candidate)) return candidate;
+	}
+
+	return null;
+}
+
 /**
  * Resolve a command to an executable path.
  * Checks project-local bin directories first, then falls back to $PATH.
@@ -210,14 +225,15 @@ export function resolveCommand(command: string, cwd: string): string | null {
 	for (const { markers, binDir } of LOCAL_BIN_PATHS) {
 		if (hasRootMarkers(cwd, markers)) {
 			const localPath = path.join(cwd, binDir, command);
-			if (fs.existsSync(localPath)) {
-				return localPath;
+			const resolvedLocalPath = resolveLocalCommand(localPath);
+			if (resolvedLocalPath) {
+				return resolvedLocalPath;
 			}
 		}
 	}
 
 	// Fall back to $PATH
-	return Bun.which(command);
+	return $which(command);
 }
 
 /**