lazycodex-ai 5.1.48 → 5.1.54

package/packages/lsp-core/src/lsp/connection.ts

@@ -0,0 +1,95 @@
+import { pathToFileURL } from "node:url";
+
+import { LspClientTransport } from "./transport.js";
+
+interface InitializeCapabilities {
+	readonly diagnosticProvider?: unknown;
+	readonly documentFormattingProvider?: unknown;
+}
+
+function supportsDiagnosticPull(capabilities: InitializeCapabilities | undefined): boolean {
+	if (capabilities === undefined) return false;
+	return Object.hasOwn(capabilities, "diagnosticProvider");
+}
+
+/**
+ * Reads the whole-document formatting capability the server advertised at initialize time.
+ *
+ * The provider is either a boolean or an options object, and an explicit `false` means the
+ * server refuses the request, so both shapes are checked instead of mere key presence.
+ */
+function supportsDocumentFormatting(capabilities: InitializeCapabilities | undefined): boolean {
+	if (capabilities === undefined) return false;
+	const provider = capabilities.documentFormattingProvider;
+	if (provider === undefined || provider === null || provider === false) return false;
+	return provider === true || typeof provider === "object";
+}
+
+export class LspClientConnection extends LspClientTransport {
+	async initialize(): Promise<void> {
+		const rootUri = pathToFileURL(this.root).href;
+		const result = await this.sendRequest<{ readonly capabilities?: InitializeCapabilities }>(
+			"initialize",
+			{
+				processId: process.pid,
+				rootUri,
+				rootPath: this.root,
+				workspaceFolders: [{ uri: rootUri, name: "workspace" }],
+				capabilities: {
+					textDocument: {
+						hover: { contentFormat: ["markdown", "plaintext"] },
+						definition: { linkSupport: true },
+						references: {},
+						documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+						publishDiagnostics: {},
+						formatting: { dynamicRegistration: false },
+						rename: {
+							prepareSupport: true,
+							prepareSupportDefaultBehavior: 1,
+						},
+						codeAction: {
+							codeActionLiteralSupport: {
+								codeActionKind: {
+									valueSet: [
+										"quickfix",
+										"refactor",
+										"refactor.extract",
+										"refactor.inline",
+										"refactor.rewrite",
+										"source",
+										"source.organizeImports",
+										"source.fixAll",
+									],
+								},
+							},
+							isPreferredSupport: true,
+							disabledSupport: true,
+							dataSupport: true,
+							resolveSupport: {
+								properties: ["edit", "command"],
+							},
+						},
+					},
+					workspace: {
+						symbol: {},
+						workspaceFolders: true,
+						configuration: true,
+						...(this.hasWorkspaceApplyEditHandler() ? { applyEdit: true } : {}),
+						workspaceEdit: {
+							documentChanges: true,
+							resourceOperations: ["create", "rename", "delete"],
+						},
+					},
+				},
+				initializationOptions: this.server.initialization,
+			},
+			{ timeoutMs: this.initializeTimeoutMs },
+		);
+		this.setDiagnosticPullSupported(supportsDiagnosticPull(result?.capabilities));
+		this.setDocumentFormattingSupported(supportsDocumentFormatting(result?.capabilities));
+		await this.sendNotification("initialized", {});
+		await this.sendNotification("workspace/didChangeConfiguration", {
+			settings: { json: { validate: { enable: true } } },
+		});
+	}
+}

package/packages/lsp-core/src/lsp/constants.ts

@@ -0,0 +1,17 @@
+export const DEFAULT_MAX_REFERENCES = 200;
+export const DEFAULT_MAX_SYMBOLS = 200;
+export const DEFAULT_MAX_DIAGNOSTICS = 200;
+export const DEFAULT_MAX_DIRECTORY_FILES = 50;
+
+export const REQUEST_TIMEOUT_MS = 15_000;
+export const INIT_TIMEOUT_MS = 60_000;
+export const IDLE_TIMEOUT_MS = 5 * 60_000;
+export const MAX_RESIDENT_CLIENTS = 6;
+export const REAPER_INTERVAL_MS = 60_000;
+export const STOP_HARD_KILL_TIMEOUT_MS = 5_000;
+export const STOP_SIGKILL_GRACE_MS = 1_000;
+
+/** Max consecutive dead client generations respawned for one key before admission is blocked. */
+export const CLIENT_RESPAWN_RETRY_LIMIT = 2;
+/** How long a spent respawn budget blocks admission before a fresh attempt window opens. */
+export const CLIENT_RESPAWN_COOLDOWN_MS = 60_000;

package/packages/lsp-core/src/lsp/controlled-clock-test-support.ts

@@ -0,0 +1,90 @@
+import type { TimerProvider } from "./timer-provider.js";
+
+interface ControlledTimer {
+	readonly at: number;
+	readonly callback: () => void;
+	cancelled: boolean;
+}
+
+interface TimerWaiter {
+	readonly delayMs: number | undefined;
+	readonly resolve: () => void;
+}
+
+interface ScheduleWaiter {
+	readonly count: number;
+	readonly resolve: () => void;
+}
+
+/**
+ * Deterministic TimerProvider for tests: timers fire only through advanceBy(),
+ * and waitForTimer(delayMs) resolves once a timer with exactly that delay is
+ * scheduled, so tests order themselves behind the timer they intend to fire.
+ */
+export class ControlledClock implements TimerProvider {
+	private readonly timers: ControlledTimer[] = [];
+	private currentTime = 0;
+	private readonly timerWaiters = new Set<TimerWaiter>();
+	private readonly scheduleWaiters = new Set<ScheduleWaiter>();
+	readonly scheduledDelays: number[] = [];
+
+	readonly now = (): number => this.currentTime;
+	readonly setTimeout = (callback: () => void, delayMs: number): ReturnType<typeof setTimeout> => {
+		const timer: ControlledTimer = { at: this.currentTime + delayMs, callback, cancelled: false };
+		this.scheduledDelays.push(delayMs);
+		this.timers.push(timer);
+		for (const waiter of this.timerWaiters) {
+			if (waiter.delayMs === undefined || waiter.delayMs === delayMs) {
+				this.timerWaiters.delete(waiter);
+				waiter.resolve();
+			}
+		}
+		for (const waiter of this.scheduleWaiters) {
+			if (this.scheduledDelays.length >= waiter.count) {
+				this.scheduleWaiters.delete(waiter);
+				waiter.resolve();
+			}
+		}
+		return timer as unknown as ReturnType<typeof setTimeout>;
+	};
+	readonly clearTimeout = (handle: ReturnType<typeof setTimeout>): void => {
+		(handle as unknown as { cancelled: boolean }).cancelled = true;
+	};
+
+	waitForTimer(delayMs?: number): Promise<void> {
+		const hasTimer = this.timers.some(
+			(timer) => !timer.cancelled && (delayMs === undefined || timer.at === this.currentTime + delayMs),
+		);
+		if (hasTimer) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.timerWaiters.add({ delayMs, resolve });
+		});
+	}
+
+	/**
+	 * Resolves once this clock has been asked to schedule `count` timers in total.
+	 *
+	 * Timer DELAYS are ambiguous whenever the code under test derives several budgets from the same
+	 * remaining window (an LSP request timeout and the push-fallback wait are both "whatever is left
+	 * of the freshness window"). The schedule ORDER is not ambiguous: a step that only runs after an
+	 * earlier request settled can only arm its timer once that request's own timer was cleared. So a
+	 * test that must fire the LATER timer waits for the later schedule instead of a delay value, and
+	 * never races the earlier one.
+	 */
+	waitForScheduled(count: number): Promise<void> {
+		if (this.scheduledDelays.length >= count) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.scheduleWaiters.add({ count, resolve });
+		});
+	}
+
+	advanceBy(delayMs: number): void {
+		this.currentTime += delayMs;
+		for (;;) {
+			const index = this.timers.findIndex((timer) => timer.at <= this.currentTime);
+			if (index < 0) return;
+			const timer = this.timers.splice(index, 1)[0];
+			if (timer && !timer.cancelled) timer.callback();
+		}
+	}
+}

package/packages/lsp-core/src/lsp/directory-diagnostics.test.ts

@@ -0,0 +1,221 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+import { aggregateDiagnosticsForDirectory } from "./directory-diagnostics.js";
+import { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
+import type { Diagnostic, ResolvedServer } from "./types.js";
+
+describe("directory diagnostics", () => {
+	it("#given multiple files and one per-file failure #when directory diagnostics run #then work stays bounded and file failures stay structured", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-"));
+		const active: string[] = [];
+		let maxActive = 0;
+		const diagnosticsByFile = new Map<string, Diagnostic[] | Error>([
+			[join(workspace, "a.ts"), [diagnostic("a")]],
+			[join(workspace, "b.ts"), new Error("b failed")],
+			[join(workspace, "c.ts"), [diagnostic("c")]],
+			[join(workspace, "d.ts"), [diagnostic("d")]],
+			[join(workspace, "e.ts"), [diagnostic("e")]],
+		]);
+		const client = {
+			async diagnostics(filePath: string) {
+				active.push(filePath);
+				maxActive = Math.max(maxActive, active.length);
+				await Promise.resolve();
+				active.splice(active.indexOf(filePath), 1);
+				const entry = diagnosticsByFile.get(filePath);
+				if (entry instanceof Error) throw entry;
+				return { items: entry ?? [] };
+			},
+		} as Pick<LspClient, "diagnostics"> as LspClient;
+		const server: ResolvedServer = { id: "typescript", command: ["typescript-language-server"], extensions: [".ts"], priority: 1 };
+		const manager = {
+			async getClient() {
+				return client;
+			},
+			releaseClient() {},
+		};
+
+		try {
+			const result = await aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 4, {
+				manager: manager as never,
+				listFiles: () => [...diagnosticsByFile.keys()],
+				workspaceRoot: workspace,
+				server,
+				maxConcurrency: 2,
+			});
+
+			expect(maxActive).toBeLessThanOrEqual(2);
+			expect(result.fileFailures).toEqual([{ file: join(workspace, "b.ts"), error: "b failed" }]);
+			expect(result.totalDiagnostics).toBe(3);
+			expect(result.output).toContain("File processing errors:");
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("#given directory diagnostics are aborted after one file #when the worker loops #then no later file is scheduled", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-cancel-"));
+		const controller = new AbortController();
+		const visited: string[] = [];
+		const firstFile = join(workspace, "a.ts");
+		const files = [firstFile, join(workspace, "b.ts"), join(workspace, "c.ts")];
+		const client = {
+			async diagnostics(filePath: string) {
+				visited.push(filePath);
+				controller.abort();
+				return { items: [] };
+			},
+		} as Pick<LspClient, "diagnostics"> as LspClient;
+		const server: ResolvedServer = { id: "typescript", command: ["typescript-language-server"], extensions: [".ts"], priority: 1 };
+		const manager = {
+			async getClient() {
+				return client;
+			},
+			releaseClient() {},
+		};
+
+		try {
+			const result = await aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 3, {
+				manager: manager as never,
+				listFiles: () => files,
+				workspaceRoot: workspace,
+				server,
+				maxConcurrency: 1,
+				signal: controller.signal,
+			});
+
+			expect(result.totalDiagnostics).toBe(0);
+			expect(visited).toEqual([firstFile]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("#given cold client acquisition is pending #when directory diagnostics are aborted #then acquisition settles and cleans up before startup releases", async () => {
+		const workspace = mkdtempSync(join(tmpdir(), "lsp-directory-diag-cold-cancel-"));
+		const controller = new AbortController();
+		const startupStarted = deferred();
+		const startupRelease = deferred();
+		const server: ResolvedServer = {
+			id: "typescript",
+			command: ["typescript-language-server"],
+			extensions: [".ts"],
+			priority: 1,
+		};
+		const client = new PendingStartLspClient({
+			root: workspace,
+			server,
+			startupStarted,
+			startupRelease,
+		});
+		const manager = new LspManager({
+			clientFactory: () => client,
+			reaperIntervalMs: 60_000,
+		});
+		const aggregation = aggregateDiagnosticsForDirectory(workspace, ".ts", "all", 1, {
+			manager,
+			listFiles: () => [join(workspace, "a.ts")],
+			workspaceRoot: workspace,
+			server,
+			signal: controller.signal,
+		});
+
+		try {
+			await startupStarted.promise;
+			controller.abort();
+
+			const settledBeforeStartupRelease = await settlesWithin(aggregation, 100);
+
+			expect(settledBeforeStartupRelease).toBe(true);
+			await expect(aggregation).rejects.toHaveProperty("name", "AbortError");
+			expect(manager.clientCount()).toBe(0);
+			expect(client.stopCallCount).toBe(1);
+		} finally {
+			startupRelease.resolve();
+			await aggregation.catch(() => undefined);
+			await manager.stopAll();
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	});
+});
+
+class PendingStartLspClient extends LspClient {
+	stopCallCount = 0;
+	private readonly startupStarted: Deferred;
+	private readonly startupRelease: Deferred;
+
+	constructor(options: PendingStartLspClientOptions) {
+		super(options.root, options.server);
+		this.startupStarted = options.startupStarted;
+		this.startupRelease = options.startupRelease;
+	}
+
+	override async start(): Promise<void> {
+		this.startupStarted.resolve();
+		await this.startupRelease.promise;
+	}
+
+	override async initialize(): Promise<void> {}
+
+	override async stop(): Promise<void> {
+		this.stopCallCount += 1;
+	}
+
+	override isAlive(): boolean {
+		return true;
+	}
+
+	override async diagnostics(): Promise<{ readonly items: Diagnostic[] }> {
+		return { items: [] };
+	}
+}
+
+interface PendingStartLspClientOptions {
+	readonly root: string;
+	readonly server: ResolvedServer;
+	readonly startupStarted: Deferred;
+	readonly startupRelease: Deferred;
+}
+
+interface Deferred {
+	readonly promise: Promise<void>;
+	resolve(): void;
+}
+
+function deferred(): Deferred {
+	let resolvePromise: (() => void) | undefined;
+	const promise = new Promise<void>((resolve) => {
+		resolvePromise = resolve;
+	});
+	return { promise, resolve: () => resolvePromise?.() };
+}
+
+async function settlesWithin(promise: Promise<unknown>, timeoutMs: number): Promise<boolean> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	try {
+		return await Promise.race([
+			promise.then(
+				() => true,
+				() => true,
+			),
+			new Promise<boolean>((resolve) => {
+				timer = setTimeout(() => resolve(false), timeoutMs);
+				timer.unref();
+			}),
+		]);
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
+function diagnostic(message: string): Diagnostic {
+	return {
+		range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+		message,
+	};
+}

package/packages/lsp-core/src/lsp/directory-diagnostics.ts

@@ -0,0 +1,187 @@
+import { existsSync, lstatSync, readdirSync, type Stats } from "node:fs";
+import { join, resolve } from "node:path";
+import { contextCwd } from "../request-context.js";
+import { findWorkspaceRoot, formatServerLookupError } from "./client-wrapper.js";
+import { DEFAULT_MAX_DIAGNOSTICS, DEFAULT_MAX_DIRECTORY_FILES } from "./constants.js";
+import { effectiveExtension } from "./effective-extension.js";
+import { LspInvalidPathError, LspServerLookupError } from "./errors.js";
+import { filterDiagnosticsBySeverity, formatDiagnostic } from "./formatters.js";
+import { getLspManager, type LspManager } from "./manager.js";
+import { findServerForExtension } from "./server-resolution.js";
+import type { Diagnostic, ResolvedServer, SeverityFilter } from "./types.js";
+
+const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
+const DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY = 4;
+
+interface FileDiagnostic {
+	filePath: string;
+	diagnostic: Diagnostic;
+}
+
+export interface DirectoryDiagnosticsFileFailure {
+	readonly file: string;
+	readonly error: string;
+}
+
+export interface DirectoryDiagnosticsResult {
+	readonly output: string;
+	readonly totalDiagnostics: number;
+	readonly fileFailures: readonly DirectoryDiagnosticsFileFailure[];
+}
+
+export interface DirectoryDiagnosticsOptions {
+	readonly listFiles?: (directory: string, extension: string, maxFiles: number) => string[];
+	readonly manager?: LspManager;
+	readonly maxConcurrency?: number;
+	readonly workspaceRoot?: string;
+	readonly server?: ResolvedServer;
+	readonly signal?: AbortSignal;
+}
+
+export function collectFilesWithExtension(dir: string, extension: string, maxFiles: number): string[] {
+	const files: string[] = [];
+
+	function walk(currentDir: string): void {
+		if (files.length >= maxFiles) return;
+
+		let entries: string[] = [];
+		try {
+			entries = readdirSync(currentDir);
+		} catch {
+			return;
+		}
+
+		for (const entry of entries) {
+			if (files.length >= maxFiles) return;
+
+			const fullPath = join(currentDir, entry);
+
+			let stat: Stats | undefined;
+			try {
+				stat = lstatSync(fullPath);
+			} catch {
+				continue;
+			}
+
+			if (!stat || stat.isSymbolicLink()) continue;
+
+			if (stat.isDirectory()) {
+				if (!SKIP_DIRECTORIES.has(entry)) {
+					walk(fullPath);
+				}
+			} else if (stat.isFile() && effectiveExtension(fullPath) === extension) {
+				files.push(fullPath);
+			}
+		}
+	}
+
+	walk(dir);
+	return files;
+}
+
+export async function aggregateDiagnosticsForDirectory(
+	directory: string,
+	extension: string,
+	severity?: SeverityFilter,
+	maxFiles: number = DEFAULT_MAX_DIRECTORY_FILES,
+	options: DirectoryDiagnosticsOptions = {},
+): Promise<DirectoryDiagnosticsResult> {
+	if (!extension.startsWith(".")) {
+		throw new LspInvalidPathError(
+			`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`,
+		);
+	}
+
+	const absDir = resolve(options.workspaceRoot ?? contextCwd(), directory);
+	if (!existsSync(absDir)) {
+		throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
+	}
+
+	const serverResult = options.server === undefined ? findServerForExtension(extension) : { status: "found" as const, server: options.server };
+	if (serverResult.status !== "found") {
+		throw new LspServerLookupError(formatServerLookupError(serverResult));
+	}
+
+	const server = serverResult.server;
+	const allFiles = (options.listFiles ?? collectFilesWithExtension)(absDir, extension, maxFiles + 1);
+	const wasCapped = allFiles.length > maxFiles;
+	const filesToProcess = allFiles.slice(0, maxFiles);
+
+	if (filesToProcess.length === 0) {
+		const output = [
+			`Directory: ${absDir}`,
+			`Extension: ${extension}`,
+			"Files scanned: 0",
+			`No files found with extension "${extension}".`,
+		].join("\n");
+		return { output, totalDiagnostics: 0, fileFailures: [] };
+	}
+
+	const root = options.workspaceRoot ?? findWorkspaceRoot(absDir);
+	const manager = options.manager ?? getLspManager();
+	const allDiagnostics: FileDiagnostic[] = [];
+	const fileErrors: DirectoryDiagnosticsFileFailure[] = [];
+	const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
+
+	options.signal?.throwIfAborted();
+	const client = await manager.getClient(root, server, options.signal);
+	try {
+		let nextIndex = 0;
+		const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
+			for (;;) {
+				if (options.signal?.aborted) return;
+				const file = filesToProcess[nextIndex];
+				nextIndex += 1;
+				if (file === undefined) return;
+				try {
+					const result = await client.diagnostics(file, options.signal);
+					const filtered = filterDiagnosticsBySeverity(result.items, severity);
+					allDiagnostics.push(
+						...filtered.map((diagnostic) => ({
+							filePath: file,
+							diagnostic,
+						})),
+					);
+				} catch (e) {
+					fileErrors.push({
+						file,
+						error: e instanceof Error ? e.message : String(e),
+					});
+				}
+			}
+		});
+		await Promise.all(workers);
+	} finally {
+		manager.releaseClient(root, server.id);
+	}
+
+	const displayDiagnostics = allDiagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS);
+	const wasDiagCapped = allDiagnostics.length > DEFAULT_MAX_DIAGNOSTICS;
+
+	const lines: string[] = [
+		`Directory: ${absDir}`,
+		`Extension: ${extension}`,
+		`Files scanned: ${filesToProcess.length}${wasCapped ? ` (capped at ${maxFiles})` : ""}`,
+		`Files with errors: ${fileErrors.length}`,
+		`Total diagnostics: ${allDiagnostics.length}`,
+	];
+
+	if (fileErrors.length > 0) {
+		lines.push("", "File processing errors:");
+		for (const { file, error } of fileErrors) {
+			lines.push(`  ${file}: ${error}`);
+		}
+	}
+
+	if (displayDiagnostics.length > 0) {
+		lines.push("");
+		for (const { filePath, diagnostic } of displayDiagnostics) {
+			lines.push(`${filePath}: ${formatDiagnostic(diagnostic)}`);
+		}
+		if (wasDiagCapped) {
+			lines.push("", `... (${allDiagnostics.length - DEFAULT_MAX_DIAGNOSTICS} more diagnostics not shown)`);
+		}
+	}
+
+	return { output: lines.join("\n"), totalDiagnostics: allDiagnostics.length, fileFailures: fileErrors };
+}

package/packages/lsp-core/src/lsp/effective-extension.ts

@@ -0,0 +1,10 @@
+import { basename, extname } from "node:path";
+
+const BASENAME_EXTENSIONS: Record<string, string> = {
+	Dockerfile: ".dockerfile",
+	Containerfile: ".dockerfile",
+};
+
+export function effectiveExtension(filePath: string): string {
+	return BASENAME_EXTENSIONS[basename(filePath)] ?? extname(filePath);
+}