pi-lens 3.8.39 → 3.8.41

package/clients/lsp/launch.ts

@@ -402,7 +402,19 @@ function _attachErrorHandler(
 	proc.on("error", (err) => {
 		if (logContext) {
 			logSessionStart(
-				"lsp process " + context + ": spawn-error command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + " error=" + err.message + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
+				"lsp process " +
+					context +
+					": spawn-error command=" +
+					logContext.command +
+					" args=" +
+					JSON.stringify(logContext.args) +
+					" cwd=" +
+					logContext.cwd +
+					" pid=" +
+					(logContext.pid ?? 0) +
+					" error=" +
+					err.message +
+					(stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
 			);
 		}
 
@@ -422,12 +434,37 @@ function _attachErrorHandler(
 		if (code !== 0 && code !== null) {
 			if (logContext) {
 				logSessionStart(
-					"lsp process " + context + ": closed code=" + code + (signal ? " signal=" + signal : "") + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
+					"lsp process " +
+						context +
+						": closed code=" +
+						code +
+						(signal ? " signal=" + signal : "") +
+						" command=" +
+						logContext.command +
+						" args=" +
+						JSON.stringify(logContext.args) +
+						" cwd=" +
+						logContext.cwd +
+						" pid=" +
+						(logContext.pid ?? 0) +
+						(stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
 				);
 			}
 		} else if (signal && logContext) {
 			logSessionStart(
-				"lsp process " + context + ": closed signal=" + signal + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
+				"lsp process " +
+					context +
+					": closed signal=" +
+					signal +
+					" command=" +
+					logContext.command +
+					" args=" +
+					JSON.stringify(logContext.args) +
+					" cwd=" +
+					logContext.cwd +
+					" pid=" +
+					(logContext.pid ?? 0) +
+					(stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""),
 			);
 		}
 	});
@@ -451,7 +488,7 @@ export async function launchLSP(
 	command: string,
 	args: string[] = [],
 	options: SpawnOptions & {
-		startupFailureWindowMs?: number,
+		startupFailureWindowMs?: number;
 	} = {},
 ): Promise<LSPProcess> {
 	const cwd = String(options.cwd ?? process.cwd());
@@ -467,7 +504,9 @@ export async function launchLSP(
 	// - If already absolute, use as-is
 	// - If it's a simple command (no path separators), let system find it via PATH
 	// - Otherwise, resolve relative to cwd
-	const isRelativePath = !path.isAbsolute(command) && (command.includes(path.sep) || command.includes("/"));
+	const isRelativePath =
+		!path.isAbsolute(command) &&
+		(command.includes(path.sep) || command.includes("/"));
 	const explicitCommand = isRelativePath ? path.resolve(cwd, command) : command;
 	const resolvedCommand =
 		!path.isAbsolute(command) &&
@@ -645,7 +684,7 @@ export async function launchLSP(
 					return DEFAULT_STARTUP_FAILURE_WINDOW_MS;
 				}
 			})();
-				
+
 			// Give shell-backed Windows launches a slightly longer window because
 			// npm/cmd shims can fail asynchronously after the initial spawn succeeds.
 			setTimeout(() => {
@@ -803,38 +842,72 @@ export async function launchViaPython(
  * Stop an LSP process gracefully
  */
 export async function stopLSP(handle: LSPProcess): Promise<void> {
+	if (handle.process.exitCode !== null || handle.process.signalCode !== null) {
+		return;
+	}
+
 	return new Promise((resolve) => {
-		// Send SIGTERM first
-		handle.process.kill("SIGTERM");
-
-		// Force kill after timeout
-		const timeout = setTimeout(() => {
-			if (!handle.process.killed) {
-				if (isWindows && handle.pid > 0) {
-					// SIGKILL is unreliable for cmd.exe/PowerShell child trees on Windows.
-					// taskkill /F /T kills the process and all its children.
-					try {
-						nodeSpawn("taskkill", ["/F", "/T", "/PID", String(handle.pid)], {
-							shell: false,
-							windowsHide: true,
-						});
-					} catch {
-						handle.process.kill("SIGKILL");
-					}
-				} else {
+		let settled = false;
+		let forceTimeout: ReturnType<typeof setTimeout> | undefined;
+		let giveUpTimeout: ReturnType<typeof setTimeout> | undefined;
+
+		const done = () => {
+			if (settled) return;
+			settled = true;
+			if (forceTimeout) clearTimeout(forceTimeout);
+			if (giveUpTimeout) clearTimeout(giveUpTimeout);
+			handle.process.off("exit", done);
+			handle.process.off("error", done);
+			resolve();
+		};
+
+		handle.process.once("exit", done);
+		handle.process.once("error", done);
+
+		const killWindowsTree = (): boolean => {
+			if (!isWindows || handle.pid <= 0) return false;
+			try {
+				// Absolute path avoids PATH-resolution substitution on Windows.
+				const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
+				const killer = nodeSpawn(
+					taskkill,
+					["/F", "/T", "/PID", String(handle.pid)],
+					{
+						shell: false,
+						windowsHide: true,
+					},
+				);
+				killer.once("error", done);
+				return true;
+			} catch {
+				return false;
+			}
+		};
+
+		try {
+			// On Windows, kill the tree first; killing the direct child can orphan
+			// grandchildren (e.g. tsserver.js behind a cmd/npm shim).
+			if (!killWindowsTree()) {
+				handle.process.kill("SIGTERM");
+			}
+		} catch {
+			done();
+			return;
+		}
+
+		forceTimeout = setTimeout(() => {
+			if (settled) return;
+			try {
+				if (!killWindowsTree()) {
 					handle.process.kill("SIGKILL");
 				}
+			} catch {
+				done();
+				return;
 			}
+			// If the process had already exited before listeners were attached, no
+			// exit event will arrive. Resolve rather than hanging test cleanup forever.
+			giveUpTimeout = setTimeout(done, 500);
 		}, 5000);
-
-		handle.process.on("exit", () => {
-			clearTimeout(timeout);
-			resolve();
-		});
-
-		handle.process.on("error", () => {
-			clearTimeout(timeout);
-			resolve();
-		});
 	});
 }

package/clients/lsp/server-strategies.ts

@@ -0,0 +1,71 @@
+/**
+ * Per-Server Diagnostic Strategies for pi-lens LSP
+ *
+ * Codifies known server behavior so timing decisions (debounce, retry budget,
+ * first-push seeding) are automatic rather than one-size-fits-all.
+ *
+ * Env var overrides (PI_LENS_LSP_*) always take precedence over strategy values.
+ */
+
+export interface DiagnosticStrategy {
+	/** Seed the push cache on the very first publishDiagnostics notification.
+	 *  True for servers whose first push is known to be complete. */
+	seedFirstPush: boolean;
+	/** Maximum ms to spend retrying pull diagnostics when the first pull returns
+	 *  empty. 0 = skip pull retry entirely, rely on push. */
+	pullRetryBudgetMs: number;
+	/** Debounce window for push diagnostics (ms). Applied in both the notification
+	 *  handler and the waitForDiagnostics listener. */
+	debounceMs: number;
+	/** The aggregate timeout for waitForDiagnostics per this server (ms).
+	 *  Overrides the global DIAGNOSTICS_AGGREGATE_WAIT_MS in the service layer. */
+	aggregateWaitMs: number;
+	/** Whether this server benefits from a second pull after an empty fast first
+	 *  pull. TypeScript: no (rely on push). rust-analyzer: yes (incremental). */
+	expectSemanticSecondPush: boolean;
+}
+
+export const SERVER_DIAGNOSTIC_STRATEGIES: Record<string, DiagnosticStrategy> =
+	{
+		typescript: {
+			seedFirstPush: true,
+			pullRetryBudgetMs: 0,
+			debounceMs: 50,
+			aggregateWaitMs: 1000,
+			expectSemanticSecondPush: false,
+		},
+		"rust-analyzer": {
+			seedFirstPush: false,
+			pullRetryBudgetMs: 500,
+			debounceMs: 150,
+			aggregateWaitMs: 3000,
+			expectSemanticSecondPush: true,
+		},
+		pyright: {
+			seedFirstPush: false,
+			pullRetryBudgetMs: 250,
+			debounceMs: 100,
+			aggregateWaitMs: 1500,
+			expectSemanticSecondPush: false,
+		},
+		eslint: {
+			seedFirstPush: true,
+			pullRetryBudgetMs: 0,
+			debounceMs: 200,
+			aggregateWaitMs: 2000,
+			expectSemanticSecondPush: false,
+		},
+	};
+
+/** Fallback for unknown servers. Conservative defaults. */
+export const DEFAULT_STRATEGY: DiagnosticStrategy = {
+	seedFirstPush: false,
+	pullRetryBudgetMs: 250,
+	debounceMs: 150,
+	aggregateWaitMs: 1500,
+	expectSemanticSecondPush: false,
+};
+
+export function getStrategy(serverId: string): DiagnosticStrategy {
+	return SERVER_DIAGNOSTIC_STRATEGIES[serverId] ?? DEFAULT_STRATEGY;
+}

package/clients/lsp/server.ts

@@ -12,10 +12,11 @@ import { existsSync, mkdirSync, readdirSync } from "node:fs";
 import { access, appendFile, mkdir, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { KIND_EXTENSIONS } from "../file-kinds.js"
+import { KIND_EXTENSIONS } from "../file-kinds.js";
 import { ensureTool, getToolEnvironment } from "../installer/index.js";
 import { logLatency } from "../latency-logger.js";
 import { type LSPProcess, launchLSP } from "./launch.js";
+import { normalizeMapKey } from "./path-utils.js";
 
 // --- Types ---
 
@@ -489,56 +490,90 @@ export function NearestRoot(
 	excludePatterns?: string[],
 	stopDir?: string,
 ): RootFunction {
+	// Per-instance caches — each NearestRoot(markers) call gets its own Map so
+	// different servers (e.g. TypeScript vs Go) with different marker sets never
+	// share entries. vi.resetModules() in tests resets module state between cases.
+	const cache = new Map<string, string>();
+	const inFlight = new Map<string, Promise<string | undefined>>();
+
 	return async (file: string): Promise<string | undefined> => {
-		let currentDir = path.resolve(path.dirname(file));
-		const fsRoot = path.parse(currentDir).root;
-		const stop = stopDir ? path.resolve(stopDir) : fsRoot;
+		// Cache key is the resolved directory — all files in the same dir share a root.
+		const startDir = path.resolve(path.dirname(file));
+		const dirKey = normalizeMapKey(startDir);
+
+		// Fast path: already resolved for this directory.
+		const cached = cache.get(dirKey);
+		if (cached !== undefined) return cached;
+
+		// In-flight deduplication: if N parallel pipelines edit files in the same
+		// directory simultaneously, only one stat-walk runs; the rest await the same
+		// promise. This is the main fix for parallel-turn LSP timeout spikes.
+		const flying = inFlight.get(dirKey);
+		if (flying) return flying;
+
+		const promise = (async (): Promise<string | undefined> => {
+			let currentDir = startDir;
+			const fsRoot = path.parse(currentDir).root;
+			const stop = stopDir ? path.resolve(stopDir) : fsRoot;
+
+			while (true) {
+				if (
+					stop !== fsRoot &&
+					currentDir.startsWith(stop + path.sep) === false &&
+					currentDir !== stop
+				) {
+					break;
+				}
 
-		while (true) {
-			if (
-				stop !== fsRoot &&
-				currentDir.startsWith(stop + path.sep) === false &&
-				currentDir !== stop
-			) {
-				break;
-			}
+				// Check exclude patterns — skip this dir (but keep walking up)
+				if (excludePatterns) {
+					let excluded = false;
+					for (const pattern of excludePatterns) {
+						try {
+							await stat(path.join(currentDir, pattern));
+							excluded = true;
+							break;
+						} catch {
+							/* not found */
+						}
+					}
+					if (excluded) {
+						currentDir = path.dirname(currentDir);
+						continue;
+					}
+				}
 
-			// Check exclude patterns — skip this dir (but keep walking up)
-			if (excludePatterns) {
-				let excluded = false;
-				for (const pattern of excludePatterns) {
+				// Check include patterns
+				for (const pattern of includePatterns) {
 					try {
 						await stat(path.join(currentDir, pattern));
-						excluded = true;
-						break;
+						return currentDir;
 					} catch {
 						/* not found */
 					}
 				}
-				if (excluded) {
-					currentDir = path.dirname(currentDir);
-					continue;
-				}
-			}
 
-			// Check include patterns
-			for (const pattern of includePatterns) {
-				try {
-					await stat(path.join(currentDir, pattern));
-					return currentDir;
-				} catch {
-					/* not found */
+				if (currentDir === stop || currentDir === fsRoot) {
+					break;
 				}
-			}
 
-			if (currentDir === stop || currentDir === fsRoot) {
-				break;
+				currentDir = path.dirname(currentDir);
 			}
 
-			currentDir = path.dirname(currentDir);
-		}
+			return undefined;
+		})();
 
-		return undefined;
+		inFlight.set(dirKey, promise);
+		try {
+			const result = await promise;
+			// Only cache successful hits. Undefined results are not cached so that
+			// a newly-created root marker (e.g. package.json added mid-session) is
+			// detected on the next call.
+			if (result !== undefined) cache.set(dirKey, result);
+			return result;
+		} finally {
+			inFlight.delete(dirKey);
+		}
 	};
 }
 
@@ -1362,11 +1397,7 @@ export const NixServer = createInteractiveServer({
 export const BashServer: LSPServerInfo = {
 	id: "bash",
 	name: "Bash Language Server",
-	extensions: [
-		".bash",
-		".sh",
-		".zsh",
-	],
+	extensions: [".bash", ".sh", ".zsh"],
 	root: FileDirRoot,
 	spawn(root, options) {
 		return resolveAndLaunch(
@@ -1384,10 +1415,7 @@ export const BashServer: LSPServerInfo = {
 export const DockerServer: LSPServerInfo = {
 	id: "docker",
 	name: "Dockerfile Language Server",
-	extensions: [
-		".dockerfile",
-		"Dockerfile",
-	],
+	extensions: [".dockerfile", "Dockerfile"],
 	root: RootWithFallback(
 		PriorityRoot([
 			[
@@ -1525,9 +1553,7 @@ export const PrismaServer: LSPServerInfo = {
 export const VueServer: LSPServerInfo = {
 	id: "vue",
 	name: "Vue Language Server",
-	extensions: [
-		".vue",
-	],
+	extensions: [".vue"],
 	root: RootWithFallback(
 		IgnoreHomeRoot(
 			createRootDetector([
@@ -1577,9 +1603,7 @@ export const VueServer: LSPServerInfo = {
 export const SvelteServer: LSPServerInfo = {
 	id: "svelte",
 	name: "Svelte Language Server",
-	extensions: [
-		".svelte",
-	],
+	extensions: [".svelte"],
 	root: RootWithFallback(
 		IgnoreHomeRoot(
 			createRootDetector([
@@ -1621,12 +1645,7 @@ export const ESLintServer: LSPServerInfo = {
 	id: "eslint",
 	name: "ESLint Language Server",
 	// Note: .ts/.tsx handled by TypeScript LSP + Biome
-	extensions: [
-		".js",
-		".jsx",
-		".svelte",
-		".vue",
-	],
+	extensions: [".js", ".jsx", ".svelte", ".vue"],
 	root: IgnoreHomeRoot(
 		createRootDetector([
 			".eslintrc",

package/clients/path-utils.ts

@@ -151,3 +151,20 @@ export function isUnderDir(child: string, parent: string): boolean {
 	const parentPrefix = normParent.endsWith("/") ? normParent : `${normParent}/`;
 	return normChild === normParent || normChild.startsWith(parentPrefix);
 }
+
+/**
+ * Returns true when a file should be treated as external/vendor and excluded
+ * from pipelines (LSP, diagnostics, complexity, read-guard, etc.).
+ *
+ * Two cases:
+ *   1. Outside the project root entirely (e.g. global npm packages, system files)
+ *   2. Inside the project but under node_modules (local deps, never user-editable)
+ */
+export function isExternalOrVendorFile(
+	filePath: string,
+	projectRoot: string,
+): boolean {
+	if (!isUnderDir(filePath, projectRoot)) return true;
+	const normalized = normalizeFilePath(filePath);
+	return normalized.includes("/node_modules/");
+}

package/clients/pipeline.ts

@@ -15,6 +15,7 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import type { BiomeClient } from "./biome-client.js";
+import { recordDiagnostics } from "./widget-state.js";
 import { getDiagnosticLogger } from "./diagnostic-logger.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
 import {
@@ -725,7 +726,12 @@ export async function runFormatPhase(
 		if (result.anyChanged) {
 			formatChanged = true;
 			dbg(
-				"autoformat: " + result.formatters.map((f) => f.name + "(" + (f.changed ? "changed" : "unchanged") + ")").join(", "),
+				"autoformat: " +
+					result.formatters
+						.map(
+							(f) => f.name + "(" + (f.changed ? "changed" : "unchanged") + ")",
+						)
+						.join(", "),
 			);
 		}
 		if (!result.allSucceeded) {
@@ -734,7 +740,10 @@ export async function runFormatPhase(
 				...failures.map((f) => `${f.name}: ${f.error ?? "unknown error"}`),
 			);
 			dbg(
-				"autoformat: " + failures.map((f) => f.name + " failed: " + (f.error ?? "unknown error")).join("; "),
+				"autoformat: " +
+					failures
+						.map((f) => f.name + " failed: " + (f.error ?? "unknown error"))
+						.join("; "),
 			);
 		}
 	} catch (err) {
@@ -889,6 +898,7 @@ export async function runPipeline(
 			writeIndex: ctx.telemetry?.writeIndex ?? 0,
 		},
 	);
+	recordDiagnostics(filePath, dispatchResult.diagnostics);
 	const hasBlockers = dispatchResult.hasBlockers;
 
 	if (dispatchResult.diagnostics.length > 0) {
@@ -946,9 +956,17 @@ export async function runPipeline(
 		const changedList = [...piChangedFiles].map((changedFile) =>
 			toRunnerDisplayPath(cwd, changedFile),
 		);
-		const topFiles = changedList.slice(0, 8).map((f) => "  - " + f).join("\n");
-		const overflow = changedList.length > 8 ? "\n  - ... and " + (changedList.length - 8) + " more" : "";
-		const fileList = changedList.length ? "\nModified files:\n" + topFiles + overflow : "";
+		const topFiles = changedList
+			.slice(0, 8)
+			.map((f) => "  - " + f)
+			.join("\n");
+		const overflow =
+			changedList.length > 8
+				? "\n  - ... and " + (changedList.length - 8) + " more"
+				: "";
+		const fileList = changedList.length
+			? "\nModified files:\n" + topFiles + overflow
+			: "";
 		output += `\n\n⚠️ **File was modified by auto-format/fix. You MUST re-read modified file(s) before making any further edits — the content on disk has changed (whitespace, indentation, quotes, or code). Editing from memory will produce mismatches.**${fileList}`;
 	}
 	phase.end("dispatch_lint", {

package/clients/production-readiness.ts

@@ -256,9 +256,9 @@ function validateConfig(root: string): CategoryResult {
 
 	const found: string[] = [];
 
-	for (const { file, critical, dir } of checks) {
+	for (const { file, critical } of checks) {
 		const filePath = path.join(root, file);
-		const exists = dir ? fs.existsSync(filePath) : fs.existsSync(filePath);
+		const exists = fs.existsSync(filePath);
 		if (exists) {
 			found.push(file);
 		} else if (critical) {

package/clients/read-guard-logger.ts

@@ -4,6 +4,19 @@ import * as path from "node:path";
 
 const READ_GUARD_LOG_DIR = path.join(os.homedir(), ".pi-lens");
 const READ_GUARD_LOG_FILE = path.join(READ_GUARD_LOG_DIR, "read-guard.log");
+const READ_GUARD_LOG_BACKUP_FILE = path.join(
+	READ_GUARD_LOG_DIR,
+	"read-guard.log.1",
+);
+const MAX_LOG_BYTES = Math.max(
+	128 * 1024,
+	Number.parseInt(process.env.PI_LENS_READ_GUARD_MAX_BYTES ?? "1048576", 10) ||
+		1048576,
+);
+const VERBOSE_READ_GUARD_LOG =
+	process.env.PI_LENS_READ_GUARD_VERBOSE === "1" ||
+	process.env.PI_LENS_READ_GUARD_LOG === "verbose";
+const LOG_ALLOWED_EDITS = process.env.PI_LENS_READ_GUARD_LOG_ALLOWS === "1";
 
 try {
 	if (!fs.existsSync(READ_GUARD_LOG_DIR)) {
@@ -26,15 +39,42 @@ export interface ReadGuardLogEntry {
 	metadata?: Record<string, unknown>;
 }
 
+function shouldLogEvent(event: string): boolean {
+	if (VERBOSE_READ_GUARD_LOG) return true;
+	if (event === "edit_allowed") return LOG_ALLOWED_EDITS;
+	return (
+		event === "edit_blocked" ||
+		event === "edit_warned" ||
+		event === "exemption_added" ||
+		event === "oldtext_not_found" ||
+		event === "oldtext_duplicate" ||
+		event === "touched_lines_missing"
+	);
+}
+
+function rotateIfNeeded(): void {
+	try {
+		if (!fs.existsSync(READ_GUARD_LOG_FILE)) return;
+		const size = fs.statSync(READ_GUARD_LOG_FILE).size;
+		if (size < MAX_LOG_BYTES) return;
+		try {
+			fs.rmSync(READ_GUARD_LOG_BACKUP_FILE, { force: true });
+		} catch {}
+		fs.renameSync(READ_GUARD_LOG_FILE, READ_GUARD_LOG_BACKUP_FILE);
+	} catch {}
+}
+
 export function logReadGuardEvent(entry: ReadGuardLogEntry): void {
 	if (
 		process.env.PI_LENS_TEST_MODE === "1" ||
-		(process.env.VITEST && process.env.PI_LENS_TEST_MODE !== "0")
+		(process.env.VITEST && process.env.PI_LENS_TEST_MODE !== "0") ||
+		!shouldLogEvent(entry.event)
 	) {
 		return;
 	}
 	const line = `${JSON.stringify({ ts: new Date().toISOString(), ...entry })}\n`;
 	try {
+		rotateIfNeeded();
 		fs.appendFileSync(READ_GUARD_LOG_FILE, line);
 	} catch {}
 }