pi-lens 3.8.39 → 3.8.40

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/pipeline.ts

@@ -725,7 +725,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 +739,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) {
@@ -946,9 +954,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/read-guard-tool-lines.ts

@@ -4,6 +4,9 @@ import { logReadGuardEvent } from "./read-guard-logger.js";
 
 export interface GuardLineResult {
 	touchedLines: [number, number] | undefined;
+	// Individual ranges for multi-edit calls (e.g. rename at 4 scattered spots).
+	// When set, read-guard checks each range independently instead of the bounding box.
+	editRanges?: [number, number][];
 	preflightError?: string;
 }
 
@@ -182,6 +185,7 @@ function resolveOldTextEdits(
 		Math.min(...starts),
 		Math.max(...ends),
 	];
+	const editRanges = resolvedRanges.length > 1 ? resolvedRanges : undefined;
 	logReadGuardEvent({
 		event: "touched_lines_detected",
 		sessionId,
@@ -194,7 +198,7 @@ function resolveOldTextEdits(
 			totalEditCount: edits.length,
 		},
 	});
-	return { touchedLines };
+	return { touchedLines, editRanges };
 }
 
 /**
@@ -309,6 +313,7 @@ export function getTouchedLinesForGuard(
 				return { touchedLines: undefined };
 			}
 			let oldTextTouchedLines: [number, number] | undefined;
+			let oldTextEditRanges: [number, number][] | undefined;
 			if (unresolvedOldTextEdits.length > 0 && filePath) {
 				const resolved = resolveOldTextEdits(
 					unresolvedOldTextEdits,
@@ -319,6 +324,7 @@ export function getTouchedLinesForGuard(
 					return resolved;
 				}
 				oldTextTouchedLines = resolved.touchedLines;
+				oldTextEditRanges = resolved.editRanges;
 			}
 			const starts = rangedEdits.map(([start]) => start);
 			const ends = rangedEdits.map(([, end]) => end);
@@ -330,6 +336,13 @@ export function getTouchedLinesForGuard(
 				Math.min(...starts),
 				Math.max(...ends),
 			];
+			const allEditRanges = [...rangedEdits];
+			if (oldTextEditRanges?.length) {
+				allEditRanges.push(...oldTextEditRanges);
+			} else if (oldTextTouchedLines) {
+				allEditRanges.push(oldTextTouchedLines);
+			}
+			const editRanges = allEditRanges.length > 1 ? allEditRanges : undefined;
 			if (filePath) {
 				logReadGuardEvent({
 					event: "touched_lines_detected",
@@ -348,7 +361,7 @@ export function getTouchedLinesForGuard(
 					},
 				});
 			}
-			return { touchedLines };
+			return { touchedLines, editRanges };
 		}
 		if (filePath) {
 			logReadGuardEvent({

package/clients/read-guard.ts

@@ -136,6 +136,7 @@ export class ReadGuard {
 	checkEdit(
 		filePath: string,
 		touchedLines?: [number, number],
+		editRanges?: [number, number][],
 	): ReadGuardVerdict {
 		// Check exemptions
 		if (this.exemptions.has(filePath)) {
@@ -195,44 +196,50 @@ export class ReadGuard {
 		}
 
 		// 3. Range coverage check
-		const coverage = this.checkCoverage(filePath, touchedLines);
-
-		if (coverage.covered) {
-			const verdict = this.allow();
-			this.recordVerdict(filePath, "edit", touchedLines, verdict, {
-				reasonKind: coverage.viaSymbol ? "symbol_coverage" : "range_coverage",
-				viaSymbol: coverage.viaSymbol,
-			});
-			return verdict;
+		// When the edit touches multiple disjoint spots (e.g. rename across 4 tool
+		// registrations), check each spot independently. Collapsing to a bounding
+		// box would falsely flag reads that cover exactly the right lines.
+		const rangesToCheck: [number, number][] =
+			editRanges && editRanges.length > 1 ? editRanges : [touchedLines];
+
+		let viaSymbol = false;
+		for (const range of rangesToCheck) {
+			const coverage = this.checkCoverage(filePath, range);
+			if (!coverage.covered) {
+				const lastRead = fileReads[fileReads.length - 1];
+				const [editStart, editEnd] = range;
+				const lastReadEnd =
+					lastRead.effectiveOffset + lastRead.effectiveLimit - 1;
+				const verdict = this.blockOrWarn(
+					"out-of-range",
+					`🔴 BLOCKED — Edit outside read range\n\nYou read \`${filePath}\` lines ${lastRead.effectiveOffset}-${lastReadEnd}${lastRead.enclosingSymbol ? ` (${lastRead.enclosingSymbol.kind} \`${lastRead.enclosingSymbol.name}\`)` : ""}, but your edit touches lines ${editStart}-${editEnd}.\n\nThe edit target is outside the context you previously read.\nTo proceed:\n  1. Read the relevant section: \`read path="${filePath}" offset=${Math.max(1, editStart - 5)} limit=${Math.min(30, editEnd - editStart + 10)}\`\n  2. Or read the full file: \`read path="${filePath}"\``,
+					{
+						editRange: range,
+						readRanges: fileReads.map((r) => ({
+							start: r.effectiveOffset,
+							end: r.effectiveOffset + r.effectiveLimit - 1,
+						})),
+						symbolRanges: fileReads
+							.filter((r) => r.enclosingSymbol)
+							.map((r) => ({
+								name: r.enclosingSymbol!.name,
+								start: r.enclosingSymbol!.startLine,
+								end: r.enclosingSymbol!.endLine,
+							})),
+					},
+				);
+				this.recordVerdict(filePath, "edit", touchedLines, verdict, {
+					reasonKind: "out_of_range",
+				});
+				return verdict;
+			}
+			if (coverage.viaSymbol) viaSymbol = true;
 		}
 
-		// Not covered — block or warn
-		const lastRead = fileReads[fileReads.length - 1];
-		const [editStart, editEnd] = touchedLines;
-		const lastReadEnd = lastRead.effectiveOffset + lastRead.effectiveLimit - 1;
-		const symbolCtx = lastRead.enclosingSymbol
-			? ` (${lastRead.enclosingSymbol.kind} \`${lastRead.enclosingSymbol.name}\`)`
-			: "";
-		const verdict = this.blockOrWarn(
-			"out-of-range",
-			`🔴 BLOCKED — Edit outside read range\n\nYou read \`${filePath}\` lines ${lastRead.effectiveOffset}-${lastReadEnd}${symbolCtx}, but your edit touches lines ${editStart}-${editEnd}.\n\nThe edit target is outside the context you previously read.\nTo proceed:\n  1. Read the relevant section: \`read path="${filePath}" offset=${Math.max(1, editStart - 5)} limit=${Math.min(30, editEnd - editStart + 10)}\`\n  2. Or read the full file: \`read path="${filePath}"\``,
-			{
-				editRange: touchedLines,
-				readRanges: fileReads.map((r) => ({
-					start: r.effectiveOffset,
-					end: r.effectiveOffset + r.effectiveLimit - 1,
-				})),
-				symbolRanges: fileReads
-					.filter((r) => r.enclosingSymbol)
-					.map((r) => ({
-						name: r.enclosingSymbol!.name,
-						start: r.enclosingSymbol!.startLine,
-						end: r.enclosingSymbol!.endLine,
-					})),
-			},
-		);
+		const verdict = this.allow();
 		this.recordVerdict(filePath, "edit", touchedLines, verdict, {
-			reasonKind: "out_of_range",
+			reasonKind: viaSymbol ? "symbol_coverage" : "range_coverage",
+			viaSymbol,
 		});
 		return verdict;
 	}
@@ -249,6 +256,15 @@ export class ReadGuard {
 		}
 	}
 
+	/**
+	 * Refresh the FileTime stamp after the model's own write lands on disk.
+	 * Call this from the tool_result handler so the next checkEdit on the same
+	 * file doesn't see "file_modified" caused by our own previous edit.
+	 */
+	recordWritten(filePath: string): void {
+		this.fileTime.read(filePath);
+	}
+
 	/**
 	 * Add a one-time exemption for a file.
 	 * Called via /lens-allow-edit command.
@@ -473,7 +489,11 @@ export class ReadGuard {
 		const reads = this.reads.get(filePath) ?? [];
 		logReadGuardEvent({
 			event:
-				verdict.action === "allow" ? "edit_allowed" : (verdict.action === "warn" ? "edit_warned" : "edit_blocked"),
+				verdict.action === "allow"
+					? "edit_allowed"
+					: verdict.action === "warn"
+						? "edit_warned"
+						: "edit_blocked",
 			sessionId: this.sessionId,
 			filePath,
 			metadata: {

package/clients/runtime-session.ts

@@ -5,6 +5,7 @@ import type { BiomeClient } from "./biome-client.js";
 import type { CacheManager } from "./cache-manager.js";
 import type { DependencyChecker } from "./dependency-checker.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
+import { clearAllSessions as clearFileTimeSessions } from "./file-time.js";
 import { getKnipIgnorePatterns } from "./file-utils.js";
 import type { GoClient } from "./go-client.js";
 import type { JscpdClient } from "./jscpd-client.js";
@@ -440,6 +441,7 @@ export async function handleSessionStart(
 
 	metricsClient.reset();
 	getDiagnosticTracker().reset();
+	clearFileTimeSessions();
 	runtime.complexityBaselines.clear();
 	resetDispatchBaselines();
 	runtime.resetForSession();

package/clients/runtime-tool-result.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import type { BiomeClient } from "./biome-client.js";
 import type { CacheManager } from "./cache-manager.js";
 import { createFileTime } from "./file-time.js";
+import type { ReadGuard } from "./read-guard.js";
 import { getFormatService } from "./format-service.js";
 import { resolveLanguageRootForFile } from "./language-profile.js";
 import { logLatency } from "./latency-logger.js";
@@ -35,6 +36,7 @@ interface ToolResultDeps {
 	resetLSPService: () => void;
 	agentBehaviorRecord: (toolName: string, filePath?: string) => unknown[];
 	formatBehaviorWarnings: (warnings: unknown[]) => string;
+	readGuard?: ReadGuard;
 }
 
 function parseDiffRanges(diff: string): { start: number; end: number }[] {
@@ -77,6 +79,13 @@ const lastAnalyzedStateByFile = new Map<
 	{ turnIndex: number; stateHash: string }
 >();
 
+// Called at turn_start — entries from the previous turn can never match the new
+// turnIndex so they're dead weight. Clearing here keeps the map bounded to the
+// files touched in the current turn only (typically < 20).
+export function clearLastAnalyzedStateCache(): void {
+	lastAnalyzedStateByFile.clear();
+}
+
 function getFileStateHash(filePath: string): string {
 	try {
 		const content = nodeFs.readFileSync(filePath);
@@ -108,7 +117,9 @@ export async function handleToolResult(deps: ToolResultDeps): Promise<{
 	const rawFilePath = (event.input as { path?: string }).path;
 	const workspaceRoot = runtime.projectRoot || process.cwd();
 	const filePath = rawFilePath
-		? (path.isAbsolute(rawFilePath) ? rawFilePath : path.resolve(workspaceRoot, rawFilePath))
+		? path.isAbsolute(rawFilePath)
+			? rawFilePath
+			: path.resolve(workspaceRoot, rawFilePath)
 		: rawFilePath;
 	const behaviorWarnings = agentBehaviorRecord(event.toolName, filePath);
 
@@ -125,6 +136,10 @@ export async function handleToolResult(deps: ToolResultDeps): Promise<{
 		return;
 	}
 
+	// Refresh the read-guard's FileTime stamp so that the model's own write
+	// doesn't trigger a spurious "file_modified" block on the next edit.
+	deps.readGuard?.recordWritten(filePath);
+
 	// Keep cachedExports in sync after each write/edit so the pre-write STOP
 	// check doesn't fire on names that were removed from this file this session.
 	if (runtime.cachedExports.size > 0 && nodeFs.existsSync(filePath)) {
@@ -177,6 +192,14 @@ export async function handleToolResult(deps: ToolResultDeps): Promise<{
 	// tool_result is emitted after write/edit has already been applied.
 	// Asserting pre-write stamps here produces false positives on rapid edits.
 	sessionFileTime.read(filePath);
+	if (!getFlag("no-read-guard")) {
+		const readGuard = (
+			runtime as {
+				readGuard?: { recordWritten?: (writtenPath: string) => void };
+			}
+		).readGuard;
+		readGuard?.recordWritten?.(filePath);
+	}
 
 	const toolResultStart = Date.now();
 	dbg(`tool_result: tracking turn state for ${event.toolName} on ${filePath}`);