pi-lens 3.8.63 → 3.8.64

package/dist/clients/lsp/index.js

@@ -15,6 +15,7 @@ import { isTestMode } from "../env-utils.js";
 import { getGlobalPiLensDir, getProjectIgnoreMatcher, isExcludedDirName, } from "../file-utils.js";
 import { recordLsp } from "../widget-state.js";
 import { logLatency } from "../latency-logger.js";
+import { withDeadline } from "../deadline-utils.js";
 import { normalizeMapKey, uriToPath } from "../path-utils.js";
 import { createLSPClient } from "./client.js";
 import { getServersForFileWithConfig } from "./config.js";
@@ -84,6 +85,24 @@ function mergeLspDiagnostics(diagnostics) {
     return merged;
 }
 const WORKSPACE_DIAGNOSTICS_CONCURRENCY = 8;
+// The notify write (didOpen/didChange) is normally instant, but it awaits a
+// JSON-RPC send that BACKPRESSURES when the server's stdin isn't being drained
+// (a wedged/CPU-bound server, e.g. TypeScript mid-recheck). Unbounded, that
+// write parks every touchFile caller: the pre-dispatch sync, the dispatch LSP
+// runner (which then rides to its 30s dispatcher timeout — the observed ~31s
+// edits), and the workspace sweep. Bounding it here degrades a wedged server to
+// "no fresh diagnostics" instead of hanging the edit, for ALL callers.
+function notifyWriteBudgetMs() {
+    const raw = Number(process.env.PI_LENS_LSP_NOTIFY_BUDGET_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 2000;
+}
+// Budget for one project-wide `workspace/diagnostic` pull (#387 Item 2). Larger
+// than a per-file wait — it's a single request but scans the whole program —
+// yet bounded so a hung server still falls back to the per-file path.
+function workspacePullBudgetMs() {
+    const raw = Number(process.env.PI_LENS_LSP_WORKSPACE_PULL_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
+}
 // Hard cap on the workspace-diagnostics walk. Even though this is an explicit,
 // user-invoked project-wide tool, the walk must be bounded so a misrooted run
 // (e.g. cwd that resolves to $HOME) can't enumerate an entire home tree (#250).
@@ -711,8 +730,22 @@ export class LSPService {
         // runner touch sequence expensive on slow TS projects.
         const notifySkipped = this.shouldSkipNotify(filePath, content, clientScope);
         const diagnosticBaselines = new Map(spawned.map((entry) => [entry.client, entry.client.diagnosticsVersion]));
+        let notifyWriteTimedOut = false;
         if (!notifySkipped) {
-            await Promise.all(spawned.map((entry) => entry.client.notify.open(filePath, content, languageId, undefined, silent)));
+            // Bounded so a backpressured write can't hang the caller (see
+            // notifyWriteBudgetMs). On timeout we proceed: the diagnostics wait below
+            // is separately bounded and simply returns no fresh diagnostics.
+            const wrote = await withDeadline(Promise.all(spawned.map((entry) => entry.client.notify.open(filePath, content, languageId, undefined, silent))), { ms: notifyWriteBudgetMs(), onTimeout: "undefined", onReject: "undefined" });
+            if (wrote === undefined) {
+                notifyWriteTimedOut = true;
+                logLatency({
+                    type: "phase",
+                    phase: "lsp_notify_timeout",
+                    filePath: normalizedPath,
+                    durationMs: Date.now() - startedAt,
+                    metadata: { source, clientScope, serverCount: spawned.length },
+                });
+            }
         }
         let diagnosticsTimedOut = false;
         if (diagnosticsMode !== "none") {
@@ -821,6 +854,7 @@ export class LSPService {
                 failureKind: "success",
                 collectedDiagnostics: collected?.length,
                 notifySkipped,
+                notifyWriteTimedOut,
                 diagnosticsTimedOut,
             },
         });
@@ -1353,42 +1387,148 @@ export class LSPService {
             ? Math.floor(options.maxFiles)
             : getMaxWorkspaceDiagnosticFiles();
         const files = await collectWorkspaceDiagnosticFiles(root, maxFiles, signal);
-        const results = new Array(files.length);
-        let nextIndex = 0;
-        const workers = Math.min(WORKSPACE_DIAGNOSTICS_CONCURRENCY, files.length);
-        await Promise.all(Array.from({ length: workers }, async () => {
+        // Per-file wall-clock: a language server that hangs during spawn/initialize
+        // would otherwise park a worker on `touchFile` FOREVER (the per-edit
+        // diagnostic wait is bounded, but client acquisition here is not) — the root
+        // of an observed multi-hour hang. Budget each file so the worker always
+        // returns to the loop (and its abort check). Env-tunable.
+        const perFileMs = (() => {
+            const raw = Number(process.env.PI_LENS_LSP_WORKSPACE_PER_FILE_MS);
+            return Number.isFinite(raw) && raw > 0 ? raw : 15_000;
+        })();
+        const results = [];
+        let completed = 0;
+        let timedOutFiles = 0;
+        let lastHeartbeat = Date.now();
+        // Group files by their primary language server (#387). tsserver — and most
+        // servers — is single-threaded per project: N concurrent touches to ONE
+        // server don't parallelize, they queue. That inflates the working set (each
+        // didOpen can force a project recheck) and cascades per-file-budget timeouts
+        // by queue position (observed: 51/123 files "timed out" purely from being
+        // behind others in an 8-wide flat pool). So serialize WITHIN a server (one
+        // in-flight touch each) and parallelize ACROSS servers — real parallelism
+        // where it exists (a mixed TS+Python repo runs both), no flooding where it
+        // doesn't. Capped so a many-language monorepo can't spawn unbounded groups.
+        const byServer = new Map();
+        for (const filePath of files) {
+            const servers = getServersForFileWithConfig(filePath);
+            const primary = servers[0]?.id ?? "none";
+            const group = byServer.get(primary);
+            if (group) {
+                group.files.push(filePath);
+                if (servers.length > 1)
+                    group.multiServer = true;
+            }
+            else {
+                byServer.set(primary, {
+                    files: [filePath],
+                    multiServer: servers.length > 1,
+                });
+            }
+        }
+        const groups = [...byServer.values()];
+        // Opt-in project-wide pull: one `workspace/diagnostic` per server instead of
+        // N per-file opens (#387 Item 2). Gated off by default — a cold server can
+        // answer with an empty/partial report that reads as a false "all clean", and
+        // the pull covers only the primary server (files with auxiliary scanners
+        // would lose those). Enabled per group only when the server advertises it and
+        // no file in the group has an auxiliary; any miss falls back to per-file.
+        const workspacePullEnabled = process.env.PI_LENS_LSP_WORKSPACE_PULL === "1";
+        // Start marker: without this a hang leaves no trace that the sweep even
+        // began (the completion log below never fires). Per-file `lsp_touch_file`
+        // phases + these heartbeats let a hang be bracketed to a file/time.
+        logLatency({
+            type: "phase",
+            phase: "lsp_workspace_diagnostics_start",
+            filePath: root,
+            durationMs: 0,
+            metadata: {
+                fileCount: files.length,
+                maxFiles,
+                perFileMs,
+                serverGroups: byServer.size,
+            },
+        });
+        const processFile = async (filePath) => {
+            try {
+                const content = await nodeFs.promises.readFile(filePath, "utf-8");
+                // onTimeout:"undefined" so a hung file yields no diagnostics and the
+                // worker moves on; a real touchFile rejection still propagates to the
+                // catch below and is recorded as an error.
+                const diagnostics = await withDeadline(this.touchFile(filePath, content, {
+                    diagnostics: "document",
+                    collectDiagnostics: true,
+                    clientScope: "all",
+                    source: "lens_diagnostics_full",
+                }), { ms: perFileMs, onTimeout: "undefined" });
+                if (diagnostics === undefined)
+                    timedOutFiles += 1;
+                results.push({
+                    filePath,
+                    diagnostics: diagnostics ?? [],
+                    count: diagnostics?.length ?? 0,
+                });
+            }
+            catch (err) {
+                results.push({
+                    filePath,
+                    diagnostics: [],
+                    count: 0,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            completed += 1;
+            // User-facing progress (streamed to the tool's onUpdate). Per-file so the
+            // bar moves; the tool throttles the actual UI writes.
+            options.onProgress?.(completed, files.length);
+            // Time-based heartbeat (every ~10s): a hang shows the last heartbeat
+            // then silence, so latency.log pinpoints how far it got.
+            if (Date.now() - lastHeartbeat >= 10_000) {
+                lastHeartbeat = Date.now();
+                logLatency({
+                    type: "phase",
+                    phase: "lsp_workspace_diagnostics_progress",
+                    filePath: root,
+                    durationMs: Date.now() - startedAt,
+                    metadata: {
+                        completed,
+                        total: files.length,
+                        timedOutFiles,
+                        aborted: signal?.aborted ?? false,
+                    },
+                });
+            }
+        };
+        // One worker per server group (serial within a server), up to the
+        // concurrency cap across distinct servers.
+        let nextGroup = 0;
+        const groupWorkers = Math.min(WORKSPACE_DIAGNOSTICS_CONCURRENCY, groups.length);
+        await Promise.all(Array.from({ length: groupWorkers }, async () => {
             while (true) {
-                // Honor cancellation: a long sweep must stop when the agent/user
-                // aborts the turn rather than chew through the remaining files
-                // (#341). Already-collected results are returned as a partial.
                 if (signal?.aborted)
                     return;
-                const index = nextIndex;
-                nextIndex += 1;
-                if (index >= files.length)
+                const gi = nextGroup;
+                nextGroup += 1;
+                if (gi >= groups.length)
                     return;
-                const filePath = files[index];
-                try {
-                    const content = await nodeFs.promises.readFile(filePath, "utf-8");
-                    const diagnostics = await this.touchFile(filePath, content, {
-                        diagnostics: "document",
-                        collectDiagnostics: true,
-                        clientScope: "all",
-                        source: "lens_diagnostics_full",
-                    });
-                    results[index] = {
-                        filePath,
-                        diagnostics: diagnostics ?? [],
-                        count: diagnostics?.length ?? 0,
-                    };
+                const group = groups[gi];
+                // Fast path: one project-wide pull for the whole group (opt-in).
+                if (workspacePullEnabled && !group.multiServer) {
+                    const pulled = await this.tryWorkspacePull(group.files, perFileMs);
+                    if (pulled) {
+                        for (const result of pulled)
+                            results.push(result);
+                        completed += group.files.length;
+                        options.onProgress?.(completed, files.length);
+                        continue;
+                    }
                 }
-                catch (err) {
-                    results[index] = {
-                        filePath,
-                        diagnostics: [],
-                        count: 0,
-                        error: err instanceof Error ? err.message : String(err),
-                    };
+                for (const filePath of group.files) {
+                    // Honor cancellation between files (#341); already-collected
+                    // results are returned as a partial.
+                    if (signal?.aborted)
+                        return;
+                    await processFile(filePath);
                 }
             }
         }));
@@ -1400,13 +1540,48 @@ export class LSPService {
             metadata: {
                 filesChecked: files.length,
                 diagnosticCount: results.reduce((sum, result) => sum + (result?.count ?? 0), 0),
-                concurrency: WORKSPACE_DIAGNOSTICS_CONCURRENCY,
+                serverGroups: byServer.size,
+                concurrency: groupWorkers,
                 maxFiles,
+                timedOutFiles,
                 aborted: signal?.aborted ?? false,
             },
         });
         return results.filter(Boolean);
     }
+    /**
+     * #387 Item 2: one `workspace/diagnostic` pull covering a whole server group,
+     * instead of N per-file opens. Returns per-file results (files absent from the
+     * report are reported clean), or `undefined` when the server doesn't advertise
+     * workspace pull / the pull fails — the caller then falls back to per-file.
+     */
+    async tryWorkspacePull(groupFiles, perFileMs) {
+        try {
+            const first = groupFiles[0];
+            if (!first)
+                return undefined;
+            const spawned = await this.getClientForFile(first, perFileMs);
+            if (!spawned)
+                return undefined;
+            if (!spawned.client.getWorkspaceDiagnosticsSupport().workspaceDiagnostics) {
+                return undefined;
+            }
+            const report = await spawned.client.requestWorkspaceDiagnostics(Math.max(perFileMs, workspacePullBudgetMs()));
+            if (!report)
+                return undefined;
+            const byPath = new Map();
+            for (const entry of report) {
+                byPath.set(normalizeMapKey(entry.filePath), entry.diagnostics);
+            }
+            return groupFiles.map((filePath) => {
+                const diagnostics = byPath.get(normalizeMapKey(filePath)) ?? [];
+                return { filePath, diagnostics, count: diagnostics.length };
+            });
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Get all diagnostics across all tracked files (for cascade checking)
      */

package/dist/clients/lsp/interactive-install.js

@@ -12,6 +12,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getProjectDataDir } from "../file-utils.js";
+import { globalInstallArgs, pmBinary, resolveNodePackageManager, } from "../package-manager.js";
 import { safeSpawnAsync } from "../safe-spawn.js";
 function canUseInteractivePrompt() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -255,7 +256,7 @@ function isAutoInstallEnabled() {
 /**
  * Attempt to install a tool using the configured strategy.
  *
- * - "npm":    npm install -g <packageName>
+ * - "npm":    global install via the resolved manager (npm/pnpm/yarn/bun)
  * - "shell":  run the static installCommand as argv (gem, dotnet, brew, etc.)
  * - "manual": can't auto-install — print the command and return false
  */
@@ -274,9 +275,18 @@ async function installTool(config) {
     if (installStrategy === "manual") {
         return false;
     }
-    const invocation = installStrategy === "npm" && packageName
-        ? ["npm", ["install", "-g", packageName]]
-        : _parseStaticInstallCommandForTest(installCommand);
+    let invocation;
+    if (installStrategy === "npm" && packageName) {
+        // Resolve the machine's package manager (npm/pnpm/yarn/bun) rather than
+        // hardcoding npm — this global install is what makes an LSP server
+        // available on hosts without npm. The result lands in that manager's
+        // global bin dir, which `allAvailableGlobalBinDirs` already discovers.
+        const pm = await resolveNodePackageManager();
+        invocation = [pmBinary(pm), globalInstallArgs(pm, packageName)];
+    }
+    else {
+        invocation = _parseStaticInstallCommandForTest(installCommand);
+    }
     if (!invocation)
         return false;
     const [cmd, args] = invocation;

package/dist/clients/lsp/launch.js

@@ -6,12 +6,13 @@
  * - Node.js scripts (npx/bun)
  * - Package manager execution
  */
-import { execFileSync, execSync, spawn as nodeSpawn, } from "node:child_process";
+import { execFileSync, spawn as nodeSpawn, } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isTestMode } from "../env-utils.js";
 import { getGlobalPiLensDir } from "../file-utils.js";
+import { allAvailableGlobalBinDirs } from "../package-manager.js";
 const isWindows = process.platform === "win32";
 /**
  * Whether a resolved command must be spawned through a shell on Windows.
@@ -161,27 +162,26 @@ function buildAugmentedPath(basePath) {
     return `${basePath}${path.delimiter}${toAppend.join(path.delimiter)}`;
 }
 /**
- * Find binary in npm global directory
- * Works around PATH caching issue after npm install -g
+ * Find a globally-installed binary across every installed package manager's
+ * global bin dir (npm/pnpm/yarn/bun). Works around PATH caching right after an
+ * `install -g` and covers tools installed via any manager.
  */
-function _findBinaryInNpmGlobal(command) {
+async function _findBinaryInGlobalBin(command) {
     try {
-        // Get npm global prefix
-        const prefix = execSync("npm prefix -g", { encoding: "utf-8" }).trim();
-        // On Windows, binaries are directly in the prefix dir
-        // On Unix, they're in prefix/bin
-        const binDir = isWindows ? prefix : path.join(prefix, "bin");
-        // Check for Windows variants
-        const candidates = isWindows
-            ? [
-                path.join(binDir, `${command}.cmd`),
-                path.join(binDir, `${command}.exe`),
-                path.join(binDir, command),
-            ]
-            : [path.join(binDir, command)];
-        for (const candidate of candidates) {
-            if (fs.existsSync(candidate)) {
-                return candidate;
+        for (const binDir of await allAvailableGlobalBinDirs()) {
+            // On Windows, binaries are directly in the dir (with .cmd/.exe shims);
+            // on Unix they're the bare command name.
+            const candidates = isWindows
+                ? [
+                    path.join(binDir, `${command}.cmd`),
+                    path.join(binDir, `${command}.exe`),
+                    path.join(binDir, command),
+                ]
+                : [path.join(binDir, command)];
+            for (const candidate of candidates) {
+                if (fs.existsSync(candidate)) {
+                    return candidate;
+                }
             }
         }
         return undefined;
@@ -457,10 +457,10 @@ export async function launchLSP(command, args = [], options = {}) {
     if (!path.isAbsolute(command) &&
         !command.includes(path.sep) &&
         !command.includes("/")) {
-        const npmGlobalPath = _findBinaryInNpmGlobal(command);
-        if (npmGlobalPath) {
-            spawnCommand = npmGlobalPath;
-            // Recompute needsShell for npm global path
+        const globalBinPath = await _findBinaryInGlobalBin(command);
+        if (globalBinPath) {
+            spawnCommand = globalBinPath;
+            // Recompute needsShell for the resolved global path
             needsShell = computeNeedsShell(spawnCommand);
         }
     }
@@ -495,11 +495,11 @@ export async function launchLSP(command, args = [], options = {}) {
         if (!path.isAbsolute(command) &&
             !command.includes(path.sep) &&
             !command.includes("/")) {
-            const npmGlobalPath = _findBinaryInNpmGlobal(command);
-            if (npmGlobalPath && npmGlobalPath !== spawnCommand) {
-                // Recompute needsShell for npm global path
-                const needsShellGlobal = computeNeedsShell(npmGlobalPath);
-                proc = trySpawn(npmGlobalPath, args, cwd, env, needsShellGlobal);
+            const globalBinPath = await _findBinaryInGlobalBin(command);
+            if (globalBinPath && globalBinPath !== spawnCommand) {
+                // Recompute needsShell for the resolved global path
+                const needsShellGlobal = computeNeedsShell(globalBinPath);
+                proc = trySpawn(globalBinPath, args, cwd, env, needsShellGlobal);
             }
             else {
                 throw err;
@@ -597,77 +597,6 @@ export async function launchLSP(command, args = [], options = {}) {
         pid: proc.pid ?? 0,
     };
 }
-/**
- * Spawn via package manager (npx/bun)
- */
-export async function launchViaPackageManager(packageName, args = [], options = {}) {
-    // Prefer bun if available, fall back to npx (use .cmd on Windows)
-    const isWin = process.platform === "win32";
-    if (process.env.BUN_INSTALL) {
-        return launchLSP(isWin ? "bun.exe" : "bun", ["x", packageName, ...args], options);
-    }
-    // shell:true justified: npx on Windows is npx.cmd — requires shell to execute.
-    if (isWin) {
-        const argsStr = args.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ");
-        // --no prevents silent download of uncached packages
-        const shellCommand = `npx --no ${packageName}${argsStr ? ` ${argsStr}` : ""}`;
-        const cwd = String(options.cwd ?? process.cwd());
-        const mergedEnv = { ...process.env, ...options.env };
-        const augmentedPath = buildAugmentedPath(resolvePathValue(mergedEnv));
-        const env = {
-            ...mergedEnv,
-            PATH: augmentedPath,
-            ...(isWindows ? { Path: augmentedPath } : {}),
-        };
-        const proc = nodeSpawn(shellCommand, [], {
-            cwd,
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-            detached: false,
-            windowsHide: true,
-            shell: true,
-        });
-        if (!proc.stdin || !proc.stdout || !proc.stderr) {
-            throw new Error(`Failed to spawn package manager for: ${packageName}`);
-        }
-        // Check for immediate spawn failure on Windows
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            proc.on("error", (err) => {
-                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.`));
-                }
-            });
-            proc.on("exit", (code) => {
-                if (!settled && code !== null) {
-                    settled = true;
-                    reject(new Error(`Package manager exited immediately for: ${packageName} (code: ${code})`));
-                }
-            });
-            setTimeout(() => {
-                if (!settled) {
-                    settled = true;
-                    resolve();
-                }
-            }, 50);
-        });
-        // Attach permanent error handler
-        _attachErrorHandler(proc, packageName);
-        unrefLspProcessHandles(proc);
-        return {
-            process: proc,
-            stdin: proc.stdin,
-            stdout: proc.stdout,
-            stderr: proc.stderr,
-            pid: proc.pid ?? 0,
-        };
-    }
-    // --no prevents silent download of uncached packages; user must have
-    // already installed the LSP server via the interactive-install flow.
-    return launchLSP("npx", ["--no", packageName, ...args], options);
-}
 /**
  * Spawn via Node.js directly
  */

package/dist/clients/mcp/review.js

@@ -7,6 +7,7 @@
  * `pilens_analyze mode=fresh` measures the just-built code first-hand.
  */
 import { spawn } from "node:child_process";
+import { pmBinary, resolveNodePackageManager, runScriptArgs, } from "../package-manager.js";
 import { safeSpawnAsync } from "../safe-spawn.js";
 /**
  * Which npm script rebuilds the layout the server is running from. A server at
@@ -71,13 +72,14 @@ export function analyzeFileFresh(workerPath, file, cwd, options = {}, timeoutMs
     });
 }
 /**
- * Run `npm run <script>` in the pi-lens repo. Uses `safeSpawnAsync` (Windows
- * `.cmd`/shell-aware) since the command is plain `npm`. `ignoreAmbientSignal` —
- * a rebuild must run to completion.
+ * Run `<pm> run <script>` in the pi-lens repo, where `<pm>` is resolved from the
+ * repo's lockfile / installed managers. Uses `safeSpawnAsync` (Windows
+ * `.cmd`/shell-aware). `ignoreAmbientSignal` — a rebuild must run to completion.
  */
 export async function runRebuild(repoRoot, script, timeoutMs = 300_000) {
     const start = Date.now();
-    const res = await safeSpawnAsync("npm", ["run", script], {
+    const packageManager = await resolveNodePackageManager(repoRoot);
+    const res = await safeSpawnAsync(pmBinary(packageManager), runScriptArgs(script), {
         cwd: repoRoot,
         timeout: timeoutMs,
         ignoreAmbientSignal: true,
@@ -86,6 +88,7 @@ export async function runRebuild(repoRoot, script, timeoutMs = 300_000) {
     return {
         ok: !res.error && res.status === 0,
         script,
+        packageManager,
         durationMs: Date.now() - start,
         output: output.slice(-2000),
     };