oh-my-opencode 4.18.0 → 4.18.2

package/packages/lsp-core/src/post-edit/orchestration.ts

@@ -0,0 +1,178 @@
+import { extname } from "node:path";
+
+const DEFAULT_MAX_CONCURRENCY = 4;
+const CLEAN_DIAGNOSTICS_TEXT = "No diagnostics found";
+
+export type PostEditDiagnosticsOutcome =
+	| string
+	| {
+			readonly kind: "not_configured";
+			readonly extension: string;
+	  };
+
+export type DiagnosticsRunner = (filePath: string) => Promise<PostEditDiagnosticsOutcome>;
+
+export interface PostEditDiagnosticsBlock {
+	readonly filePath: string;
+	readonly diagnostics: string;
+}
+
+export interface PostEditDiagnosticsObservation {
+	readonly filePath: string;
+	readonly kind: "block" | "clean" | "not_configured";
+}
+
+export interface PostEditDiagnosticsResult {
+	readonly blocks: readonly PostEditDiagnosticsBlock[];
+	readonly observations: readonly PostEditDiagnosticsObservation[];
+}
+
+export interface PostEditNotConfiguredCache {
+	readonly notConfiguredExtensions: Set<string>;
+}
+
+export interface CollectPostEditDiagnosticsInput {
+	readonly filePaths: readonly string[];
+	readonly runDiagnostics: DiagnosticsRunner;
+	readonly cache?: PostEditNotConfiguredCache;
+	readonly maxConcurrency?: number;
+}
+
+interface IndexedFilePath {
+	readonly index: number;
+	readonly filePath: string;
+}
+
+interface IndexedDiagnostics {
+	readonly index: number;
+	readonly filePath: string;
+	readonly outcome: PostEditDiagnosticsOutcome;
+}
+
+export function createPostEditNotConfiguredCache(): PostEditNotConfiguredCache {
+	return { notConfiguredExtensions: new Set() };
+}
+
+export function resetPostEditNotConfiguredCache(cache: PostEditNotConfiguredCache): void {
+	cache.notConfiguredExtensions.clear();
+}
+
+export async function collectPostEditDiagnostics(
+	input: CollectPostEditDiagnosticsInput,
+): Promise<PostEditDiagnosticsResult> {
+	const cache = input.cache === undefined ? createPostEditNotConfiguredCache() : input.cache;
+	const filePaths = firstSeenDiagnosticTargets(input.filePaths, cache);
+	const results = await runBoundedDiagnostics(filePaths, input.runDiagnostics, input.maxConcurrency);
+	const blocks: PostEditDiagnosticsBlock[] = [];
+	const observations: PostEditDiagnosticsObservation[] = [];
+
+	for (const result of results) {
+		const classification = classifyDiagnostics(result.outcome);
+		switch (classification.kind) {
+			case "clean":
+				observations.push({ filePath: result.filePath, kind: "clean" });
+				break;
+			case "not_configured":
+				cache.notConfiguredExtensions.add(classification.extension);
+				observations.push({ filePath: result.filePath, kind: "not_configured" });
+				break;
+			case "block":
+				blocks.push({ filePath: result.filePath, diagnostics: classification.diagnostics });
+				observations.push({ filePath: result.filePath, kind: "block" });
+				break;
+			default: {
+				const exhaustive: never = classification;
+				return exhaustive;
+			}
+		}
+	}
+
+	return { blocks, observations };
+}
+
+function firstSeenDiagnosticTargets(
+	filePaths: readonly string[],
+	cache: PostEditNotConfiguredCache,
+): readonly IndexedFilePath[] {
+	const seen = new Set<string>();
+	const targets: IndexedFilePath[] = [];
+	for (const filePath of filePaths) {
+		if (filePath.length === 0 || seen.has(filePath)) continue;
+		seen.add(filePath);
+		const extension = extensionKey(filePath);
+		if (extension !== undefined && cache.notConfiguredExtensions.has(extension)) continue;
+		targets.push({ index: targets.length, filePath });
+	}
+	return targets;
+}
+
+async function runBoundedDiagnostics(
+	filePaths: readonly IndexedFilePath[],
+	runDiagnostics: DiagnosticsRunner,
+	maxConcurrency: number | undefined,
+): Promise<readonly IndexedDiagnostics[]> {
+	const results: IndexedDiagnostics[] = [];
+	const workerCount = Math.min(Math.max(1, maxConcurrency ?? DEFAULT_MAX_CONCURRENCY), filePaths.length);
+	let nextIndex = 0;
+
+	async function worker(): Promise<void> {
+		for (;;) {
+			const target = filePaths[nextIndex];
+			nextIndex += 1;
+			if (target === undefined) return;
+			results[target.index] = {
+				index: target.index,
+				filePath: target.filePath,
+				outcome: await collectFileDiagnostics(target.filePath, runDiagnostics),
+			};
+		}
+	}
+
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	return results.filter((result) => result !== undefined);
+}
+
+async function collectFileDiagnostics(
+	filePath: string,
+	runDiagnostics: DiagnosticsRunner,
+): Promise<PostEditDiagnosticsOutcome> {
+	try {
+		return normalizeDiagnosticsOutcome(await runDiagnostics(filePath));
+	} catch (error) {
+		if (error instanceof Error) return formatDiagnosticsError(error);
+		return normalizeDiagnosticsText(String(error));
+	}
+}
+
+function normalizeDiagnosticsOutcome(outcome: PostEditDiagnosticsOutcome): PostEditDiagnosticsOutcome {
+	if (typeof outcome === "string") return normalizeDiagnosticsText(outcome);
+	return outcome;
+}
+
+function normalizeDiagnosticsText(text: string): string {
+	return text.trim();
+}
+
+function formatDiagnosticsError(error: Error): string {
+	const message = normalizeDiagnosticsText(error.message);
+	return message.length > 0 ? message : normalizeDiagnosticsText(String(error));
+}
+
+function classifyDiagnostics(
+	outcome: PostEditDiagnosticsOutcome,
+):
+	| { readonly kind: "clean" }
+	| { readonly kind: "not_configured"; readonly extension: string }
+	| { readonly kind: "block"; readonly diagnostics: string } {
+	if (typeof outcome !== "string") {
+		return { kind: "not_configured", extension: outcome.extension };
+	}
+	const diagnostics = outcome;
+	if (diagnostics.length === 0 || diagnostics === CLEAN_DIAGNOSTICS_TEXT) return { kind: "clean" };
+	return { kind: "block", diagnostics };
+}
+
+function extensionKey(filePath: string): string | undefined {
+	const extension = extname(filePath).toLowerCase();
+	return extension.length === 0 ? undefined : extension;
+}

package/packages/lsp-core/src/request-context.test.ts

@@ -0,0 +1,171 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { afterEach, describe, expect, it } from "bun:test";
+
+import {
+	createStandaloneMcpRequestContext,
+	LspRequestContextUnavailableError,
+	LspRequestContextParseError,
+	parseLspRequestContext,
+	runWithRequestContext,
+	lspRequestContext,
+} from "./request-context.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function tempRoot(prefix: string): string {
+	const root = mkdtempSync(join(homedir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+function tempSystemRoot(prefix: string): string {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	tempDirectories.push(root);
+	return root;
+}
+
+describe("LspRequestContext", () => {
+	it("#given exact typed context #when parsed #then canonicalizes cwd and preserves typed paths", () => {
+		const root = tempRoot("lsp-context-root-");
+		const projectPath = join(root, ".codex", "lsp-client.json");
+		const userPath = join(homedir(), ".codex", "lsp-client.json");
+		const decisionsPath = join(homedir(), ".codex", "lsp-install-decisions.json");
+		mkdirSync(join(root, ".codex"), { recursive: true });
+
+		const context = parseLspRequestContext({
+			cwd: join(root, "."),
+			projectConfigPaths: [projectPath],
+			userConfigPath: userPath,
+			installDecisionsPath: decisionsPath,
+			capabilities: { installDecisionTool: false },
+		});
+
+		expect(context).toEqual({
+			cwd: root,
+			projectConfigPaths: [projectPath],
+			userConfigPath: userPath,
+			installDecisionsPath: decisionsPath,
+			capabilities: { installDecisionTool: false },
+		});
+		expect(runWithRequestContext(context, () => lspRequestContext())).toEqual(context);
+	});
+
+	it("#given no active context #when requested #then throws an actionable typed error", () => {
+		expect(() => lspRequestContext()).toThrow(LspRequestContextUnavailableError);
+	});
+
+	it("#given unknown field #when parsed #then rejects before lookup", () => {
+		const root = tempRoot("lsp-context-unknown-");
+		const projectPath = join(root, ".codex", "lsp-client.json");
+
+		expect(() =>
+			parseLspRequestContext({
+				cwd: root,
+				projectConfigPaths: [projectPath],
+				userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+				installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: true },
+				env: {},
+			}),
+		).toThrow(LspRequestContextParseError);
+	});
+
+	it("#given project path outside cwd #when parsed #then rejects before config loading", () => {
+		const root = tempRoot("lsp-context-confined-");
+		const outside = tempRoot("lsp-context-outside-");
+
+		expect(() =>
+			parseLspRequestContext({
+				cwd: root,
+				projectConfigPaths: [join(outside, "lsp-client.json")],
+				userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+				installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: true },
+			}),
+		).toThrow(LspRequestContextParseError);
+	});
+
+	it("#given equivalent macOS var spelling #when parsed #then canonicalizes to one identity", () => {
+		const systemRoot = tempSystemRoot("lsp-context-private-var-");
+		const canonicalRoot = realpathSync(systemRoot);
+		const aliasRoot = canonicalRoot.startsWith("/private/var/") ? canonicalRoot.replace("/private/var/", "/var/") : systemRoot;
+		mkdirSync(join(canonicalRoot, ".codex"), { recursive: true });
+
+		const context = parseLspRequestContext({
+			cwd: aliasRoot,
+			projectConfigPaths: [join(aliasRoot, ".codex", "lsp-client.json")],
+			userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+			installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+			capabilities: { installDecisionTool: true },
+		});
+
+		expect(context.cwd).toBe(canonicalRoot);
+		expect(context.projectConfigPaths).toEqual([join(canonicalRoot, ".codex", "lsp-client.json")]);
+	});
+
+	it("#given missing standard project config inside cwd #when parsed #then accepts and preserves the intended suffix", () => {
+		const root = tempRoot("lsp-context-missing-config-");
+		mkdirSync(join(root, ".codex"), { recursive: true });
+
+		const context = parseLspRequestContext({
+			cwd: root,
+			projectConfigPaths: [join(root, ".codex", "missing-lsp-client.json")],
+			userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+			installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+			capabilities: { installDecisionTool: true },
+		});
+
+		expect(context.projectConfigPaths).toEqual([join(root, ".codex", "missing-lsp-client.json")]);
+	});
+
+	it("#given symlink project config escaping cwd #when parsed #then rejects the escape", () => {
+		const root = tempRoot("lsp-context-symlink-root-");
+		const outside = tempRoot("lsp-context-symlink-outside-");
+		const outsideConfig = join(outside, "lsp-client.json");
+		writeFileSync(outsideConfig, "{}");
+		const linkedConfig = join(root, "linked-lsp-client.json");
+		symlinkSync(outsideConfig, linkedConfig);
+
+		expect(() =>
+			parseLspRequestContext({
+				cwd: root,
+				projectConfigPaths: [linkedConfig],
+				userConfigPath: join(homedir(), ".codex", "lsp-client.json"),
+				installDecisionsPath: join(homedir(), ".codex", "lsp-install-decisions.json"),
+				capabilities: { installDecisionTool: true },
+			}),
+		).toThrow(LspRequestContextParseError);
+	});
+
+	it("#given standalone MCP env #when translated #then resolves exact defaults and relative paths", () => {
+		const root = tempRoot("lsp-context-standalone-");
+		const home = tempRoot("lsp-context-home-");
+		const absoluteProjectPath = join(root, ".omo", "lsp-client.json");
+
+		const context = createStandaloneMcpRequestContext({
+			cwd: root,
+			homeDir: home,
+			env: {
+				LSP_TOOLS_MCP_PROJECT_CONFIG: ["relative.json", "", absoluteProjectPath].join(delimiter),
+				LSP_TOOLS_MCP_USER_CONFIG: "user-lsp.json",
+				LSP_TOOLS_MCP_INSTALL_DECISIONS: "decisions.json",
+			},
+		});
+
+		expect(context).toEqual({
+			cwd: root,
+			projectConfigPaths: [join(root, "relative.json"), absoluteProjectPath],
+			userConfigPath: join(home, "user-lsp.json"),
+			installDecisionsPath: join(home, "decisions.json"),
+			capabilities: { installDecisionTool: true },
+		});
+	});
+});

package/packages/lsp-core/src/request-context.ts

@@ -1,22 +1,235 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
 
-export interface RequestContext {
-	cwd?: string;
-	env?: Record<string, string>;
+export interface LspRequestContext {
+	readonly cwd: string;
+	readonly projectConfigPaths: readonly string[];
+	readonly userConfigPath: string;
+	readonly installDecisionsPath: string;
+	readonly capabilities: {
+		readonly installDecisionTool: boolean;
+	};
 }
 
-const storage = new AsyncLocalStorage<RequestContext>();
+export type RequestContext = LspRequestContext;
 
-export function runWithRequestContext<T>(context: RequestContext, fn: () => T): T {
+export interface StandaloneMcpRequestContextInput {
+	readonly cwd?: string;
+	readonly env?: Record<string, string | undefined>;
+	readonly homeDir?: string;
+}
+
+export class LspRequestContextParseError extends Error {
+	override readonly name = "LspRequestContextParseError";
+
+	constructor(
+		readonly code: string,
+		message: string,
+	) {
+		super(message);
+	}
+}
+
+export class LspRequestContextUnavailableError extends Error {
+	override readonly name = "LspRequestContextUnavailableError";
+
+	constructor() {
+		super(
+			"LSP request context is required. Standalone MCP startup must install one with runWithRequestContext(createStandaloneMcpRequestContext()).",
+		);
+	}
+}
+
+const storage = new AsyncLocalStorage<LspRequestContext>();
+const CONTEXT_FIELDS = new Set(["cwd", "projectConfigPaths", "userConfigPath", "installDecisionsPath", "capabilities"]);
+const CAPABILITY_FIELDS = new Set(["installDecisionTool"]);
+
+export function runWithRequestContext<T>(context: LspRequestContext, fn: () => T): T {
 	return storage.run(context, fn);
 }
 
+export function lspRequestContext(): LspRequestContext {
+	const context = storage.getStore();
+	if (!context) throw new LspRequestContextUnavailableError();
+	return context;
+}
+
 export function contextCwd(): string {
-	return storage.getStore()?.cwd ?? process.cwd();
+	return lspRequestContext().cwd;
 }
 
 export function contextEnv(key: string): string | undefined {
-	const store = storage.getStore();
-	if (store?.env) return store.env[key];
-	return process.env[key];
+	const context = lspRequestContext();
+	if (key === "LSP_TOOLS_MCP_PROJECT_CONFIG") return context.projectConfigPaths.join(delimiter);
+	if (key === "LSP_TOOLS_MCP_USER_CONFIG") return context.userConfigPath;
+	if (key === "LSP_TOOLS_MCP_INSTALL_DECISIONS") return context.installDecisionsPath;
+	return undefined;
+}
+
+export function createStandaloneMcpRequestContext(
+	input: StandaloneMcpRequestContextInput = {},
+): LspRequestContext {
+	const env = input.env ?? process.env;
+	const cwd = canonicalCwd(input.cwd ?? process.cwd());
+	const home = input.homeDir ?? homedir();
+	const projectConfigPaths = translateProjectConfigEnv(env["LSP_TOOLS_MCP_PROJECT_CONFIG"], cwd);
+	const userConfigPath = translateHomeConfigEnv(env["LSP_TOOLS_MCP_USER_CONFIG"], home, ".codex/lsp-client.json");
+	const installDecisionsPath = translateHomeConfigEnv(
+		env["LSP_TOOLS_MCP_INSTALL_DECISIONS"],
+		home,
+		".codex/lsp-install-decisions.json",
+	);
+	return parseLspRequestContext({
+		cwd,
+		projectConfigPaths,
+		userConfigPath,
+		installDecisionsPath,
+		capabilities: { installDecisionTool: true },
+	});
+}
+
+export function parseLspRequestContext(value: unknown): LspRequestContext {
+	if (!isRecord(value)) {
+		throw new LspRequestContextParseError("invalid_context", "LSP request context must be an object.");
+	}
+	rejectUnknownFields(value, CONTEXT_FIELDS, "context");
+
+	const cwd = stringField(value, "cwd");
+	const projectConfigPaths = stringArrayField(value, "projectConfigPaths");
+	const userConfigPath = stringField(value, "userConfigPath");
+	const installDecisionsPath = stringField(value, "installDecisionsPath");
+	const capabilities = capabilitiesField(value["capabilities"]);
+	const canonical = canonicalCwd(cwd);
+
+	for (const path of projectConfigPaths) {
+		requireAbsolutePath(path, "projectConfigPaths");
+		const projectPath = canonicalizeExistingOrNearestAncestor(path);
+		if (!isPathInside(canonical, projectPath)) {
+			throw new LspRequestContextParseError(
+				"project_config_outside_cwd",
+				`Project LSP config path must be inside cwd: ${path}`,
+			);
+		}
+	}
+	requireAbsolutePath(userConfigPath, "userConfigPath");
+	requireAbsolutePath(installDecisionsPath, "installDecisionsPath");
+
+	return {
+		cwd: canonical,
+		projectConfigPaths: projectConfigPaths.map((path) => canonicalizeExistingOrNearestAncestor(path)),
+		userConfigPath,
+		installDecisionsPath,
+		capabilities,
+	};
+}
+
+function translateProjectConfigEnv(value: string | undefined, cwd: string): readonly string[] {
+	if (value === undefined || value.length === 0) return [join(cwd, ".codex", "lsp-client.json")];
+	return value
+		.split(delimiter)
+		.filter((entry) => entry.length > 0)
+		.map((entry) => (isAbsolute(entry) ? entry : join(cwd, entry)));
+}
+
+function translateHomeConfigEnv(value: string | undefined, home: string, fallback: string): string {
+	if (value === undefined || value.length === 0) return join(home, fallback);
+	return isAbsolute(value) ? value : join(home, value);
+}
+
+function canonicalCwd(cwd: string): string {
+	const resolved = resolve(cwd);
+	if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+		throw new LspRequestContextParseError("invalid_cwd", `LSP request cwd must be an existing directory: ${cwd}`);
+	}
+	return realpathSync(resolved);
+}
+
+export function canonicalizeExistingOrNearestAncestor(path: string): string {
+	let current = resolve(path);
+	const suffix: string[] = [];
+	while (true) {
+		try {
+			const existing = realpathSync(current);
+			return suffix.length === 0 ? existing : join(existing, ...suffix);
+		} catch (error) {
+			if (!isMissingPathError(error)) throw error;
+			const parent = dirname(current);
+			if (parent === current) throw error;
+			suffix.unshift(basename(current));
+			current = parent;
+		}
+	}
+}
+
+function capabilitiesField(value: unknown): LspRequestContext["capabilities"] {
+	if (!isRecord(value)) {
+		throw new LspRequestContextParseError("invalid_capabilities", "LSP request capabilities must be an object.");
+	}
+	rejectUnknownFields(value, CAPABILITY_FIELDS, "capabilities");
+	const installDecisionTool = value["installDecisionTool"];
+	if (typeof installDecisionTool !== "boolean") {
+		throw new LspRequestContextParseError(
+			"invalid_install_decision_capability",
+			"LSP request capabilities.installDecisionTool must be a boolean.",
+		);
+	}
+	return { installDecisionTool };
+}
+
+function stringField(value: Record<string, unknown>, field: string): string {
+	const fieldValue = value[field];
+	if (typeof fieldValue !== "string" || fieldValue.length === 0) {
+		throw new LspRequestContextParseError("invalid_field", `LSP request context.${field} must be a non-empty string.`);
+	}
+	return fieldValue;
+}
+
+function stringArrayField(value: Record<string, unknown>, field: string): readonly string[] {
+	const fieldValue = value[field];
+	if (!Array.isArray(fieldValue) || !fieldValue.every((item) => typeof item === "string" && item.length > 0)) {
+		throw new LspRequestContextParseError(
+			"invalid_field",
+			`LSP request context.${field} must be a non-empty string array.`,
+		);
+	}
+	return fieldValue;
+}
+
+function requireAbsolutePath(path: string, field: string): void {
+	if (!isAbsolute(path)) {
+		throw new LspRequestContextParseError("relative_path", `LSP request context.${field} must be absolute: ${path}`);
+	}
+}
+
+export function isPathInside(parent: string, child: string): boolean {
+	const childPath = resolve(child);
+	const relativePath = relative(parent, childPath);
+	return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+
+function isMissingPathError(error: unknown): boolean {
+	const code = errorCode(error);
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+
+function rejectUnknownFields(value: Record<string, unknown>, allowed: ReadonlySet<string>, scope: string): void {
+	const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+	if (unknown.length > 0) {
+		throw new LspRequestContextParseError(
+			"unknown_field",
+			`Unknown LSP request ${scope} field: ${unknown.join(", ")}`,
+		);
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function errorCode(error: unknown): string | undefined {
+	if (!error || typeof error !== "object" || !("code" in error)) return undefined;
+	const code = Reflect.get(error, "code");
+	return typeof code === "string" ? code : undefined;
 }

package/packages/lsp-core/src/tool-surface.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
+import { createStandaloneMcpRequestContext, runWithRequestContext } from "./request-context.js";
 import { coerceToolArguments, executeLspTool, LSP_MCP_TOOLS } from "./tools.js";
 
 const expectedToolSurface = [
@@ -142,7 +143,9 @@ describe("LSP core tool surface", () => {
 
 	test("#given legacy tool aliases #when executed #then aliases are callable but not listed", async () => {
 		// given / when
-		const result = await executeLspTool("lsp_diagnostics", { filePath: "module.wat" });
+		const result = await runWithRequestContext(createStandaloneMcpRequestContext(), () =>
+			executeLspTool("lsp_diagnostics", { filePath: "module.wat" }),
+		);
 
 		// then
 		expect(result.content[0]?.text).toContain("No LSP server configured for extension: .wat");

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

@@ -1,13 +1,10 @@
-import { resolve } from "node:path";
-
-import { isDirectoryPath, withLspClient } from "../lsp/client-wrapper.js";
+import { isDirectoryPath, resolvePathInsideContext, withLspClient } from "../lsp/client-wrapper.js";
 import { DEFAULT_MAX_DIAGNOSTICS } from "../lsp/constants.js";
 import { aggregateDiagnosticsForDirectory } from "../lsp/directory-diagnostics.js";
 import { filterDiagnosticsBySeverity, formatDiagnostic } from "../lsp/formatters.js";
 import { inferExtensionFromDirectory } from "../lsp/infer-extension.js";
 import type { Diagnostic } from "../lsp/types.js";
 import { missingDependencyResult } from "../missing-dependency-result.js";
-import { contextCwd } from "../request-context.js";
 import { clientOptions, requireString, severityFilter } from "./parameters.js";
 import { text } from "./result.js";
 import type { LspDiagnosticsDetails, ToolExecutionResult } from "./types.js";
@@ -26,7 +23,7 @@ export async function executeLspDiagnostics(
 	const severity = severityFilter(params);
 
 	try {
-		const absPath = resolve(contextCwd(), filePath);
+		const absPath = resolvePathInsideContext(filePath);
 		if (isDirectoryPath(absPath)) {
 			const extension = inferExtensionFromDirectory(absPath);
 			if (!extension) {
@@ -44,24 +41,46 @@ export async function executeLspDiagnostics(
 				return text(message, details);
 			}
 
-			const output = await aggregateDiagnosticsForDirectory(absPath, extension, severity);
+				const output = await aggregateDiagnosticsForDirectory(
+					absPath,
+					extension,
+					severity,
+					undefined,
+					signal === undefined ? {} : { signal },
+				);
 			const details: LspDiagnosticsDetails = {
 				filePath,
 				severity,
 				mode: "directory",
 				diagnostics: [],
-				totalDiagnostics: 0,
+				totalDiagnostics: output.totalDiagnostics,
 				truncated: false,
+				fileFailures: [...output.fileFailures],
 			};
-			return text(output, details);
+			return text(output.output, details);
 		}
 
 		const result = await withLspClient(
-			filePath,
-			async (client) => client.diagnostics(filePath),
-			"diagnostics",
-			clientOptions(signal),
-		);
+				filePath,
+				async (client) => client.diagnostics(filePath, signal),
+				"diagnostics",
+				clientOptions(signal),
+			);
+		if (result.transientError) {
+			const message = result.transientError.message;
+			const details: LspDiagnosticsDetails = {
+				filePath,
+				severity,
+				mode: "file",
+				diagnostics: [],
+				totalDiagnostics: 0,
+				truncated: false,
+				error: message,
+				errorKind: result.transientError.kind,
+			};
+			return text(message, details, true);
+		}
+
 		const diagnostics = filterDiagnosticsBySeverity(asDiagnosticArray(result), severity);
 		const total = diagnostics.length;
 		const truncated = total > DEFAULT_MAX_DIAGNOSTICS;