pi-lsp-lite 0.4.0 → 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

@@ -5,7 +5,8 @@ import { formatDiagnostics } from "./src/format.js";
 import { DiagnosticSeverity } from "vscode-languageserver-protocol";
 import { loadConfig, writeGlobalConfig, readGlobalConfig } from "./src/config.js";
 import { fileUri, which, isInsideCwd } from "./src/util.js";
-import { installRegistry } from "./src/install-registry.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";
@@ -29,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);
   });
@@ -71,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");
     },
   });
 
@@ -169,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");
@@ -193,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 } } });
@@ -246,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");
     },
   });
 
@@ -263,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;
       }
 
@@ -283,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.4.0",
+  "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";
 
@@ -54,8 +54,12 @@ 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}:${d.message}`;
+  return `${d.severity}:${d.range.start.line}:${d.range.start.character}:${diagnosticMessage(d)}`;
 }
 
 function fingerprintSet(diags: Diagnostic[]): Set<string> {
@@ -202,7 +206,7 @@ export function createLspClient(child: ChildProcess): LspClient {
                 severity: first.severity ?? DiagnosticSeverity.Error,
                 line: first.range.start.line,
                 col: first.range.start.character,
-                message: first.message,
+                message: diagnosticMessage(first),
                 ...(first.source && { source: first.source }),
               },
             }),
@@ -285,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

@@ -183,9 +183,13 @@ function mergeConfigs(
     const existing = result.get(id);
     if (existing) {
       const { disabled: _, diagnosticTimeout: __, ...lspFields } = override;
-      if (source === "project" && lspFields.command !== undefined) {
-        console.error(`[pi-lsp-lite] project config cannot override "command" for server "${id}" — ignoring (use global config instead)`);
-        delete lspFields.command;
+      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),

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/server-manager.ts

@@ -1,4 +1,5 @@
-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, languageIdForFile } from "./languages.js";

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 { 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> {