lazycodex-ai 5.1.47 → 5.1.51

package/packages/lsp-core/src/lsp/language-mappings.ts

@@ -0,0 +1,173 @@
+export const SYMBOL_KIND_MAP: Record<number, string> = {
+	1: "File",
+	2: "Module",
+	3: "Namespace",
+	4: "Package",
+	5: "Class",
+	6: "Method",
+	7: "Property",
+	8: "Field",
+	9: "Constructor",
+	10: "Enum",
+	11: "Interface",
+	12: "Function",
+	13: "Variable",
+	14: "Constant",
+	15: "String",
+	16: "Number",
+	17: "Boolean",
+	18: "Array",
+	19: "Object",
+	20: "Key",
+	21: "Null",
+	22: "EnumMember",
+	23: "Struct",
+	24: "Event",
+	25: "Operator",
+	26: "TypeParameter",
+};
+
+export const SEVERITY_MAP: Record<number, string> = {
+	1: "error",
+	2: "warning",
+	3: "information",
+	4: "hint",
+};
+
+export const EXT_TO_LANG: Record<string, string> = {
+	".abap": "abap",
+	".bat": "bat",
+	".bib": "bibtex",
+	".bibtex": "bibtex",
+	".clj": "clojure",
+	".cljs": "clojure",
+	".cljc": "clojure",
+	".edn": "clojure",
+	".coffee": "coffeescript",
+	".c": "c",
+	".cpp": "cpp",
+	".cxx": "cpp",
+	".cc": "cpp",
+	".c++": "cpp",
+	".cs": "csharp",
+	".css": "css",
+	".d": "d",
+	".pas": "pascal",
+	".pascal": "pascal",
+	".diff": "diff",
+	".patch": "diff",
+	".dart": "dart",
+	".dockerfile": "dockerfile",
+	".ex": "elixir",
+	".exs": "elixir",
+	".erl": "erlang",
+	".hrl": "erlang",
+	".fs": "fsharp",
+	".fsi": "fsharp",
+	".fsx": "fsharp",
+	".fsscript": "fsharp",
+	".gitcommit": "git-commit",
+	".gitrebase": "git-rebase",
+	".go": "go",
+	".groovy": "groovy",
+	".gleam": "gleam",
+	".hbs": "handlebars",
+	".handlebars": "handlebars",
+	".hs": "haskell",
+	".html": "html",
+	".htm": "html",
+	".ini": "ini",
+	".java": "java",
+	".jl": "julia",
+	".js": "javascript",
+	".jsx": "javascriptreact",
+	".json": "json",
+	".jsonc": "jsonc",
+	".tex": "latex",
+	".latex": "latex",
+	".less": "less",
+	".lua": "lua",
+	".makefile": "makefile",
+	makefile: "makefile",
+	".md": "markdown",
+	".markdown": "markdown",
+	".m": "objective-c",
+	".mm": "objective-cpp",
+	".pl": "perl",
+	".pm": "perl",
+	".pm6": "perl6",
+	".php": "php",
+	".ps1": "powershell",
+	".psm1": "powershell",
+	".pug": "jade",
+	".jade": "jade",
+	".py": "python",
+	".pyi": "python",
+	".r": "r",
+	".cshtml": "razor",
+	".razor": "razor",
+	".rb": "ruby",
+	".rake": "ruby",
+	".gemspec": "ruby",
+	".ru": "ruby",
+	".erb": "erb",
+	".html.erb": "erb",
+	".js.erb": "erb",
+	".css.erb": "erb",
+	".json.erb": "erb",
+	".rs": "rust",
+	".scss": "scss",
+	".sass": "sass",
+	".scala": "scala",
+	".shader": "shaderlab",
+	".sh": "shellscript",
+	".bash": "shellscript",
+	".zsh": "shellscript",
+	".ksh": "shellscript",
+	".sql": "sql",
+	".svelte": "svelte",
+	".swift": "swift",
+	".ts": "typescript",
+	".tsx": "typescriptreact",
+	".mts": "typescript",
+	".cts": "typescript",
+	".mtsx": "typescriptreact",
+	".ctsx": "typescriptreact",
+	".xml": "xml",
+	".xsl": "xsl",
+	".yaml": "yaml",
+	".yml": "yaml",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".vue": "vue",
+	".zig": "zig",
+	".zon": "zig",
+	".astro": "astro",
+	".ml": "ocaml",
+	".mli": "ocaml",
+	".tf": "terraform",
+	".tfvars": "terraform-vars",
+	".hcl": "hcl",
+	".nix": "nix",
+	".typ": "typst",
+	".typc": "typst",
+	".ets": "typescript",
+	".lhs": "haskell",
+	".kt": "kotlin",
+	".kts": "kotlin",
+	".prisma": "prisma",
+	".h": "c",
+	".hpp": "cpp",
+	".hh": "cpp",
+	".hxx": "cpp",
+	".h++": "cpp",
+	".objc": "objective-c",
+	".objcpp": "objective-cpp",
+	".fish": "fish",
+	".graphql": "graphql",
+	".gql": "graphql",
+};
+
+export function getLanguageId(ext: string): string {
+	return EXT_TO_LANG[ext] ?? "plaintext";
+}

package/packages/lsp-core/src/lsp/manager-lifecycle.test.ts

@@ -0,0 +1,262 @@
+import { describe, expect, it } from "bun:test";
+
+import type { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
+import type { ResolvedServer } from "./types.js";
+
+const SERVER: ResolvedServer = {
+	id: "typescript",
+	command: ["typescript-language-server", "--stdio"],
+	extensions: [".ts"],
+	priority: 1,
+};
+
+/** Simulates a stop that lingers (production stops reach ~21s), which is the behavior under test. */
+const SLOW_STOP_MS = 50;
+
+interface RecordingClientOptions {
+	readonly stopDelayMs: number;
+	readonly initializeError?: Error;
+	readonly alive: boolean;
+}
+
+class RecordingFakeClient {
+	alive: boolean;
+	stopCallCount = 0;
+
+	constructor(
+		readonly root: string,
+		private readonly log: EventLog,
+		private readonly options: RecordingClientOptions,
+	) {
+		this.alive = options.alive;
+	}
+
+	async start(): Promise<void> {
+		this.log.push(`spawn:${this.root}`);
+	}
+
+	async initialize(): Promise<void> {
+		if (this.options.initializeError !== undefined) {
+			throw this.options.initializeError;
+		}
+	}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	command(): string[] {
+		return [...SERVER.command];
+	}
+
+	async stop(): Promise<void> {
+		this.stopCallCount += 1;
+		this.log.push(`stop-start:${this.root}`);
+		await delay(this.options.stopDelayMs);
+		this.alive = false;
+		this.log.push(`stop-end:${this.root}`);
+	}
+}
+
+class EventLog {
+	readonly entries: string[] = [];
+	private waiters: Array<{ readonly event: string; readonly resolve: () => void }> = [];
+
+	push(event: string): void {
+		this.entries.push(event);
+		const due = this.waiters.filter((waiter) => waiter.event === event);
+		if (due.length === 0) return;
+		this.waiters = this.waiters.filter((waiter) => waiter.event !== event);
+		for (const waiter of due) waiter.resolve();
+	}
+
+	waitFor(event: string): Promise<void> {
+		if (this.entries.includes(event)) return Promise.resolve();
+		return new Promise<void>((resolve) => {
+			this.waiters.push({ event, resolve });
+		});
+	}
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+interface HarnessOptions {
+	readonly maxResidentClients?: number;
+	readonly stopDelayMs?: number;
+	/** Leading generations whose initialize() rejects; later generations start cleanly. */
+	readonly initializeFailures?: number;
+	/** Generations at or above this index report alive; earlier ones emulate a crash-looping server. */
+	readonly aliveFromGeneration?: number;
+}
+
+function managerHarness(options: HarnessOptions = {}): {
+	readonly manager: LspManager;
+	readonly clients: RecordingFakeClient[];
+	readonly log: EventLog;
+	readonly clock: { value: number };
+} {
+	const clients: RecordingFakeClient[] = [];
+	const log = new EventLog();
+	const clock = { value: 1_000 };
+	const generations = new Map<string, number>();
+	const aliveFrom = options.aliveFromGeneration ?? 1;
+	const stopDelayMs = options.stopDelayMs ?? 0;
+	const initializeFailures = options.initializeFailures ?? 0;
+	const manager = new LspManager({
+		maxResidentClients: options.maxResidentClients ?? 6,
+		reaperIntervalMs: 60_000,
+		idleTimeoutMs: 60_000_000,
+		now: () => clock.value,
+		clientFactory: (root) => {
+			const generation = (generations.get(root) ?? 0) + 1;
+			generations.set(root, generation);
+			const client = new RecordingFakeClient(root, log, {
+				stopDelayMs,
+				alive: generation >= aliveFrom,
+				...(generation <= initializeFailures ? { initializeError: new Error("initialize boom") } : {}),
+			});
+			clients.push(client);
+			return client as unknown as LspClient;
+		},
+	});
+	return { manager, clients, log, clock };
+}
+
+describe("LspManager pending-stop tombstones", () => {
+	it("#given a slow-stopping client evicted at the resident cap #when the evicted root is re-acquired while the stop is pending #then the replacement spawns only after the old client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({ maxResidentClients: 1, stopDelayMs: SLOW_STOP_MS });
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// when: admitting root-b synchronously evicts idle root-a (void stop), and root-a is
+			// re-acquired in the same window while the evicted client's stop is still pending.
+			const rootBPromise = manager.getClient("/root-b", SERVER);
+			const rootAPromise = manager.getClient("/root-a", SERVER);
+			await Promise.all([rootBPromise, rootAPromise]);
+			manager.releaseClient("/root-b", SERVER.id);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// then
+			expect(log.entries.filter((event) => event.endsWith("/root-a"))).toEqual([
+				"spawn:/root-a",
+				"stop-start:/root-a",
+				"stop-end:/root-a",
+				"spawn:/root-a",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given an invalidated client whose stop is still pending #when the same root is re-acquired #then the replacement spawns only after the invalidated client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({ stopDelayMs: SLOW_STOP_MS });
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// when
+			manager.invalidateClient("/root-a", SERVER.id);
+			await manager.getClient("/root-a", SERVER);
+
+			// then
+			expect(log.entries).toEqual([
+				"spawn:/root-a",
+				"stop-start:/root-a",
+				"stop-end:/root-a",
+				"spawn:/root-a",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given a client whose initialization failed while its stop is pending #when another getClient races the stop #then the replacement spawns only after the failed client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({
+			stopDelayMs: SLOW_STOP_MS,
+			initializeFailures: 1,
+		});
+		try {
+			const failing = manager.getClient("/root-fail", SERVER);
+
+			// when: the second acquisition starts once the first one's stop is provably in flight.
+			await log.waitFor("stop-start:/root-fail");
+			const racing = manager.getClient("/root-fail", SERVER);
+			await expect(failing).rejects.toThrow("initialize boom");
+			await racing;
+			manager.releaseClient("/root-fail", SERVER.id);
+
+			// then
+			expect(log.entries).toEqual([
+				"spawn:/root-fail",
+				"stop-start:/root-fail",
+				"stop-end:/root-fail",
+				"spawn:/root-fail",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});
+
+describe("LspManager dead-client respawn budget", () => {
+	it("#given a crash-looping client that is dead on every acquisition #when getClient is called repeatedly #then respawn attempts stay within the retry budget", async () => {
+		// given
+		const { manager, clients } = managerHarness({ aliveFromGeneration: Number.POSITIVE_INFINITY });
+		try {
+			// when
+			for (let attempt = 0; attempt < 8; attempt += 1) {
+				await manager
+					.getClient("/root-crash", SERVER)
+					.then(
+						() => manager.releaseClient("/root-crash", SERVER.id),
+						() => undefined,
+					);
+			}
+
+			// then: one initial generation plus at most two budgeted respawns.
+			expect(clients.length).toBeLessThanOrEqual(3);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the respawn budget is exhausted #when getClient is called again #then it rejects with a budget error instead of respawning", async () => {
+		// given
+		const { manager } = managerHarness({ aliveFromGeneration: Number.POSITIVE_INFINITY });
+		try {
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+
+			// when / then
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the budget was exhausted but the cooldown elapsed and the server recovered #when getClient is called #then it spawns again and resets the budget on a healthy generation", async () => {
+		// given: generations one and two crash, the third is healthy.
+		const { manager, clients, clock } = managerHarness({ aliveFromGeneration: 3 });
+		try {
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+
+			// when: cooldown elapses (60s default) and the server stays alive again.
+			clock.value += 60_001;
+			const recovered = await manager.getClient("/root-crash", SERVER);
+			manager.releaseClient("/root-crash", SERVER.id);
+
+			// then
+			expect(clients.length).toBe(3);
+			await expect(manager.getClient("/root-crash", SERVER)).resolves.toBe(recovered);
+			manager.releaseClient("/root-crash", SERVER.id);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});

package/packages/lsp-core/src/lsp/manager-max-clients.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "bun:test";
+
+import type { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
+import type { ResolvedServer } from "./types.js";
+
+const SERVER: ResolvedServer = {
+	id: "typescript",
+	command: ["typescript-language-server", "--stdio"],
+	extensions: [".ts"],
+	priority: 1,
+};
+
+class FakeLspClient {
+	alive = true;
+	stopCallCount = 0;
+
+	constructor(readonly root: string) {}
+
+	async start(): Promise<void> {}
+
+	async initialize(): Promise<void> {}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	command(): string[] {
+		return [...SERVER.command];
+	}
+
+	async stop(): Promise<void> {
+		this.stopCallCount += 1;
+		this.alive = false;
+	}
+}
+
+function managerWithFakes(maxResidentClients: number): {
+	readonly manager: LspManager;
+	readonly clients: Map<string, FakeLspClient>;
+	readonly clock: { value: number };
+} {
+	const clients = new Map<string, FakeLspClient>();
+	const clock = { value: 1_000 };
+	const manager = new LspManager({
+		maxResidentClients,
+		reaperIntervalMs: 60_000,
+		idleTimeoutMs: 60_000_000,
+		now: () => clock.value,
+		clientFactory: (root) => {
+			const client = new FakeLspClient(root);
+			clients.set(root, client);
+			return client as unknown as LspClient;
+		},
+	});
+	return { manager, clients, clock };
+}
+
+describe("LspManager resident client cap", () => {
+	it("#given a cap of two idle clients #when a third client is admitted #then the least recently used one is stopped and evicted", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(2);
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+			clock.value += 10;
+			await manager.getClient("/root-b", SERVER);
+			manager.releaseClient("/root-b", SERVER.id);
+			clock.value += 10;
+
+			// when
+			await manager.getClient("/root-c", SERVER);
+			manager.releaseClient("/root-c", SERVER.id);
+
+			// then
+			expect(manager.clientCount()).toBe(2);
+			expect(manager.hasClient("/root-a", SERVER.id)).toBe(false);
+			expect(manager.hasClient("/root-b", SERVER.id)).toBe(true);
+			expect(manager.hasClient("/root-c", SERVER.id)).toBe(true);
+			expect(clients.get("/root-a")?.stopCallCount).toBe(1);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the least recently used client is mid-request #when a new client is admitted #then the busy client survives and an idle one is evicted", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(2);
+		try {
+			await manager.getClient("/root-busy", SERVER);
+			clock.value += 10;
+			await manager.getClient("/root-idle", SERVER);
+			manager.releaseClient("/root-idle", SERVER.id);
+			clock.value += 10;
+
+			// when
+			await manager.getClient("/root-new", SERVER);
+			manager.releaseClient("/root-new", SERVER.id);
+
+			// then
+			expect(manager.hasClient("/root-busy", SERVER.id)).toBe(true);
+			expect(manager.hasClient("/root-idle", SERVER.id)).toBe(false);
+			expect(clients.get("/root-busy")?.stopCallCount).toBe(0);
+			expect(clients.get("/root-idle")?.stopCallCount).toBe(1);
+		} finally {
+			manager.releaseClient("/root-busy", SERVER.id);
+			await manager.stopAll();
+		}
+	});
+
+	it("#given every resident client is busy #when a new client is admitted #then nothing is evicted and the cap is exceeded rather than breaking a live request", async () => {
+		// given
+		const { manager, clients } = managerWithFakes(1);
+		try {
+			await manager.getClient("/root-busy", SERVER);
+
+			// when
+			await manager.getClient("/root-second", SERVER);
+
+			// then
+			expect(manager.clientCount()).toBe(2);
+			expect(clients.get("/root-busy")?.stopCallCount).toBe(0);
+		} finally {
+			manager.releaseClient("/root-busy", SERVER.id);
+			manager.releaseClient("/root-second", SERVER.id);
+			await manager.stopAll();
+		}
+	});
+
+	it("#given warmup requests beyond the cap #when a warm client is admitted #then the idle least recently used client is evicted too", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(1);
+		try {
+			await manager.getClient("/root-first", SERVER);
+			manager.releaseClient("/root-first", SERVER.id);
+			clock.value += 10;
+
+			// when
+			manager.warmupClient("/root-warm", SERVER);
+			await Promise.resolve();
+			await Promise.resolve();
+
+			// then
+			expect(manager.hasClient("/root-first", SERVER.id)).toBe(false);
+			expect(clients.get("/root-first")?.stopCallCount).toBe(1);
+			expect(manager.hasClient("/root-warm", SERVER.id)).toBe(true);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});