@oh-my-pi/pi-coding-agent 1.340.0 → 2.0.1337

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,13 +1,22 @@
 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 { ensureFileOpen, getOrCreateClient, refreshFile, sendRequest } from "./client.js";
-import { getServerForFile, hasCapability, type LspConfig, loadConfig } from "./config.js";
-import { applyWorkspaceEdit } from "./edits.js";
-import { renderCall, renderResult } from "./render.js";
-import * as rustAnalyzer from "./rust-analyzer.js";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+import { logger } from "../../logger";
+import { resolveToCwd } from "../path-utils";
+import {
+	ensureFileOpen,
+	getActiveClients,
+	getOrCreateClient,
+	type LspServerStatus,
+	refreshFile,
+	sendRequest,
+	setIdleTimeout,
+} 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,
@@ -25,8 +34,9 @@ import {
 	lspSchema,
 	type ServerConfig,
 	type SymbolInformation,
+	type TextEdit,
 	type WorkspaceEdit,
-} from "./types.js";
+} from "./types";
 import {
 	extractHoverText,
 	fileToUri,
@@ -39,9 +49,69 @@ import {
 	sleep,
 	symbolKindToIcon,
 	uriToFile,
-} from "./utils.js";
+} from "./utils";
+
+export type { LspServerStatus } from "./client";
+export type { LspToolDetails } from "./types";
+
+/** Result from warming up LSP servers */
+export interface LspWarmupResult {
+	servers: Array<{
+		name: string;
+		status: "ready" | "error";
+		fileTypes: string[];
+		error?: string;
+	}>;
+}
+
+/**
+ * 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
+ * @returns Status of each server that was started
+ */
+export async function warmupLspServers(cwd: string): Promise<LspWarmupResult> {
+	const config = loadConfig(cwd);
+	setIdleTimeout(config.idleTimeoutMs);
+	const servers: LspWarmupResult["servers"] = [];
+
+	// Start all detected servers in parallel
+	const results = await Promise.allSettled(
+		Object.entries(config.servers).map(async ([name, serverConfig]) => {
+			const client = await getOrCreateClient(serverConfig, cwd);
+			return { name, client, fileTypes: serverConfig.fileTypes };
+		}),
+	);
+
+	for (const result of results) {
+		if (result.status === "fulfilled") {
+			servers.push({
+				name: result.value.name,
+				status: "ready",
+				fileTypes: result.value.fileTypes,
+			});
+		} else {
+			// Extract server name from error if possible
+			const errorMsg = result.reason?.message ?? String(result.reason);
+			servers.push({
+				name: "unknown",
+				status: "error",
+				fileTypes: [],
+				error: errorMsg,
+			});
+		}
+	}
+
+	return { servers };
+}
 
-export type { LspToolDetails } from "./types.js";
+/**
+ * Get status of currently active LSP servers.
+ */
+export function getLspStatus(): LspServerStatus[] {
+	return getActiveClients();
+}
 
 // Cache config per cwd to avoid repeated file I/O
 const configCache = new Map<string, LspConfig>();
@@ -50,6 +120,7 @@ function getConfig(cwd: string): LspConfig {
 	let config = configCache.get(cwd);
 	if (!config) {
 		config = loadConfig(cwd);
+		setIdleTimeout(config.idleTimeoutMs);
 		configCache.set(cwd, config);
 	}
 	return config;
@@ -139,6 +210,304 @@ async function waitForDiagnostics(client: LspClient, uri: string, timeoutMs = 30
 	return client.diagnostics.get(uri) ?? [];
 }
 
+/** Project type detection result */
+interface ProjectType {
+	type: "rust" | "typescript" | "go" | "python" | "unknown";
+	command?: string[];
+	description: string;
+}
+
+/** Detect project type from root markers */
+function detectProjectType(cwd: string): ProjectType {
+	// Check for Rust (Cargo.toml)
+	if (fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+		return { type: "rust", command: ["cargo", "check", "--message-format=short"], description: "Rust (cargo check)" };
+	}
+
+	// Check for TypeScript (tsconfig.json)
+	if (fs.existsSync(path.join(cwd, "tsconfig.json"))) {
+		return { type: "typescript", command: ["npx", "tsc", "--noEmit"], description: "TypeScript (tsc --noEmit)" };
+	}
+
+	// Check for Go (go.mod)
+	if (fs.existsSync(path.join(cwd, "go.mod"))) {
+		return { type: "go", command: ["go", "build", "./..."], description: "Go (go build)" };
+	}
+
+	// Check for Python (pyproject.toml or pyrightconfig.json)
+	if (fs.existsSync(path.join(cwd, "pyproject.toml")) || fs.existsSync(path.join(cwd, "pyrightconfig.json"))) {
+		return { type: "python", command: ["pyright"], description: "Python (pyright)" };
+	}
+
+	return { type: "unknown", description: "Unknown project type" };
+}
+
+/** Run workspace diagnostics command and parse output */
+async function runWorkspaceDiagnostics(
+	cwd: string,
+	config: LspConfig,
+): Promise<{ output: string; projectType: ProjectType }> {
+	const projectType = detectProjectType(cwd);
+
+	// For Rust, use flycheck via rust-analyzer if available
+	if (projectType.type === "rust") {
+		const rustServer = getRustServer(config);
+		if (rustServer && hasCapability(rustServer[1], "flycheck")) {
+			const [_serverName, serverConfig] = rustServer;
+			try {
+				const client = await getOrCreateClient(serverConfig, cwd);
+				await rustAnalyzer.flycheck(client);
+
+				const collected: Array<{ filePath: string; diagnostic: Diagnostic }> = [];
+				for (const [diagUri, diags] of client.diagnostics.entries()) {
+					const relPath = path.relative(cwd, uriToFile(diagUri));
+					for (const diag of diags) {
+						collected.push({ filePath: relPath, diagnostic: diag });
+					}
+				}
+
+				if (collected.length === 0) {
+					return { output: "No issues found", projectType };
+				}
+
+				const summary = formatDiagnosticsSummary(collected.map((d) => d.diagnostic));
+				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 (err) {
+				logger.debug("LSP diagnostics failed, falling back to shell", { error: String(err) });
+				// Fall through to shell command
+			}
+		}
+	}
+
+	// Fall back to shell command
+	if (!projectType.command) {
+		return {
+			output: `Cannot detect project type. Supported: Rust (Cargo.toml), TypeScript (tsconfig.json), Go (go.mod), Python (pyproject.toml)`,
+			projectType,
+		};
+	}
+
+	try {
+		const proc = Bun.spawn(projectType.command, {
+			cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+
+		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+		await proc.exited;
+
+		const combined = (stdout + stderr).trim();
+		if (!combined) {
+			return { output: "No issues found", projectType };
+		}
+
+		// 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: combined, projectType };
+	} catch (e) {
+		return { output: `Failed to run ${projectType.command.join(" ")}: ${e}`, projectType };
+	}
+}
+
+/** Result from getDiagnosticsForFile */
+export interface FileDiagnosticsResult {
+	/** Whether an LSP server was available for the file type */
+	available: boolean;
+	/** Name of the LSP server used (if available) */
+	serverName?: string;
+	/** Formatted diagnostic messages */
+	diagnostics: string[];
+	/** Summary string (e.g., "2 error(s), 1 warning(s)") */
+	summary: string;
+	/** Whether there are any errors (severity 1) */
+	hasErrors: boolean;
+	/** Whether there are any warnings (severity 2) */
+	hasWarnings: boolean;
+}
+
+/**
+ * Get LSP diagnostics for a file after it has been written.
+ * Queries all applicable language servers (e.g., TypeScript + Biome) and merges results.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param cwd - Working directory for LSP config resolution
+ * @param timeoutMs - Timeout for waiting for diagnostics (default: 5000ms)
+ * @returns Diagnostic results or null if no LSP server available
+ */
+export async function getDiagnosticsForFile(
+	absolutePath: string,
+	cwd: string,
+	timeoutMs = 5000,
+): Promise<FileDiagnosticsResult> {
+	const config = getConfig(cwd);
+	const servers = getServersForFile(config, absolutePath);
+
+	if (servers.length === 0) {
+		return {
+			available: false,
+			diagnostics: [],
+			summary: "",
+			hasErrors: false,
+			hasWarnings: false,
+		};
+	}
+
+	const uri = fileToUri(absolutePath);
+	const relPath = path.relative(cwd, absolutePath);
+	const allDiagnostics: Diagnostic[] = [];
+	const serverNames: string[] = [];
+
+	// Query all applicable servers in parallel
+	const results = await Promise.allSettled(
+		servers.map(async ([serverName, serverConfig]) => {
+			const client = await getOrCreateClient(serverConfig, cwd);
+			await refreshFile(client, absolutePath);
+			const diagnostics = await waitForDiagnostics(client, uri, timeoutMs);
+			return { serverName, diagnostics };
+		}),
+	);
+
+	for (const result of results) {
+		if (result.status === "fulfilled") {
+			serverNames.push(result.value.serverName);
+			allDiagnostics.push(...result.value.diagnostics);
+		}
+	}
+
+	if (serverNames.length === 0) {
+		// All servers failed
+		return {
+			available: false,
+			diagnostics: [],
+			summary: "",
+			hasErrors: false,
+			hasWarnings: false,
+		};
+	}
+
+	if (allDiagnostics.length === 0) {
+		return {
+			available: true,
+			serverName: serverNames.join(", "),
+			diagnostics: [],
+			summary: "No issues",
+			hasErrors: false,
+			hasWarnings: false,
+		};
+	}
+
+	// Deduplicate diagnostics by range + message (different servers might report similar issues)
+	const seen = new Set<string>();
+	const uniqueDiagnostics: Diagnostic[] = [];
+	for (const d of allDiagnostics) {
+		const key = `${d.range.start.line}:${d.range.start.character}:${d.range.end.line}:${d.range.end.character}:${d.message}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			uniqueDiagnostics.push(d);
+		}
+	}
+
+	const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
+	const summary = formatDiagnosticsSummary(uniqueDiagnostics);
+	const hasErrors = uniqueDiagnostics.some((d) => d.severity === 1);
+	const hasWarnings = uniqueDiagnostics.some((d) => d.severity === 2);
+
+	return {
+		available: true,
+		serverName: serverNames.join(", "),
+		diagnostics: formatted,
+		summary,
+		hasErrors,
+		hasWarnings,
+	};
+}
+
+/** Result from formatFile */
+export interface FileFormatResult {
+	/** Whether an LSP server with formatting support was available */
+	available: boolean;
+	/** Name of the LSP server used (if available) */
+	serverName?: string;
+	/** Whether formatting was applied */
+	formatted: boolean;
+	/** Error message if formatting failed */
+	error?: string;
+}
+
+/** Default formatting options for LSP */
+const DEFAULT_FORMAT_OPTIONS = {
+	tabSize: 3,
+	insertSpaces: true,
+	trimTrailingWhitespace: true,
+	insertFinalNewline: true,
+	trimFinalNewlines: true,
+};
+
+/**
+ * Format a file using LSP.
+ * Uses the first available server that supports formatting.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param cwd - Working directory for LSP config resolution
+ * @returns Format result indicating success/failure
+ */
+export async function formatFile(absolutePath: string, cwd: string): Promise<FileFormatResult> {
+	const config = getConfig(cwd);
+	const servers = getServersForFile(config, absolutePath);
+
+	if (servers.length === 0) {
+		return { available: false, formatted: false };
+	}
+
+	const uri = fileToUri(absolutePath);
+
+	// Try each server until one successfully formats
+	for (const [serverName, serverConfig] of servers) {
+		try {
+			const client = await getOrCreateClient(serverConfig, cwd);
+
+			// Check if server supports formatting
+			const caps = client.serverCapabilities;
+			if (!caps?.documentFormattingProvider) {
+				continue;
+			}
+
+			// Ensure file is open and synced
+			await ensureFileOpen(client, absolutePath);
+			await refreshFile(client, absolutePath);
+
+			// Request formatting
+			const edits = (await sendRequest(client, "textDocument/formatting", {
+				textDocument: { uri },
+				options: DEFAULT_FORMAT_OPTIONS,
+			})) as TextEdit[] | null;
+
+			if (!edits || edits.length === 0) {
+				// No changes needed - file already formatted
+				return { available: true, serverName, formatted: false };
+			}
+
+			// Apply the formatting edits
+			await applyTextEdits(absolutePath, edits);
+
+			// Notify LSP of the change so diagnostics update
+			await refreshFile(client, absolutePath);
+
+			return { available: true, serverName, formatted: true };
+		} catch {}
+	}
+
+	// No server could format
+	return { available: false, formatted: false };
+}
+
 export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolDetails, Theme> {
 	return {
 		name: "lsp",
@@ -147,6 +516,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 
 Standard operations:
 - diagnostics: Get errors/warnings for a file
+- workspace_diagnostics: Check entire project for errors (uses tsc, cargo check, go build, etc.)
 - definition: Go to symbol definition
 - references: Find all references to a symbol
 - hover: Get type info and documentation
@@ -201,7 +571,21 @@ Rust-analyzer specific (require rust-analyzer):
 				};
 			}
 
-			// Diagnostics can be batch or single-file
+			// Workspace diagnostics - check entire project
+			if (action === "workspace_diagnostics") {
+				const result = await runWorkspaceDiagnostics(cwd, config);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Workspace diagnostics (${result.projectType.description}):\n${result.output}`,
+						},
+					],
+					details: { action, success: true },
+				};
+			}
+
+			// Diagnostics can be batch or single-file - queries all applicable servers
 			if (action === "diagnostics") {
 				const targets = files?.length ? files : file ? [file] : null;
 				if (!targets) {
@@ -213,49 +597,67 @@ Rust-analyzer specific (require rust-analyzer):
 
 				const detailed = Boolean(files?.length);
 				const results: string[] = [];
-				let lastServerName: string | undefined;
+				const allServerNames = new Set<string>();
 
 				for (const target of targets) {
 					const resolved = resolveToCwd(target, cwd);
-					const serverInfo = getServerForFile(config, resolved);
-					if (!serverInfo) {
+					const servers = getServersForFile(config, resolved);
+					if (servers.length === 0) {
 						results.push(`✗ ${target}: No language server found`);
 						continue;
 					}
 
-					const [serverName, serverConfig] = serverInfo;
-					lastServerName = serverName;
-
-					const client = await getOrCreateClient(serverConfig, cwd);
-					await refreshFile(client, resolved);
-
 					const uri = fileToUri(resolved);
-					const diagnostics = await waitForDiagnostics(client, uri);
 					const relPath = path.relative(cwd, resolved);
+					const allDiagnostics: Diagnostic[] = [];
+
+					// Query all applicable servers for this file
+					for (const [serverName, serverConfig] of servers) {
+						allServerNames.add(serverName);
+						try {
+							const client = await getOrCreateClient(serverConfig, cwd);
+							await refreshFile(client, resolved);
+							const diagnostics = await waitForDiagnostics(client, uri);
+							allDiagnostics.push(...diagnostics);
+						} catch {
+							// Server failed, continue with others
+						}
+					}
+
+					// Deduplicate diagnostics
+					const seen = new Set<string>();
+					const uniqueDiagnostics: Diagnostic[] = [];
+					for (const d of allDiagnostics) {
+						const key = `${d.range.start.line}:${d.range.start.character}:${d.range.end.line}:${d.range.end.character}:${d.message}`;
+						if (!seen.has(key)) {
+							seen.add(key);
+							uniqueDiagnostics.push(d);
+						}
+					}
 
 					if (!detailed && targets.length === 1) {
-						if (diagnostics.length === 0) {
+						if (uniqueDiagnostics.length === 0) {
 							return {
 								content: [{ type: "text", text: "No diagnostics" }],
-								details: { action, serverName, success: true },
+								details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 							};
 						}
 
-						const summary = formatDiagnosticsSummary(diagnostics);
-						const formatted = diagnostics.map((d) => formatDiagnostic(d, relPath));
+						const summary = formatDiagnosticsSummary(uniqueDiagnostics);
+						const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
 						const output = `${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}`;
 						return {
 							content: [{ type: "text", text: output }],
-							details: { action, serverName, success: true },
+							details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 						};
 					}
 
-					if (diagnostics.length === 0) {
+					if (uniqueDiagnostics.length === 0) {
 						results.push(`✓ ${relPath}: no issues`);
 					} else {
-						const summary = formatDiagnosticsSummary(diagnostics);
+						const summary = formatDiagnosticsSummary(uniqueDiagnostics);
 						results.push(`✗ ${relPath}: ${summary}`);
-						for (const diag of diagnostics) {
+						for (const diag of uniqueDiagnostics) {
 							results.push(`  ${formatDiagnostic(diag, relPath)}`);
 						}
 					}
@@ -263,7 +665,7 @@ Rust-analyzer specific (require rust-analyzer):
 
 				return {
 					content: [{ type: "text", text: results.join("\n") }],
-					details: { action, serverName: lastServerName, success: true },
+					details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 				};
 			}
 

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/types.ts

@@ -10,6 +10,7 @@ export const lspSchema = Type.Object({
 		[
 			// Standard LSP operations
 			Type.Literal("diagnostics"),
+			Type.Literal("workspace_diagnostics"),
 			Type.Literal("references"),
 			Type.Literal("definition"),
 			Type.Literal("hover"),
@@ -336,6 +337,10 @@ export interface ServerConfig {
 	settings?: Record<string, unknown>;
 	disabled?: boolean;
 	capabilities?: ServerCapabilities;
+	/** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
+	isLinter?: boolean;
+	/** Resolved absolute path to the command binary (set during config loading) */
+	resolvedCommand?: string;
 }
 
 // =============================================================================

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")], {