pi-lsp-lite 0.3.2 → 0.5.0

package/README.md

@@ -53,7 +53,7 @@ The agent sees these too — they're appended to the tool result, so it can self
 | `pylsp` | Python | `pip install python-lsp-server` |
 | `clangd` | C/C++ | Xcode CLI tools / `apt install clangd` |
 
-Missing a server? `/lsp-add` lets you configure any LSP server that speaks stdio. Or add it to `.pi-lsp-lite.json`:
+Missing a server? `/lsp-add` lets you configure any LSP server that speaks stdio. Or add it to global config (`~/.pi-lsp-lite.json`):
 
 ```json
 {
@@ -70,7 +70,7 @@ Missing a server? `/lsp-add` lets you configure any LSP server that speaks stdio
 
 ## Configuration
 
-Works without config. For customisation, create `.pi-lsp-lite.json` (project) or `~/.pi-lsp-lite.json` (global):
+Works without config. Use project config (`.pi-lsp-lite.json` or `.pi/lsp-lite.json`) for safe local tuning, and global config (`~/.pi-lsp-lite.json`) for trusted executable/server-shape changes like custom servers, `command`, `args`, `extensions`, and `rootPatterns`:
 
 | Field | Description | Default |
 |-------|-------------|---------|
@@ -80,7 +80,7 @@ Works without config. For customisation, create `.pi-lsp-lite.json` (project) or
 | `diagnosticTimeout` | Global default timeout (ms) | `5000` |
 | `documentIdleTimeout` | Close idle documents after (ms) | `120000` |
 
-Project config merges over global. Partial overrides work — only specify what you want to change.
+Project config merges over global for safe tuning fields. Repositories can disable servers and tune timeouts/retries, but they cannot change the executable, argv, extensions, or root patterns for any existing server; put those trusted changes in global config.
 
 ## How it works
 
@@ -101,7 +101,7 @@ Servers are lazy (spawn on first edit), idle-shutdown after 240s, and clean up o
 git clone https://github.com/mcphailtom/pi-lsp-lite
 cd pi-lsp-lite && npm install
 npm run check              # typecheck
-npm test                   # unit tests (106, no servers needed)
+npm test                   # unit tests (no servers needed)
 npm run test:integration   # real server tests (needs servers on PATH)
 ```
 

package/index.ts

@@ -4,9 +4,11 @@ import { languageForFile, checkExtensionOverlaps, builtinLanguages, type Languag
 import { formatDiagnostics } from "./src/format.js";
 import { DiagnosticSeverity } from "vscode-languageserver-protocol";
 import { loadConfig, writeGlobalConfig, readGlobalConfig } from "./src/config.js";
-import { fileUri, which } from "./src/util.js";
-import { installRegistry } from "./src/install-registry.js";
-import { resolve, relative, isAbsolute } from "node:path";
+import { fileUri, which, isInsideCwd } from "./src/util.js";
+import { installRegistry, installCommandFor } from "./src/install-registry.js";
+import { buildServerStates, formatServerStates } from "./src/status.js";
+import { resolve } from "node:path";
+import { realpath } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
 export default function (pi: ExtensionAPI) {
@@ -28,6 +30,17 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  async function currentServerStates() {
+    return buildServerStates({
+      builtins: builtinLanguages,
+      active: servers,
+      globalConfig: await readGlobalConfig(),
+      running: manager.status(),
+      installRegistry,
+      resolveCommand: which,
+    });
+  }
+
   pi.on("session_start", async (_event, ctx) => {
     await initConfig(ctx.cwd);
   });
@@ -38,16 +51,21 @@ export default function (pi: ExtensionAPI) {
     const rawPath = event.input?.path;
     const filePath = typeof rawPath === "string" ? rawPath : undefined;
     if (!filePath) return;
+    if (event.isError) return;
 
-    const absolutePath = resolve(ctx.cwd, filePath);
-    const rel = relative(ctx.cwd, absolutePath);
-    if (!rel || rel.startsWith("..") || isAbsolute(rel)) return;
+    let absolutePath: string;
+    try {
+      absolutePath = await realpath(resolve(ctx.cwd, filePath));
+    } catch {
+      return;
+    }
+    if (!isInsideCwd(absolutePath, ctx.cwd)) return;
     const langConfig = languageForFile(absolutePath, servers);
     if (!langConfig) return;
 
     try {
       const result = await manager.handleEdit(absolutePath, langConfig, ctx.cwd);
-      const formatted = formatDiagnostics(filePath, result);
+      const formatted = formatDiagnostics(filePath, result, ctx.cwd);
       if (!formatted) return;
 
       ctx.ui.notify(formatted.trim(), "warning");
@@ -65,19 +83,9 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.registerCommand("lsp-status", {
-    description: "Show running LSP servers and recent diagnostic counts",
+    description: "Show configured LSP servers, install state, and running processes",
     handler: async (_args, ctx) => {
-      const running = manager.status();
-      if (running.length === 0) {
-        ctx.ui.notify("pi-lsp-lite: no servers running", "info");
-        return;
-      }
-      const lines = running.map((s) => {
-        const idle = Math.round((Date.now() - s.lastActivity) / 1000);
-        const up = Math.round(s.uptime / 1000);
-        return `${s.id} (pid ${s.pid}) root=${s.root} — ${s.openDocuments} open files, up ${up}s, idle ${idle}s`;
-      });
-      ctx.ui.notify(lines.join("\n"), "info");
+      ctx.ui.notify(formatServerStates(await currentServerStates()), "info");
     },
   });
 
@@ -163,18 +171,19 @@ export default function (pi: ExtensionAPI) {
       const rootPatterns = rootRaw ? rootRaw.split(",").map((r) => r.trim()).filter(Boolean) : [];
 
       const resolved = await which(command);
-      if (!resolved) {
-        ctx.ui.notify(`pi-lsp-lite: "${command}" not found on PATH — server added but won't start until installed`, "warning");
-      }
-
       await writeGlobalConfig({ servers: { [id]: { command, args, extensions, rootPatterns } } });
       await initConfig(ctx.cwd);
-      ctx.ui.notify(`pi-lsp-lite: added server "${id}"`, "info");
+
+      if (!resolved) {
+        ctx.ui.notify(`pi-lsp-lite: configured server "${id}", but "${command}" is missing from PATH — install it manually before use`, "warning");
+        return;
+      }
+      ctx.ui.notify(`pi-lsp-lite: configured server "${id}" (${resolved})`, "info");
     },
   });
 
   pi.registerCommand("lsp-remove", {
-    description: "Remove or disable a language server",
+    description: "Disable a language server",
     handler: async (_args, ctx) => {
       if (!ctx.hasUI) {
         ctx.ui.notify("pi-lsp-lite: /lsp-remove requires interactive mode", "error");
@@ -187,10 +196,10 @@ export default function (pi: ExtensionAPI) {
       }
 
       const ids = servers.map((s) => s.id);
-      const selected = await ctx.ui.select("Remove which server?", ids);
+      const selected = await ctx.ui.select("Disable which server?", ids);
       if (!selected) return;
 
-      const confirmed = await ctx.ui.confirm("Confirm removal", `Disable server "${selected}"?`);
+      const confirmed = await ctx.ui.confirm("Confirm disable", `Disable server "${selected}"?`);
       if (!confirmed) return;
 
       await writeGlobalConfig({ servers: { [selected]: { disabled: true } } });
@@ -240,7 +249,23 @@ export default function (pi: ExtensionAPI) {
       }
 
       await initConfig(ctx.cwd);
-      ctx.ui.notify(`pi-lsp-lite: ${isCurrentlyEnabled ? "disabled" : "enabled"} server "${id}"`, "info");
+
+      if (isCurrentlyEnabled) {
+        ctx.ui.notify(`pi-lsp-lite: disabled server "${id}"`, "info");
+        return;
+      }
+
+      const state = (await currentServerStates()).find((s) => s.id === id);
+      if (state?.installed === false) {
+        const installHint = state.installable ? "run /lsp-install" : "install it manually";
+        ctx.ui.notify(`pi-lsp-lite: enabled server "${id}", but "${state.command}" is missing from PATH — ${installHint} before use`, "warning");
+        return;
+      }
+      if (state?.installed === null) {
+        ctx.ui.notify(`pi-lsp-lite: enabled server "${id}", but its command is incomplete — check global config`, "warning");
+        return;
+      }
+      ctx.ui.notify(`pi-lsp-lite: enabled server "${id}"`, "info");
     },
   });
 
@@ -257,13 +282,13 @@ export default function (pi: ExtensionAPI) {
           const lang = builtinLanguages.find((l) => l.id === id);
           const binary = lang?.command ?? id;
           const found = await which(binary);
-          return found ? null : { id, command: binary, installCmd: entry.command, description: entry.description };
+          return found ? null : { id, command: binary, installCmd: installCommandFor(entry), description: entry.description };
         }),
       );
       const missing = checks.filter((c): c is NonNullable<typeof c> => c !== null);
 
       if (missing.length === 0) {
-        ctx.ui.notify("pi-lsp-lite: all known servers are available", "info");
+        ctx.ui.notify("pi-lsp-lite: all built-in installable servers are available; custom servers must be installed manually", "info");
         return;
       }
 
@@ -277,7 +302,9 @@ export default function (pi: ExtensionAPI) {
       const confirmed = await ctx.ui.confirm("Confirm install", `Run: ${selected.installCmd}`);
       if (!confirmed) return;
 
-      const result = await pi.exec("sh", ["-c", selected.installCmd]);
+      const result = process.platform === "win32"
+        ? await pi.exec(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", selected.installCmd])
+        : await pi.exec("sh", ["-c", selected.installCmd]);
       if (result.code !== 0) {
         ctx.ui.notify(`pi-lsp-lite: install failed (exit ${result.code})\n${result.stderr}`, "error");
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lsp-lite",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "LSP diagnostics for pi — errors and warnings on every edit, same turn. Go, Rust, TypeScript, Python, C/C++.",
   "type": "module",
   "private": false,
@@ -29,7 +29,9 @@
     ]
   },
   "dependencies": {
-    "vscode-languageserver-protocol": "^3.17.5"
+    "cross-spawn": "^7.0.6",
+    "vscode-languageserver-protocol": "~3.18.1",
+    "which": "^2.0.2"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
@@ -37,13 +39,19 @@
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.74.0",
-    "@types/node": "^20.0.0",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.0.0",
+    "@types/which": "^2.0.2",
+    "cross-env": "^7.0.3",
     "tsx": "^4.21.0",
     "typescript": "^5.4.0"
   },
   "scripts": {
     "check": "tsc --noEmit",
     "test": "tsx --test test/*.test.ts",
-    "test:integration": "INTEGRATION=1 tsx --test test/*.test.ts test/integration/*.test.ts"
+    "test:integration": "cross-env INTEGRATION=1 tsx --test test/*.test.ts test/integration/*.test.ts"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   }
 }

package/src/client.ts

@@ -13,7 +13,7 @@ import {
   DiagnosticSeverity,
   type InitializeParams,
   type Diagnostic,
-} from "vscode-languageserver-protocol/node.js";
+} from "vscode-languageserver-protocol/node";
 import type { ChildProcess } from "node:child_process";
 import { fileUri } from "./util.js";
 
@@ -21,6 +21,7 @@ export interface OtherFileDiagnostics {
   uri: string;
   errorCount: number;
   warningCount: number;
+  firstDiagnostic?: { severity: number; line: number; col: number; message: string; source?: string };
 }
 
 export interface DiagnosticResult {
@@ -53,6 +54,32 @@ function countDiagnostics(diags: Diagnostic[]): { errors: number; warnings: numb
   return { errors, warnings };
 }
 
+function diagnosticMessage(d: Diagnostic): string {
+  return typeof d.message === "string" ? d.message : d.message.value;
+}
+
+function diagnosticFingerprint(d: Diagnostic): string {
+  return `${d.severity}:${d.range.start.line}:${d.range.start.character}:${diagnosticMessage(d)}`;
+}
+
+function fingerprintSet(diags: Diagnostic[]): Set<string> {
+  const set = new Set<string>();
+  for (const d of diags) {
+    if (d.severity === DiagnosticSeverity.Error || d.severity === DiagnosticSeverity.Warning) {
+      set.add(diagnosticFingerprint(d));
+    }
+  }
+  return set;
+}
+
+function setsEqual(a: Set<string>, b: Set<string>): boolean {
+  if (a.size !== b.size) return false;
+  for (const v of a) {
+    if (!b.has(v)) return false;
+  }
+  return true;
+}
+
 export function createLspClient(child: ChildProcess): LspClient {
   if (!child.stdout || !child.stdin) {
     throw new Error("LSP child process must be spawned with stdio: pipe");
@@ -152,10 +179,10 @@ export function createLspClient(child: ChildProcess): LspClient {
     async waitForDiagnostics(uri: string, timeoutMs: number): Promise<DiagnosticResult> {
       const targetGen = uriGeneration.get(uri) ?? 0;
 
-      const preSnapshot = new Map<string, { errors: number; warnings: number }>();
+      const preSnapshot = new Map<string, Set<string>>();
       for (const [trackedUri, entry] of diagnosticsMap) {
         if (trackedUri !== uri) {
-          preSnapshot.set(trackedUri, countDiagnostics(entry.diagnostics));
+          preSnapshot.set(trackedUri, fingerprintSet(entry.diagnostics));
         }
       }
 
@@ -163,13 +190,27 @@ export function createLspClient(child: ChildProcess): LspClient {
         const result: OtherFileDiagnostics[] = [];
         for (const [trackedUri, entry] of diagnosticsMap) {
           if (trackedUri === uri) continue;
+          const postFp = fingerprintSet(entry.diagnostics);
+          const preFp = preSnapshot.get(trackedUri) ?? new Set();
+          if (setsEqual(postFp, preFp)) continue;
           const post = countDiagnostics(entry.diagnostics);
-          const pre = preSnapshot.get(trackedUri) ?? { errors: 0, warnings: 0 };
-          const newErrors = post.errors - pre.errors;
-          const newWarnings = post.warnings - pre.warnings;
-          if (newErrors > 0 || newWarnings > 0) {
-            result.push({ uri: trackedUri, errorCount: newErrors, warningCount: newWarnings });
-          }
+          const first =
+            entry.diagnostics.find((d) => d.severity === DiagnosticSeverity.Error) ??
+            entry.diagnostics.find((d) => d.severity === DiagnosticSeverity.Warning);
+          result.push({
+            uri: trackedUri,
+            errorCount: post.errors,
+            warningCount: post.warnings,
+            ...(first && {
+              firstDiagnostic: {
+                severity: first.severity ?? DiagnosticSeverity.Error,
+                line: first.range.start.line,
+                col: first.range.start.character,
+                message: diagnosticMessage(first),
+                ...(first.source && { source: first.source }),
+              },
+            }),
+          });
         }
         return result;
       };
@@ -214,9 +255,9 @@ export function createLspClient(child: ChildProcess): LspClient {
         // edited file is valid but dependents break
         crossFileCallback = (changedUri: string) => {
           if (settled || changedUri === uri) return;
-          const pre = preSnapshot.get(changedUri) ?? { errors: 0, warnings: 0 };
-          const post = countDiagnostics(diagnosticsMap.get(changedUri)?.diagnostics ?? []);
-          if (post.errors !== pre.errors || post.warnings !== pre.warnings) {
+          const preFp = preSnapshot.get(changedUri) ?? new Set<string>();
+          const postFp = fingerprintSet(diagnosticsMap.get(changedUri)?.diagnostics ?? []);
+          if (!setsEqual(preFp, postFp)) {
             clearTimeout(timeout);
             resetQuiescence();
           }
@@ -248,7 +289,7 @@ export function createLspClient(child: ChildProcess): LspClient {
             timer = setTimeout(() => reject(new Error("shutdown timed out")), SHUTDOWN_TIMEOUT_MS);
           }),
         ]);
-        connection.sendNotification(ExitNotification.type);
+        await connection.sendNotification(ExitNotification.type);
       } catch {
         // timed out or server already exited
       } finally {

package/src/config.ts

@@ -66,7 +66,7 @@ function validateOverride(id: string, raw: unknown): ServerConfigOverride | null
       console.error(`[pi-lsp-lite] config "${id}": extensions must be a non-empty string array, skipping`);
       return null;
     }
-    override.extensions = (raw.extensions as string[]).map((e) => e.toLowerCase());
+    override.extensions = raw.extensions.map((e) => e.toLowerCase());
   }
 
   if (raw.command !== undefined) {
@@ -74,7 +74,7 @@ function validateOverride(id: string, raw: unknown): ServerConfigOverride | null
       console.error(`[pi-lsp-lite] config "${id}": command must be a non-empty string, skipping`);
       return null;
     }
-    override.command = raw.command as string;
+    override.command = raw.command;
   }
 
   if (raw.args !== undefined) {
@@ -82,7 +82,7 @@ function validateOverride(id: string, raw: unknown): ServerConfigOverride | null
       console.error(`[pi-lsp-lite] config "${id}": args must be a string array, skipping`);
       return null;
     }
-    override.args = raw.args as string[];
+    override.args = raw.args;
   }
 
   if (raw.rootPatterns !== undefined) {
@@ -90,7 +90,7 @@ function validateOverride(id: string, raw: unknown): ServerConfigOverride | null
       console.error(`[pi-lsp-lite] config "${id}": rootPatterns must be a string array, skipping`);
       return null;
     }
-    override.rootPatterns = raw.rootPatterns as string[];
+    override.rootPatterns = raw.rootPatterns;
   }
 
   if (raw.diagnosticTimeout !== undefined) {
@@ -150,12 +150,18 @@ async function findProjectConfig(cwd: string): Promise<UserConfig | null> {
 
 type ConfigSource = "global" | "project";
 
+interface MergeResult {
+  servers: LanguageServerConfig[];
+  perServerTimeouts: Map<string, number>;
+}
+
 function mergeConfigs(
   base: LanguageServerConfig[],
   overrides: Record<string, ServerConfigOverride>,
   source: ConfigSource,
-): LanguageServerConfig[] {
+): MergeResult {
   const result = new Map<string, LanguageServerConfig>();
+  const perServerTimeouts = new Map<string, number>();
 
   for (const server of base) {
     result.set(server.id, { ...server });
@@ -170,9 +176,21 @@ function mergeConfigs(
       continue;
     }
 
+    if (override.diagnosticTimeout !== undefined) {
+      perServerTimeouts.set(id, override.diagnosticTimeout);
+    }
+
     const existing = result.get(id);
     if (existing) {
       const { disabled: _, diagnosticTimeout: __, ...lspFields } = override;
+      if (source === "project") {
+        for (const field of ["command", "args", "extensions", "rootPatterns"] as const) {
+          if (lspFields[field] !== undefined) {
+            console.error(`[pi-lsp-lite] project config cannot override "${field}" for server "${id}" — ignoring (use global config instead)`);
+            delete lspFields[field];
+          }
+        }
+      }
       const defined = Object.fromEntries(
         Object.entries(lspFields).filter(([, v]) => v !== undefined),
       );
@@ -197,7 +215,7 @@ function mergeConfigs(
     }
   }
 
-  return Array.from(result.values());
+  return { servers: Array.from(result.values()), perServerTimeouts };
 }
 
 export function globalConfigFilePath(globalConfigPath?: string): string {
@@ -275,12 +293,10 @@ export async function loadConfig(cwd: string, globalConfigPath?: string): Promis
   for (const [layer, source] of layers) {
     if (!layer) continue;
     if (layer.servers && isPlainObject(layer.servers)) {
-      servers = mergeConfigs(servers, layer.servers as Record<string, ServerConfigOverride>, source);
-      for (const [id, rawOverride] of Object.entries(layer.servers)) {
-        const override = validateOverride(id, rawOverride);
-        if (override?.diagnosticTimeout !== undefined) {
-          perServerTimeout.set(id, override.diagnosticTimeout);
-        }
+      const merged = mergeConfigs(servers, layer.servers as Record<string, ServerConfigOverride>, source);
+      servers = merged.servers;
+      for (const [id, timeout] of merged.perServerTimeouts) {
+        perServerTimeout.set(id, timeout);
       }
     }
     if (layer.diagnosticTimeout !== undefined) {

package/src/format.ts

@@ -1,20 +1,30 @@
 import { DiagnosticSeverity } from "vscode-languageserver-protocol";
+import { fileURLToPath } from "node:url";
+import { relative } from "node:path";
 import type { DiagnosticResult } from "./client.js";
 
-export function formatDiagnostics(filePath: string, result: DiagnosticResult): string {
-  const relevant = result.diagnostics.filter(
+const MAX_DIAGNOSTICS_PER_FILE = 50;
+
+export function formatDiagnostics(filePath: string, result: DiagnosticResult, cwd?: string): string {
+  const allRelevant = result.diagnostics.filter(
     (d) => d.severity === DiagnosticSeverity.Error || d.severity === DiagnosticSeverity.Warning,
   );
 
-  if (relevant.length === 0 && result.status === "ok" && result.otherFiles.length === 0) return "";
-  if (result.status === "unavailable") return "";
+  if (allRelevant.length === 0 && result.status === "ok" && result.otherFiles.length === 0) return "";
+
+  if (result.status === "unavailable") {
+    return `\n⚠ LSP diagnostics unavailable for ${filePath} (server missing or failed to start)`;
+  }
+
+  const truncated = allRelevant.length > MAX_DIAGNOSTICS_PER_FILE;
+  const relevant = truncated ? allRelevant.slice(0, MAX_DIAGNOSTICS_PER_FILE) : allRelevant;
 
   const retryNote = result.status === "timeout" && result.retryAttempts > 0
     ? ` after ${result.retryAttempts} ${result.retryAttempts === 1 ? "retry" : "retries"}`
     : "";
 
   if (relevant.length === 0 && result.status === "ok" && result.otherFiles.length > 0) {
-    return `\n⚠ LSP diagnostics for ${filePath}: no issues${otherFilesFooter(result)}`;
+    return `\n⚠ LSP diagnostics for ${filePath}: no issues${otherFilesFooter(result, cwd)}`;
   }
 
   const lines = relevant.map((d) => {
@@ -25,8 +35,11 @@ export function formatDiagnostics(filePath: string, result: DiagnosticResult): s
     return `  ${severity} ${line}:${col} ${source}${d.message}`;
   });
 
-  const errorCount = relevant.filter((d) => d.severity === DiagnosticSeverity.Error).length;
-  const warnCount = relevant.length - errorCount;
+  let errorCount = 0;
+  for (const d of allRelevant) {
+    if (d.severity === DiagnosticSeverity.Error) errorCount++;
+  }
+  const warnCount = allRelevant.length - errorCount;
 
   const summary = [
     errorCount > 0 ? `${errorCount} error${errorCount > 1 ? "s" : ""}` : "",
@@ -36,12 +49,30 @@ export function formatDiagnostics(filePath: string, result: DiagnosticResult): s
     .filter(Boolean)
     .join(", ");
 
-  return `\n⚠ LSP diagnostics for ${filePath} (${summary}):\n${lines.join("\n")}${otherFilesFooter(result)}`;
+  const truncatedNote = truncated ? `\n  ... and ${allRelevant.length - MAX_DIAGNOSTICS_PER_FILE} more` : "";
+
+  return `\n⚠ LSP diagnostics for ${filePath} (${summary}):\n${lines.join("\n")}${truncatedNote}${otherFilesFooter(result, cwd)}`;
 }
 
-function otherFilesFooter(result: DiagnosticResult): string {
+function otherFilesFooter(result: DiagnosticResult, cwd?: string): string {
   if (result.otherFiles.length === 0) return "";
-  const totalDiags = result.otherFiles.reduce((sum, f) => sum + f.errorCount + f.warningCount, 0);
-  const fileCount = result.otherFiles.length;
-  return `\n  + ${totalDiags} diagnostic${totalDiags !== 1 ? "s" : ""} in ${fileCount} other file${fileCount !== 1 ? "s" : ""}`;
+  const lines = result.otherFiles.map((f) => {
+    let path: string;
+    try {
+      const abs = fileURLToPath(f.uri);
+      path = cwd ? relative(cwd, abs) : abs;
+    } catch {
+      path = f.uri;
+    }
+    const counts = [
+      f.errorCount > 0 ? `${f.errorCount} error${f.errorCount > 1 ? "s" : ""}` : "",
+      f.warningCount > 0 ? `${f.warningCount} warning${f.warningCount > 1 ? "s" : ""}` : "",
+    ].filter(Boolean).join(", ");
+    if (!f.firstDiagnostic) return `  ${path} (${counts})`;
+    const d = f.firstDiagnostic;
+    const sev = d.severity === DiagnosticSeverity.Error ? "error" : "warning";
+    const src = d.source ? `[${d.source}] ` : "";
+    return `  ${path} (${counts}): ${sev} ${d.line + 1}:${d.col + 1} ${src}${d.message}`;
+  });
+  return `\n${lines.join("\n")}`;
 }

package/src/install-registry.ts

@@ -1,27 +1,37 @@
 export interface InstallEntry {
-  command: string;
+  // Per-platform install command; `win32` overrides `default` on Windows.
+  command: { default: string; win32?: string };
   description: string;
 }
 
 export const installRegistry = new Map<string, InstallEntry>([
   ["go", {
-    command: "go install golang.org/x/tools/gopls@latest",
+    command: { default: "go install golang.org/x/tools/gopls@latest" },
     description: "Go language server",
   }],
   ["rust", {
-    command: "rustup component add rust-analyzer",
+    command: { default: "rustup component add rust-analyzer" },
     description: "Rust language server",
   }],
   ["typescript", {
-    command: "npm install -g typescript-language-server typescript",
+    command: { default: "npm install -g typescript-language-server typescript" },
     description: "TypeScript/JavaScript language server",
   }],
   ["python", {
-    command: "pip install python-lsp-server",
+    command: { default: "pip install python-lsp-server" },
     description: "Python language server",
   }],
   ["cpp", {
-    command: "sudo apt-get install -y clangd || brew install llvm",
+    command: {
+      default: "sudo apt-get install -y clangd || brew install llvm",
+      win32: "winget install -e --id LLVM.clangd",
+    },
     description: "C/C++ language server",
   }],
 ]);
+
+// Resolve the install command for the current platform.
+export function installCommandFor(entry: InstallEntry): string {
+  if (process.platform === "win32" && entry.command.win32) return entry.command.win32;
+  return entry.command.default;
+}

package/src/languages.ts

@@ -6,6 +6,7 @@ export interface LanguageServerConfig {
   rootPatterns: string[];
   diagnosticTimeout?: number;
   maxRetries?: number;
+  languageIds?: Record<string, string>;
 }
 
 export const builtinLanguages: LanguageServerConfig[] = [
@@ -32,6 +33,7 @@ export const builtinLanguages: LanguageServerConfig[] = [
     args: ["--stdio"],
     rootPatterns: ["tsconfig.json", "package.json"],
     diagnosticTimeout: 30_000,
+    languageIds: { ".tsx": "typescriptreact", ".js": "javascript", ".jsx": "javascriptreact" },
   },
   {
     id: "python",
@@ -48,6 +50,7 @@ export const builtinLanguages: LanguageServerConfig[] = [
     args: [],
     rootPatterns: ["compile_commands.json", "CMakeLists.txt", ".clangd"],
     diagnosticTimeout: 15_000,
+    languageIds: { ".c": "c", ".h": "c", ".cc": "cpp", ".cxx": "cpp", ".hpp": "cpp", ".hxx": "cpp" },
   },
 ];
 
@@ -56,6 +59,14 @@ export function languageForFile(path: string, configs: LanguageServerConfig[]):
   return configs.find((lang) => lang.extensions.some((ext) => lower.endsWith(ext)));
 }
 
+export function languageIdForFile(filePath: string, config: LanguageServerConfig): string {
+  if (config.languageIds) {
+    const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0];
+    if (ext && config.languageIds[ext]) return config.languageIds[ext];
+  }
+  return config.id;
+}
+
 export function checkExtensionOverlaps(configs: LanguageServerConfig[]): string[] {
   const warnings: string[] = [];
   const seen = new Map<string, string>();

package/src/server-manager.ts

@@ -1,7 +1,8 @@
-import { spawn, type ChildProcess } from "node:child_process";
+import { type ChildProcess } from "node:child_process";
+import spawn from "cross-spawn";
 import { which, fileUri, findWorkspaceRoot } from "./util.js";
 import { createLspClient, type LspClient, type DiagnosticResult } from "./client.js";
-import type { LanguageServerConfig } from "./languages.js";
+import { type LanguageServerConfig, languageIdForFile } from "./languages.js";
 import type { Diagnostic } from "vscode-languageserver-protocol";
 import { DEFAULT_DIAGNOSTIC_TIMEOUT, DEFAULT_DOCUMENT_IDLE_TIMEOUT, DEFAULT_MAX_RETRIES } from "./config.js";
 import { readFile } from "node:fs/promises";
@@ -221,7 +222,7 @@ export function createServerManager(options: ServerManagerOptions = {}): ServerM
     if (server.openDocuments.has(uri)) {
       server.client.didChange(uri, content);
     } else {
-      server.client.didOpen(uri, server.config.id, content);
+      server.client.didOpen(uri, languageIdForFile(filePath, server.config), content);
     }
     server.openDocuments.set(uri, Date.now());
 

package/src/status.ts

@@ -0,0 +1,95 @@
+import type { UserConfig } from "./config.js";
+import type { InstallEntry } from "./install-registry.js";
+import type { LanguageServerConfig } from "./languages.js";
+import type { ServerStatus } from "./server-manager.js";
+
+export interface ServerState {
+  id: string;
+  command: string | null;
+  enabled: boolean;
+  installed: boolean | null;
+  installable: boolean;
+  running: ServerStatus[];
+}
+
+export interface BuildServerStatesOptions {
+  builtins: LanguageServerConfig[];
+  active: LanguageServerConfig[];
+  globalConfig: UserConfig | null;
+  running: ServerStatus[];
+  installRegistry: Map<string, InstallEntry>;
+  resolveCommand(command: string): Promise<string | null>;
+}
+
+const RESERVED_SERVER_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function globalServerIds(globalConfig: UserConfig | null): string[] {
+  const servers = globalConfig?.servers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) return [];
+  return Object.keys(servers).filter((id) => !RESERVED_SERVER_KEYS.has(id));
+}
+
+function commandFor(id: string, active: Map<string, LanguageServerConfig>, builtins: Map<string, LanguageServerConfig>, globalConfig: UserConfig | null): string | null {
+  const activeConfig = active.get(id);
+  if (activeConfig) return activeConfig.command;
+
+  const globalCommand = globalConfig?.servers?.[id]?.command;
+  if (typeof globalCommand === "string" && globalCommand.length > 0) return globalCommand;
+
+  const builtin = builtins.get(id);
+  return builtin?.command ?? null;
+}
+
+export async function buildServerStates(options: BuildServerStatesOptions): Promise<ServerState[]> {
+  const active = new Map(options.active.map((server) => [server.id, server]));
+  const builtins = new Map(options.builtins.map((server) => [server.id, server]));
+  const runningById = new Map<string, ServerStatus[]>();
+
+  for (const status of options.running) {
+    const entries = runningById.get(status.id) ?? [];
+    entries.push(status);
+    runningById.set(status.id, entries);
+  }
+
+  const ids = new Set<string>([
+    ...builtins.keys(),
+    ...active.keys(),
+    ...globalServerIds(options.globalConfig),
+  ]);
+
+  const states = await Promise.all([...ids].sort().map(async (id): Promise<ServerState> => {
+    const command = commandFor(id, active, builtins, options.globalConfig);
+    const installed = command ? (await options.resolveCommand(command)) !== null : null;
+    return {
+      id,
+      command,
+      enabled: active.has(id),
+      installed,
+      installable: options.installRegistry.has(id),
+      running: runningById.get(id) ?? [],
+    };
+  }));
+
+  return states;
+}
+
+export function formatServerStates(states: ServerState[]): string {
+  if (states.length === 0) return "pi-lsp-lite: no servers configured";
+
+  return states.map((state) => {
+    const enabled = state.enabled ? "enabled" : "disabled";
+    const installed = state.installed === null ? "unknown" : state.installed ? "installed" : "missing";
+    const installHint = state.installed === false
+      ? state.installable ? "installable via /lsp-install" : "manual install required"
+      : "";
+    const running = state.running.length > 0
+      ? state.running.map((s) => {
+        const idle = Math.round((Date.now() - s.lastActivity) / 1000);
+        const up = Math.round(s.uptime / 1000);
+        return `running pid=${s.pid} root=${s.root} open=${s.openDocuments} up=${up}s idle=${idle}s`;
+      }).join("; ")
+      : "not running";
+    const command = state.command ? `cmd=${state.command}` : "cmd=unknown";
+    return [state.id, enabled, installed, running, command, installHint].filter(Boolean).join(" — ");
+  }).join("\n");
+}

package/src/util.ts

@@ -1,29 +1,28 @@
-import { access, constants } from "node:fs/promises";
-import { join, dirname } from "node:path";
+import { access } from "node:fs/promises";
+import { join, dirname, relative, isAbsolute } from "node:path";
 import { pathToFileURL } from "node:url";
+import which_ from "which";
 
 export function fileUri(absolutePath: string): string {
   return pathToFileURL(absolutePath).href;
 }
 
+// Find a binary on PATH. Delegates to the `which` package — the same resolver
+// cross-spawn uses to locate the command it launches — so preflight resolution
+// and the eventual spawn agree on every platform.
+function isNotFoundError(err: unknown): boolean {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+
 export async function which(command: string): Promise<string | null> {
-  if (command.includes("/")) {
-    try {
-      await access(command, constants.X_OK);
-      return command;
-    } catch {
-      return null;
+  try {
+    return await which_(command);
+  } catch (err) {
+    if (!isNotFoundError(err)) {
+      console.error(`[pi-lsp-lite] failed to resolve command "${command}":`, err);
     }
+    return null;
   }
-  const pathDirs = (process.env.PATH ?? "").split(":");
-  for (const dir of pathDirs) {
-    const candidate = join(dir, command);
-    try {
-      await access(candidate, constants.X_OK);
-      return candidate;
-    } catch {}
-  }
-  return null;
 }
 
 export async function findWorkspaceRoot(filePath: string, rootPatterns: string[], cwd: string): Promise<string> {
@@ -42,3 +41,8 @@ export async function findWorkspaceRoot(filePath: string, rootPatterns: string[]
   }
   return cwd;
 }
+
+export function isInsideCwd(absolutePath: string, cwd: string): boolean {
+  const rel = relative(cwd, absolutePath);
+  return !!rel && !rel.startsWith("..") && !isAbsolute(rel);
+}

package/.github/workflows/ci.yml

@@ -1,30 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-permissions:
-  contents: read
-
-jobs:
-  check:
-    name: typecheck + unit tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 20
-          cache: npm
-
-      - run: npm ci
-
-      - name: typecheck
-        run: npm run check
-
-      - name: unit tests
-        run: npm test

package/.github/workflows/integration.yml

@@ -1,79 +0,0 @@
-name: Integration Tests
-
-on:
-  pull_request:
-    branches: [main]
-
-permissions:
-  contents: read
-
-jobs:
-  gopls:
-    name: gopls
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 20
-          cache: npm
-      - uses: actions/setup-go@v6
-        with:
-          go-version: stable
-      - run: go install golang.org/x/tools/gopls@latest
-      - run: npm ci
-      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/gopls.test.ts
-
-  rust-analyzer:
-    name: rust-analyzer
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 20
-          cache: npm
-      - run: |
-          rustup update stable
-          rustup component add rust-analyzer
-      - run: npm ci
-      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/rust-analyzer.test.ts
-
-  typescript:
-    name: typescript-language-server
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 20
-          cache: npm
-      - run: npm install -g typescript-language-server typescript
-      - run: npm ci
-      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/typescript.test.ts
-
-  pylsp:
-    name: pylsp
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 20
-          cache: npm
-      - run: pip install 'python-lsp-server[all]'
-      - run: npm ci
-      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/pylsp.test.ts
-
-  clangd:
-    name: clangd
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 20
-          cache: npm
-      - run: sudo apt-get update -qq && sudo apt-get install -y -qq clangd
-      - run: npm ci
-      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/clangd.test.ts

package/.github/workflows/release.yml

@@ -1,34 +0,0 @@
-name: Publish to npm
-
-on:
-  release:
-    types: [published]
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  publish:
-    name: publish to npm
-    runs-on: ubuntu-latest
-    environment: public
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org
-          cache: npm
-
-      - run: npm ci
-
-      - name: typecheck
-        run: npm run check
-
-      - name: unit tests
-        run: npm test
-
-      - name: publish
-        run: npm publish --access public