pi-lens 3.8.21 → 3.8.22

package/clients/lsp/client.ts

@@ -49,6 +49,53 @@ export interface LSPHover {
 	range?: LSPLocation["range"];
 }
 
+export interface LSPSignatureHelp {
+	signatures: Array<{
+		label: string;
+		documentation?: string | { kind: string; value: string };
+		parameters?: Array<{
+			label: string | [number, number];
+			documentation?: string | { kind: string; value: string };
+		}>;
+	}>;
+	activeSignature?: number;
+	activeParameter?: number;
+}
+
+export interface LSPCodeAction {
+	title: string;
+	kind?: string;
+	diagnostics?: LSPDiagnostic[];
+	edit?: unknown;
+	command?: unknown;
+	data?: unknown;
+}
+
+export interface LSPWorkspaceEdit {
+	changes?: Record<string, unknown[]>;
+	documentChanges?: unknown[];
+	changeAnnotations?: Record<string, unknown>;
+}
+
+export interface LSPWorkspaceDiagnosticsSupport {
+	advertised: boolean;
+	mode: "pull" | "push-only";
+	diagnosticProviderKind: string;
+}
+
+export interface LSPOperationSupport {
+	definition: boolean;
+	references: boolean;
+	hover: boolean;
+	signatureHelp: boolean;
+	documentSymbol: boolean;
+	workspaceSymbol: boolean;
+	codeAction: boolean;
+	rename: boolean;
+	implementation: boolean;
+	callHierarchy: boolean;
+}
+
 export interface LSPSymbol {
 	name: string;
 	kind: number;
@@ -93,6 +140,10 @@ export interface LSPClientInfo {
 	waitForDiagnostics(filePath: string, timeoutMs?: number): Promise<void>;
 	/** Get all tracked diagnostics (for cascade checking) */
 	getAllDiagnostics(): Map<string, LSPDiagnostic[]>;
+	/** Capability snapshot for workspace diagnostics support */
+	getWorkspaceDiagnosticsSupport(): LSPWorkspaceDiagnosticsSupport;
+	/** Capability snapshot for navigation/edit operations */
+	getOperationSupport(): LSPOperationSupport;
 	/** Go to definition — returns Location[] */
 	definition(
 		filePath: string,
@@ -112,10 +163,31 @@ export interface LSPClientInfo {
 		line: number,
 		character: number,
 	): Promise<LSPHover | null>;
+	/** Signature help at position */
+	signatureHelp(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<LSPSignatureHelp | null>;
 	/** Symbols in a document */
 	documentSymbol(filePath: string): Promise<LSPSymbol[]>;
 	/** Workspace-wide symbol search */
 	workspaceSymbol(query: string): Promise<LSPSymbol[]>;
+	/** Available code actions at a range */
+	codeAction(
+		filePath: string,
+		line: number,
+		character: number,
+		endLine: number,
+		endCharacter: number,
+	): Promise<LSPCodeAction[]>;
+	/** Rename symbol at position */
+	rename(
+		filePath: string,
+		line: number,
+		character: number,
+		newName: string,
+	): Promise<LSPWorkspaceEdit | null>;
 	/** Go to implementation */
 	implementation(
 		filePath: string,
@@ -141,8 +213,18 @@ export interface LSPClientInfo {
 
 // --- Constants ---
 
-const DIAGNOSTICS_DEBOUNCE_MS = 150; // ms — waits for follow-up semantic diagnostics
-const INITIALIZE_TIMEOUT_MS = 15_000; // 15s — npx downloads are handled by ensureTool, not here
+const DIAGNOSTICS_DEBOUNCE_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_DIAGNOSTICS_DEBOUNCE_MS",
+	150,
+); // ms — waits for follow-up semantic diagnostics
+const INITIALIZE_TIMEOUT_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_INIT_TIMEOUT_MS",
+	15_000,
+); // 15s — npx downloads are handled by ensureTool, not here
+const DIAGNOSTICS_WAIT_TIMEOUT_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_DIAGNOSTICS_WAIT_MS",
+	10_000,
+);
 
 // --- Client Factory ---
 
@@ -327,6 +409,9 @@ export async function createLSPClient(options: {
 		);
 	}
 
+	const workspaceDiagnosticsSupport = detectWorkspaceDiagnosticsSupport(initResult);
+	const operationSupport = detectOperationSupport(initResult);
+
 	// Send initialized notification
 	await safeSendNotification(connection, "initialized", {});
 
@@ -437,7 +522,15 @@ export async function createLSPClient(options: {
 			return new Map(diagnostics);
 		},
 
-		async waitForDiagnostics(filePath, timeoutMs = 10000) {
+		getWorkspaceDiagnosticsSupport() {
+			return workspaceDiagnosticsSupport;
+		},
+
+		getOperationSupport() {
+			return operationSupport;
+		},
+
+		async waitForDiagnostics(filePath, timeoutMs = DIAGNOSTICS_WAIT_TIMEOUT_MS) {
 			const normalizedPath = normalizeMapKey(filePath);
 
 			// Fast path: diagnostics already available
@@ -517,6 +610,20 @@ export async function createLSPClient(options: {
 			return result ?? null;
 		},
 
+		async signatureHelp(filePath, line, character) {
+			if (!isProcessAlive()) return null;
+			const uri = pathToFileURL(filePath).href;
+			const result = await safeSendRequest<LSPSignatureHelp>(
+				connection,
+				"textDocument/signatureHelp",
+				{
+					textDocument: { uri },
+					position: { line, character },
+				},
+			);
+			return result ?? null;
+		},
+
 		async documentSymbol(filePath) {
 			if (!isProcessAlive()) return [];
 			const uri = pathToFileURL(filePath).href;
@@ -542,6 +649,51 @@ export async function createLSPClient(options: {
 			return result ?? [];
 		},
 
+		async codeAction(
+			filePath,
+			line,
+			character,
+			endLine,
+			endCharacter,
+		) {
+			if (!isProcessAlive()) return [];
+			const uri = pathToFileURL(filePath).href;
+			const result = await safeSendRequest<unknown[]>(
+				connection,
+				"textDocument/codeAction",
+				{
+					textDocument: { uri },
+					range: {
+						start: { line, character },
+						end: { line: endLine, character: endCharacter },
+					},
+					context: {
+						diagnostics: diagnostics.get(normalizeMapKey(filePath)) ?? [],
+					},
+				},
+			);
+			if (!result || !Array.isArray(result)) return [];
+			return result.filter(
+				(item): item is LSPCodeAction =>
+					typeof item === "object" && item !== null && "title" in item,
+			);
+		},
+
+		async rename(filePath, line, character, newName) {
+			if (!isProcessAlive()) return null;
+			const uri = pathToFileURL(filePath).href;
+			const result = await safeSendRequest<LSPWorkspaceEdit>(
+				connection,
+				"textDocument/rename",
+				{
+					textDocument: { uri },
+					position: { line, character },
+					newName,
+				},
+			);
+			return result ?? null;
+		},
+
 		async implementation(filePath, line, character) {
 			if (!isProcessAlive()) return [];
 			const uri = pathToFileURL(filePath).href;
@@ -722,3 +874,77 @@ async function withTimeout<T>(
 		),
 	]);
 }
+
+function positiveIntFromEnv(name: string, fallback: number): number {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return parsed;
+}
+
+function detectWorkspaceDiagnosticsSupport(
+	initResult: unknown,
+): LSPWorkspaceDiagnosticsSupport {
+	const capabilities =
+		typeof initResult === "object" && initResult !== null
+			? (initResult as { capabilities?: Record<string, unknown> }).capabilities
+			: undefined;
+	const diagnosticProvider = capabilities?.diagnosticProvider;
+	if (!diagnosticProvider) {
+		return {
+			advertised: false,
+			mode: "push-only",
+			diagnosticProviderKind: "none",
+		};
+	}
+
+	if (typeof diagnosticProvider === "boolean") {
+		return {
+			advertised: diagnosticProvider,
+			mode: diagnosticProvider ? "pull" : "push-only",
+			diagnosticProviderKind: "boolean",
+		};
+	}
+
+	if (typeof diagnosticProvider === "object") {
+		return {
+			advertised: true,
+			mode: "pull",
+			diagnosticProviderKind: "object",
+		};
+	}
+
+	return {
+		advertised: false,
+		mode: "push-only",
+		diagnosticProviderKind: typeof diagnosticProvider,
+	};
+}
+
+function detectOperationSupport(initResult: unknown): LSPOperationSupport {
+	const capabilities =
+		typeof initResult === "object" && initResult !== null
+			? (initResult as { capabilities?: Record<string, unknown> }).capabilities
+			: undefined;
+
+	const hasProvider = (key: string): boolean => {
+		const value = capabilities?.[key];
+		if (value === undefined || value === null) return false;
+		if (typeof value === "boolean") return value;
+		return true;
+	};
+
+	return {
+		definition: hasProvider("definitionProvider"),
+		references: hasProvider("referencesProvider"),
+		hover: hasProvider("hoverProvider"),
+		signatureHelp: hasProvider("signatureHelpProvider"),
+		documentSymbol: hasProvider("documentSymbolProvider"),
+		workspaceSymbol: hasProvider("workspaceSymbolProvider"),
+		codeAction: hasProvider("codeActionProvider"),
+		rename: hasProvider("renameProvider"),
+		implementation: hasProvider("implementationProvider"),
+		callHierarchy: hasProvider("callHierarchyProvider"),
+	};
+}

package/clients/lsp/index.ts

@@ -53,6 +53,7 @@ export interface SpawnedServer {
 export class LSPService {
 	private state: LSPState;
 	private languagePolicyCache = new Map<string, { allowInstall: boolean; expiresAt: number }>();
+	private workspaceProbeLogged = new Set<string>();
 
 	constructor() {
 		this.state = {
@@ -192,11 +193,25 @@ export class LSPService {
 				root,
 				initialization: spawned.initialization,
 			});
+			const wsDiag =
+				typeof client.getWorkspaceDiagnosticsSupport === "function"
+					? client.getWorkspaceDiagnosticsSupport()
+					: {
+						advertised: false,
+						mode: "push-only" as const,
+						diagnosticProviderKind: "unavailable",
+					};
 
 			this.state.clients.set(key, client);
 			logSessionStart(
 				`lsp spawn ${server.id}: success source=${spawned.source ?? server.installPolicy ?? "unknown"} (${Date.now() - startedAt}ms)`,
 			);
+			if (!this.workspaceProbeLogged.has(key)) {
+				logSessionStart(
+					`lsp workspace-diag probe ${server.id}: advertised=${wsDiag.advertised} mode=${wsDiag.mode} provider=${wsDiag.diagnosticProviderKind}`,
+				);
+				this.workspaceProbeLogged.add(key);
+			}
 			return { client, info: server };
 		} catch (err) {
 			logSessionStart(
@@ -294,6 +309,15 @@ export class LSPService {
 		return spawned.client.hover(filePath, line, character);
 	}
 
+	/**
+	 * Navigation: signature help at cursor position
+	 */
+	async signatureHelp(filePath: string, line: number, character: number) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return null;
+		return spawned.client.signatureHelp(filePath, line, character);
+	}
+
 	/**
 	 * Navigation: symbols in document
 	 */
@@ -306,13 +330,98 @@ export class LSPService {
 	/**
 	 * Navigation: workspace-wide symbol search
 	 */
-	async workspaceSymbol(query: string) {
+	async workspaceSymbol(query: string, filePath?: string) {
+		if (filePath) {
+			const spawned = await this.getClientForFile(filePath);
+			if (!spawned) return [];
+			return spawned.client.workspaceSymbol(query);
+		}
+
 		// Use the first active client for workspace-level queries
 		const clients = Array.from(this.state.clients.values());
 		if (clients.length === 0) return [];
 		return clients[0].workspaceSymbol(query);
 	}
 
+	/**
+	 * Capability snapshot for LSP operations.
+	 * If filePath is provided, probes that server; otherwise uses first active client.
+	 */
+	async getOperationSupport(filePath?: string): Promise<
+		import("./client.js").LSPOperationSupport | null
+	> {
+		if (filePath) {
+			const spawned = await this.getClientForFile(filePath);
+			if (!spawned) return null;
+			const getter = spawned.client.getOperationSupport;
+			if (typeof getter !== "function") return null;
+			return getter();
+		}
+
+		const first = this.state.clients.values().next().value;
+		if (!first) return null;
+		const getter = first.getOperationSupport;
+		if (typeof getter !== "function") return null;
+		return getter();
+	}
+
+	/**
+	 * Capability snapshot for workspace diagnostics support.
+	 * If filePath is provided, probes that server; otherwise uses first active client.
+	 */
+	async getWorkspaceDiagnosticsSupport(filePath?: string): Promise<
+		import("./client.js").LSPWorkspaceDiagnosticsSupport | null
+	> {
+		if (filePath) {
+			const spawned = await this.getClientForFile(filePath);
+			if (!spawned) return null;
+			const getter = spawned.client.getWorkspaceDiagnosticsSupport;
+			if (typeof getter !== "function") return null;
+			return getter();
+		}
+
+		const first = this.state.clients.values().next().value;
+		if (!first) return null;
+		const getter = first.getWorkspaceDiagnosticsSupport;
+		if (typeof getter !== "function") return null;
+		return getter();
+	}
+
+	/**
+	 * Navigation: available code actions at position/range
+	 */
+	async codeAction(
+		filePath: string,
+		line: number,
+		character: number,
+		endLine: number,
+		endCharacter: number,
+	) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return [];
+		return spawned.client.codeAction(
+			filePath,
+			line,
+			character,
+			endLine,
+			endCharacter,
+		);
+	}
+
+	/**
+	 * Navigation: rename symbol at position
+	 */
+	async rename(
+		filePath: string,
+		line: number,
+		character: number,
+		newName: string,
+	) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return null;
+		return spawned.client.rename(filePath, line, character, newName);
+	}
+
 	/**
 	 * Navigation: go to implementation
 	 */
@@ -402,6 +511,7 @@ export class LSPService {
 		}
 		this.state.clients.clear();
 		this.state.broken.clear();
+		this.workspaceProbeLogged.clear();
 	}
 
 	/**

package/clients/pipeline.ts

@@ -672,8 +672,8 @@ export async function runPipeline(
 					for (const e of limited) {
 						const line = (e.range?.start?.line ?? 0) + 1;
 						const col = (e.range?.start?.character ?? 0) + 1;
-						const code = e.code ? ` [${e.code}]` : "";
-						c += `\n  ${code} (${line}:${col}) ${e.message.split("\n")[0].slice(0, 100)}`;
+						const code = e.code ? ` code=${String(e.code)}` : "";
+						c += `\n  line ${line}, col ${col}${code}: ${e.message.split("\n")[0].slice(0, 100)}`;
 					}
 					c += `${suffix}\n</diagnostics>`;
 				}

package/clients/runtime-session.ts

@@ -62,11 +62,27 @@ interface SessionStartDeps {
 	resetLSPService: () => void;
 }
 
+type StartupMode = "full" | "minimal" | "quick";
+
 function isCommandAvailable(command: string, args: string[] = ["--version"]): boolean {
 	const result = safeSpawn(command, args, { timeout: 5000 });
 	return !result.error && result.status === 0;
 }
 
+function resolveStartupMode(): StartupMode {
+	const envMode = (process.env.PI_LENS_STARTUP_MODE ?? "").trim().toLowerCase();
+	if (envMode === "full" || envMode === "minimal" || envMode === "quick") {
+		return envMode;
+	}
+
+	const argv = process.argv;
+	if (argv.includes("--print") || argv.includes("-p")) {
+		return "quick";
+	}
+
+	return "full";
+}
+
 function getLanguageInstallHints(
 	languageProfile: ReturnType<typeof detectProjectLanguageProfile>,
 ): string[] {
@@ -99,6 +115,9 @@ export async function handleSessionStart(
 	deps: SessionStartDeps,
 ): Promise<void> {
 	const sessionStartMs = Date.now();
+	const startupMode = resolveStartupMode();
+	const allowBootstrapTasks = startupMode === "full";
+	const quickMode = startupMode === "quick";
 	const {
 		ctxCwd,
 		getFlag,
@@ -131,10 +150,14 @@ export async function handleSessionStart(
 	runtime.complexityBaselines.clear();
 	resetDispatchBaselines();
 	runtime.resetForSession();
+	dbg(`session_start startup mode: ${startupMode}`);
 
 	if (getFlag("lens-lsp") && !getFlag("no-lsp")) {
 		resetLSPService();
 		dbg("session_start: LSP service reset");
+		dbg(
+			"session_start: phase0 workspace diagnostics observation enabled (capability probe only)",
+		);
 	}
 
 	if (getFlag("auto-install")) {
@@ -166,7 +189,7 @@ export async function handleSessionStart(
 	log(`Active tools: ${tools.join(", ")}`);
 	dbg(`session_start tools: ${tools.join(", ")}`);
 
-	if (getFlag("lens-lsp") && !getFlag("no-lsp")) {
+	if (allowBootstrapTasks && getFlag("lens-lsp") && !getFlag("no-lsp")) {
 		const cleaned = cleanStaleTsBuildInfo(ctxCwd ?? process.cwd());
 		if (cleaned.length > 0) {
 			notify(
@@ -179,6 +202,15 @@ export async function handleSessionStart(
 
 	const hasWorkspaceCwd = typeof ctxCwd === "string" && ctxCwd.length > 0;
 	const cwd = ctxCwd ?? process.cwd();
+	if (quickMode) {
+		runtime.projectRoot = cwd;
+		dbg(
+			"session_start: quick mode active - skipping language profiling, preinstall, scans, and error debt baseline",
+		);
+		dbg(`session_start total: ${Date.now() - sessionStartMs}ms`);
+		return;
+	}
+
 	const startupScan = resolveStartupScanContext(cwd);
 	const scanRoot = startupScan.projectRoot ?? cwd;
 	const useScanRootForSignals =
@@ -217,7 +249,9 @@ export async function handleSessionStart(
 		return true;
 	});
 
-	if (startupDefaults.length > 0) {
+	if (!allowBootstrapTasks) {
+		dbg("session_start: skipping tool preinstall (startup mode)");
+	} else if (startupDefaults.length > 0) {
 		dbg(`session_start: pre-install defaults -> ${startupDefaults.join(", ")}`);
 		for (const tool of startupDefaults) {
 			const startedAt = Date.now();
@@ -247,7 +281,7 @@ export async function handleSessionStart(
 		dbg("session_start: no language defaults selected for pre-install");
 	}
 
-	{
+	if (allowBootstrapTasks) {
 		const pkgPath = path.join(analysisRoot, "package.json");
 		try {
 			const raw = await nodeFs.promises.readFile(pkgPath, "utf-8");
@@ -272,6 +306,8 @@ export async function handleSessionStart(
 		} catch {
 			// no package.json at cwd root
 		}
+	} else {
+		dbg("session_start: skipping prettier preinstall probe (startup mode)");
 	}
 
 	const hasArchitectRules = architectClient.loadConfig(analysisRoot);
@@ -349,7 +385,9 @@ export async function handleSessionStart(
 	// Each consumer already handles the "not ready yet" case gracefully
 	// (cachedExports.size > 0, cachedProjectIndex != null, cache miss paths).
 
-	if (!startupScan.canWarmCaches) {
+	if (!allowBootstrapTasks) {
+		dbg("session_start: skipping startup background scans (startup mode)");
+	} else if (!startupScan.canWarmCaches) {
 		dbg(
 			`session_start: skipping heavy scans (${startupScan.reason ?? "unknown"})`,
 		);
@@ -500,7 +538,7 @@ export async function handleSessionStart(
 		`session_start: background scans launched (${startupNotes.length} startup note(s))`,
 	);
 
-	const errorDebtEnabled = getFlag("error-debt");
+	const errorDebtEnabled = allowBootstrapTasks && getFlag("error-debt");
 	const pendingDebt = cacheManager.readCache<{
 		pendingCheck: boolean;
 		baselineTestsPassed: boolean;