@oh-my-pi/pi-coding-agent 8.0.20 → 8.2.0

package/src/ipy/kernel.ts

@@ -1,11 +1,12 @@
 import { createServer } from "node:net";
-import { delimiter, join } from "node:path";
-import { getShellConfig, killProcessTree } from "@oh-my-pi/pi-coding-agent/utils/shell";
-import { getOrCreateSnapshot } from "@oh-my-pi/pi-coding-agent/utils/shell-snapshot";
-import { htmlToBasicMarkdown } from "@oh-my-pi/pi-coding-agent/web/scrapers/types";
+import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { $, type Subprocess } from "bun";
 import { nanoid } from "nanoid";
+import { getShellConfig, killProcessTree } from "../utils/shell";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+import { time } from "../utils/timings";
+import { htmlToBasicMarkdown } from "../web/scrapers/types";
 import { acquireSharedGateway, releaseSharedGateway } from "./gateway-coordinator";
 import { loadPythonModules } from "./modules";
 import { PYTHON_PRELUDE } from "./prelude";
@@ -131,13 +132,13 @@ const BASE_ENV_ALLOWLIST = CASE_INSENSITIVE_ENV
 	? new Set([...DEFAULT_ENV_ALLOWLIST, ...WINDOWS_ENV_ALLOWLIST])
 	: DEFAULT_ENV_ALLOWLIST;
 const NORMALIZED_ALLOWLIST = new Set(
-	Array.from(BASE_ENV_ALLOWLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
+	Array.from(BASE_ENV_ALLOWLIST, key => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
 );
 const NORMALIZED_DENYLIST = new Set(
-	Array.from(DEFAULT_ENV_DENYLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
+	Array.from(DEFAULT_ENV_DENYLIST, key => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
 );
 const NORMALIZED_ALLOW_PREFIXES = CASE_INSENSITIVE_ENV
-	? DEFAULT_ENV_ALLOW_PREFIXES.map((prefix) => prefix.toUpperCase())
+	? DEFAULT_ENV_ALLOW_PREFIXES.map(prefix => prefix.toUpperCase())
 	: DEFAULT_ENV_ALLOW_PREFIXES;
 
 function normalizeEnvKey(key: string): string {
@@ -146,7 +147,7 @@ function normalizeEnvKey(key: string): string {
 
 function resolvePathKey(env: Record<string, string | undefined>): string {
 	if (!CASE_INSENSITIVE_ENV) return "PATH";
-	const match = Object.keys(env).find((candidate) => candidate.toLowerCase() === "path");
+	const match = Object.keys(env).find(candidate => candidate.toLowerCase() === "path");
 	return match ?? "PATH";
 }
 
@@ -230,7 +231,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 			filtered[destKey] = value;
 			continue;
 		}
-		if (NORMALIZED_ALLOW_PREFIXES.some((prefix) => normalizedKey.startsWith(prefix))) {
+		if (NORMALIZED_ALLOW_PREFIXES.some(prefix => normalizedKey.startsWith(prefix))) {
 			filtered[key] = value;
 		}
 	}
@@ -239,7 +240,7 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 
 async function resolveVenvPath(cwd: string): Promise<string | null> {
 	if (process.env.VIRTUAL_ENV) return process.env.VIRTUAL_ENV;
-	const candidates = [join(cwd, ".venv"), join(cwd, "venv")];
+	const candidates = [path.join(cwd, ".venv"), path.join(cwd, "venv")];
 	for (const candidate of candidates) {
 		if (await Bun.file(candidate).exists()) {
 			return candidate;
@@ -253,12 +254,12 @@ async function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string
 	const venvPath = env.VIRTUAL_ENV ?? (await resolveVenvPath(cwd));
 	if (venvPath) {
 		env.VIRTUAL_ENV = venvPath;
-		const binDir = process.platform === "win32" ? join(venvPath, "Scripts") : join(venvPath, "bin");
-		const pythonCandidate = join(binDir, process.platform === "win32" ? "python.exe" : "python");
+		const binDir = process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
+		const pythonCandidate = path.join(binDir, process.platform === "win32" ? "python.exe" : "python");
 		if (await Bun.file(pythonCandidate).exists()) {
 			const pathKey = resolvePathKey(env);
 			const currentPath = env[pathKey];
-			env[pathKey] = currentPath ? `${binDir}${delimiter}${currentPath}` : binDir;
+			env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
 			return { pythonPath: pythonCandidate, env };
 		}
 	}
@@ -309,13 +310,11 @@ async function checkExternalGatewayAvailability(config: ExternalGatewayConfig):
 		}
 
 		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), 5000);
 
 		const response = await fetch(`${config.url}/api/kernelspecs`, {
 			headers,
-			signal: controller.signal,
+			signal: AbortSignal.any([controller.signal, AbortSignal.timeout(5000)]),
 		});
-		clearTimeout(timeout);
 
 		if (response.ok) {
 			return { ok: true };
@@ -505,6 +504,7 @@ export class PythonKernel {
 
 	static async start(options: KernelStartOptions): Promise<PythonKernel> {
 		const availability = await checkPythonKernelAvailability(options.cwd);
+		time("PythonKernel.start:availabilityCheck");
 		if (!availability.ok) {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
 		}
@@ -518,8 +518,11 @@ export class PythonKernel {
 		if (options.useSharedGateway !== false) {
 			try {
 				const sharedResult = await acquireSharedGateway(options.cwd);
+				time("PythonKernel.start:acquireSharedGateway");
 				if (sharedResult) {
-					return PythonKernel.startWithSharedGateway(sharedResult.url, options.cwd, options.env);
+					const kernel = await PythonKernel.startWithSharedGateway(sharedResult.url, options.cwd, options.env);
+					time("PythonKernel.start:startWithSharedGateway");
+					return kernel;
 				}
 			} catch (err) {
 				logger.warn("Failed to acquire shared gateway, falling back to local", {
@@ -582,6 +585,7 @@ export class PythonKernel {
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ name: "python3" }),
 		});
+		time("startWithSharedGateway:createKernel");
 
 		if (!createResponse.ok) {
 			await releaseSharedGateway();
@@ -595,13 +599,17 @@ export class PythonKernel {
 
 		try {
 			await kernel.connectWebSocket();
+			time("startWithSharedGateway:connectWS");
 			await kernel.initializeKernelEnvironment(cwd, env);
+			time("startWithSharedGateway:initEnv");
 			kernel.startHeartbeat();
 			const preludeResult = await kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false });
+			time("startWithSharedGateway:prelude");
 			if (preludeResult.cancelled || preludeResult.status === "error") {
 				throw new Error("Failed to initialize Python kernel prelude");
 			}
 			await loadPythonModules(kernel, { cwd });
+			time("startWithSharedGateway:loadModules");
 			return kernel;
 		} catch (err: unknown) {
 			await kernel.shutdown();
@@ -627,7 +635,7 @@ export class PythonKernel {
 			OMP_SHELL_SNAPSHOT: snapshotPath ?? undefined,
 		};
 
-		const pythonPathParts = [options.cwd, kernelEnv.PYTHONPATH].filter(Boolean).join(delimiter);
+		const pythonPathParts = [options.cwd, kernelEnv.PYTHONPATH].filter(Boolean).join(path.delimiter);
 		if (pythonPathParts) {
 			kernelEnv.PYTHONPATH = pythonPathParts;
 		}
@@ -754,7 +762,7 @@ export class PythonKernel {
 			resolve();
 		};
 
-		ws.onerror = (event) => {
+		ws.onerror = event => {
 			const error = new Error(`WebSocket error: ${event}`);
 			if (!settled) {
 				settled = true;
@@ -779,7 +787,7 @@ export class PythonKernel {
 			this.abortPendingExecutions("WebSocket closed");
 		};
 
-		ws.onmessage = (event) => {
+		ws.onmessage = event => {
 			let msg: JupyterMessage | null = null;
 			if (event.data instanceof ArrayBuffer) {
 				msg = deserializeWebSocketMessage(event.data);
@@ -950,7 +958,7 @@ export class PythonKernel {
 			return promise;
 		}
 
-		this.#messageHandlers.set(msgId, async (response) => {
+		this.#messageHandlers.set(msgId, async response => {
 			switch (response.header.msg_type) {
 				case "execute_reply": {
 					replyReceived = true;
@@ -1045,7 +1053,7 @@ export class PythonKernel {
 		const result = await this.execute(PRELUDE_INTROSPECTION_SNIPPET, {
 			silent: false,
 			storeHistory: false,
-			onChunk: (text) => {
+			onChunk: text => {
 				output += text;
 			},
 		});
@@ -1064,14 +1072,11 @@ export class PythonKernel {
 
 	async interrupt(): Promise<void> {
 		try {
-			const controller = new AbortController();
-			const timeout = setTimeout(() => controller.abort(), 2000);
 			await fetch(`${this.gatewayUrl}/api/kernels/${this.kernelId}/interrupt`, {
 				method: "POST",
 				headers: this.#authHeaders(),
-				signal: controller.signal,
+				signal: AbortSignal.timeout(2000),
 			});
-			clearTimeout(timeout);
 		} catch (err: unknown) {
 			logger.warn("Failed to interrupt kernel via API", { error: err instanceof Error ? err.message : String(err) });
 		}
@@ -1138,13 +1143,10 @@ export class PythonKernel {
 	async ping(timeoutMs: number = HEARTBEAT_TIMEOUT_MS): Promise<boolean> {
 		if (!this.isAlive()) return false;
 		try {
-			const controller = new AbortController();
-			const timeout = setTimeout(() => controller.abort(), timeoutMs);
 			const response = await fetch(`${this.gatewayUrl}/api/kernels/${this.kernelId}`, {
-				signal: controller.signal,
+				signal: AbortSignal.timeout(timeoutMs),
 				headers: this.#authHeaders(),
 			});
-			clearTimeout(timeout);
 			if (response.ok) {
 				this.#heartbeatFailures = 0;
 				return true;

package/src/ipy/modules.ts

@@ -1,6 +1,6 @@
-import { readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
 
 export type PythonModuleSource = "user" | "project";
 
@@ -38,12 +38,12 @@ interface ModuleCandidate {
 
 async function listModuleCandidates(dir: string, source: PythonModuleSource): Promise<ModuleCandidate[]> {
 	try {
-		const entries = await readdir(dir, { withFileTypes: true });
+		const entries = await fs.readdir(dir, { withFileTypes: true });
 		return entries
-			.filter((entry) => entry.isFile() && entry.name.endsWith(".py"))
-			.map((entry) => ({
+			.filter(entry => entry.isFile() && entry.name.endsWith(".py"))
+			.map(entry => ({
 				name: entry.name,
-				path: resolve(dir, entry.name),
+				path: path.resolve(dir, entry.name),
 				source,
 			}));
 	} catch {
@@ -66,13 +66,13 @@ async function readModuleContent(candidate: ModuleCandidate): Promise<PythonModu
  */
 export async function discoverPythonModules(options: DiscoverPythonModulesOptions = {}): Promise<PythonModuleEntry[]> {
 	const cwd = options.cwd ?? process.cwd();
-	const homeDir = options.homeDir ?? homedir();
+	const homeDir = options.homeDir ?? os.homedir();
 
-	const userDirs = [join(homeDir, ".omp", "agent", "modules"), join(homeDir, ".pi", "agent", "modules")];
-	const projectDirs = [resolve(cwd, ".omp", "modules"), resolve(cwd, ".pi", "modules")];
+	const userDirs = [path.join(homeDir, ".omp", "agent", "modules"), path.join(homeDir, ".pi", "agent", "modules")];
+	const projectDirs = [path.resolve(cwd, ".omp", "modules"), path.resolve(cwd, ".pi", "modules")];
 
-	const userCandidates = (await Promise.all(userDirs.map((dir) => listModuleCandidates(dir, "user")))).flat();
-	const projectCandidates = (await Promise.all(projectDirs.map((dir) => listModuleCandidates(dir, "project")))).flat();
+	const userCandidates = (await Promise.all(userDirs.map(dir => listModuleCandidates(dir, "user")))).flat();
+	const projectCandidates = (await Promise.all(projectDirs.map(dir => listModuleCandidates(dir, "project")))).flat();
 
 	const byName = new Map<string, ModuleCandidate>();
 	for (const candidate of userCandidates) {
@@ -88,7 +88,7 @@ export async function discoverPythonModules(options: DiscoverPythonModulesOption
 	}
 
 	const sorted = Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
-	return Promise.all(sorted.map((candidate) => readModuleContent(candidate)));
+	return Promise.all(sorted.map(candidate => readModuleContent(candidate)));
 }
 
 /**

package/src/lsp/client.ts

@@ -1,6 +1,5 @@
-import * as fs from "node:fs";
-import { ToolAbortError, throwIfAborted } from "@oh-my-pi/pi-coding-agent/tools/tool-errors";
-import { logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
 import type {
@@ -298,7 +297,7 @@ async function handleConfigurationRequest(client: LspClient, message: LspJsonRpc
 	if (typeof message.id !== "number") return;
 	const params = message.params as { items?: Array<{ section?: string }> };
 	const items = params?.items ?? [];
-	const result = items.map((item) => {
+	const result = items.map(item => {
 		const section = item.section ?? "";
 		return client.config.settings?.[section] ?? {};
 	});
@@ -512,7 +511,13 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
 			return;
 		}
 
-		const content = fs.readFileSync(filePath, "utf-8");
+		let content: string;
+		try {
+			content = await Bun.file(filePath).text();
+		} catch (err) {
+			if (isEnoent(err)) return;
+			throw err;
+		}
 		const languageId = detectLanguageId(filePath);
 
 		await sendNotification(client, "textDocument/didOpen", {
@@ -634,7 +639,13 @@ export async function refreshFile(client: LspClient, filePath: string): Promise<
 			return;
 		}
 
-		const content = fs.readFileSync(filePath, "utf-8");
+		let content: string;
+		try {
+			content = await Bun.file(filePath).text();
+		} catch (err) {
+			if (isEnoent(err)) return;
+			throw err;
+		}
 		const version = ++info.version;
 
 		await sendNotification(client, "textDocument/didChange", {
@@ -748,12 +759,12 @@ export async function sendRequest(
 
 	// Register pending request with timeout wrapper
 	client.pendingRequests.set(id, {
-		resolve: (result) => {
+		resolve: result => {
 			if (timeout) clearTimeout(timeout);
 			cleanup();
 			resolve(result);
 		},
-		reject: (err) => {
+		reject: err => {
 			if (timeout) clearTimeout(timeout);
 			cleanup();
 			reject(err);
@@ -762,7 +773,7 @@ export async function sendRequest(
 	});
 
 	// Write request
-	writeMessage(client.process.stdin as import("bun").FileSink, request).catch((err) => {
+	writeMessage(client.process.stdin as import("bun").FileSink, request).catch(err => {
 		if (timeout) clearTimeout(timeout);
 		client.pendingRequests.delete(id);
 		cleanup();
@@ -816,7 +827,7 @@ export interface LspServerStatus {
  * Get status of all active LSP clients.
  */
 export function getActiveClients(): LspServerStatus[] {
-	return Array.from(clients.values()).map((client) => ({
+	return Array.from(clients.values()).map(client => ({
 		name: client.config.command,
 		status: "ready" as const,
 		fileTypes: client.config.fileTypes,

package/src/lsp/clients/biome-client.ts

@@ -2,9 +2,8 @@
  * Biome CLI-based linter client.
  * Uses Biome's CLI with JSON output instead of LSP (which has stale diagnostics issues).
  */
-
 import path from "node:path";
-import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "@oh-my-pi/pi-coding-agent/lsp/types";
+import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "../../lsp/types";
 
 // =============================================================================
 // Biome JSON Output Types

package/src/lsp/clients/index.ts

@@ -1,3 +1,6 @@
+import type { LinterClient, ServerConfig } from "../../lsp/types";
+import { LspLinterClient } from "./lsp-linter-client";
+
 /**
  * Linter client implementations.
  *
@@ -8,9 +11,6 @@
 export { BiomeClient } from "./biome-client";
 export { LspLinterClient } from "./lsp-linter-client";
 
-import type { LinterClient, ServerConfig } from "@oh-my-pi/pi-coding-agent/lsp/types";
-import { LspLinterClient } from "./lsp-linter-client";
-
 // Cache of linter clients by server name + cwd
 const clientCache = new Map<string, LinterClient>();
 

package/src/lsp/clients/lsp-linter-client.ts

@@ -2,11 +2,10 @@
  * LSP-based linter client.
  * Uses the Language Server Protocol for formatting and diagnostics.
  */
-
-import { getOrCreateClient, notifySaved, sendRequest, syncContent } from "@oh-my-pi/pi-coding-agent/lsp/client";
-import { applyTextEditsToString } from "@oh-my-pi/pi-coding-agent/lsp/edits";
-import type { Diagnostic, LinterClient, LspClient, ServerConfig, TextEdit } from "@oh-my-pi/pi-coding-agent/lsp/types";
-import { fileToUri } from "@oh-my-pi/pi-coding-agent/lsp/utils";
+import { getOrCreateClient, notifySaved, sendRequest, syncContent } from "../../lsp/client";
+import { applyTextEditsToString } from "../../lsp/edits";
+import type { Diagnostic, LinterClient, LspClient, ServerConfig, TextEdit } from "../../lsp/types";
+import { fileToUri } from "../../lsp/utils";
 
 /** Default formatting options for LSP */
 const DEFAULT_FORMAT_OPTIONS = {

package/src/lsp/config.ts

@@ -1,9 +1,9 @@
-import { homedir } from "node:os";
-import { basename, extname, join } from "node:path";
-import { getConfigDirPaths } from "@oh-my-pi/pi-coding-agent/config";
+import * as os from "node:os";
+import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { globSync } from "glob";
+import { getConfigDirPaths } from "../config";
 import { BiomeClient } from "./clients/biome-client";
 import DEFAULTS from "./defaults.json" with { type: "json" };
 import type { ServerConfig } from "./types";
@@ -30,7 +30,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function parseConfigContent(content: string, filePath: string): unknown {
-	const extension = extname(filePath).toLowerCase();
+	const extension = path.extname(filePath).toLowerCase();
 	if (extension === ".yaml" || extension === ".yml") {
 		return YAML.parse(content) as unknown;
 	}
@@ -141,7 +141,7 @@ function applyRuntimeDefaults(servers: Record<string, ServerConfig>): Record<str
 	}
 
 	if (updated.omnisharp?.args) {
-		const args = updated.omnisharp.args.map((arg) => (arg === PID_TOKEN ? String(process.pid) : arg));
+		const args = updated.omnisharp.args.map(arg => (arg === PID_TOKEN ? String(process.pid) : arg));
 		updated.omnisharp = { ...updated.omnisharp, args };
 	}
 
@@ -160,7 +160,7 @@ export async function hasRootMarkers(cwd: string, markers: string[]): Promise<bo
 		// Handle glob-like patterns (e.g., "*.cabal")
 		if (marker.includes("*")) {
 			try {
-				const matches = globSync(join(cwd, marker));
+				const matches = globSync(path.join(cwd, marker));
 				if (matches.length > 0) {
 					return true;
 				}
@@ -169,7 +169,7 @@ export async function hasRootMarkers(cwd: string, markers: string[]): Promise<bo
 			}
 			continue;
 		}
-		const filePath = join(cwd, marker);
+		const filePath = path.join(cwd, marker);
 		if (await Bun.file(filePath).exists()) {
 			return true;
 		}
@@ -211,7 +211,7 @@ export async function resolveCommand(command: string, cwd: string): Promise<stri
 	// Check local bin directories based on project markers
 	for (const { markers, binDir } of LOCAL_BIN_PATHS) {
 		if (await hasRootMarkers(cwd, markers)) {
-			const localPath = join(cwd, binDir, command);
+			const localPath = path.join(cwd, binDir, command);
 			if (await Bun.file(localPath).exists()) {
 				return localPath;
 			}
@@ -232,14 +232,14 @@ function getConfigPaths(cwd: string): string[] {
 
 	// Project root files (highest priority)
 	for (const filename of filenames) {
-		paths.push(join(cwd, filename));
+		paths.push(path.join(cwd, filename));
 	}
 
 	// Project config directories (.omp/, .pi/, .claude/)
 	const projectDirs = getConfigDirPaths("", { user: false, project: true, cwd });
 	for (const dir of projectDirs) {
 		for (const filename of filenames) {
-			paths.push(join(dir, filename));
+			paths.push(path.join(dir, filename));
 		}
 	}
 
@@ -247,13 +247,13 @@ function getConfigPaths(cwd: string): string[] {
 	const userDirs = getConfigDirPaths("", { user: true, project: false });
 	for (const dir of userDirs) {
 		for (const filename of filenames) {
-			paths.push(join(dir, filename));
+			paths.push(path.join(dir, filename));
 		}
 	}
 
 	// User home root files (lowest priority fallback)
 	for (const filename of filenames) {
-		paths.push(join(homedir(), filename));
+		paths.push(path.join(os.homedir(), filename));
 	}
 
 	return paths;
@@ -352,12 +352,12 @@ export async function loadConfig(cwd: string): Promise<LspConfig> {
  * Returns servers sorted with primary (non-linter) servers first.
  */
 export function getServersForFile(config: LspConfig, filePath: string): Array<[string, ServerConfig]> {
-	const ext = extname(filePath).toLowerCase();
-	const fileName = basename(filePath).toLowerCase();
+	const ext = path.extname(filePath).toLowerCase();
+	const fileName = path.basename(filePath).toLowerCase();
 	const matches: Array<[string, ServerConfig]> = [];
 
 	for (const [name, serverConfig] of Object.entries(config.servers)) {
-		const supportsFile = serverConfig.fileTypes.some((fileType) => {
+		const supportsFile = serverConfig.fileTypes.some(fileType => {
 			const normalized = fileType.toLowerCase();
 			return normalized === ext || normalized === fileName;
 		});

package/src/lsp/edits.ts

@@ -1,4 +1,4 @@
-import { mkdir, rename, rm } from "node:fs/promises";
+import * as fs from "node:fs/promises";
 import path from "node:path";
 import type { CreateFile, DeleteFile, RenameFile, TextDocumentEdit, TextEdit, WorkspaceEdit } from "./types";
 import { uriToFile } from "./utils";
@@ -86,20 +86,19 @@ export async function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Prom
 				if (change.kind === "create") {
 					const createOp = change as CreateFile;
 					const filePath = uriToFile(createOp.uri);
-					await mkdir(path.dirname(filePath), { recursive: true });
 					await Bun.write(filePath, "");
 					applied.push(`Created ${path.relative(cwd, filePath)}`);
 				} else if (change.kind === "rename") {
 					const renameOp = change as RenameFile;
 					const oldPath = uriToFile(renameOp.oldUri);
 					const newPath = uriToFile(renameOp.newUri);
-					await mkdir(path.dirname(newPath), { recursive: true });
-					await rename(oldPath, newPath);
+					await fs.mkdir(path.dirname(newPath), { recursive: true });
+					await fs.rename(oldPath, newPath);
 					applied.push(`Renamed ${path.relative(cwd, oldPath)} → ${path.relative(cwd, newPath)}`);
 				} else if (change.kind === "delete") {
 					const deleteOp = change as DeleteFile;
 					const filePath = uriToFile(deleteOp.uri);
-					await rm(filePath, { recursive: true });
+					await fs.rm(filePath, { recursive: true });
 					applied.push(`Deleted ${path.relative(cwd, filePath)}`);
 				}
 			}