lazycodex-ai 5.1.48 → 5.1.54

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

@@ -0,0 +1,144 @@
+import { fileURLToPath } from "node:url";
+
+import { SEVERITY_MAP, SYMBOL_KIND_MAP } from "./language-mappings.js";
+import type {
+	Diagnostic,
+	DocumentSymbol,
+	Location,
+	LocationLink,
+	PrepareRenameDefaultBehavior,
+	PrepareRenameResult,
+	Range,
+	SeverityFilter,
+	SymbolInfo,
+} from "./types.js";
+import type { ApplyResult } from "./workspace-edit.js";
+
+type FilteredSeverity = Exclude<SeverityFilter, "all">;
+
+const DIAGNOSTIC_SEVERITY_FILTERS = {
+	error: 1,
+	warning: 2,
+	information: 3,
+	hint: 4,
+} as const satisfies Readonly<Record<FilteredSeverity, number>>;
+
+export function uriToPath(uri: string): string {
+	return fileURLToPath(uri);
+}
+
+export function formatLocation(loc: Location | LocationLink): string {
+	if ("targetUri" in loc) {
+		const uri = uriToPath(loc.targetUri);
+		const line = loc.targetRange.start.line + 1;
+		const char = loc.targetRange.start.character;
+		return `${uri}:${line}:${char}`;
+	}
+
+	const uri = uriToPath(loc.uri);
+	const line = loc.range.start.line + 1;
+	const char = loc.range.start.character;
+	return `${uri}:${line}:${char}`;
+}
+
+export function formatSymbolKind(kind: number): string {
+	return SYMBOL_KIND_MAP[kind] ?? `Unknown(${kind})`;
+}
+
+export function formatSeverity(severity: number | undefined): string {
+	if (!severity) return "unknown";
+	return SEVERITY_MAP[severity] ?? `unknown(${severity})`;
+}
+
+export function formatDocumentSymbol(symbol: DocumentSymbol, indent = 0): string {
+	const prefix = "  ".repeat(indent);
+	const kind = formatSymbolKind(symbol.kind);
+	const line = symbol.range.start.line + 1;
+	let result = `${prefix}${symbol.name} (${kind}) - line ${line}`;
+
+	if (symbol.children && symbol.children.length > 0) {
+		for (const child of symbol.children) {
+			result += `\n${formatDocumentSymbol(child, indent + 1)}`;
+		}
+	}
+
+	return result;
+}
+
+export function formatSymbolInfo(symbol: SymbolInfo): string {
+	const kind = formatSymbolKind(symbol.kind);
+	const loc = formatLocation(symbol.location);
+	const container = symbol.containerName ? ` (in ${symbol.containerName})` : "";
+	return `${symbol.name} (${kind})${container} - ${loc}`;
+}
+
+export function formatDiagnostic(diag: Diagnostic): string {
+	const severity = formatSeverity(diag.severity);
+	const line = diag.range.start.line + 1;
+	const char = diag.range.start.character;
+	const source = diag.source ? `[${diag.source}]` : "";
+	const code = diag.code ? ` (${diag.code})` : "";
+	return `${severity}${source}${code} at ${line}:${char}: ${diag.message}`;
+}
+
+export function filterDiagnosticsBySeverity(diagnostics: Diagnostic[], severityFilter?: SeverityFilter): Diagnostic[] {
+	if (!severityFilter || severityFilter === "all") {
+		return diagnostics;
+	}
+
+	const targetSeverity = DIAGNOSTIC_SEVERITY_FILTERS[severityFilter];
+	return diagnostics.filter((d) => d.severity === targetSeverity);
+}
+
+export function formatPrepareRenameResult(
+	result: PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null,
+): string {
+	if (!result) return "Cannot rename at this position";
+
+	if ("defaultBehavior" in result) {
+		return result.defaultBehavior ? "Rename supported (using default behavior)" : "Cannot rename at this position";
+	}
+
+	if ("range" in result && result.range) {
+		const startLine = result.range.start.line + 1;
+		const startChar = result.range.start.character;
+		const endLine = result.range.end.line + 1;
+		const endChar = result.range.end.character;
+		const placeholder = result.placeholder ? ` (current: "${result.placeholder}")` : "";
+		return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}${placeholder}`;
+	}
+
+	if ("start" in result && "end" in result) {
+		const startLine = result.start.line + 1;
+		const startChar = result.start.character;
+		const endLine = result.end.line + 1;
+		const endChar = result.end.character;
+		return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}`;
+	}
+
+	return "Cannot rename at this position";
+}
+
+export function formatApplyResult(result: ApplyResult): string {
+	const lines: string[] = [];
+
+	if (result.success) {
+		lines.push(`Applied ${result.totalEdits} edit(s) to ${result.filesModified.length} file(s):`);
+		for (const file of result.filesModified) {
+			lines.push(`  - ${file}`);
+		}
+		if (result.lateAbort) {
+			lines.push("Cancellation arrived after the filesystem commit began; the committed edit completed.");
+		}
+	} else {
+		lines.push("Failed to apply some changes:");
+		for (const err of result.errors) {
+			lines.push(`  Error: ${err}`);
+		}
+		if (result.filesModified.length > 0) {
+			lines.push(`Successfully modified: ${result.filesModified.join(", ")}`);
+		}
+	}
+
+	return lines.join("\n");
+}

package/packages/lsp-core/src/lsp/host-js-runtime.test.ts

@@ -0,0 +1,150 @@
+import { chmodSync, mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { runWithRequestContext } from "../request-context.js";
+import { withHostJsRuntime } from "./host-js-runtime.js";
+import { __resetServerBinaryResolutionCacheForTests } from "./server-installation.js";
+import { findServerForExtension } from "./server-resolution.js";
+
+const tempDirectories: string[] = [];
+let previousPath: string | undefined;
+const BUN = "/opt/bun/bin/bun";
+
+function makeTempRoot(): string {
+	const root = mkdtempSync(join(tmpdir(), "lsp-host-js-"));
+	tempDirectories.push(root);
+	return root;
+}
+
+function writeFile(path: string, content: string): string {
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, content);
+	chmodSync(path, 0o755);
+	return path;
+}
+
+function installTypescriptLanguageServer(root: string): { bin: string; cli: string } {
+	writeFileSync(join(root, "package.json"), "{}\n");
+	const cli = writeFile(
+		join(root, "node_modules", "typescript-language-server", "lib", "cli.mjs"),
+		"#!/usr/bin/env node\nexport {};\n",
+	);
+	const bin = join(root, "node_modules", ".bin", "typescript-language-server");
+	mkdirSync(join(bin, ".."), { recursive: true });
+	symlinkSync(join("..", "typescript-language-server", "lib", "cli.mjs"), bin);
+	return { bin, cli: realpathSync(cli) };
+}
+
+beforeEach(() => {
+	previousPath = process.env["PATH"];
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+afterEach(() => {
+	if (previousPath === undefined) delete process.env["PATH"];
+	else process.env["PATH"] = previousPath;
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+	__resetServerBinaryResolutionCacheForTests();
+});
+
+describe("withHostJsRuntime", () => {
+	test("#given a Bun host and the npm bin link of typescript-language-server #then it runs the real script with Bun", () => {
+		const { bin, cli } = installTypescriptLanguageServer(makeTempRoot());
+
+		expect(withHostJsRuntime("typescript", [bin, "--stdio"], { bunExecPath: BUN })).toEqual([
+			BUN,
+			cli,
+			"--stdio",
+		]);
+	});
+
+	test("#given a Node host #then the command is unchanged", () => {
+		const { bin } = installTypescriptLanguageServer(makeTempRoot());
+
+		expect(withHostJsRuntime("typescript", [bin, "--stdio"], { bunExecPath: undefined })).toEqual([bin, "--stdio"]);
+	});
+
+	test("#given another node-based server #then the command is unchanged", () => {
+		const root = makeTempRoot();
+		const eslint = writeFile(join(root, "eslint-ls.js"), "#!/usr/bin/env node\n");
+
+		expect(withHostJsRuntime("eslint", [eslint, "--stdio"], { bunExecPath: BUN })).toEqual([eslint, "--stdio"]);
+	});
+
+	test("#given a typescript command that is a native binary or shell shim #then the command is unchanged", () => {
+		const root = makeTempRoot();
+		const shim = writeFile(join(root, "typescript-language-server"), "#!/bin/sh\nexec node cli.mjs \"$@\"\n");
+
+		expect(withHostJsRuntime("typescript", [shim, "--stdio"], { bunExecPath: BUN })).toEqual([shim, "--stdio"]);
+	});
+});
+
+describe("withHostJsRuntime fallbacks", () => {
+	test("#given a bare command that is not on PATH #then the command is unchanged instead of throwing", () => {
+		expect(withHostJsRuntime("typescript", ["node", "/x/cli.mjs", "--stdio"], { bunExecPath: BUN })).toEqual([
+			"node",
+			"/x/cli.mjs",
+			"--stdio",
+		]);
+	});
+
+	test("#given a resolved path that no longer exists #then the command is unchanged instead of throwing", () => {
+		const missing = join(makeTempRoot(), "gone", "typescript-language-server");
+
+		expect(withHostJsRuntime("typescript", [missing, "--stdio"], { bunExecPath: BUN })).toEqual([missing, "--stdio"]);
+	});
+});
+
+describe("findServerForExtension on a Bun host", () => {
+	test("#given a user typescript entry with its own command #then the command is not moved to Bun", () => {
+		const root = makeTempRoot();
+		const { bin } = installTypescriptLanguageServer(root);
+		process.env["PATH"] = join(root, "definitely-empty");
+		mkdirSync(join(root, "home-config"), { recursive: true });
+		writeFileSync(
+			join(root, "home-config", "lsp-client.json"),
+			JSON.stringify({ lsp: { typescript: { command: [bin, "--stdio"], extensions: [".ts"] } } }),
+		);
+
+		const result = runWithRequestContext(
+			{
+				cwd: root,
+				projectConfigPaths: [join(root, ".codex", "lsp-client.json")],
+				userConfigPath: join(root, "home-config", "lsp-client.json"),
+				installDecisionsPath: join(root, "home-config", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: false },
+			},
+			() => findServerForExtension(".ts"),
+		);
+
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.command).toEqual([bin, "--stdio"]);
+	});
+
+	test("#given a repo-local typescript-language-server #when a .ts file is looked up #then the server is spawned by this Bun", () => {
+		const root = makeTempRoot();
+		const { cli } = installTypescriptLanguageServer(root);
+		process.env["PATH"] = join(root, "definitely-empty");
+
+		const result = runWithRequestContext(
+			{
+				cwd: root,
+				projectConfigPaths: [join(root, ".codex", "lsp-client.json")],
+				userConfigPath: join(root, "home-config", "lsp-client.json"),
+				installDecisionsPath: join(root, "home-config", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: false },
+			},
+			() => findServerForExtension(".ts"),
+		);
+
+		expect(result.status).toBe("found");
+		if (result.status !== "found") throw new Error("expected a found server");
+		expect(result.server.id).toBe("typescript");
+		expect(result.server.command).toEqual([process.execPath, cli, "--stdio"]);
+	});
+});

package/packages/lsp-core/src/lsp/host-js-runtime.ts

@@ -0,0 +1,57 @@
+import { closeSync, openSync, readSync, realpathSync } from "node:fs";
+
+/**
+ * Servers whose JavaScript entry is proven to run on Bun. typescript-language-server forks
+ * tsserver with `process.execPath`, so starting it with Bun keeps the whole tree on Bun
+ * instead of the `node` its shebang finds on PATH. Other node-based servers are not listed
+ * until they are measured.
+ */
+const HOST_RUNTIME_SERVER_IDS = new Set(["typescript"]);
+const JS_ENTRY = /\.[cm]?js$/;
+const NODE_SHEBANG = /^#![^\n]*\bnode\b/;
+
+export interface HostJsRuntime {
+	readonly bunExecPath: string | undefined;
+}
+
+function currentHostJsRuntime(): HostJsRuntime {
+	return { bunExecPath: process.versions["bun"] === undefined ? undefined : process.execPath };
+}
+
+export function withHostJsRuntime(
+	serverId: string,
+	command: string[],
+	host: HostJsRuntime = currentHostJsRuntime(),
+): string[] {
+	if (host.bunExecPath === undefined || !HOST_RUNTIME_SERVER_IDS.has(serverId)) return command;
+	const [binary, ...args] = command;
+	if (binary === undefined) return command;
+	const script = nodeScriptPath(binary);
+	return script === undefined ? command : [host.bunExecPath, script, ...args];
+}
+
+function nodeScriptPath(binary: string): string | undefined {
+	let real: string;
+	try {
+		real = realpathSync(binary);
+	} catch {
+		return undefined;
+	}
+	if (JS_ENTRY.test(real)) return real;
+	try {
+		return NODE_SHEBANG.test(readHead(real)) ? real : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function readHead(path: string): string {
+	const fd = openSync(path, "r");
+	try {
+		const buffer = Buffer.alloc(128);
+		const bytes = readSync(fd, buffer, 0, buffer.length, 0);
+		return buffer.toString("utf8", 0, bytes);
+	} finally {
+		closeSync(fd);
+	}
+}

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

@@ -0,0 +1,66 @@
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { effectiveExtension } from "./effective-extension.js";
+import { EXT_TO_LANG } from "./language-mappings.js";
+
+const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
+const MAX_SCAN_ENTRIES = 500;
+
+export function inferExtensionFromDirectory(directory: string): string | null {
+	const extensionCounts = new Map<string, number>();
+	let scanned = 0;
+
+	function walk(dir: string): void {
+		if (scanned >= MAX_SCAN_ENTRIES) return;
+
+		let entries: string[];
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			return;
+		}
+
+		for (const entry of entries) {
+			if (scanned >= MAX_SCAN_ENTRIES) return;
+
+			const fullPath = join(dir, entry);
+
+			let stat: ReturnType<typeof lstatSync> | undefined;
+			try {
+				stat = lstatSync(fullPath);
+			} catch {
+				continue;
+			}
+
+			if (stat.isSymbolicLink()) continue;
+			scanned++;
+
+			if (stat.isDirectory()) {
+				if (!SKIP_DIRECTORIES.has(entry)) {
+					walk(fullPath);
+				}
+			} else if (stat.isFile()) {
+				const ext = effectiveExtension(fullPath);
+				if (ext && ext in EXT_TO_LANG) {
+					extensionCounts.set(ext, (extensionCounts.get(ext) ?? 0) + 1);
+				}
+			}
+		}
+	}
+
+	walk(directory);
+
+	if (extensionCounts.size === 0) return null;
+
+	let maxExt = "";
+	let maxCount = 0;
+	for (const [ext, count] of extensionCounts) {
+		if (count > maxCount) {
+			maxCount = count;
+			maxExt = ext;
+		}
+	}
+
+	return maxExt || null;
+}

package/packages/lsp-core/src/lsp/json-rpc-connection-cancellation.test.ts

@@ -0,0 +1,97 @@
+import { PassThrough } from "node:stream";
+
+import { describe, expect, it } from "bun:test";
+
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+
+type JsonMessage = Record<string, unknown>;
+
+function messageId(message: JsonMessage): string | number | null | undefined {
+	const id = message["id"];
+	return typeof id === "string" || typeof id === "number" || id === null ? id : undefined;
+}
+
+function cancelTarget(message: JsonMessage): string | number | undefined {
+	const params = message["params"];
+	if (!params || typeof params !== "object" || Array.isArray(params)) return undefined;
+	const id = Reflect.get(params, "id");
+	return typeof id === "string" || typeof id === "number" ? id : undefined;
+}
+
+function encodeMessage(message: JsonMessage): string {
+	const body = JSON.stringify(message);
+	return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function recordJsonRpcMessages(stream: PassThrough) {
+	const messages: JsonMessage[] = [];
+	const waiters: Array<() => void> = [];
+	let buffer = Buffer.alloc(0);
+	stream.on("data", (chunk: Buffer) => {
+		buffer = Buffer.concat([buffer, chunk]);
+		for (;;) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) return;
+			const header = buffer.subarray(0, headerEnd).toString("ascii");
+			const match = /content-length:\s*(\d+)/i.exec(header);
+			if (!match?.[1]) throw new Error("missing content-length");
+			const bodyStart = headerEnd + 4;
+			const bodyEnd = bodyStart + Number.parseInt(match[1], 10);
+			if (buffer.length < bodyEnd) return;
+			const parsed: unknown = JSON.parse(buffer.subarray(bodyStart, bodyEnd).toString("utf8"));
+			buffer = buffer.subarray(bodyEnd);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				messages.push(Object.fromEntries(Object.entries(parsed)));
+			}
+			for (const wake of waiters.splice(0)) wake();
+		}
+	});
+	return {
+		messages,
+		waitForCount(count: number): Promise<void> {
+			if (messages.length >= count) return Promise.resolve();
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					reject(new Error(`waited for ${count} JSON-RPC messages, observed ${messages.length}`));
+				}, 1_000);
+				const wake = (): void => {
+					if (messages.length < count) {
+						waiters.push(wake);
+						return;
+					}
+					clearTimeout(timer);
+					resolve();
+				};
+				waiters.push(wake);
+			});
+		},
+	};
+}
+
+describe("JsonRpcConnection cancellation", () => {
+	it("#given an active request #when its signal aborts #then cancel uses the same id and late responses are ignored", async () => {
+		const serverToClient = new PassThrough();
+		const clientToServer = new PassThrough();
+		const recorder = recordJsonRpcMessages(clientToServer);
+		const connection = new JsonRpcConnection(serverToClient, clientToServer);
+		connection.listen();
+		const controller = new AbortController();
+
+		const request = connection.sendRequest("textDocument/diagnostic", { textDocument: { uri: "file:///a.ts" } }, {
+			signal: controller.signal,
+		});
+		await recorder.waitForCount(1);
+		const requestId = messageId(recorder.messages[0] ?? {});
+		expect(typeof requestId === "string" || typeof requestId === "number").toBe(true);
+
+		controller.abort(new Error("caller cancelled"));
+		await recorder.waitForCount(2);
+		await expect(request).rejects.toThrow("caller cancelled");
+		expect(connection.pendingRequestCount()).toBe(0);
+		expect(recorder.messages[1]?.["method"]).toBe("$/cancelRequest");
+		expect(cancelTarget(recorder.messages[1] ?? {})).toBe(typeof requestId === "number" || typeof requestId === "string" ? requestId : undefined);
+
+		serverToClient.write(encodeMessage({ jsonrpc: "2.0", id: requestId ?? null, result: { items: [] } }));
+		expect(connection.pendingRequestCount()).toBe(0);
+	});
+});