@oh-my-pi/pi-coding-agent 1.341.0 → 2.1.1337

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

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import { applyWorkspaceEdit } from "./edits.js";
+import { applyWorkspaceEdit } from "./edits";
 import type {
 	Diagnostic,
 	LspClient,
@@ -8,14 +8,16 @@ import type {
 	LspJsonRpcResponse,
 	ServerConfig,
 	WorkspaceEdit,
-} from "./types.js";
-import { detectLanguageId, fileToUri } from "./utils.js";
+} from "./types";
+import { detectLanguageId, fileToUri } from "./utils";
 
 // =============================================================================
 // Client State
 // =============================================================================
 
 const clients = new Map<string, LspClient>();
+const clientLocks = new Map<string, Promise<LspClient>>();
+const fileOperationLocks = new Map<string, Promise<void>>();
 
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
@@ -233,13 +235,17 @@ async function startMessageReader(client: LspClient): Promise<void> {
 			const { done, value } = await reader.read();
 			if (done) break;
 
-			client.messageBuffer = concatBuffers(client.messageBuffer, value);
+			// Atomically update buffer before processing
+			const currentBuffer = concatBuffers(client.messageBuffer, value);
+			client.messageBuffer = currentBuffer;
 
 			// Process all complete messages in buffer
-			let parsed = parseMessage(client.messageBuffer);
+			// Use local variable to avoid race with concurrent buffer updates
+			let workingBuffer = currentBuffer;
+			let parsed = parseMessage(workingBuffer);
 			while (parsed) {
 				const { message, remaining } = parsed;
-				client.messageBuffer = remaining;
+				workingBuffer = remaining;
 
 				// Route message
 				if ("id" in message && message.id !== undefined) {
@@ -263,8 +269,11 @@ async function startMessageReader(client: LspClient): Promise<void> {
 					}
 				}
 
-				parsed = parseMessage(client.messageBuffer);
+				parsed = parseMessage(workingBuffer);
 			}
+
+			// Atomically commit processed buffer
+			client.messageBuffer = workingBuffer;
 		}
 	} catch (err) {
 		// Connection closed or error - reject all pending requests
@@ -368,71 +377,88 @@ async function sendResponse(
 export async function getOrCreateClient(config: ServerConfig, cwd: string): Promise<LspClient> {
 	const key = `${config.command}:${cwd}`;
 
-	if (clients.has(key)) {
-		const client = clients.get(key)!;
-		client.lastActivity = Date.now();
-		return client;
+	// Check if client already exists
+	const existingClient = clients.get(key);
+	if (existingClient) {
+		existingClient.lastActivity = Date.now();
+		return existingClient;
 	}
 
-	const args = config.args ?? [];
-	const command = config.resolvedCommand ?? config.command;
-	const proc = Bun.spawn([command, ...args], {
-		cwd,
-		stdin: "pipe",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
+	// Check if another coroutine is already creating this client
+	const existingLock = clientLocks.get(key);
+	if (existingLock) {
+		return existingLock;
+	}
 
-	const client: LspClient = {
-		name: key,
-		cwd,
-		process: proc,
-		config,
-		requestId: 0,
-		diagnostics: new Map(),
-		openFiles: new Map(),
-		pendingRequests: new Map(),
-		messageBuffer: new Uint8Array(0),
-		isReading: false,
-		lastActivity: Date.now(),
-	};
-	clients.set(key, client);
+	// Create new client with lock
+	const clientPromise = (async () => {
+		const args = config.args ?? [];
+		const command = config.resolvedCommand ?? config.command;
+		const proc = Bun.spawn([command, ...args], {
+			cwd,
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
 
-	// Register crash recovery - remove client on process exit
-	proc.exited.then(() => {
-		clients.delete(key);
-	});
+		const client: LspClient = {
+			name: key,
+			cwd,
+			process: proc,
+			config,
+			requestId: 0,
+			diagnostics: new Map(),
+			openFiles: new Map(),
+			pendingRequests: new Map(),
+			messageBuffer: new Uint8Array(0),
+			isReading: false,
+			lastActivity: Date.now(),
+		};
+		clients.set(key, client);
+
+		// Register crash recovery - remove client on process exit
+		proc.exited.then(() => {
+			clients.delete(key);
+			clientLocks.delete(key);
+		});
 
-	// Start background message reader
-	startMessageReader(client);
+		// Start background message reader
+		startMessageReader(client);
+
+		try {
+			// Send initialize request
+			const initResult = (await sendRequest(client, "initialize", {
+				processId: process.pid,
+				rootUri: fileToUri(cwd),
+				rootPath: cwd,
+				capabilities: CLIENT_CAPABILITIES,
+				initializationOptions: config.initOptions ?? {},
+				workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
+			})) as { capabilities?: unknown };
+
+			if (!initResult) {
+				throw new Error("Failed to initialize LSP: no response");
+			}
 
-	try {
-		// Send initialize request
-		const initResult = (await sendRequest(client, "initialize", {
-			processId: process.pid,
-			rootUri: fileToUri(cwd),
-			rootPath: cwd,
-			capabilities: CLIENT_CAPABILITIES,
-			initializationOptions: config.initOptions ?? {},
-			workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
-		})) as { capabilities?: unknown };
-
-		if (!initResult) {
-			throw new Error("Failed to initialize LSP: no response");
-		}
+			client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
 
-		client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
+			// Send initialized notification
+			await sendNotification(client, "initialized", {});
 
-		// Send initialized notification
-		await sendNotification(client, "initialized", {});
+			return client;
+		} catch (err) {
+			// Clean up on initialization failure
+			clients.delete(key);
+			clientLocks.delete(key);
+			proc.kill();
+			throw err;
+		} finally {
+			clientLocks.delete(key);
+		}
+	})();
 
-		return client;
-	} catch (err) {
-		// Clean up on initialization failure
-		clients.delete(key);
-		proc.kill();
-		throw err;
-	}
+	clientLocks.set(key, clientPromise);
+	return clientPromise;
 }
 
 /**
@@ -441,24 +467,49 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string): Prom
  */
 export async function ensureFileOpen(client: LspClient, filePath: string): Promise<void> {
 	const uri = fileToUri(filePath);
+	const lockKey = `${client.name}:${uri}`;
+
+	// Check if file is already open
 	if (client.openFiles.has(uri)) {
 		return;
 	}
 
-	const content = fs.readFileSync(filePath, "utf-8");
-	const languageId = detectLanguageId(filePath);
+	// Check if another operation is already opening this file
+	const existingLock = fileOperationLocks.get(lockKey);
+	if (existingLock) {
+		await existingLock;
+		return;
+	}
 
-	await sendNotification(client, "textDocument/didOpen", {
-		textDocument: {
-			uri,
-			languageId,
-			version: 1,
-			text: content,
-		},
-	});
+	// Lock and open file
+	const openPromise = (async () => {
+		// Double-check after acquiring lock
+		if (client.openFiles.has(uri)) {
+			return;
+		}
 
-	client.openFiles.set(uri, { version: 1, languageId });
-	client.lastActivity = Date.now();
+		const content = fs.readFileSync(filePath, "utf-8");
+		const languageId = detectLanguageId(filePath);
+
+		await sendNotification(client, "textDocument/didOpen", {
+			textDocument: {
+				uri,
+				languageId,
+				version: 1,
+				text: content,
+			},
+		});
+
+		client.openFiles.set(uri, { version: 1, languageId });
+		client.lastActivity = Date.now();
+	})();
+
+	fileOperationLocks.set(lockKey, openPromise);
+	try {
+		await openPromise;
+	} finally {
+		fileOperationLocks.delete(lockKey);
+	}
 }
 
 /**
@@ -467,27 +518,45 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
  */
 export async function refreshFile(client: LspClient, filePath: string): Promise<void> {
 	const uri = fileToUri(filePath);
-	const info = client.openFiles.get(uri);
+	const lockKey = `${client.name}:${uri}`;
 
-	if (!info) {
-		await ensureFileOpen(client, filePath);
-		return;
+	// Check if another operation is in progress
+	const existingLock = fileOperationLocks.get(lockKey);
+	if (existingLock) {
+		await existingLock;
 	}
 
-	const content = fs.readFileSync(filePath, "utf-8");
-	info.version++;
+	// Lock and refresh file
+	const refreshPromise = (async () => {
+		const info = client.openFiles.get(uri);
 
-	await sendNotification(client, "textDocument/didChange", {
-		textDocument: { uri, version: info.version },
-		contentChanges: [{ text: content }],
-	});
+		if (!info) {
+			await ensureFileOpen(client, filePath);
+			return;
+		}
 
-	await sendNotification(client, "textDocument/didSave", {
-		textDocument: { uri },
-		text: content,
-	});
+		const content = fs.readFileSync(filePath, "utf-8");
+		const version = ++info.version;
 
-	client.lastActivity = Date.now();
+		await sendNotification(client, "textDocument/didChange", {
+			textDocument: { uri, version },
+			contentChanges: [{ text: content }],
+		});
+
+		await sendNotification(client, "textDocument/didSave", {
+			textDocument: { uri },
+			text: content,
+		});
+
+		client.lastActivity = Date.now();
+	})();
+
+	fileOperationLocks.set(lockKey, refreshPromise);
+	try {
+		await refreshPromise;
+	} finally {
+		fileOperationLocks.delete(lockKey);
+	}
 }
 
 /**
@@ -519,7 +588,9 @@ export function shutdownClient(key: string): void {
  * Send an LSP request and wait for response.
  */
 export async function sendRequest(client: LspClient, method: string, params: unknown): Promise<unknown> {
+	// Atomically increment and capture request ID
 	const id = ++client.requestId;
+
 	const request: LspJsonRpcRequest = {
 		jsonrpc: "2.0",
 		id,

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { extname, join } from "node:path";
-import type { ServerConfig } from "./types.js";
+import type { ServerConfig } from "./types";
 
 export interface LspConfig {
 	servers: Record<string, ServerConfig>;

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

@@ -1,7 +1,7 @@
 import { mkdir, rename, rm } from "node:fs/promises";
 import path from "node:path";
-import type { CreateFile, DeleteFile, RenameFile, TextDocumentEdit, TextEdit, WorkspaceEdit } from "./types.js";
-import { uriToFile } from "./utils.js";
+import type { CreateFile, DeleteFile, RenameFile, TextDocumentEdit, TextEdit, WorkspaceEdit } from "./types";
+import { uriToFile } from "./utils";
 
 // =============================================================================
 // Text Edit Application

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

@@ -1,8 +1,9 @@
 import * as fs from "node:fs";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { Theme } from "../../../modes/interactive/theme/theme.js";
-import { resolveToCwd } from "../path-utils.js";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+import { logger } from "../../logger";
+import { resolveToCwd } from "../path-utils";
 import {
 	ensureFileOpen,
 	getActiveClients,
@@ -11,11 +12,11 @@ import {
 	refreshFile,
 	sendRequest,
 	setIdleTimeout,
-} from "./client.js";
-import { getServerForFile, getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config.js";
-import { applyTextEdits, applyWorkspaceEdit } from "./edits.js";
-import { renderCall, renderResult } from "./render.js";
-import * as rustAnalyzer from "./rust-analyzer.js";
+} from "./client";
+import { getServerForFile, getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
+import { applyTextEdits, applyWorkspaceEdit } from "./edits";
+import { renderCall, renderResult } from "./render";
+import * as rustAnalyzer from "./rust-analyzer";
 import {
 	type CallHierarchyIncomingCall,
 	type CallHierarchyItem,
@@ -35,7 +36,7 @@ import {
 	type SymbolInformation,
 	type TextEdit,
 	type WorkspaceEdit,
-} from "./types.js";
+} from "./types";
 import {
 	extractHoverText,
 	fileToUri,
@@ -48,10 +49,10 @@ import {
 	sleep,
 	symbolKindToIcon,
 	uriToFile,
-} from "./utils.js";
+} from "./utils";
 
-export type { LspServerStatus } from "./client.js";
-export type { LspToolDetails } from "./types.js";
+export type { LspServerStatus } from "./client";
+export type { LspToolDetails } from "./types";
 
 /** Result from warming up LSP servers */
 export interface LspWarmupResult {
@@ -273,7 +274,8 @@ async function runWorkspaceDiagnostics(
 				const formatted = collected.slice(0, 50).map((d) => formatDiagnostic(d.diagnostic, d.filePath));
 				const more = collected.length > 50 ? `\n  ... and ${collected.length - 50} more` : "";
 				return { output: `${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}${more}`, projectType };
-			} catch (e) {
+			} catch (err) {
+				logger.debug("LSP diagnostics failed, falling back to shell", { error: String(err) });
 				// Fall through to shell command
 			}
 		}
@@ -305,7 +307,7 @@ async function runWorkspaceDiagnostics(
 		// 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: `${lines.slice(0, 50).join("\n")}\n... and ${lines.length - 50} more lines`, projectType };
 		}
 
 		return { output: combined, projectType };

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

@@ -11,8 +11,8 @@
 import type { AgentToolResult, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
 import { Text } from "@oh-my-pi/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
-import type { Theme } from "../../../modes/interactive/theme/theme.js";
-import type { LspParams, LspToolDetails } from "./types.js";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+import type { LspParams, LspToolDetails } from "./types";
 
 // =============================================================================
 // Tree Drawing Characters

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

@@ -1,6 +1,6 @@
-import { sendNotification, sendRequest } from "./client.js";
-import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types.js";
-import { fileToUri } from "./utils.js";
+import { sendNotification, sendRequest } from "./client";
+import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types";
+import { fileToUri } from "./utils";
 
 /**
  * Wait for specified milliseconds.

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

@@ -8,7 +8,7 @@ import type {
 	SymbolKind,
 	TextEdit,
 	WorkspaceEdit,
-} from "./types.js";
+} from "./types";
 
 // =============================================================================
 // Language Detection

package/src/core/tools/notebook.ts

@@ -1,6 +1,6 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
-import { resolveToCwd } from "./path-utils.js";
+import { resolveToCwd } from "./path-utils";
 
 const notebookSchema = Type.Object({
 	action: Type.Union([Type.Literal("edit"), Type.Literal("insert"), Type.Literal("delete")], {

package/src/core/tools/output.ts

@@ -0,0 +1,175 @@
+/**
+ * Output tool for reading agent/task outputs by ID.
+ *
+ * Resolves IDs like "reviewer_0" to artifact paths in the current session.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { TextContent } from "@oh-my-pi/pi-ai";
+import { Type } from "@sinclair/typebox";
+import type { SessionContext } from "./index";
+import { getArtifactsDir } from "./task/artifacts";
+
+const outputSchema = Type.Object({
+	ids: Type.Array(Type.String(), {
+		description: "Agent output IDs to read (e.g., ['reviewer_0', 'explore_1'])",
+		minItems: 1,
+	}),
+	format: Type.Optional(
+		Type.Union([Type.Literal("raw"), Type.Literal("json"), Type.Literal("stripped")], {
+			description: "Output format: raw (default), json (structured), stripped (no ANSI)",
+		}),
+	),
+});
+
+/** Metadata for a single output file */
+interface OutputEntry {
+	id: string;
+	path: string;
+	lineCount: number;
+	charCount: number;
+}
+
+export interface OutputToolDetails {
+	outputs: OutputEntry[];
+	notFound?: string[];
+	availableIds?: string[];
+}
+
+/** Strip ANSI escape codes from text */
+function stripAnsi(text: string): string {
+	return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+/** List available output IDs in artifacts directory */
+function listAvailableOutputs(artifactsDir: string): string[] {
+	try {
+		const files = fs.readdirSync(artifactsDir);
+		return files.filter((f) => f.endsWith(".out.md")).map((f) => f.replace(".out.md", ""));
+	} catch {
+		return [];
+	}
+}
+
+/** Format byte count for display */
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+}
+
+export function createOutputTool(
+	_cwd: string,
+	sessionContext?: SessionContext,
+): AgentTool<typeof outputSchema, OutputToolDetails> {
+	return {
+		name: "output",
+		label: "Output",
+		description: `Read full agent/task output by ID.
+
+Use when the Task tool's truncated preview isn't sufficient for your needs.
+The Task tool already returns summaries with line/char counts in its result.
+
+Parameters:
+- ids: Array of output IDs (e.g., ["reviewer_0", "explore_1"])
+- format: "raw" (default), "json" (structured object), or "stripped" (no ANSI codes)
+
+Returns the full output content. For unknown IDs, returns an error with available IDs.
+
+Example: { "ids": ["reviewer_0"] }`,
+		parameters: outputSchema,
+		execute: async (
+			_toolCallId: string,
+			params: { ids: string[]; format?: "raw" | "json" | "stripped" },
+		): Promise<{ content: TextContent[]; details: OutputToolDetails }> => {
+			const sessionFile = sessionContext?.getSessionFile();
+
+			if (!sessionFile) {
+				return {
+					content: [{ type: "text", text: "No session - output artifacts unavailable" }],
+					details: { outputs: [], notFound: params.ids },
+				};
+			}
+
+			const artifactsDir = getArtifactsDir(sessionFile);
+			if (!artifactsDir || !fs.existsSync(artifactsDir)) {
+				return {
+					content: [{ type: "text", text: "No artifacts directory found" }],
+					details: { outputs: [], notFound: params.ids },
+				};
+			}
+
+			const outputs: OutputEntry[] = [];
+			const notFound: string[] = [];
+			const format = params.format ?? "raw";
+
+			for (const id of params.ids) {
+				const outputPath = path.join(artifactsDir, `${id}.out.md`);
+
+				if (!fs.existsSync(outputPath)) {
+					notFound.push(id);
+					continue;
+				}
+
+				const content = fs.readFileSync(outputPath, "utf-8");
+				outputs.push({
+					id,
+					path: outputPath,
+					lineCount: content.split("\n").length,
+					charCount: content.length,
+				});
+			}
+
+			// Error case: some IDs not found
+			if (notFound.length > 0) {
+				const available = listAvailableOutputs(artifactsDir);
+				const errorMsg =
+					available.length > 0
+						? `Not found: ${notFound.join(", ")}\nAvailable: ${available.join(", ")}`
+						: `Not found: ${notFound.join(", ")}\nNo outputs available in current session`;
+
+				return {
+					content: [{ type: "text", text: errorMsg }],
+					details: { outputs, notFound, availableIds: available },
+				};
+			}
+
+			// Success: build response based on format
+			let contentText: string;
+
+			if (format === "json") {
+				const jsonData = outputs.map((o) => ({
+					id: o.id,
+					lineCount: o.lineCount,
+					charCount: o.charCount,
+					content: fs.readFileSync(o.path, "utf-8"),
+				}));
+				contentText = JSON.stringify(jsonData, null, 2);
+			} else {
+				// raw or stripped
+				const parts = outputs.map((o) => {
+					let content = fs.readFileSync(o.path, "utf-8");
+					if (format === "stripped") {
+						content = stripAnsi(content);
+					}
+					// Add header for multiple outputs
+					if (outputs.length > 1) {
+						return `=== ${o.id} (${o.lineCount} lines, ${formatBytes(o.charCount)}) ===\n${content}`;
+					}
+					return content;
+				});
+				contentText = parts.join("\n\n");
+			}
+
+			return {
+				content: [{ type: "text", text: contentText }],
+				details: { outputs },
+			};
+		},
+	};
+}
+
+/** Default output tool using process.cwd() - for backwards compatibility */
+export const outputTool = createOutputTool(process.cwd());

package/src/core/tools/read.ts

@@ -1,13 +1,13 @@
+import { spawnSync } from "node:child_process";
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { extname } from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
-import { spawnSync } from "child_process";
-import { constants } from "fs";
-import { access, readFile } from "fs/promises";
-import { extname } from "path";
-import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
-import { resolveReadPath } from "./path-utils.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
+import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime";
+import { resolveReadPath } from "./path-utils";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 // Document types convertible via markitdown
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);