@dyyz1993/pi-coding-agent 0.74.24 → 0.74.27

package/dist/extensions/lsp/lsp/contract.ts

@@ -0,0 +1,103 @@
+import type { ChannelContract } from "@dyyz1993/pi-coding-agent";
+import type { DiagnosticsModeName } from "./hooks/diagnostics-mode.js";
+import type { LspDiagnostic } from "./utils/lsp-helpers.js";
+
+export const LSP_CHANNEL_NAME = "lsp";
+
+export interface LspServerSummary {
+	name: string;
+	fileTypes?: string[];
+	state: string;
+	reason: string;
+	transport?: string;
+	activeCommand?: string[];
+	configuredCommand?: string[];
+}
+
+export interface LspStatusResult {
+	state: string;
+	servers: LspServerSummary[];
+	mode: DiagnosticsModeName;
+}
+
+export interface LspSetModeResult {
+	ok: boolean;
+	mode?: DiagnosticsModeName;
+}
+
+export interface LspStartupServerEntry {
+	name: string;
+	state: string;
+	fileTypes?: string[];
+}
+
+export interface LspServerStatusEntry {
+	name: string;
+	fileTypes?: string[];
+	status: {
+		state: string;
+		reason: string;
+		transport?: string;
+		activeCommand?: string[];
+		configuredCommand?: string[];
+	};
+}
+
+export interface LspChannelContract extends ChannelContract {
+	methods: {
+		"lsp.setMode": {
+			params: { mode: string };
+			return: LspSetModeResult;
+		};
+		getActiveLanguages: {
+			params: Record<string, never>;
+			return: { languages: string[] };
+		};
+		getStatus: {
+			params: Record<string, never>;
+			return: LspStatusResult;
+		};
+	};
+	events: {
+		diagnostics_update: {
+			event: "diagnostics_update";
+			timestamp: number;
+			filePath: string;
+			diagnostics: LspDiagnostic[];
+		};
+		mode_changed: {
+			event: "mode_changed";
+			timestamp: number;
+			mode: DiagnosticsModeName;
+		};
+		startup_begin: {
+			event: "startup_begin";
+			timestamp: number;
+			servers: LspStartupServerEntry[];
+			totalServers: number;
+		};
+		server_ready: {
+			event: "server_ready" | "server_error";
+			timestamp: number;
+			serverName: string;
+			servers: LspServerStatusEntry[];
+		};
+		language_activated: {
+			event: "language_activated";
+			timestamp: number;
+			serverName: string;
+			languages: string[];
+		};
+		status_changed: {
+			event: "status_changed";
+			timestamp: number;
+			servers: LspServerStatusEntry[];
+			state: string;
+		};
+		startup_complete: {
+			event: "startup_complete";
+			timestamp: number;
+			servers: LspServerStatusEntry[];
+		};
+	};
+}

package/dist/extensions/lsp/lsp/hooks/agent-end.ts

@@ -0,0 +1,169 @@
+import { readFile as fsReadFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { ExtensionAPI } from "@dyyz1993/pi-coding-agent";
+import type { FileTracker } from "../client/file-tracker.js";
+import type { LspRuntimeRegistry } from "../client/registry.js";
+import type { DependencyResolver } from "../utils/dependency-resolver.js";
+import { waitForPushDiagnostics } from "../utils/diagnostics-wait.js";
+import { extractPullDiagnostics, type LspDiagnostic, languageIdFromPath } from "../utils/lsp-helpers.js";
+import type { DiagnosticsMode } from "./diagnostics-mode.js";
+
+export interface FileDiagnostics {
+	filePath: string;
+	diagnostics: LspDiagnostic[];
+	source: "touched" | "dependent";
+}
+
+export interface AgentEndHook {
+	register(pi: ExtensionAPI): void;
+}
+
+export function createAgentEndHook(
+	runtime: LspRuntimeRegistry,
+	mode: DiagnosticsMode,
+	fileTracker?: FileTracker,
+	dependencyResolver?: DependencyResolver,
+	onDiagnostics?: (results: FileDiagnostics[]) => void,
+): AgentEndHook {
+	return {
+		register(pi: ExtensionAPI): void {
+			pi.on("agent_end", async () => {
+				await handleAgentEnd();
+			});
+		},
+	};
+
+	async function handleAgentEnd(): Promise<void> {
+		if (mode.get() !== "agent_end") {
+			return;
+		}
+
+		const touchedFiles = mode.getTouchedFiles();
+		if (touchedFiles.length === 0) {
+			return;
+		}
+
+		const allFilesToCheck = new Set<string>(touchedFiles);
+
+		if (dependencyResolver) {
+			try {
+				const dependents = await dependencyResolver.resolveDependents(touchedFiles);
+				for (const dep of dependents) {
+					allFilesToCheck.add(dep);
+				}
+				if (dependents.length > 0) {
+					console.debug(
+						`[lsp] dependency expansion: ${touchedFiles.length} touched -> ${dependents.length} dependents -> ${allFilesToCheck.size} total`,
+					);
+				}
+			} catch (err) {
+				console.debug("[lsp] dependency resolution failed:", err instanceof Error ? err.message : err);
+			}
+		}
+
+		const results: FileDiagnostics[] = [];
+
+		for (const filePath of allFilesToCheck) {
+			try {
+				const source = touchedFiles.includes(filePath) ? "touched" as const : "dependent" as const;
+				const diagnostics = await runDiagnosticsForFile(filePath);
+				if (diagnostics.length > 0) {
+					results.push({ filePath, diagnostics, source });
+				}
+			} catch (err) {
+				console.debug("[lsp] diagnostics for file failed:", filePath, err instanceof Error ? err.message : err);
+			}
+		}
+
+		mode.clearTouchedFiles();
+
+		if (results.length > 0) {
+			onDiagnostics?.(results);
+		}
+	}
+
+	async function runDiagnosticsForFile(filePath: string): Promise<LspDiagnostic[]> {
+		const cwd = process.cwd();
+		const uri = pathToFileURL(resolve(cwd, filePath)).href;
+
+		if (fileTracker) {
+			fileTracker.open(filePath, (evictedFile) => {
+				const evictedUri = pathToFileURL(resolve(cwd, evictedFile)).href;
+				runtime.notify("textDocument/didClose", { textDocument: { uri: evictedUri } }, { path: evictedFile });
+			});
+		}
+
+		let fileContent = "";
+		try {
+			fileContent = await fsReadFile(resolve(cwd, filePath), "utf8");
+		} catch (err) {
+			console.debug("[lsp] file read for diagnostics failed:", err instanceof Error ? err.message : err);
+		}
+
+		runtime.notify(
+			"textDocument/didOpen",
+			{
+				textDocument: {
+					uri,
+					languageId: languageIdFromPath(filePath),
+					version: Date.now(),
+					text: fileContent,
+				},
+			},
+			{ path: filePath },
+		);
+
+		await waitForPushDiagnostics(runtime, filePath);
+
+		let diagnostics = runtime.getPublishedDiagnostics(filePath);
+
+		try {
+			const allResults = await runtime.requestAll(
+				"textDocument/diagnostic",
+				{ textDocument: { uri } },
+				{ path: filePath, timeoutMs: 8000 },
+			);
+			for (const result of allResults) {
+				if (!result) continue;
+				const pulled = extractPullDiagnostics(result);
+				if (pulled.length > 0) {
+					diagnostics = diagnostics.concat(pulled);
+				}
+			}
+		} catch (err) {
+			console.debug("[lsp] pull diagnostics request failed:", err instanceof Error ? err.message : err);
+		}
+
+		return diagnostics;
+	}
+}
+
+export function summarizeDiagnostics(diagnostics: Array<{ severity?: number }>): string {
+	if (diagnostics.length === 0) {
+		return "no diagnostics";
+	}
+
+	let errors = 0;
+	let warnings = 0;
+	let infos = 0;
+	for (const diagnostic of diagnostics) {
+		switch (diagnostic.severity) {
+			case 1:
+				errors += 1;
+				break;
+			case 2:
+				warnings += 1;
+				break;
+			default:
+				infos += 1;
+				break;
+		}
+	}
+
+	const parts = [`${diagnostics.length} diagnostics`];
+	if (errors > 0) parts.push(`${errors} errors`);
+	if (warnings > 0) parts.push(`${warnings} warnings`);
+	if (infos > 0) parts.push(`${infos} info`);
+	return parts.join(", ");
+}

package/dist/extensions/lsp/lsp/hooks/diagnostics-mode.d.ts

@@ -0,0 +1,10 @@
+export type DiagnosticsModeName = "agent_end" | "edit_write" | "disabled";
+export interface DiagnosticsMode {
+    get(): DiagnosticsModeName;
+    set(mode: DiagnosticsModeName): void;
+    addTouchedFile(filePath: string): void;
+    getTouchedFiles(): string[];
+    clearTouchedFiles(): void;
+}
+export declare function createDiagnosticsMode(initial?: DiagnosticsModeName): DiagnosticsMode;
+//# sourceMappingURL=diagnostics-mode.d.ts.map

package/dist/extensions/lsp/lsp/hooks/diagnostics-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-mode.d.ts","sourceRoot":"","sources":["diagnostics-mode.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,YAAY,GAAG,UAAU,CAAC;AAI1E,MAAM,WAAW,eAAe;IAC/B,GAAG,IAAI,mBAAmB,CAAC;IAC3B,GAAG,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACrC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,eAAe,IAAI,MAAM,EAAE,CAAC;IAC5B,iBAAiB,IAAI,IAAI,CAAC;CAC1B;AAED,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,eAAe,CA4BpF","sourcesContent":["export type DiagnosticsModeName = \"agent_end\" | \"edit_write\" | \"disabled\";\n\nconst VALID_MODES: DiagnosticsModeName[] = [\"agent_end\", \"edit_write\", \"disabled\"];\n\nexport interface DiagnosticsMode {\n\tget(): DiagnosticsModeName;\n\tset(mode: DiagnosticsModeName): void;\n\taddTouchedFile(filePath: string): void;\n\tgetTouchedFiles(): string[];\n\tclearTouchedFiles(): void;\n}\n\nexport function createDiagnosticsMode(initial?: DiagnosticsModeName): DiagnosticsMode {\n\tlet current: DiagnosticsModeName = VALID_MODES.includes(initial!) ? initial! : \"agent_end\";\n\tconst touchedFiles: string[] = [];\n\tconst touchedSet = new Set<string>();\n\n\treturn {\n\t\tget(): DiagnosticsModeName {\n\t\t\treturn current;\n\t\t},\n\t\tset(mode: DiagnosticsModeName): void {\n\t\t\tif (VALID_MODES.includes(mode)) {\n\t\t\t\tcurrent = mode;\n\t\t\t}\n\t\t},\n\t\taddTouchedFile(filePath: string): void {\n\t\t\tif (!touchedSet.has(filePath)) {\n\t\t\t\ttouchedSet.add(filePath);\n\t\t\t\ttouchedFiles.push(filePath);\n\t\t\t}\n\t\t},\n\t\tgetTouchedFiles(): string[] {\n\t\t\treturn [...touchedFiles];\n\t\t},\n\t\tclearTouchedFiles(): void {\n\t\t\ttouchedFiles.length = 0;\n\t\t\ttouchedSet.clear();\n\t\t},\n\t};\n}\n"]}

package/dist/extensions/lsp/lsp/hooks/diagnostics-mode.js

@@ -0,0 +1,30 @@
+const VALID_MODES = ["agent_end", "edit_write", "disabled"];
+export function createDiagnosticsMode(initial) {
+    let current = VALID_MODES.includes(initial) ? initial : "agent_end";
+    const touchedFiles = [];
+    const touchedSet = new Set();
+    return {
+        get() {
+            return current;
+        },
+        set(mode) {
+            if (VALID_MODES.includes(mode)) {
+                current = mode;
+            }
+        },
+        addTouchedFile(filePath) {
+            if (!touchedSet.has(filePath)) {
+                touchedSet.add(filePath);
+                touchedFiles.push(filePath);
+            }
+        },
+        getTouchedFiles() {
+            return [...touchedFiles];
+        },
+        clearTouchedFiles() {
+            touchedFiles.length = 0;
+            touchedSet.clear();
+        },
+    };
+}
+//# sourceMappingURL=diagnostics-mode.js.map

package/dist/extensions/lsp/lsp/hooks/diagnostics-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-mode.js","sourceRoot":"","sources":["diagnostics-mode.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,GAA0B,CAAC,WAAW,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAUnF,MAAM,UAAU,qBAAqB,CAAC,OAA6B,EAAmB;IACrF,IAAI,OAAO,GAAwB,WAAW,CAAC,QAAQ,CAAC,OAAQ,CAAC,CAAC,CAAC,CAAC,OAAQ,CAAC,CAAC,CAAC,WAAW,CAAC;IAC3F,MAAM,YAAY,GAAa,EAAE,CAAC;IAClC,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;IAErC,OAAO;QACN,GAAG,GAAwB;YAC1B,OAAO,OAAO,CAAC;QAAA,CACf;QACD,GAAG,CAAC,IAAyB,EAAQ;YACpC,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBAChC,OAAO,GAAG,IAAI,CAAC;YAChB,CAAC;QAAA,CACD;QACD,cAAc,CAAC,QAAgB,EAAQ;YACtC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC/B,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBACzB,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC7B,CAAC;QAAA,CACD;QACD,eAAe,GAAa;YAC3B,OAAO,CAAC,GAAG,YAAY,CAAC,CAAC;QAAA,CACzB;QACD,iBAAiB,GAAS;YACzB,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;YACxB,UAAU,CAAC,KAAK,EAAE,CAAC;QAAA,CACnB;KACD,CAAC;AAAA,CACF","sourcesContent":["export type DiagnosticsModeName = \"agent_end\" | \"edit_write\" | \"disabled\";\n\nconst VALID_MODES: DiagnosticsModeName[] = [\"agent_end\", \"edit_write\", \"disabled\"];\n\nexport interface DiagnosticsMode {\n\tget(): DiagnosticsModeName;\n\tset(mode: DiagnosticsModeName): void;\n\taddTouchedFile(filePath: string): void;\n\tgetTouchedFiles(): string[];\n\tclearTouchedFiles(): void;\n}\n\nexport function createDiagnosticsMode(initial?: DiagnosticsModeName): DiagnosticsMode {\n\tlet current: DiagnosticsModeName = VALID_MODES.includes(initial!) ? initial! : \"agent_end\";\n\tconst touchedFiles: string[] = [];\n\tconst touchedSet = new Set<string>();\n\n\treturn {\n\t\tget(): DiagnosticsModeName {\n\t\t\treturn current;\n\t\t},\n\t\tset(mode: DiagnosticsModeName): void {\n\t\t\tif (VALID_MODES.includes(mode)) {\n\t\t\t\tcurrent = mode;\n\t\t\t}\n\t\t},\n\t\taddTouchedFile(filePath: string): void {\n\t\t\tif (!touchedSet.has(filePath)) {\n\t\t\t\ttouchedSet.add(filePath);\n\t\t\t\ttouchedFiles.push(filePath);\n\t\t\t}\n\t\t},\n\t\tgetTouchedFiles(): string[] {\n\t\t\treturn [...touchedFiles];\n\t\t},\n\t\tclearTouchedFiles(): void {\n\t\t\ttouchedFiles.length = 0;\n\t\t\ttouchedSet.clear();\n\t\t},\n\t};\n}\n"]}

package/dist/extensions/lsp/lsp/hooks/diagnostics-mode.ts

@@ -0,0 +1,41 @@
+export type DiagnosticsModeName = "agent_end" | "edit_write" | "disabled";
+
+const VALID_MODES: DiagnosticsModeName[] = ["agent_end", "edit_write", "disabled"];
+
+export interface DiagnosticsMode {
+	get(): DiagnosticsModeName;
+	set(mode: DiagnosticsModeName): void;
+	addTouchedFile(filePath: string): void;
+	getTouchedFiles(): string[];
+	clearTouchedFiles(): void;
+}
+
+export function createDiagnosticsMode(initial?: DiagnosticsModeName): DiagnosticsMode {
+	let current: DiagnosticsModeName = VALID_MODES.includes(initial!) ? initial! : "agent_end";
+	const touchedFiles: string[] = [];
+	const touchedSet = new Set<string>();
+
+	return {
+		get(): DiagnosticsModeName {
+			return current;
+		},
+		set(mode: DiagnosticsModeName): void {
+			if (VALID_MODES.includes(mode)) {
+				current = mode;
+			}
+		},
+		addTouchedFile(filePath: string): void {
+			if (!touchedSet.has(filePath)) {
+				touchedSet.add(filePath);
+				touchedFiles.push(filePath);
+			}
+		},
+		getTouchedFiles(): string[] {
+			return [...touchedFiles];
+		},
+		clearTouchedFiles(): void {
+			touchedFiles.length = 0;
+			touchedSet.clear();
+		},
+	};
+}

package/dist/extensions/lsp/lsp/hooks/writethrough.ts

@@ -0,0 +1,342 @@
+import { readFile as fsReadFile, writeFile as fsWriteFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { ExtensionAPI, ExtensionContext, ToolResultEvent } from "@dyyz1993/pi-coding-agent";
+import type { FileTracker } from "../client/file-tracker.js";
+import type { LspRuntimeRegistry } from "../client/registry.js";
+import {
+	extractPullDiagnostics,
+	type LspDiagnostic,
+	type LspPosition,
+	type LspRange,
+	languageIdFromPath,
+	normalizeRange,
+} from "../utils/lsp-helpers.js";
+import type { DiagnosticsMode } from "./diagnostics-mode.js";
+import { waitForPushDiagnostics } from "../utils/diagnostics-wait.js";
+
+interface LspTextEdit {
+	range: LspRange;
+	newText: string;
+}
+
+export interface WriteThroughHooks {
+	register(pi: ExtensionAPI): void;
+}
+
+export interface WriteThroughOptions {
+	cwd?: string;
+	formatOnWrite?: boolean;
+	diagnosticsOnWrite?: boolean;
+	formattingOptions?: {
+		tabSize?: number;
+		insertSpaces?: boolean;
+	};
+}
+
+export function createWriteThroughHooks(
+	runtime: LspRuntimeRegistry,
+	options: WriteThroughOptions = {},
+	mode?: DiagnosticsMode,
+	fileTracker?: FileTracker,
+): WriteThroughHooks {
+	const cwd = options.cwd ?? process.cwd();
+	const formatOnWrite = options.formatOnWrite ?? true;
+	const diagnosticsOnWrite = options.diagnosticsOnWrite ?? true;
+	const formattingOptions = {
+		tabSize: options.formattingOptions?.tabSize ?? 2,
+		insertSpaces: options.formattingOptions?.insertSpaces ?? true,
+	};
+
+	return {
+		register(pi: ExtensionAPI): void {
+			pi.on("tool_result", async (event: any, ctx: any) => {
+				return await maybeHandleWriteThrough(event, ctx);
+			});
+		},
+	};
+
+	async function maybeHandleWriteThrough(event: ToolResultEvent, ctx: ExtensionContext) {
+		if (event.isError) {
+			return;
+		}
+		if (event.toolName !== "write" && event.toolName !== "edit") {
+			return;
+		}
+
+		const currentMode = mode?.get() ?? "edit_write";
+
+		if (currentMode === "disabled") {
+			return;
+		}
+
+		const filePath = getToolInputPath(event.input);
+		if (!filePath) {
+			return;
+		}
+
+		const pathStatus = runtime.getStatusForPath(filePath);
+		if (!pathStatus || pathStatus.state !== "ready") {
+			return;
+		}
+
+		const uri = pathToFileURL(resolve(cwd, filePath)).href;
+		const summaries: string[] = [];
+
+		if (fileTracker) {
+			fileTracker.open(filePath, (evictedFile) => {
+				const evictedUri = pathToFileURL(resolve(cwd, evictedFile)).href;
+				runtime.notify("textDocument/didClose", { textDocument: { uri: evictedUri } }, { path: evictedFile });
+			});
+		}
+
+		try {
+			const fileContent = await fsReadFile(resolve(cwd, filePath), "utf8");
+			runtime.notify(
+				"textDocument/didOpen",
+				{
+					textDocument: {
+						uri,
+						languageId: languageIdFromPath(filePath),
+						version: Date.now(),
+						text: fileContent,
+					},
+				},
+				{ path: filePath },
+			);
+		} catch (err) {
+			console.debug("[lsp] didOpen failed:", err instanceof Error ? err.message : err);
+			summaries.push("LSP didOpen failed");
+		}
+
+		if (formatOnWrite) {
+			try {
+				const rawEdits = await runtime.request(
+					"textDocument/formatting",
+					{
+						textDocument: { uri },
+						options: formattingOptions,
+					},
+					{ path: filePath },
+				);
+				const edits = normalizeTextEdits(rawEdits);
+				const applied = await applyFormattingEdits(filePath, edits, cwd);
+				summaries.push(applied > 0 ? `formatted (${applied} edits)` : "no formatting changes");
+			} catch (error) {
+				summaries.push(`format failed: ${toErrorMessage(error)}`);
+			}
+		}
+
+		if (currentMode === "agent_end") {
+			mode?.addTouchedFile(filePath);
+			return;
+		}
+
+		if (diagnosticsOnWrite) {
+			await waitForPushDiagnostics(runtime, filePath);
+			let diagnostics = runtime.getPublishedDiagnostics(filePath);
+
+			try {
+				const results = await runtime.requestAll(
+					"textDocument/diagnostic",
+					{ textDocument: { uri } },
+					{ path: filePath, timeoutMs: 8000 },
+				);
+				for (const result of results) {
+					if (!result) continue;
+					const pulled = extractPullDiagnostics(result);
+					if (pulled.length > 0) {
+						diagnostics = diagnostics.concat(pulled);
+					}
+				}
+			} catch (err) {
+				console.debug("[lsp] pull diagnostics failed:", err instanceof Error ? err.message : err);
+			}
+
+			const diagSummary = summarizeDiagnostics(diagnostics);
+			summaries.push(diagSummary);
+
+			if (diagnostics.length > 0) {
+				const diagText = formatDiagnosticsForToolResult(filePath, diagnostics);
+				const fileSummaries = [
+					{
+						filePath,
+						summary: diagSummary,
+						issues: diagnostics.map((d) => ({
+							severity: d.severity,
+							line: d.range.start.line + 1,
+							message: d.message,
+							source: d.source,
+							code: d.code,
+						})),
+					},
+				];
+				return {
+					content: [...event.content, { type: "text" as const, text: `\n[LSP] ${diagSummary}\n${diagText}` }],
+					details: { files: fileSummaries },
+				};
+			}
+		}
+	}
+}
+
+function getToolInputPath(input: Record<string, unknown>): string | undefined {
+	const value = input.path;
+	return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+function normalizeTextEdits(raw: unknown): LspTextEdit[] {
+	if (!Array.isArray(raw)) {
+		return [];
+	}
+
+	const edits: LspTextEdit[] = [];
+	for (const entry of raw) {
+		if (!entry || typeof entry !== "object") {
+			continue;
+		}
+		const edit = entry as Record<string, unknown>;
+		if (typeof edit.newText !== "string") {
+			continue;
+		}
+		const range = normalizeRange(edit.range);
+		if (!range) {
+			continue;
+		}
+		edits.push({ range, newText: edit.newText });
+	}
+	return edits;
+}
+
+async function applyFormattingEdits(filePath: string, edits: LspTextEdit[], cwd: string): Promise<number> {
+	if (edits.length === 0) {
+		return 0;
+	}
+
+	const fullPath = resolve(cwd, filePath);
+	const originalText = await fsReadFile(fullPath, "utf8");
+	const nextText = applyTextEdits(originalText, edits);
+	if (nextText === originalText) {
+		return 0;
+	}
+
+	await fsWriteFile(fullPath, nextText, "utf8");
+	return edits.length;
+}
+
+function applyTextEdits(text: string, edits: LspTextEdit[]): string {
+	const lineStarts = computeLineStarts(text);
+	const normalized = edits
+		.map((edit) => {
+			const start = positionToOffset(lineStarts, text.length, edit.range.start);
+			const end = positionToOffset(lineStarts, text.length, edit.range.end);
+			return {
+				start,
+				end,
+				newText: edit.newText,
+			};
+		})
+		.filter((edit) => edit.start <= edit.end)
+		.sort((left, right) => {
+			if (left.start !== right.start) {
+				return right.start - left.start;
+			}
+			return right.end - left.end;
+		});
+
+	if (normalized.length === 0) {
+		return text;
+	}
+
+	const parts: string[] = [];
+	let cursor = text.length;
+	for (const edit of normalized) {
+		if (edit.end > cursor) {
+			// Defensive fallback for malformed/overlapping edit ranges.
+			let output = text;
+			for (const fallbackEdit of normalized) {
+				output = `${output.slice(0, fallbackEdit.start)}${fallbackEdit.newText}${output.slice(fallbackEdit.end)}`;
+			}
+			return output;
+		}
+
+		parts.push(text.slice(edit.end, cursor));
+		parts.push(edit.newText);
+		cursor = edit.start;
+	}
+	parts.push(text.slice(0, cursor));
+	return parts.reverse().join("");
+}
+
+function computeLineStarts(text: string): number[] {
+	const lineStarts = [0];
+	for (let index = 0; index < text.length; index += 1) {
+		if (text[index] === "\n") {
+			lineStarts.push(index + 1);
+		}
+	}
+	return lineStarts;
+}
+
+function positionToOffset(lineStarts: number[], textLength: number, position: LspPosition): number {
+	const safeLine = Math.max(0, position.line);
+	const safeChar = Math.max(0, position.character);
+	const lineStart = safeLine < lineStarts.length ? lineStarts[safeLine] : textLength;
+	return Math.min(textLength, lineStart + safeChar);
+}
+
+function summarizeDiagnostics(diagnostics: LspDiagnostic[]): string {
+	if (diagnostics.length === 0) {
+		return "no diagnostics";
+	}
+
+	let errors = 0;
+	let warnings = 0;
+	let infos = 0;
+	for (const diagnostic of diagnostics) {
+		switch (diagnostic.severity) {
+			case 1:
+				errors += 1;
+				break;
+			case 2:
+				warnings += 1;
+				break;
+			default:
+				infos += 1;
+				break;
+		}
+	}
+
+	const parts = [`${diagnostics.length} diagnostics`];
+	if (errors > 0) parts.push(`${errors} errors`);
+	if (warnings > 0) parts.push(`${warnings} warnings`);
+	if (infos > 0) parts.push(`${infos} info`);
+	return parts.join(", ");
+}
+
+function toErrorMessage(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+const SEVERITY_LABELS: Record<number, string> = {
+	1: "Error",
+	2: "Warning",
+	3: "Information",
+	4: "Hint",
+};
+
+function formatDiagnosticsForToolResult(filePath: string, diagnostics: LspDiagnostic[]): string {
+	const lines = [`File: ${filePath}`, `Found ${diagnostics.length} issue(s):`];
+	for (const diag of diagnostics) {
+		const severity = SEVERITY_LABELS[diag.severity ?? 1] ?? "Issue";
+		const loc = `L${diag.range.start.line + 1}:C${diag.range.start.character}`;
+		const source = diag.source ? ` [${diag.source}]` : "";
+		const code = diag.code !== undefined ? ` (${diag.code})` : "";
+		lines.push(`  ${severity}${source}${code}: ${loc} - ${diag.message}`);
+	}
+	lines.push("Consider fixing these issues before proceeding.");
+	return lines.join("\n");
+}