@oh-my-pi/pi-coding-agent 0.1.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);
+}