@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.12

package/src/internal-urls/issue-pr-protocol.ts

@@ -71,17 +71,24 @@ function parseListOptions(url: InternalUrl, scheme: Scheme, repo: string | undef
 	const stateRaw = url.searchParams.get("state");
 	const allowedStates: ParsedList["state"][] =
 		scheme === "pr" ? ["open", "closed", "merged", "all"] : ["open", "closed", "all"];
-	const state = (
-		stateRaw && (allowedStates as string[]).includes(stateRaw) ? stateRaw : "open"
-	) as ParsedList["state"];
+	if (stateRaw !== null && !(allowedStates as string[]).includes(stateRaw)) {
+		// Reject instead of silently falling back to "open": a typo'd state
+		// would otherwise return the open list, indistinguishable from "no
+		// matches for the requested state".
+		throw new Error(`Invalid ${scheme}:// list state '${stateRaw}'. Expected one of: ${allowedStates.join(", ")}.`);
+	}
+	const state = (stateRaw ?? "open") as ParsedList["state"];
 
 	const limitRaw = url.searchParams.get("limit");
 	let limit = LIST_LIMIT_DEFAULT;
 	if (limitRaw !== null) {
 		const parsed = parsePositiveDecimalInt(limitRaw);
-		if (parsed !== undefined) {
-			limit = Math.min(parsed, LIST_LIMIT_MAX);
+		if (parsed === undefined) {
+			throw new Error(
+				`Invalid ${scheme}:// list limit '${limitRaw}'. Expected a positive integer (max ${LIST_LIMIT_MAX}).`,
+			);
 		}
+		limit = Math.min(parsed, LIST_LIMIT_MAX);
 	}
 	return {
 		kind: "list",

package/src/internal-urls/router.ts

@@ -1,5 +1,5 @@
 /**
- * Internal URL router for internal protocols (agent://, artifact://, memory://, skill://, rule://, mcp://, omp://, local://).
+ * Internal URL router for internal protocols (`agent://`, `artifact://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`).
  *
  * One process-global router with one handler per scheme. Access via
  * `InternalUrlRouter.instance()`. Handlers are stateless; per-session and

package/src/internal-urls/types.ts

@@ -1,7 +1,7 @@
 /**
  * Types for the internal URL routing system.
  *
- * Internal URLs (agent://, artifact://, memory://, skill://, rule://, mcp://, omp://, local://) are resolved by tools like read,
+ * Internal URLs (`agent://`, `artifact://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 

package/src/lib/xai-http.ts

@@ -1,6 +1,6 @@
 // Ported from NousResearch/hermes-agent (MIT) — tools/xai_http.py.
 
-import { getBundledModels } from "@oh-my-pi/pi-ai";
+import { getBundledModels } from "@oh-my-pi/pi-catalog/models";
 import { $env } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 

package/src/lsp/client.ts

@@ -22,6 +22,10 @@ const clients = new Map<string, LspClient>();
 const clientLocks = new Map<string, Promise<LspClient>>();
 const fileOperationLocks = new Map<string, Promise<void>>();
 
+/** Negative cache of recent init failures so a broken server fails fast instead of re-spawning per call. */
+const INIT_FAILURE_BACKOFF_MS = 3 * 60 * 1000;
+const initFailures = new Map<string, { at: number; message: string }>();
+
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
 let idleCheckInterval: NodeJS.Timeout | null = null;
@@ -295,7 +299,18 @@ async function startMessageReader(client: LspClient): Promise<void> {
 
 				const headerText = MESSAGE_DECODER.decode(copyChunkRange(pendingChunks, 0, headerEnd));
 				const contentLengthMatch = headerText.match(/Content-Length: (\d+)/i);
-				if (!contentLengthMatch) break;
+				if (!contentLengthMatch) {
+					// Non-protocol bytes on stdout (e.g. a wrapper script printing).
+					// Drop past the bogus terminator and resync instead of stalling
+					// on the same junk header forever.
+					logger.warn("LSP framing resync: header block without Content-Length", {
+						server: client.name,
+						header: headerText.slice(0, 200),
+					});
+					dropChunkFront(pendingChunks, headerEnd + 4);
+					pendingLen -= headerEnd + 4;
+					continue;
+				}
 
 				const contentLength = Number.parseInt(contentLengthMatch[1], 10);
 				const messageStart = headerEnd + 4; // Skip \r\n\r\n
@@ -303,44 +318,54 @@ async function startMessageReader(client: LspClient): Promise<void> {
 				if (pendingLen < messageEnd) break;
 
 				const messageText = MESSAGE_DECODER.decode(copyChunkRange(pendingChunks, messageStart, messageEnd));
-				const message: LspJsonRpcResponse | LspJsonRpcNotification = JSON.parse(messageText);
 				dropChunkFront(pendingChunks, messageEnd);
 				pendingLen -= messageEnd;
 
-				// Route message
-				if ("id" in message && message.id !== undefined) {
-					// Response to a request
-					const pending = client.pendingRequests.get(message.id);
-					if (pending) {
-						client.pendingRequests.delete(message.id);
-						if ("error" in message && message.error) {
-							pending.reject(new Error(`LSP error: ${message.error.message}`));
-						} else {
-							pending.resolve(message.result);
+				// A malformed message or a throwing server-request handler must not
+				// kill the reader — later messages are still well-framed.
+				try {
+					const message: LspJsonRpcResponse | LspJsonRpcNotification = JSON.parse(messageText);
+
+					// Route message
+					if ("id" in message && message.id !== undefined) {
+						// Response to a request
+						const pending = client.pendingRequests.get(message.id);
+						if (pending) {
+							client.pendingRequests.delete(message.id);
+							if ("error" in message && message.error) {
+								pending.reject(new Error(`LSP error: ${message.error.message}`));
+							} else {
+								pending.resolve(message.result);
+							}
+						} else if ("method" in message) {
+							await handleServerRequest(client, message as LspJsonRpcRequest);
 						}
 					} else if ("method" in message) {
-						await handleServerRequest(client, message as LspJsonRpcRequest);
-					}
-				} else if ("method" in message) {
-					// Server notification
-					if (message.method === "textDocument/publishDiagnostics" && message.params) {
-						const params = message.params as PublishDiagnosticsParams;
-						client.diagnostics.set(params.uri, {
-							diagnostics: params.diagnostics,
-							version: params.version ?? null,
-						});
-						client.diagnosticsVersion += 1;
-					} else if (message.method === "$/progress" && message.params) {
-						const params = message.params as { token: string | number; value?: { kind?: string } };
-						if (params.value?.kind === "begin") {
-							client.activeProgressTokens.add(params.token);
-						} else if (params.value?.kind === "end") {
-							client.activeProgressTokens.delete(params.token);
-							if (client.activeProgressTokens.size === 0) {
-								client.resolveProjectLoaded();
+						// Server notification
+						if (message.method === "textDocument/publishDiagnostics" && message.params) {
+							const params = message.params as PublishDiagnosticsParams;
+							client.diagnostics.set(params.uri, {
+								diagnostics: params.diagnostics,
+								version: params.version ?? null,
+							});
+							client.diagnosticsVersion += 1;
+						} else if (message.method === "$/progress" && message.params) {
+							const params = message.params as { token: string | number; value?: { kind?: string } };
+							if (params.value?.kind === "begin") {
+								client.activeProgressTokens.add(params.token);
+							} else if (params.value?.kind === "end") {
+								client.activeProgressTokens.delete(params.token);
+								if (client.activeProgressTokens.size === 0) {
+									client.resolveProjectLoaded();
+								}
 							}
 						}
 					}
+				} catch (err) {
+					logger.warn("LSP message handling failed", {
+						server: client.name,
+						error: err instanceof Error ? err.message : String(err),
+					});
 				}
 			}
 		}
@@ -360,6 +385,22 @@ async function startMessageReader(client: LspClient): Promise<void> {
 					: Buffer.concat(pendingChunks, pendingLen);
 		reader.releaseLock();
 		client.isReading = false;
+		// Reader exited while the server process is still alive (unrecoverable
+		// read error or bad stream state): nothing will route responses anymore,
+		// so tear the client down — the next call respawns instead of timing out.
+		if (client.proc.exitCode === null) {
+			client.status = "error";
+			if (clients.get(client.name) === client) {
+				clients.delete(client.name);
+			}
+			const teardownErr = new Error("LSP reader stopped; client torn down");
+			for (const pending of client.pendingRequests.values()) {
+				pending.reject(teardownErr);
+			}
+			client.pendingRequests.clear();
+			client.resolveProjectLoaded();
+			client.proc.kill();
+		}
 	}
 }
 
@@ -565,6 +606,16 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 		return existingLock;
 	}
 
+	// Fail fast on a recent deterministic init failure instead of re-spawning
+	// a broken server (and paying its full init wait) on every call.
+	const recentFailure = initFailures.get(key);
+	if (recentFailure) {
+		if (Date.now() - recentFailure.at < INIT_FAILURE_BACKOFF_MS) {
+			throw new Error(`LSP server ${config.command} failed to initialize recently: ${recentFailure.message}`);
+		}
+		initFailures.delete(key);
+	}
+
 	// Create new client with lock
 	const clientPromise = (async () => {
 		const baseCommand = config.resolvedCommand ?? config.command;
@@ -605,18 +656,18 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			pendingRequests: new Map(),
 			messageBuffer: new Uint8Array(0),
 			isReading: false,
+			status: "connecting",
 			lastActivity: Date.now(),
 			writeQueue: Promise.resolve(),
 			activeProgressTokens: new Set(),
 			projectLoaded,
 			resolveProjectLoaded,
 		};
-		clients.set(key, client);
 
 		// Register crash recovery - remove client on process exit
 		proc.exited.then(() => {
-			clients.delete(key);
-			clientLocks.delete(key);
+			if (clients.get(key) === client) clients.delete(key);
+			if (clientLocks.get(key) === clientPromise) clientLocks.delete(key);
 			client.resolveProjectLoaded();
 
 			// Reject any pending requests — the server is gone, they will never complete.
@@ -669,12 +720,26 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			// Send initialized notification
 			await sendNotification(client, "initialized", {});
 
+			client.status = "ready";
+			// Publish only after init succeeds: pre-init clients are reachable
+			// solely through clientLocks, so concurrent callers (warmup vs first
+			// tool call) wait for init instead of using an unacknowledged client.
+			clients.set(key, client);
+			initFailures.delete(key);
 			return client;
 		} catch (err) {
 			// Clean up on initialization failure
-			clients.delete(key);
-			clientLocks.delete(key);
+			client.status = "error";
+			if (clients.get(key) === client) clients.delete(key);
 			proc.kill();
+			const message = err instanceof Error ? err.message : String(err);
+			// Negative-cache deterministic failures. Timeouts under a
+			// caller-shortened deadline (warmup/writethrough) are not cached —
+			// the server may simply be slow and a later call with the full
+			// deadline can still succeed.
+			if (!(initTimeoutMs !== undefined && message.includes("timed out"))) {
+				initFailures.set(key, { at: Date.now(), message });
+			}
 			throw err;
 		} finally {
 			clientLocks.delete(key);
@@ -1067,7 +1132,22 @@ export async function sendNotification(client: LspClient, method: string, params
 export async function shutdownAll(): Promise<void> {
 	const clientsToShutdown = Array.from(clients.values());
 	clients.clear();
-	await Promise.allSettled(clientsToShutdown.map(client => shutdownClientInstance(client)));
+	// Mid-initialize clients live only in clientLocks (publication is deferred
+	// until init succeeds) — without this, their server processes outlive
+	// shutdown. Failed init promises already cleaned up after themselves.
+	const pendingClients = Array.from(clientLocks.values());
+	clientLocks.clear();
+	const seen = new Set<LspClient>(clientsToShutdown);
+	await Promise.allSettled([
+		...clientsToShutdown.map(client => shutdownClientInstance(client)),
+		...pendingClients.map(pending =>
+			pending.then(client => {
+				if (seen.has(client)) return;
+				seen.add(client);
+				return shutdownClientInstance(client);
+			}),
+		),
+	]);
 }
 
 /** Status of an LSP server */
@@ -1084,7 +1164,7 @@ export interface LspServerStatus {
 export function getActiveClients(): LspServerStatus[] {
 	return Array.from(clients.values()).map(client => ({
 		name: client.config.command,
-		status: "ready" as const,
+		status: client.status,
 		fileTypes: client.config.fileTypes,
 	}));
 }

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

@@ -3,6 +3,7 @@
  * Uses Biome's CLI with JSON output instead of LSP (which has stale diagnostics issues).
  */
 import path from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "../../lsp/types";
 
 // =============================================================================
@@ -29,17 +30,23 @@ interface BiomeDiagnostic {
 // =============================================================================
 
 /**
- * Convert byte offset to line:column using source code.
+ * Convert byte offsets to line:column positions in a single pass over the source.
  */
-function offsetToPosition(source: string, offset: number): { line: number; column: number } {
+function offsetsToPositions(source: string, offsets: number[]): Map<number, { line: number; column: number }> {
+	const sorted = [...new Set(offsets)].sort((a, b) => a - b);
+	const result = new Map<number, { line: number; column: number }>();
 	let line = 1;
 	let column = 1;
 	let byteIndex = 0;
+	let next = 0;
 
 	for (const ch of source) {
-		const byteLen = Buffer.byteLength(ch);
-		if (byteIndex + byteLen > offset) {
-			break;
+		if (next >= sorted.length) break;
+		const cp = ch.codePointAt(0) as number;
+		const byteLen = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
+		while (next < sorted.length && byteIndex + byteLen > sorted[next]) {
+			result.set(sorted[next], { line, column });
+			next++;
 		}
 		if (ch === "\n") {
 			line++;
@@ -50,7 +57,13 @@ function offsetToPosition(source: string, offset: number): { line: number; colum
 		byteIndex += byteLen;
 	}
 
-	return { line, column };
+	// Offsets at or past end-of-file map to the final position.
+	while (next < sorted.length) {
+		result.set(sorted[next], { line, column });
+		next++;
+	}
+
+	return result;
 }
 
 /**
@@ -98,6 +111,16 @@ async function runBiome(
 	}
 }
 
+// Surface broken-binary / CLI failures once instead of silently reporting
+// "no diagnostics" forever (and instead of spamming every writethrough).
+const reportedBiomeFailures = new Set<string>();
+
+function warnBiomeOnce(key: string, message: string, meta: Record<string, unknown>): void {
+	if (reportedBiomeFailures.has(key)) return;
+	reportedBiomeFailures.add(key);
+	logger.warn(message, meta);
+}
+
 // =============================================================================
 // Biome Client
 // =============================================================================
@@ -137,6 +160,16 @@ export class BiomeClient implements LinterClient {
 		// Run biome lint with JSON reporter
 		const result = await runBiome(["lint", "--reporter=json", filePath], this.cwd, this.config.resolvedCommand);
 
+		// Biome exits non-zero when diagnostics are found, so only an empty
+		// stdout signals an actual run failure (missing binary, CLI error).
+		if (!result.success && result.stdout.trim().length === 0) {
+			warnBiomeOnce(`run:${this.cwd}`, "Biome lint failed; reporting no diagnostics", {
+				cwd: this.cwd,
+				stderr: result.stderr.slice(0, 500),
+			});
+			return [];
+		}
+
 		return this.#parseJsonOutput(result.stdout, filePath);
 	}
 
@@ -146,51 +179,80 @@ export class BiomeClient implements LinterClient {
 	#parseJsonOutput(jsonOutput: string, targetFile: string): Diagnostic[] {
 		const diagnostics: Diagnostic[] = [];
 
+		let parsed: BiomeJsonOutput;
 		try {
-			const parsed: BiomeJsonOutput = JSON.parse(jsonOutput);
+			parsed = JSON.parse(jsonOutput);
+		} catch {
+			warnBiomeOnce(`parse:${this.cwd}`, "Failed to parse Biome JSON output; reporting no diagnostics", {
+				cwd: this.cwd,
+				file: targetFile,
+			});
+			return diagnostics;
+		}
 
-			for (const diag of parsed.diagnostics) {
-				const location = diag.location;
-				if (!location?.path?.file) continue;
+		const target = path.resolve(targetFile);
+		const relevant: BiomeDiagnostic[] = [];
+		// Batch all span offsets per source text so each source is scanned once
+		// instead of twice per diagnostic.
+		const offsetsBySource = new Map<string, number[]>();
+		for (const diag of parsed.diagnostics ?? []) {
+			const location = diag.location;
+			if (!location?.path?.file) continue;
 
-				// Resolve file path
-				const diagFile = path.isAbsolute(location.path.file)
-					? location.path.file
-					: path.join(this.cwd, location.path.file);
+			// Resolve file path
+			const diagFile = path.isAbsolute(location.path.file)
+				? location.path.file
+				: path.join(this.cwd, location.path.file);
 
-				// Only include diagnostics for the target file
-				if (path.resolve(diagFile) !== path.resolve(targetFile)) {
-					continue;
-				}
+			// Only include diagnostics for the target file
+			if (path.resolve(diagFile) !== target) {
+				continue;
+			}
+
+			relevant.push(diag);
+			if (location.span && location.sourceCode) {
+				const offsets = offsetsBySource.get(location.sourceCode);
+				if (offsets) offsets.push(location.span[0], location.span[1]);
+				else offsetsBySource.set(location.sourceCode, [location.span[0], location.span[1]]);
+			}
+		}
+
+		const positionsBySource = new Map<string, Map<number, { line: number; column: number }>>();
+		for (const [source, offsets] of offsetsBySource) {
+			positionsBySource.set(source, offsetsToPositions(source, offsets));
+		}
 
-				// Convert byte offset to line:column
-				let startLine = 1;
-				let startColumn = 1;
-				let endLine = 1;
-				let endColumn = 1;
+		for (const diag of relevant) {
+			const location = diag.location;
+			let startLine = 1;
+			let startColumn = 1;
+			let endLine = 1;
+			let endColumn = 1;
 
-				if (location.span && location.sourceCode) {
-					const startPos = offsetToPosition(location.sourceCode, location.span[0]);
-					const endPos = offsetToPosition(location.sourceCode, location.span[1]);
+			if (location?.span && location.sourceCode) {
+				const positions = positionsBySource.get(location.sourceCode);
+				const startPos = positions?.get(location.span[0]);
+				const endPos = positions?.get(location.span[1]);
+				if (startPos) {
 					startLine = startPos.line;
 					startColumn = startPos.column;
+				}
+				if (endPos) {
 					endLine = endPos.line;
 					endColumn = endPos.column;
 				}
-
-				diagnostics.push({
-					range: {
-						start: { line: startLine - 1, character: startColumn - 1 },
-						end: { line: endLine - 1, character: endColumn - 1 },
-					},
-					severity: parseSeverity(diag.severity),
-					message: diag.description,
-					source: "biome",
-					code: diag.category,
-				});
 			}
-		} catch {
-			// JSON parse failed, return empty
+
+			diagnostics.push({
+				range: {
+					start: { line: startLine - 1, character: startColumn - 1 },
+					end: { line: endLine - 1, character: endColumn - 1 },
+				},
+				severity: parseSeverity(diag.severity),
+				message: diag.description,
+				source: "biome",
+				code: diag.category,
+			});
 		}
 
 		return diagnostics;