pi-lens 3.2.0 → 3.3.1

package/clients/lsp/client.ts

@@ -8,6 +8,7 @@
  * - Request/response handling
  */
 
+import { EventEmitter } from "node:events";
 import { pathToFileURL } from "node:url";
 import type { MessageConnection } from "vscode-jsonrpc";
 import {
@@ -15,7 +16,7 @@ import {
 	StreamMessageReader,
 	StreamMessageWriter,
 } from "vscode-jsonrpc/node.js";
-import { DiagnosticFound } from "../bus/events.js";
+
 import type { LSPProcess } from "./launch.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
 
@@ -104,7 +105,7 @@ export interface LSPClientInfo {
 
 // --- Constants ---
 
-const DIAGNOSTICS_DEBOUNCE_MS = 150;
+const DIAGNOSTICS_DEBOUNCE_MS = 150; // ms — waits for follow-up semantic diagnostics
 const INITIALIZE_TIMEOUT_MS = 120_000; // 2 minutes (was 45s) - allows time for npx to download packages
 
 // --- Client Factory ---
@@ -127,6 +128,12 @@ export async function createLSPClient(options: {
 	const diagnostics = new Map<string, LSPDiagnostic[]>();
 	const pendingDiagnostics = new Map<string, ReturnType<typeof setTimeout>>();
 
+	// Local event emitter — signals waitForDiagnostics when new diagnostics arrive.
+	// Scoped to this client instance; replaces global bus pub/sub.
+	// setMaxListeners guards against Node.js warning for concurrent waitForDiagnostics calls.
+	const diagnosticEmitter = new EventEmitter();
+	diagnosticEmitter.setMaxListeners(50);
+
 	// Handle incoming diagnostics with debouncing
 	connection.onNotification(
 		"textDocument/publishDiagnostics",
@@ -142,31 +149,8 @@ export async function createLSPClient(options: {
 				diagnostics.set(filePath, newDiags);
 				pendingDiagnostics.delete(filePath);
 
-				// Publish to bus
-				// Defensive: filter out malformed diagnostics that may lack range
-				const validDiags = newDiags.filter(
-					(d) => d.range?.start?.line !== undefined,
-				);
-				DiagnosticFound.publish({
-					runnerId: serverId,
-					filePath,
-					diagnostics: validDiags.map((d) => ({
-						id: `${serverId}:${d.code ?? "unknown"}:${d.range.start.line}`,
-						message: d.message,
-						filePath,
-						line: d.range.start.line + 1,
-						column: d.range.start.character + 1,
-						severity: severityFromNumber(d.severity),
-						semantic:
-							d.severity === 1
-								? "blocking"
-								: d.severity === 2
-									? "warning"
-									: "silent",
-						tool: serverId,
-					})),
-					durationMs: 0,
-				});
+				// Signal any active waitForDiagnostics calls for this file.
+				diagnosticEmitter.emit("diagnostics", filePath);
 			}, DIAGNOSTICS_DEBOUNCE_MS);
 
 			pendingDiagnostics.set(filePath, timer);
@@ -301,31 +285,35 @@ export async function createLSPClient(options: {
 
 		async waitForDiagnostics(filePath, timeoutMs = 10000) {
 			const normalizedPath = normalizeMapKey(filePath);
+
+			// Fast path: diagnostics already available
 			if (diagnostics.has(normalizedPath)) return;
 
-			// Use bus subscription like OpenCode - more reliable than polling
-			return new Promise((resolve) => {
+			return new Promise<void>((resolve) => {
 				let debounceTimer: ReturnType<typeof setTimeout> | undefined;
 
-				// Subscribe to diagnostic events from this server
-				const unsub = DiagnosticFound.subscribe((event) => {
-					if (
-						event.properties.filePath === normalizedPath &&
-						event.properties.runnerId === serverId
-					) {
-						// Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
-						if (debounceTimer) clearTimeout(debounceTimer);
-						debounceTimer = setTimeout(() => {
-							unsub();
-							clearTimeout(timeout);
-							resolve();
-						}, DIAGNOSTICS_DEBOUNCE_MS);
-					}
-				});
+				// Listen on the local emitter for this client's diagnostic notifications.
+				// No runnerId filter needed — this emitter is scoped to this client instance.
+				const onDiagnostics = (fp: string) => {
+					if (normalizeMapKey(fp) !== normalizedPath) return;
+
+					// Debounce: reset on each event to catch follow-up semantic diagnostics
+					// (LSP often sends syntax diagnostics first, semantic ones shortly after).
+					if (debounceTimer) clearTimeout(debounceTimer);
+					debounceTimer = setTimeout(() => {
+						diagnosticEmitter.off("diagnostics", onDiagnostics);
+						clearTimeout(timeout);
+						resolve();
+					}, DIAGNOSTICS_DEBOUNCE_MS);
+				};
 
+				diagnosticEmitter.on("diagnostics", onDiagnostics);
+
+				// Timeout fallback: resolve even if no diagnostics arrive
+				// (some files have no errors, or the server may be slow)
 				const timeout = setTimeout(() => {
 					if (debounceTimer) clearTimeout(debounceTimer);
-					unsub();
+					diagnosticEmitter.off("diagnostics", onDiagnostics);
 					resolve();
 				}, timeoutMs);
 			});
@@ -421,6 +409,9 @@ export async function createLSPClient(options: {
 			}
 			pendingDiagnostics.clear();
 
+			// Remove all diagnostic listeners (cancels any in-flight waitForDiagnostics)
+			diagnosticEmitter.removeAllListeners();
+
 			// Graceful shutdown
 			try {
 				await connection.sendRequest("shutdown");

package/clients/lsp/launch.js

@@ -149,8 +149,11 @@ export async function launchLSP(command, args = [], options = {}) {
         if (npmGlobalPath) {
             spawnCommand = npmGlobalPath;
             // Recompute needsShell for npm global path
-            const globalHasExt = /\.(exe|cmd|bat)$/i.test(spawnCommand);
-            needsShell = isWindows && (spawnCommand.includes(" ") || !globalHasExt);
+            needsShell =
+                isWindows &&
+                    (spawnCommand.includes(" ") ||
+                        /\.(cmd|bat)$/i.test(spawnCommand) ||
+                        !/\.(exe|cmd|bat)$/i.test(spawnCommand));
         }
     }
     let proc;
@@ -166,8 +169,10 @@ export async function launchLSP(command, args = [], options = {}) {
             if (npmGlobalPath && npmGlobalPath !== spawnCommand) {
                 console.error(`[lsp] Trying npm global: ${npmGlobalPath}`);
                 // Recompute needsShell for npm global path
-                const globalHasExt = /\.(exe|cmd|bat)$/i.test(npmGlobalPath);
-                const needsShellGlobal = isWindows && (npmGlobalPath.includes(" ") || !globalHasExt);
+                const needsShellGlobal = isWindows &&
+                    (npmGlobalPath.includes(" ") ||
+                        /\.(cmd|bat)$/i.test(npmGlobalPath) ||
+                        !/\.(exe|cmd|bat)$/i.test(npmGlobalPath));
                 proc = trySpawn(npmGlobalPath, args, cwd, env, needsShellGlobal);
             }
             else {
@@ -192,7 +197,7 @@ export async function launchLSP(command, args = [], options = {}) {
         let settled = false;
         // Attach error handler that can reject for immediate errors
         proc.on("error", (err) => {
-            if (!settled && err.code === "ENOENT") {
+            if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
                 settled = true;
                 reject(new Error(`LSP server binary not found: ${command}. ` +
                     `Install it or check your PATH.`));
@@ -254,7 +259,7 @@ export async function launchViaPackageManager(packageName, args = [], options =
         await new Promise((resolve, reject) => {
             let settled = false;
             proc.on("error", (err) => {
-                if (!settled && err.code === "ENOENT") {
+                if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
                     settled = true;
                     reject(new Error(`Package manager not found for: ${packageName}. ` +
                         `Install Node.js or check your PATH.`));

package/clients/lsp/launch.ts

@@ -205,8 +205,11 @@ export async function launchLSP(
 		if (npmGlobalPath) {
 			spawnCommand = npmGlobalPath;
 			// Recompute needsShell for npm global path
-			const globalHasExt = /\.(exe|cmd|bat)$/i.test(spawnCommand);
-			needsShell = isWindows && (spawnCommand.includes(" ") || !globalHasExt);
+			needsShell =
+				isWindows &&
+				(spawnCommand.includes(" ") ||
+					/\.(cmd|bat)$/i.test(spawnCommand) ||
+					!/\.(exe|cmd|bat)$/i.test(spawnCommand));
 		}
 	}
 
@@ -225,9 +228,11 @@ export async function launchLSP(
 			if (npmGlobalPath && npmGlobalPath !== spawnCommand) {
 				console.error(`[lsp] Trying npm global: ${npmGlobalPath}`);
 				// Recompute needsShell for npm global path
-				const globalHasExt = /\.(exe|cmd|bat)$/i.test(npmGlobalPath);
 				const needsShellGlobal =
-					isWindows && (npmGlobalPath.includes(" ") || !globalHasExt);
+					isWindows &&
+					(npmGlobalPath.includes(" ") ||
+						/\.(cmd|bat)$/i.test(npmGlobalPath) ||
+						!/\.(exe|cmd|bat)$/i.test(npmGlobalPath));
 				proc = trySpawn(npmGlobalPath, args, cwd, env, needsShellGlobal);
 			} else {
 				throw err;
@@ -256,7 +261,7 @@ export async function launchLSP(
 
 		// Attach error handler that can reject for immediate errors
 		proc.on("error", (err: Error & { code?: string }) => {
-			if (!settled && err.code === "ENOENT") {
+			if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
 				settled = true;
 				reject(
 					new Error(
@@ -346,7 +351,7 @@ export async function launchViaPackageManager(
 			let settled = false;
 
 			proc.on("error", (err: Error & { code?: string }) => {
-				if (!settled && err.code === "ENOENT") {
+				if (!settled && (err.code === "ENOENT" || err.code === "EINVAL")) {
 					settled = true;
 					reject(
 						new Error(

package/clients/lsp/server.js

@@ -233,7 +233,19 @@ export const GoServer = {
     root: createRootDetector(["go.mod", "go.sum"]),
     async spawn(root) {
         const proc = await spawnWithInteractiveInstall("go", "gopls", [], { cwd: root }, async () => await launchLSP("gopls", [], { cwd: root }));
-        return proc ? { process: proc } : undefined;
+        // gopls works best with minimal initialization options
+        // The client capabilities fix (workspaceFolders: true) is the key fix
+        return proc
+            ? {
+                process: proc,
+                initialization: {
+                    // Disable experimental features that may cause issues
+                    ui: {
+                        semanticTokens: true,
+                    },
+                },
+            }
+            : undefined;
     },
 };
 export const RustServer = {
@@ -243,7 +255,20 @@ export const RustServer = {
     root: createRootDetector(["Cargo.toml", "Cargo.lock"]),
     async spawn(root) {
         const proc = await spawnWithInteractiveInstall("rust", "rust-analyzer", [], { cwd: root }, async () => await launchLSP("rust-analyzer", [], { cwd: root }));
-        return proc ? { process: proc } : undefined;
+        // rust-analyzer needs minimal initialization to avoid capability mismatches
+        return proc
+            ? {
+                process: proc,
+                initialization: {
+                    // Disable features that may conflict with our client capabilities
+                    cargo: {
+                        buildScripts: { enable: true },
+                    },
+                    procMacro: { enable: true },
+                    diagnostics: { enable: true },
+                },
+            }
+            : undefined;
     },
 };
 export const RubyServer = {

package/clients/metrics-client.test.js

@@ -0,0 +1,141 @@
+import * as fs from "node:fs";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { MetricsClient } from "./metrics-client.js";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
+describe("MetricsClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new MetricsClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-metrics-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("calculateEntropy", () => {
+        it("should return 0 for empty string", () => {
+            expect(client.calculateEntropy("")).toBe(0);
+        });
+        it("should return 0 for single repeated character", () => {
+            expect(client.calculateEntropy("aaaaaa")).toBe(0);
+        });
+        it("should return 1 for two equally likely characters", () => {
+            expect(client.calculateEntropy("ababab")).toBe(1);
+        });
+        it("should return higher entropy for more diverse content", () => {
+            const lowEntropy = "aaaaaaaaaaaaaaaaaaaaaaaaaa";
+            const highEntropy = "abcdefghijklmnopqrstuvwxyz";
+            expect(client.calculateEntropy(highEntropy)).toBeGreaterThan(client.calculateEntropy(lowEntropy));
+        });
+        it("should match expected Shannon entropy for known input", () => {
+            // "aabb" has p(a)=0.5, p(b)=0.5, entropy = -2*(0.5*log2(0.5)) = 1
+            expect(client.calculateEntropy("aabb")).toBeCloseTo(1, 5);
+        });
+    });
+    describe("recordBaseline", () => {
+        it("should record baseline for existing file", () => {
+            const content = "const x = 1;\nconst y = 2;";
+            const filePath = createTempFile(tmpDir, "test.ts", content);
+            client.recordBaseline(filePath);
+            const metrics = client.getFileMetrics(filePath);
+            expect(metrics).not.toBeNull();
+            expect(metrics?.totalLines).toBeGreaterThanOrEqual(2);
+        });
+        it("should not record baseline for non-existent file", () => {
+            client.recordBaseline("/nonexistent/file.ts");
+            // Should not throw, just silently skip
+        });
+        it("should not overwrite existing baseline", () => {
+            const content1 = "const x = 1;\n";
+            const content2 = "const x = 1;\nconst y = 2;\nconst z = 3;\n";
+            const filePath = createTempFile(tmpDir, "test.ts", content1);
+            client.recordBaseline(filePath);
+            // Modify file
+            fs.writeFileSync(filePath, content2);
+            // Record again - should not update baseline
+            client.recordBaseline(filePath);
+            const metrics = client.getFileMetrics(filePath);
+            expect(metrics?.entropyStart).toBe(client.calculateEntropy(content1));
+        });
+    });
+    describe("recordWrite", () => {
+        it("should track agent-written lines", () => {
+            const original = "const x = 1;\n";
+            const filePath = createTempFile(tmpDir, "test.ts", original);
+            client.recordBaseline(filePath);
+            const modified = "const x = 1;\nconst y = 2;\nconst z = 3;\n";
+            fs.writeFileSync(filePath, modified);
+            client.recordWrite(filePath, modified);
+            const aiRatio = client.getAICodeRatio();
+            expect(aiRatio.agentLines).toBeGreaterThan(0);
+        });
+        it("should calculate AI code ratio", () => {
+            const file1 = createTempFile(tmpDir, "file1.ts", "original content line 1\noriginal content line 2\n");
+            const file2 = createTempFile(tmpDir, "file2.ts", "original\n");
+            client.recordBaseline(file1);
+            client.recordBaseline(file2);
+            // Simulate agent writing new content
+            const newContent1 = "original content line 1\noriginal content line 2\nagent line 3\nagent line 4\n";
+            fs.writeFileSync(file1, newContent1);
+            client.recordWrite(file1, newContent1);
+            const aiRatio = client.getAICodeRatio();
+            expect(aiRatio.fileCount).toBe(2);
+            expect(aiRatio.ratio).toBeGreaterThanOrEqual(0);
+            expect(aiRatio.ratio).toBeLessThanOrEqual(1);
+        });
+    });
+    describe("getEntropyDeltas", () => {
+        it("should track entropy changes", () => {
+            const simple = "const x = 1;\n";
+            const filePath = createTempFile(tmpDir, "test.ts", simple);
+            client.recordBaseline(filePath);
+            // Make file more complex
+            const complex = `
+function complex(a: number, b: number, c: number): number {
+  if (a > 0) {
+    if (b > 0) {
+      if (c > 0) {
+        return a + b + c;
+      }
+    }
+  }
+  return 0;
+}
+`;
+            fs.writeFileSync(filePath, complex);
+            client.recordWrite(filePath, complex);
+            const deltas = client.getEntropyDeltas();
+            expect(deltas.length).toBe(1);
+            expect(deltas[0].delta).not.toBe(0);
+        });
+    });
+    describe("formatSessionSummary", () => {
+        it("should return empty string when no files touched", () => {
+            expect(client.formatSessionSummary()).toBe("");
+        });
+        it("should format AI code ratio when files are modified", () => {
+            const filePath = createTempFile(tmpDir, "test.ts", "original\n");
+            client.recordBaseline(filePath);
+            const modified = "original\nnew line 1\nnew line 2\n";
+            fs.writeFileSync(filePath, modified);
+            client.recordWrite(filePath, modified);
+            const summary = client.formatSessionSummary();
+            expect(summary).toContain("AI Code");
+            expect(summary).toContain("file(s)");
+        });
+    });
+    describe("reset", () => {
+        it("should clear all tracked data", () => {
+            const filePath = createTempFile(tmpDir, "test.ts", "content\n");
+            client.recordBaseline(filePath);
+            client.reset();
+            const aiRatio = client.getAICodeRatio();
+            expect(aiRatio.fileCount).toBe(0);
+            expect(client.formatSessionSummary()).toBe("");
+        });
+    });
+});

package/clients/ruff-client.test.js

@@ -0,0 +1,132 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { RuffClient } from "./ruff-client.js";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
+describe("RuffClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new RuffClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ruff-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("isPythonFile", () => {
+        it("should recognize Python files", () => {
+            expect(client.isPythonFile("test.py")).toBe(true);
+            expect(client.isPythonFile("module.py")).toBe(true);
+        });
+        it("should not recognize non-Python files", () => {
+            expect(client.isPythonFile("test.ts")).toBe(false);
+            expect(client.isPythonFile("test.js")).toBe(false);
+            expect(client.isPythonFile("test.txt")).toBe(false);
+        });
+    });
+    describe("isAvailable", () => {
+        it("should check ruff availability", () => {
+            const available = client.isAvailable();
+            expect(typeof available).toBe("boolean");
+        });
+    });
+    describe("checkFile", () => {
+        it("should return empty array for non-existent files", () => {
+            if (!client.isAvailable())
+                return;
+            const result = client.checkFile("/nonexistent/file.py");
+            expect(result).toEqual([]);
+        });
+        it("should detect lint issues in Python code", () => {
+            if (!client.isAvailable())
+                return;
+            const content = `
+import os
+import sys
+
+x = 1
+`;
+            const filePath = createTempFile(tmpDir, "test.py", content);
+            const result = client.checkFile(filePath);
+            // Should detect unused imports
+            expect(result.some((d) => d.rule === "F401" || d.message.includes("unused"))).toBe(true);
+        });
+        it("should return array of diagnostics", () => {
+            if (!client.isAvailable())
+                return;
+            const content = `
+def foo():
+    x = undefined_variable
+    return x
+`;
+            const filePath = createTempFile(tmpDir, "test.py", content);
+            const result = client.checkFile(filePath);
+            // Should return an array
+            expect(Array.isArray(result)).toBe(true);
+        });
+    });
+    describe("formatDiagnostics", () => {
+        it("should format diagnostics for display", () => {
+            const diags = [
+                {
+                    line: 1,
+                    column: 0,
+                    endLine: 1,
+                    endColumn: 10,
+                    severity: "error",
+                    message: "Undefined name 'x'",
+                    rule: "F821",
+                    file: "test.py",
+                    fixable: false,
+                },
+            ];
+            const formatted = client.formatDiagnostics(diags);
+            expect(formatted).toContain("Ruff");
+            expect(formatted).toContain("F821");
+            expect(formatted).toContain("Undefined name");
+        });
+        it("should show fixable count", () => {
+            const diags = [
+                {
+                    line: 1,
+                    column: 0,
+                    endLine: 1,
+                    endColumn: 10,
+                    severity: "warning",
+                    message: "Unused import",
+                    rule: "F401",
+                    file: "test.py",
+                    fixable: true,
+                },
+            ];
+            const formatted = client.formatDiagnostics(diags);
+            expect(formatted).toContain("fixable");
+        });
+    });
+    describe("checkFormatting", () => {
+        it("should detect formatting issues", () => {
+            if (!client.isAvailable())
+                return;
+            const content = `x=1
+y=2
+`;
+            const filePath = createTempFile(tmpDir, "test.py", content);
+            const result = client.checkFormatting(filePath);
+            // Should suggest formatting (missing spaces around =)
+            expect(typeof result).toBe("string");
+        });
+        it("should return empty string for well-formatted code", () => {
+            if (!client.isAvailable())
+                return;
+            const content = `x = 1
+y = 2
+`;
+            const filePath = createTempFile(tmpDir, "test.py", content);
+            const result = client.checkFormatting(filePath);
+            // Well-formatted code should return empty or minimal output
+            expect(result).toBe("");
+        });
+    });
+});

package/clients/rust-client.test.js

@@ -0,0 +1,108 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { RustClient } from "./rust-client.js";
+import { setupTestEnvironment } from "./test-utils.js";
+describe("RustClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new RustClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-rust-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("isRustFile", () => {
+        it("should recognize Rust files", () => {
+            expect(client.isRustFile("main.rs")).toBe(true);
+            expect(client.isRustFile("lib.rs")).toBe(true);
+        });
+        it("should not recognize non-Rust files", () => {
+            expect(client.isRustFile("main.ts")).toBe(false);
+            expect(client.isRustFile("main.py")).toBe(false);
+        });
+    });
+    describe("isAvailable", () => {
+        it("should check cargo availability", () => {
+            const available = client.isAvailable();
+            expect(typeof available).toBe("boolean");
+        });
+    });
+    describe("checkFile", () => {
+        it("should return empty array for non-existent files", () => {
+            if (!client.isAvailable())
+                return;
+            const result = client.checkFile("/nonexistent/file.rs", tmpDir);
+            expect(result).toEqual([]);
+        });
+        it("should return array for valid Rust files", () => {
+            if (!client.isAvailable())
+                return;
+            // Need a Cargo.toml for cargo to work
+            fs.writeFileSync(path.join(tmpDir, "Cargo.toml"), `
+[package]
+name = "test"
+version = "0.1.0"
+edition = "2021"
+`);
+            fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
+            fs.writeFileSync(path.join(tmpDir, "src", "main.rs"), `
+fn main() {
+    println!("Hello, world!");
+}
+`);
+            const result = client.checkFile(path.join(tmpDir, "src", "main.rs"), tmpDir);
+            expect(Array.isArray(result)).toBe(true);
+        });
+    });
+    describe("formatDiagnostics", () => {
+        it("should format diagnostics for display", () => {
+            const diags = [
+                {
+                    line: 3,
+                    column: 0,
+                    endLine: 3,
+                    endColumn: 10,
+                    severity: "error",
+                    message: "cannot find value `x` in this scope",
+                    code: "E0425",
+                    file: "main.rs",
+                },
+            ];
+            const formatted = client.formatDiagnostics(diags);
+            expect(formatted).toContain("Rust");
+            expect(formatted).toContain("1 issue");
+            expect(formatted).toContain("E0425");
+        });
+        it("should show error and warning counts", () => {
+            const diags = [
+                {
+                    line: 1,
+                    column: 0,
+                    endLine: 1,
+                    endColumn: 10,
+                    severity: "error",
+                    message: "Error",
+                    file: "test.rs",
+                },
+                {
+                    line: 2,
+                    column: 0,
+                    endLine: 2,
+                    endColumn: 10,
+                    severity: "warning",
+                    message: "Warning",
+                    file: "test.rs",
+                },
+            ];
+            const formatted = client.formatDiagnostics(diags);
+            expect(formatted).toContain("1 error(s)");
+            expect(formatted).toContain("1 warning(s)");
+        });
+    });
+});