@oh-my-pi/pi-coding-agent 3.13.1337 → 3.15.0

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

@@ -0,0 +1,207 @@
+/**
+ * Biome CLI-based linter client.
+ * Uses Biome's CLI with JSON output instead of LSP (which has stale diagnostics issues).
+ */
+
+import path from "node:path";
+import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "../types";
+
+// =============================================================================
+// Biome JSON Output Types
+// =============================================================================
+
+interface BiomeJsonOutput {
+	diagnostics: BiomeDiagnostic[];
+}
+
+interface BiomeDiagnostic {
+	category: string; // e.g., "lint/correctness/noUnusedVariables"
+	severity: "error" | "warning" | "info" | "hint";
+	description: string;
+	location?: {
+		path?: { file: string };
+		span?: [number, number]; // [startOffset, endOffset] in bytes
+		sourceCode?: string;
+	};
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/**
+ * Convert byte offset to line:column using source code.
+ */
+function offsetToPosition(source: string, offset: number): { line: number; column: number } {
+	let line = 1;
+	let column = 1;
+	let byteIndex = 0;
+
+	for (const ch of source) {
+		const byteLen = Buffer.byteLength(ch);
+		if (byteIndex + byteLen > offset) {
+			break;
+		}
+		if (ch === "\n") {
+			line++;
+			column = 1;
+		} else {
+			column++;
+		}
+		byteIndex += byteLen;
+	}
+
+	return { line, column };
+}
+
+/**
+ * Parse Biome severity to LSP DiagnosticSeverity.
+ */
+function parseSeverity(severity: string): DiagnosticSeverity {
+	switch (severity) {
+		case "error":
+			return 1;
+		case "warning":
+			return 2;
+		case "info":
+			return 3;
+		case "hint":
+			return 4;
+		default:
+			return 2;
+	}
+}
+
+/**
+ * Run a Biome CLI command.
+ */
+async function runBiome(
+	args: string[],
+	cwd: string,
+	resolvedCommand?: string,
+): Promise<{ stdout: string; stderr: string; success: boolean }> {
+	const command = resolvedCommand ?? "biome";
+
+	try {
+		const proc = Bun.spawn([command, ...args], {
+			cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+
+		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+		const exitCode = await proc.exited;
+
+		return { stdout, stderr, success: exitCode === 0 };
+	} catch (err) {
+		return { stdout: "", stderr: String(err), success: false };
+	}
+}
+
+// =============================================================================
+// Biome Client
+// =============================================================================
+
+/**
+ * Biome CLI-based linter client.
+ * Parses Biome's --reporter=json output into LSP Diagnostic format.
+ */
+export class BiomeClient implements LinterClient {
+	private config: ServerConfig;
+	private cwd: string;
+
+	constructor(config: ServerConfig, cwd: string) {
+		this.config = config;
+		this.cwd = cwd;
+	}
+
+	async format(filePath: string, content: string): Promise<string> {
+		// Write content to file first
+		await Bun.write(filePath, content);
+
+		// Run biome format --write
+		const result = await runBiome(["format", "--write", filePath], this.cwd, this.config.resolvedCommand);
+
+		if (result.success) {
+			// Read back formatted content
+			return await Bun.file(filePath).text();
+		}
+
+		// Format failed, return original
+		return content;
+	}
+
+	async lint(filePath: string): Promise<Diagnostic[]> {
+		// Run biome lint with JSON reporter
+		const result = await runBiome(["lint", "--reporter=json", filePath], this.cwd, this.config.resolvedCommand);
+
+		return this.parseJsonOutput(result.stdout, filePath);
+	}
+
+	/**
+	 * Parse Biome's JSON output into LSP Diagnostics.
+	 */
+	private parseJsonOutput(jsonOutput: string, targetFile: string): Diagnostic[] {
+		const diagnostics: Diagnostic[] = [];
+
+		try {
+			const parsed: BiomeJsonOutput = JSON.parse(jsonOutput);
+
+			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);
+
+				// Only include diagnostics for the target file
+				if (path.resolve(diagFile) !== path.resolve(targetFile)) {
+					continue;
+				}
+
+				// Convert byte offset to line:column
+				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]);
+					startLine = startPos.line;
+					startColumn = startPos.column;
+					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
+		}
+
+		return diagnostics;
+	}
+
+	dispose(): void {
+		// Nothing to dispose for CLI client
+	}
+}
+
+/**
+ * Factory function to create a Biome client.
+ */
+export function createBiomeClient(config: ServerConfig, cwd: string): LinterClient {
+	return new BiomeClient(config, cwd);
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Linter client implementations.
+ *
+ * The LinterClient interface provides a common API for formatters and linters.
+ * Different implementations can use LSP protocol, CLI tools, or other mechanisms.
+ */
+
+export { BiomeClient, createBiomeClient } from "./biome-client";
+export { createLspLinterClient, LspLinterClient } from "./lsp-linter-client";
+
+import type { LinterClient, ServerConfig } from "../types";
+import { createLspLinterClient } from "./lsp-linter-client";
+
+// Cache of linter clients by server name + cwd
+const clientCache = new Map<string, LinterClient>();
+
+/**
+ * Get or create a linter client for a server configuration.
+ * Uses the server's custom factory if provided, otherwise falls back to LSP.
+ */
+export function getLinterClient(serverName: string, config: ServerConfig, cwd: string): LinterClient {
+	const key = `${serverName}:${cwd}`;
+
+	let client = clientCache.get(key);
+	if (client) {
+		return client;
+	}
+
+	// Use custom factory if provided
+	if (config.createClient) {
+		client = config.createClient(config, cwd);
+	} else {
+		// Default to LSP
+		client = createLspLinterClient(config, cwd);
+	}
+
+	clientCache.set(key, client);
+	return client;
+}
+
+/**
+ * Clear all cached linter clients.
+ */
+export function clearLinterClientCache(): void {
+	for (const client of clientCache.values()) {
+		client.dispose?.();
+	}
+	clientCache.clear();
+}

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

@@ -0,0 +1,98 @@
+/**
+ * LSP-based linter client.
+ * Uses the Language Server Protocol for formatting and diagnostics.
+ */
+
+import { getOrCreateClient, notifySaved, sendRequest, syncContent } from "../client";
+import { applyTextEditsToString } from "../edits";
+import type { Diagnostic, LinterClient, LspClient, ServerConfig, TextEdit } from "../types";
+import { fileToUri } from "../utils";
+
+/** Default formatting options for LSP */
+const DEFAULT_FORMAT_OPTIONS = {
+	tabSize: 3,
+	insertSpaces: true,
+	trimTrailingWhitespace: true,
+	insertFinalNewline: true,
+	trimFinalNewlines: true,
+};
+
+/**
+ * LSP-based linter client implementation.
+ * Wraps the existing LSP client infrastructure.
+ */
+export class LspLinterClient implements LinterClient {
+	private config: ServerConfig;
+	private cwd: string;
+	private client: LspClient | null = null;
+
+	constructor(config: ServerConfig, cwd: string) {
+		this.config = config;
+		this.cwd = cwd;
+	}
+
+	private async getClient(): Promise<LspClient> {
+		if (!this.client) {
+			this.client = await getOrCreateClient(this.config, this.cwd);
+		}
+		return this.client;
+	}
+
+	async format(filePath: string, content: string): Promise<string> {
+		const client = await this.getClient();
+		const uri = fileToUri(filePath);
+
+		// Sync content to LSP
+		await syncContent(client, filePath, content);
+
+		// Check if server supports formatting
+		const caps = client.serverCapabilities;
+		if (!caps?.documentFormattingProvider) {
+			return content;
+		}
+
+		// Request formatting
+		const edits = (await sendRequest(client, "textDocument/formatting", {
+			textDocument: { uri },
+			options: DEFAULT_FORMAT_OPTIONS,
+		})) as TextEdit[] | null;
+
+		if (!edits || edits.length === 0) {
+			return content;
+		}
+
+		return applyTextEditsToString(content, edits);
+	}
+
+	async lint(filePath: string): Promise<Diagnostic[]> {
+		const client = await this.getClient();
+		const uri = fileToUri(filePath);
+
+		// Notify that file was saved to trigger diagnostics
+		await notifySaved(client, filePath);
+
+		// Wait for diagnostics with timeout
+		const timeoutMs = 3000;
+		const start = Date.now();
+		while (Date.now() - start < timeoutMs) {
+			const diagnostics = client.diagnostics.get(uri);
+			if (diagnostics !== undefined) {
+				return diagnostics;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+
+		return client.diagnostics.get(uri) ?? [];
+	}
+
+	dispose(): void {
+		// Client lifecycle is managed globally, nothing to dispose here
+	}
+}
+
+/**
+ * Factory function to create an LSP linter client.
+ */
+export function createLspLinterClient(config: ServerConfig, cwd: string): LinterClient {
+	return new LspLinterClient(config, cwd);
+}

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

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { extname, join } from "node:path";
 import { getConfigDirPaths } from "../../../config.js";
+import { createBiomeClient } from "./clients/biome-client";
 import type { ServerConfig } from "./types";
 
 export interface LspConfig {
@@ -110,6 +111,8 @@ export const SERVERS: Record<string, ServerConfig> = {
 		fileTypes: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".jsonc"],
 		rootMarkers: ["biome.json", "biome.jsonc"],
 		isLinter: true,
+		// Use CLI instead of LSP - Biome's LSP has known stale diagnostics issues
+		createClient: createBiomeClient,
 	},
 
 	eslint: {

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

@@ -2,7 +2,8 @@ import * as fs from "node:fs";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { BunFile } from "bun";
-import type { Theme } from "../../../modes/interactive/theme/theme";
+import { type Theme, theme } from "../../../modes/interactive/theme/theme";
+import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
 import { logger } from "../../logger";
 import { once, untilAborted } from "../../utils";
 import { resolveToCwd } from "../path-utils";
@@ -17,7 +18,8 @@ import {
 	setIdleTimeout,
 	syncContent,
 } from "./client";
-import { getServerForFile, getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
+import { getLinterClient } from "./clients";
+import { getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
 import { applyTextEditsToString, applyWorkspaceEdit } from "./edits";
 import { renderCall, renderResult } from "./render";
 import * as rustAnalyzer from "./rust-analyzer";
@@ -79,10 +81,11 @@ export async function warmupLspServers(cwd: string): Promise<LspWarmupResult> {
 	const config = loadConfig(cwd);
 	setIdleTimeout(config.idleTimeoutMs);
 	const servers: LspWarmupResult["servers"] = [];
+	const lspServers = getLspServers(config);
 
 	// Start all detected servers in parallel
 	const results = await Promise.allSettled(
-		Object.entries(config.servers).map(async ([name, serverConfig]) => {
+		lspServers.map(async ([name, serverConfig]) => {
 			const client = await getOrCreateClient(serverConfig, cwd);
 			return { name, client, fileTypes: serverConfig.fileTypes };
 		}),
@@ -134,6 +137,9 @@ async function syncFileContent(
 ): Promise<void> {
 	await Promise.allSettled(
 		servers.map(async ([_serverName, serverConfig]) => {
+			if (serverConfig.createClient) {
+				return;
+			}
 			const client = await getOrCreateClient(serverConfig, cwd);
 			await syncContent(client, absolutePath, content);
 		}),
@@ -155,6 +161,9 @@ async function notifyFileSaved(
 ): Promise<void> {
 	await Promise.allSettled(
 		servers.map(async ([_serverName, serverConfig]) => {
+			if (serverConfig.createClient) {
+				return;
+			}
 			const client = await getOrCreateClient(serverConfig, cwd);
 			await notifySaved(client, absolutePath);
 		}),
@@ -174,6 +183,41 @@ function getConfig(cwd: string): LspConfig {
 	return config;
 }
 
+function isCustomLinter(serverConfig: ServerConfig): boolean {
+	return Boolean(serverConfig.createClient);
+}
+
+function splitServers(servers: Array<[string, ServerConfig]>): {
+	lspServers: Array<[string, ServerConfig]>;
+	customLinterServers: Array<[string, ServerConfig]>;
+} {
+	const lspServers: Array<[string, ServerConfig]> = [];
+	const customLinterServers: Array<[string, ServerConfig]> = [];
+	for (const entry of servers) {
+		if (isCustomLinter(entry[1])) {
+			customLinterServers.push(entry);
+		} else {
+			lspServers.push(entry);
+		}
+	}
+	return { lspServers, customLinterServers };
+}
+
+function getLspServers(config: LspConfig): Array<[string, ServerConfig]> {
+	return (Object.entries(config.servers) as Array<[string, ServerConfig]>).filter(
+		([, serverConfig]) => !isCustomLinter(serverConfig),
+	);
+}
+
+function getLspServersForFile(config: LspConfig, filePath: string): Array<[string, ServerConfig]> {
+	return getServersForFile(config, filePath).filter(([, serverConfig]) => !isCustomLinter(serverConfig));
+}
+
+function getLspServerForFile(config: LspConfig, filePath: string): [string, ServerConfig] | null {
+	const servers = getLspServersForFile(config, filePath);
+	return servers.length > 0 ? servers[0] : null;
+}
+
 const FILE_SEARCH_MAX_DEPTH = 5;
 const IGNORED_DIRS = new Set(["node_modules", "target", "dist", "build", ".git"]);
 
@@ -214,7 +258,7 @@ function findFileForServer(cwd: string, serverConfig: ServerConfig): string | nu
 }
 
 function getRustServer(config: LspConfig): [string, ServerConfig] | null {
-	const entries = Object.entries(config.servers) as Array<[string, ServerConfig]>;
+	const entries = getLspServers(config);
 	const byName = entries.find(([name, server]) => name === "rust-analyzer" || server.command === "rust-analyzer");
 	if (byName) return byName;
 
@@ -234,7 +278,7 @@ function getRustServer(config: LspConfig): [string, ServerConfig] | null {
 }
 
 function getServerForWorkspaceAction(config: LspConfig, action: string): [string, ServerConfig] | null {
-	const entries = Object.entries(config.servers) as Array<[string, ServerConfig]>;
+	const entries = getLspServers(config);
 	if (entries.length === 0) return null;
 
 	if (action === "workspace_symbols") {
@@ -379,8 +423,7 @@ export interface FileDiagnosticsResult {
 }
 
 /**
- * Get LSP diagnostics for a file.
- * Assumes content was synced and didSave was sent - just waits for diagnostics.
+ * Get diagnostics for a file using LSP or custom linter client.
  *
  * @param absolutePath - Absolute path to the file
  * @param cwd - Working directory for LSP config resolution
@@ -404,6 +447,14 @@ async function getDiagnosticsForFile(
 	// Wait for diagnostics from all servers in parallel
 	const results = await Promise.allSettled(
 		servers.map(async ([serverName, serverConfig]) => {
+			// Use custom linter client if configured
+			if (serverConfig.createClient) {
+				const linterClient = getLinterClient(serverName, serverConfig, cwd);
+				const diagnostics = await linterClient.lint(absolutePath);
+				return { serverName, diagnostics };
+			}
+
+			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
 			// Content already synced + didSave sent, just wait for diagnostics
 			const diagnostics = await waitForDiagnostics(client, uri);
@@ -469,9 +520,7 @@ const DEFAULT_FORMAT_OPTIONS = {
 };
 
 /**
- * Format content in-memory using LSP.
- * Assumes content was already synced to all servers via syncFileContent.
- * Requests formatting from first capable server, applies edits in-memory.
+ * Format content using LSP or custom linter client.
  *
  * @param absolutePath - Absolute path (for URI)
  * @param content - Content to format
@@ -491,8 +540,15 @@ async function formatContent(
 
 	const uri = fileToUri(absolutePath);
 
-	for (const [_serverName, serverConfig] of servers) {
+	for (const [serverName, serverConfig] of servers) {
 		try {
+			// Use custom linter client if configured
+			if (serverConfig.createClient) {
+				const linterClient = getLinterClient(serverName, serverConfig, cwd);
+				return await linterClient.format(absolutePath, content);
+			}
+
+			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
 
 			const caps = client.serverCapabilities;
@@ -561,36 +617,48 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 		if (servers.length === 0) {
 			return writethroughNoop(dst, content, signal, file);
 		}
+		const { lspServers, customLinterServers } = splitServers(servers);
 
 		let finalContent = content;
-		const getWritePromise = once(() => (file ? file.write(finalContent) : Bun.write(dst, finalContent)));
+		const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
+		const getWritePromise = once(() => writeContent(finalContent));
+		const useCustomFormatter = enableFormat && customLinterServers.length > 0;
 
 		let formatter: FileFormatResult | undefined;
 		let diagnostics: FileDiagnosticsResult | undefined;
 		try {
 			signal ??= AbortSignal.timeout(10_000);
 			await untilAborted(signal, async () => {
-				// 1. Sync original content to ALL servers
-				await syncFileContent(dst, content, cwd, servers);
-
-				// 2. Format in-memory (servers already have content)
-				if (enableFormat) {
-					finalContent = await formatContent(dst, content, cwd, servers);
+				if (useCustomFormatter) {
+					// Custom linters (e.g. Biome CLI) require on-disk input.
+					await writeContent(content);
+					finalContent = await formatContent(dst, content, cwd, customLinterServers);
 					formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
-				}
+					await writeContent(finalContent);
+					await syncFileContent(dst, finalContent, cwd, lspServers);
+				} else {
+					// 1. Sync original content to LSP servers
+					await syncFileContent(dst, content, cwd, lspServers);
+
+					// 2. Format in-memory via LSP
+					if (enableFormat) {
+						finalContent = await formatContent(dst, content, cwd, lspServers);
+						formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
+					}
 
-				// 3. If formatted, sync formatted content to ALL servers
-				if (finalContent !== content) {
-					await syncFileContent(dst, finalContent, cwd, servers);
-				}
+					// 3. If formatted, sync formatted content to LSP servers
+					if (finalContent !== content) {
+						await syncFileContent(dst, finalContent, cwd, lspServers);
+					}
 
-				// 4. Write to disk
-				await getWritePromise();
+					// 4. Write to disk
+					await getWritePromise();
+				}
 
-				// 5. Notify saved to ALL servers
-				await notifyFileSaved(dst, cwd, servers);
+				// 5. Notify saved to LSP servers
+				await notifyFileSaved(dst, cwd, lspServers);
 
-				// 6. Get diagnostics from ALL servers
+				// 6. Get diagnostics from all servers
 				if (enableDiagnostics) {
 					diagnostics = await getDiagnosticsForFile(dst, cwd, servers);
 				}
@@ -618,29 +686,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 	return {
 		name: "lsp",
 		label: "LSP",
-		description: `Interact with Language Server Protocol (LSP) servers to get code intelligence features.
-
-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
-- symbols: List symbols in a file (functions, classes, etc.)
-- workspace_symbols: Search for symbols across the project
-- rename: Rename a symbol across the codebase
-- actions: List and apply code actions (quick fixes, refactors)
-- incoming_calls: Find all callers of a function
-- outgoing_calls: Find all functions called by a function
-- status: Show active language servers
-
-Rust-analyzer specific (require rust-analyzer):
-- flycheck: Run clippy/cargo check
-- expand_macro: Show macro expansion at cursor
-- ssr: Structural search-replace
-- runnables: Find runnable tests/binaries
-- related_tests: Find tests for a function
-- reload_workspace: Reload Cargo.toml changes`,
+		description: lspDescription,
 		parameters: lspSchema,
 		renderCall,
 		renderResult,
@@ -709,7 +755,7 @@ Rust-analyzer specific (require rust-analyzer):
 					const resolved = resolveToCwd(target, cwd);
 					const servers = getServersForFile(config, resolved);
 					if (servers.length === 0) {
-						results.push(`✗ ${target}: No language server found`);
+						results.push(`${theme.status.error} ${target}: No language server found`);
 						continue;
 					}
 
@@ -721,6 +767,12 @@ Rust-analyzer specific (require rust-analyzer):
 					for (const [serverName, serverConfig] of servers) {
 						allServerNames.add(serverName);
 						try {
+							if (serverConfig.createClient) {
+								const linterClient = getLinterClient(serverName, serverConfig, cwd);
+								const diagnostics = await linterClient.lint(resolved);
+								allDiagnostics.push(...diagnostics);
+								continue;
+							}
 							const client = await getOrCreateClient(serverConfig, cwd);
 							await refreshFile(client, resolved);
 							const diagnostics = await waitForDiagnostics(client, uri);
@@ -759,10 +811,10 @@ Rust-analyzer specific (require rust-analyzer):
 					}
 
 					if (uniqueDiagnostics.length === 0) {
-						results.push(`✓ ${relPath}: no issues`);
+						results.push(`${theme.status.success} ${relPath}: no issues`);
 					} else {
 						const summary = formatDiagnosticsSummary(uniqueDiagnostics);
-						results.push(`✗ ${relPath}: ${summary}`);
+						results.push(`${theme.status.error} ${relPath}: ${summary}`);
 						for (const diag of uniqueDiagnostics) {
 							results.push(`  ${formatDiagnostic(diag, relPath)}`);
 						}
@@ -792,7 +844,7 @@ Rust-analyzer specific (require rust-analyzer):
 
 			const resolvedFile = file ? resolveToCwd(file, cwd) : null;
 			const serverInfo = resolvedFile
-				? getServerForFile(config, resolvedFile)
+				? getLspServerForFile(config, resolvedFile)
 				: getServerForWorkspaceAction(config, action);
 
 			if (!serverInfo) {