lazycodex-ai 5.1.48 → 5.1.54

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

@@ -0,0 +1,88 @@
+import { DEFAULT_MAX_REFERENCES } from "../lsp/constants.js";
+import { formatLocation } from "../lsp/formatters.js";
+import { withLspClient } from "../lsp/client-wrapper.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { clientOptions, optionalBoolean, requireNumber, requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspFindReferencesDetails, LspGotoDefinitionDetails, ToolExecutionResult } from "./types.js";
+
+export async function executeLspGotoDefinition(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+
+	try {
+			const result = await withLspClient(
+				filePath,
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.definition(resolvedFilePath, line, character, signal),
+				"definition",
+				clientOptions(signal),
+			);
+		const locations = !result ? [] : Array.isArray(result) ? result : [result];
+		const details: LspGotoDefinitionDetails = { filePath, line, character, locations };
+		if (locations.length === 0) return text("No definition found", details);
+		return text(locations.map(formatLocation).join("\n"), details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			locations: [],
+		} satisfies Omit<LspGotoDefinitionDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}
+
+export async function executeLspFindReferences(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+	const includeDeclaration = optionalBoolean(params, "includeDeclaration") ?? true;
+
+	try {
+			const result = await withLspClient(
+				filePath,
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.references(resolvedFilePath, line, character, includeDeclaration, signal),
+				"references",
+				clientOptions(signal),
+			);
+		const references = Array.isArray(result) ? result : [];
+		const total = references.length;
+		const truncated = total > DEFAULT_MAX_REFERENCES;
+		const limited = truncated ? references.slice(0, DEFAULT_MAX_REFERENCES) : references;
+		const details: LspFindReferencesDetails = {
+			filePath,
+			line,
+			character,
+			references,
+			totalReferences: total,
+			truncated,
+		};
+		if (total === 0) return text("No references found", details);
+		const output = [
+			...(truncated ? [`Found ${total} references (showing first ${DEFAULT_MAX_REFERENCES}):`] : []),
+			...limited.map(formatLocation),
+		].join("\n");
+		return text(output, details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			references: [],
+			totalReferences: 0,
+			truncated: false,
+		} satisfies Omit<LspFindReferencesDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}

package/packages/lsp-core/src/tools/parameters.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+	clientOptions,
+	optionalBoolean,
+	optionalNumber,
+	optionalString,
+	requireNumber,
+	requireString,
+	severityFilter,
+} from "./parameters.js";
+
+describe("LSP tool parameter helpers", () => {
+	test("#given required string parameter #when value is missing or empty #then throws clear error", () => {
+		expect(requireString({ filePath: "index.ts" }, "filePath")).toBe("index.ts");
+		expect(() => requireString({}, "filePath")).toThrow("Missing required string parameter 'filePath'");
+		expect(() => requireString({ filePath: "" }, "filePath")).toThrow("Missing required string parameter 'filePath'");
+		expect(() => requireString({ filePath: 42 }, "filePath")).toThrow("Missing required string parameter 'filePath'");
+	});
+
+	test("#given required number parameter #when value is non-finite #then throws clear error", () => {
+		expect(requireNumber({ line: 3 }, "line")).toBe(3);
+		expect(() => requireNumber({}, "line")).toThrow("Missing required number parameter 'line'");
+		expect(() => requireNumber({ line: Number.NaN }, "line")).toThrow("Missing required number parameter 'line'");
+		expect(() => requireNumber({ line: Number.POSITIVE_INFINITY }, "line")).toThrow(
+			"Missing required number parameter 'line'",
+		);
+	});
+
+	test("#given optional parameters #when values have wrong type #then ignores them", () => {
+		expect(optionalString({ query: "symbol" }, "query")).toBe("symbol");
+		expect(optionalString({ query: 7 }, "query")).toBeUndefined();
+		expect(optionalNumber({ limit: 10 }, "limit")).toBe(10);
+		expect(optionalNumber({ limit: Number.NaN }, "limit")).toBeUndefined();
+		expect(optionalBoolean({ includeDeclaration: false }, "includeDeclaration")).toBe(false);
+		expect(optionalBoolean({ includeDeclaration: "false" }, "includeDeclaration")).toBeUndefined();
+	});
+
+	test("#given severity parameter #when value is unknown #then defaults to all", () => {
+		expect(severityFilter({ severity: "warning" })).toBe("warning");
+		expect(severityFilter({ severity: "fatal" })).toBe("all");
+		expect(severityFilter({})).toBe("all");
+	});
+
+	test("#given optional abort signal #when building client options #then includes only defined signal", () => {
+		const controller = new AbortController();
+
+		expect(clientOptions(undefined)).toEqual({});
+		expect(clientOptions(controller.signal)).toEqual({ signal: controller.signal });
+	});
+});

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

@@ -0,0 +1,49 @@
+import type { WithLspClientOptions } from "../lsp/client-wrapper.js";
+import type { SeverityFilter } from "../lsp/types.js";
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function requireString(params: Record<string, unknown>, key: string): string {
+	const value = params[key];
+	if (typeof value !== "string" || value.length === 0) {
+		throw new Error(`Missing required string parameter '${key}'`);
+	}
+	return value;
+}
+
+export function optionalString(params: Record<string, unknown>, key: string): string | undefined {
+	const value = params[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+export function requireNumber(params: Record<string, unknown>, key: string): number {
+	const value = params[key];
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		throw new Error(`Missing required number parameter '${key}'`);
+	}
+	return value;
+}
+
+export function optionalNumber(params: Record<string, unknown>, key: string): number | undefined {
+	const value = params[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function optionalBoolean(params: Record<string, unknown>, key: string): boolean | undefined {
+	const value = params[key];
+	return typeof value === "boolean" ? value : undefined;
+}
+
+export function severityFilter(params: Record<string, unknown>): SeverityFilter {
+	const value = params["severity"];
+	if (value === "error" || value === "warning" || value === "information" || value === "hint" || value === "all") {
+		return value;
+	}
+	return "all";
+}
+
+export function clientOptions(signal: AbortSignal | undefined): WithLspClientOptions {
+	return signal === undefined ? {} : { signal };
+}

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

@@ -0,0 +1,69 @@
+import { formatApplyResult, formatPrepareRenameResult } from "../lsp/formatters.js";
+import { withLspClient } from "../lsp/client-wrapper.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { clientOptions, requireNumber, requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspPrepareRenameDetails, LspRenameDetails, ToolExecutionResult } from "./types.js";
+
+export async function executeLspPrepareRename(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+
+	try {
+			const result = await withLspClient(
+				filePath,
+				async (client, _workspaceRoot, resolvedFilePath) =>
+					client.prepareRename(resolvedFilePath, line, character, signal),
+				"prepareRename",
+				clientOptions(signal),
+			);
+		const details: LspPrepareRenameDetails = { filePath, line, character, result };
+		return text(formatPrepareRenameResult(result), details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			result: null,
+		} satisfies Omit<LspPrepareRenameDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}
+
+export async function executeLspRename(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+	const newName = requireString(params, "newName");
+
+	try {
+		const result = await withLspClient(
+			filePath,
+			async (client, _workspaceRoot, resolvedFilePath) =>
+				client.rename(resolvedFilePath, line, character, newName, signal),
+			"rename",
+			clientOptions(signal),
+		);
+		const details: LspRenameDetails = { filePath, line, character, newName, apply: result.apply, edit: result.edit };
+		return text(formatApplyResult(result.apply), details, !result.apply.success);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			newName,
+			apply: null,
+			edit: null,
+		} satisfies Omit<LspRenameDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}

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

@@ -0,0 +1,5 @@
+import type { ToolExecutionResult } from "./types.js";
+
+export function text(text: string, details?: unknown, isError = false): ToolExecutionResult {
+	return { content: [{ type: "text", text }], details, isError };
+}

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

@@ -0,0 +1,21 @@
+import { LSP_MCP_TOOLS } from "./definitions.js";
+import { isRecord } from "./parameters.js";
+import type { LspMcpTool, ToolExecutionResult } from "./types.js";
+
+export async function executeLspTool(
+	name: string,
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const tool = LSP_MCP_TOOLS.find((candidate) => matchesToolName(candidate, name));
+	if (!tool) throw new Error(`Unknown LSP tool: ${name}`);
+	return tool.execute(params, signal);
+}
+
+function matchesToolName(tool: LspMcpTool, name: string): boolean {
+	return tool.name === name || (tool.aliases?.includes(name) ?? false);
+}
+
+export function coerceToolArguments(value: unknown): Record<string, unknown> {
+	return isRecord(value) ? value : {};
+}

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

@@ -0,0 +1,9 @@
+import type { JsonSchema } from "./types.js";
+
+export function objectSchema(properties: Record<string, JsonSchema>, required: string[] = []): JsonSchema {
+	return {
+		type: "object",
+		properties,
+		required,
+	};
+}

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

@@ -0,0 +1,28 @@
+import { getLspManager } from "../lsp/manager.js";
+import { getAllServers } from "../lsp/server-resolution.js";
+import { text } from "./result.js";
+import type { ToolExecutionResult } from "./types.js";
+
+export async function executeLspStatus(): Promise<ToolExecutionResult> {
+	const servers = getAllServers();
+	const snapshots = getLspManager().getSnapshot();
+	const installed = servers.filter((server) => server.installed && !server.disabled);
+	const configuredLines = servers.map((server) => {
+		const state = server.disabled ? "disabled" : server.installed ? "installed" : "missing";
+		return `- ${server.id}: ${state}; source=${server.source}; extensions=${server.extensions.join(", ")}`;
+	});
+	const activeLines = snapshots.map((snapshot) => {
+		const state = snapshot.alive ? (snapshot.isInitializing ? "initializing" : "alive") : "dead";
+		return `- ${snapshot.serverId}: ${state}; root=${snapshot.root}; refs=${snapshot.refCount}`;
+	});
+	const lines = [
+		`Configured LSP servers: ${servers.length}`,
+		`Installed LSP servers: ${installed.length}`,
+		"",
+		...configuredLines,
+		"",
+		`Active LSP clients: ${snapshots.length}`,
+		...activeLines,
+	];
+	return text(lines.join("\n"), { servers, snapshots });
+}

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

@@ -0,0 +1,99 @@
+import { DEFAULT_MAX_SYMBOLS } from "../lsp/constants.js";
+import { formatDocumentSymbol, formatSymbolInfo } from "../lsp/formatters.js";
+import { withLspClient } from "../lsp/client-wrapper.js";
+import type { DocumentSymbol, SymbolInfo } from "../lsp/types.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { clientOptions, optionalNumber, optionalString, requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspSymbolsDetails, ToolExecutionResult } from "./types.js";
+
+function isDocumentSymbol(symbol: DocumentSymbol | SymbolInfo): symbol is DocumentSymbol {
+	return "range" in symbol;
+}
+
+export async function executeLspSymbols(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const rawScope = optionalString(params, "scope") ?? "document";
+	const scope = rawScope === "workspace" ? "workspace" : "document";
+	const limit = Math.min(optionalNumber(params, "limit") ?? DEFAULT_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS);
+
+	try {
+		if (scope === "workspace") {
+			const query = optionalString(params, "query");
+			if (!query) {
+				const message = "Error: 'query' is required for workspace scope";
+				return text(message, {
+					filePath,
+					scope,
+					symbols: [],
+					totalSymbols: 0,
+					truncated: false,
+					error: message,
+					errorKind: "missing_query",
+				});
+			}
+
+				const symbols = await withLspClient(
+					filePath,
+					async (client) => client.workspaceSymbols(query, signal),
+					"workspaceSymbols",
+					clientOptions(signal),
+				);
+			return formatSymbolsResult(filePath, scope, symbols, limit, query);
+		}
+
+			const symbols = await withLspClient(
+				filePath,
+				async (client, _workspaceRoot, resolvedFilePath) => client.documentSymbols(resolvedFilePath, signal),
+				"documentSymbols",
+				clientOptions(signal),
+			);
+		return formatSymbolsResult(filePath, scope, symbols, limit);
+	} catch (error) {
+		const query = optionalString(params, "query");
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			scope,
+			symbols: [],
+			totalSymbols: 0,
+			truncated: false,
+			...(query === undefined ? {} : { query }),
+		} satisfies Omit<LspSymbolsDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}
+
+function formatSymbolsResult(
+	filePath: string,
+	scope: "document" | "workspace",
+	symbols: Array<DocumentSymbol | SymbolInfo>,
+	limit: number,
+	query?: string,
+): ToolExecutionResult {
+	const total = symbols.length;
+	const truncated = total > limit;
+	const limited = truncated ? symbols.slice(0, limit) : symbols;
+	const details: LspSymbolsDetails = {
+		filePath,
+		scope,
+		symbols,
+		totalSymbols: total,
+		truncated,
+		...(query === undefined ? {} : { query }),
+	};
+	if (total === 0) return text("No symbols found", details);
+
+	const lines: string[] = [];
+	if (truncated) lines.push(`Found ${total} symbols (showing first ${limit}):`);
+	const documentSymbols = limited.filter(isDocumentSymbol);
+	if (documentSymbols.length === limited.length) {
+		lines.push(...documentSymbols.map((symbol) => formatDocumentSymbol(symbol)));
+	} else {
+		lines.push(...limited.filter((symbol): symbol is SymbolInfo => !isDocumentSymbol(symbol)).map(formatSymbolInfo));
+	}
+	return text(lines.join("\n"), details);
+}

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

@@ -0,0 +1,116 @@
+import type {
+	Diagnostic,
+	DocumentSymbol,
+	Location,
+	LocationLink,
+	PrepareRenameDefaultBehavior,
+	PrepareRenameResult,
+	Range,
+	SeverityFilter,
+	SymbolInfo,
+	WorkspaceEdit,
+} from "../lsp/types.js";
+import type { ApplyResult } from "../lsp/workspace-edit.js";
+
+export interface TextContent {
+	type: "text";
+	text: string;
+}
+
+export interface ToolExecutionResult {
+	content: TextContent[];
+	isError?: boolean;
+	details?: unknown;
+}
+
+export interface JsonSchema {
+	type: string;
+	description?: string;
+	properties?: Record<string, JsonSchema>;
+	required?: string[];
+	items?: JsonSchema;
+	enum?: string[];
+}
+
+export interface LspMcpTool {
+	name: string;
+	aliases?: string[];
+	title: string;
+	description: string;
+	inputSchema: JsonSchema;
+	execute(params: Record<string, unknown>, signal?: AbortSignal): Promise<ToolExecutionResult>;
+}
+
+export interface LspDiagnosticsDetails {
+	filePath: string;
+	severity: SeverityFilter;
+	mode: "file" | "directory";
+	diagnostics: Array<{ file: string; diagnostic: Diagnostic }>;
+	totalDiagnostics: number;
+	truncated: boolean;
+	error?: string;
+	errorKind?: "freshness_timeout" | "missing_dependency" | "no_files" | "invalid_path";
+	fileFailures?: Array<{ file: string; error: string }>;
+	projectCommands?: string[];
+}
+
+export interface LspGotoDefinitionDetails {
+	filePath: string;
+	line: number;
+	character: number;
+	locations: Array<Location | LocationLink>;
+	error?: string;
+	errorKind?: "missing_dependency";
+}
+
+export interface LspFindReferencesDetails {
+	filePath: string;
+	line: number;
+	character: number;
+	references: Location[];
+	totalReferences: number;
+	truncated: boolean;
+	error?: string;
+	errorKind?: "missing_dependency";
+}
+
+export interface LspSymbolsDetails {
+	filePath: string;
+	scope: "document" | "workspace";
+	query?: string;
+	symbols: Array<DocumentSymbol | SymbolInfo>;
+	totalSymbols: number;
+	truncated: boolean;
+	error?: string;
+	errorKind?: "missing_dependency" | "missing_query";
+}
+
+export interface LspPrepareRenameDetails {
+	filePath: string;
+	line: number;
+	character: number;
+	result: PrepareRenameResult | PrepareRenameDefaultBehavior | Range | null;
+	error?: string;
+	errorKind?: "missing_dependency";
+}
+
+export interface LspFormatDetails {
+	filePath: string;
+	status: "formatted" | "unchanged" | "unavailable";
+	reason?: "capability_not_advertised" | "server_unavailable";
+	linesAdded: number;
+	linesRemoved: number;
+	error?: string;
+	errorKind?: "missing_dependency";
+}
+
+export interface LspRenameDetails {
+	filePath: string;
+	line: number;
+	character: number;
+	newName: string;
+	apply: ApplyResult | null;
+	edit: WorkspaceEdit | null;
+	error?: string;
+	errorKind?: "missing_dependency";
+}

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

@@ -0,0 +1 @@
+export * from "./tools/index.js";