@oh-my-pi/pi-coding-agent 1.341.0 → 2.0.1337

package/src/core/tools/index.ts

@@ -1,12 +1,12 @@
-export { type AskToolDetails, askTool, createAskTool } from "./ask.js";
-export { type BashToolDetails, bashTool, createBashTool } from "./bash.js";
-export { createEditTool, type EditToolOptions, editTool } from "./edit.js";
+export { type AskToolDetails, askTool, createAskTool } from "./ask";
+export { type BashToolDetails, bashTool, createBashTool } from "./bash";
+export { createEditTool, type EditToolOptions, editTool } from "./edit";
 // Exa MCP tools (22 tools)
-export { exaTools } from "./exa/index.js";
-export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types.js";
-export { createFindTool, type FindToolDetails, findTool } from "./find.js";
-export { createGrepTool, type GrepToolDetails, grepTool } from "./grep.js";
-export { createLsTool, type LsToolDetails, lsTool } from "./ls.js";
+export { exaTools } from "./exa/index";
+export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
+export { createFindTool, type FindToolDetails, findTool } from "./find";
+export { createGrepTool, type GrepToolDetails, grepTool } from "./grep";
+export { createLsTool, type LsToolDetails, lsTool } from "./ls";
 export {
 	createLspTool,
 	type FileDiagnosticsResult,
@@ -19,12 +19,14 @@ export {
 	type LspWarmupResult,
 	lspTool,
 	warmupLspServers,
-} from "./lsp/index.js";
-export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./notebook.js";
-export { createReadTool, type ReadToolDetails, readTool } from "./read.js";
-export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index.js";
-export type { TruncationResult } from "./truncate.js";
-export { createWebFetchTool, type WebFetchToolDetails, webFetchCustomTool, webFetchTool } from "./web-fetch.js";
+} from "./lsp/index";
+export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./notebook";
+export { createOutputTool, type OutputToolDetails, outputTool } from "./output";
+export { createReadTool, type ReadToolDetails, readTool } from "./read";
+export { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
+export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
+export type { TruncationResult } from "./truncate";
+export { createWebFetchTool, type WebFetchToolDetails, webFetchCustomTool, webFetchTool } from "./web-fetch";
 export {
 	companyWebSearchTools,
 	createWebSearchTool,
@@ -42,24 +44,26 @@ export {
 	webSearchDeepTool,
 	webSearchLinkedinTool,
 	webSearchTool,
-} from "./web-search/index.js";
-export { createWriteTool, type WriteToolDetails, type WriteToolOptions, writeTool } from "./write.js";
+} from "./web-search/index";
+export { createWriteTool, type WriteToolDetails, type WriteToolOptions, writeTool } from "./write";
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { askTool, createAskTool } from "./ask.js";
-import { bashTool, createBashTool } from "./bash.js";
-import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor.js";
-import { createEditTool, editTool } from "./edit.js";
-import { createFindTool, findTool } from "./find.js";
-import { createGrepTool, grepTool } from "./grep.js";
-import { createLsTool, lsTool } from "./ls.js";
-import { createLspTool, formatFile, getDiagnosticsForFile, lspTool } from "./lsp/index.js";
-import { createNotebookTool, notebookTool } from "./notebook.js";
-import { createReadTool, readTool } from "./read.js";
-import { createTaskTool, taskTool } from "./task/index.js";
-import { createWebFetchTool, webFetchTool } from "./web-fetch.js";
-import { createWebSearchTool, webSearchTool } from "./web-search/index.js";
-import { createWriteTool, writeTool } from "./write.js";
+import { askTool, createAskTool } from "./ask";
+import { bashTool, createBashTool } from "./bash";
+import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
+import { createEditTool, editTool } from "./edit";
+import { createFindTool, findTool } from "./find";
+import { createGrepTool, grepTool } from "./grep";
+import { createLsTool, lsTool } from "./ls";
+import { createLspTool, formatFile, getDiagnosticsForFile, lspTool } from "./lsp/index";
+import { createNotebookTool, notebookTool } from "./notebook";
+import { createOutputTool, outputTool } from "./output";
+import { createReadTool, readTool } from "./read";
+import { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
+import { createTaskTool, taskTool } from "./task/index";
+import { createWebFetchTool, webFetchTool } from "./web-fetch";
+import { createWebSearchTool, webSearchTool } from "./web-search/index";
+import { createWriteTool, writeTool } from "./write";
 
 /** Tool type (AgentTool from pi-ai) */
 export type Tool = AgentTool<any, any, any>;
@@ -79,6 +83,8 @@ export interface CodingToolsOptions {
 	lspFormatOnWrite?: boolean;
 	/** Whether to accept high-confidence fuzzy matches in edit tool (default: true) */
 	editFuzzyMatch?: boolean;
+	/** Set of tool names available to the agent (for cross-tool awareness) */
+	availableTools?: Set<string>;
 }
 
 // Factory function type
@@ -115,9 +121,12 @@ const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
 	ls: { tool: lsTool, create: createLsTool },
 	lsp: { tool: lspTool, create: createLspTool },
 	notebook: { tool: notebookTool, create: createNotebookTool },
-	task: { tool: taskTool, create: (cwd, ctx) => createTaskTool(cwd, ctx) },
+	output: { tool: outputTool, create: (cwd, ctx) => createOutputTool(cwd, ctx) },
+	task: { tool: taskTool, create: (cwd, ctx, opts) => createTaskTool(cwd, ctx, opts) },
 	web_fetch: { tool: webFetchTool, create: createWebFetchTool },
 	web_search: { tool: webSearchTool, create: createWebSearchTool },
+	report_finding: { tool: reportFindingTool, create: createReportFindingTool },
+	submit_review: { tool: submitReviewTool, create: createSubmitReviewTool },
 };
 
 export type ToolName = keyof typeof toolDefs;
@@ -136,6 +145,7 @@ const baseCodingToolNames: ToolName[] = [
 	"ls",
 	"lsp",
 	"notebook",
+	"output",
 	"task",
 	"web_fetch",
 	"web_search",
@@ -168,7 +178,8 @@ export function createCodingTools(
 	options?: CodingToolsOptions,
 ): Tool[] {
 	const names = hasUI ? [...baseCodingToolNames, ...uiToolNames] : baseCodingToolNames;
-	return names.map((name) => toolDefs[name].create(cwd, sessionContext, options));
+	const optionsWithTools = { ...options, availableTools: new Set(names) };
+	return names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools));
 }
 
 /**
@@ -185,7 +196,8 @@ export function createReadOnlyTools(
 	options?: CodingToolsOptions,
 ): Tool[] {
 	const names = hasUI ? [...baseReadOnlyToolNames, ...uiToolNames] : baseReadOnlyToolNames;
-	return names.map((name) => toolDefs[name].create(cwd, sessionContext, options));
+	const optionsWithTools = { ...options, availableTools: new Set(names) };
+	return names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools));
 }
 
 /**
@@ -199,8 +211,10 @@ export function createAllTools(
 	sessionContext?: SessionContext,
 	options?: CodingToolsOptions,
 ): Record<ToolName, Tool> {
+	const names = Object.keys(toolDefs);
+	const optionsWithTools = { ...options, availableTools: new Set(names) };
 	return Object.fromEntries(
-		Object.entries(toolDefs).map(([name, def]) => [name, def.create(cwd, sessionContext, options)]),
+		Object.entries(toolDefs).map(([name, def]) => [name, def.create(cwd, sessionContext, optionsWithTools)]),
 	) as Record<ToolName, Tool>;
 }
 

package/src/core/tools/ls.ts

@@ -1,9 +1,9 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import nodePath from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
-import { existsSync, readdirSync, statSync } from "fs";
-import nodePath from "path";
-import { resolveToCwd } from "./path-utils.js";
-import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
+import { resolveToCwd } from "./path-utils";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 const lsSchema = Type.Object({
 	path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),

package/src/core/tools/lsp/client.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import { applyWorkspaceEdit } from "./edits.js";
+import { applyWorkspaceEdit } from "./edits";
 import type {
 	Diagnostic,
 	LspClient,
@@ -8,14 +8,16 @@ import type {
 	LspJsonRpcResponse,
 	ServerConfig,
 	WorkspaceEdit,
-} from "./types.js";
-import { detectLanguageId, fileToUri } from "./utils.js";
+} from "./types";
+import { detectLanguageId, fileToUri } from "./utils";
 
 // =============================================================================
 // Client State
 // =============================================================================
 
 const clients = new Map<string, LspClient>();
+const clientLocks = new Map<string, Promise<LspClient>>();
+const fileOperationLocks = new Map<string, Promise<void>>();
 
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
@@ -233,13 +235,17 @@ async function startMessageReader(client: LspClient): Promise<void> {
 			const { done, value } = await reader.read();
 			if (done) break;
 
-			client.messageBuffer = concatBuffers(client.messageBuffer, value);
+			// Atomically update buffer before processing
+			const currentBuffer = concatBuffers(client.messageBuffer, value);
+			client.messageBuffer = currentBuffer;
 
 			// Process all complete messages in buffer
-			let parsed = parseMessage(client.messageBuffer);
+			// Use local variable to avoid race with concurrent buffer updates
+			let workingBuffer = currentBuffer;
+			let parsed = parseMessage(workingBuffer);
 			while (parsed) {
 				const { message, remaining } = parsed;
-				client.messageBuffer = remaining;
+				workingBuffer = remaining;
 
 				// Route message
 				if ("id" in message && message.id !== undefined) {
@@ -263,8 +269,11 @@ async function startMessageReader(client: LspClient): Promise<void> {
 					}
 				}
 
-				parsed = parseMessage(client.messageBuffer);
+				parsed = parseMessage(workingBuffer);
 			}
+
+			// Atomically commit processed buffer
+			client.messageBuffer = workingBuffer;
 		}
 	} catch (err) {
 		// Connection closed or error - reject all pending requests
@@ -368,71 +377,88 @@ async function sendResponse(
 export async function getOrCreateClient(config: ServerConfig, cwd: string): Promise<LspClient> {
 	const key = `${config.command}:${cwd}`;
 
-	if (clients.has(key)) {
-		const client = clients.get(key)!;
-		client.lastActivity = Date.now();
-		return client;
+	// Check if client already exists
+	const existingClient = clients.get(key);
+	if (existingClient) {
+		existingClient.lastActivity = Date.now();
+		return existingClient;
 	}
 
-	const args = config.args ?? [];
-	const command = config.resolvedCommand ?? config.command;
-	const proc = Bun.spawn([command, ...args], {
-		cwd,
-		stdin: "pipe",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
+	// Check if another coroutine is already creating this client
+	const existingLock = clientLocks.get(key);
+	if (existingLock) {
+		return existingLock;
+	}
 
-	const client: LspClient = {
-		name: key,
-		cwd,
-		process: proc,
-		config,
-		requestId: 0,
-		diagnostics: new Map(),
-		openFiles: new Map(),
-		pendingRequests: new Map(),
-		messageBuffer: new Uint8Array(0),
-		isReading: false,
-		lastActivity: Date.now(),
-	};
-	clients.set(key, client);
+	// Create new client with lock
+	const clientPromise = (async () => {
+		const args = config.args ?? [];
+		const command = config.resolvedCommand ?? config.command;
+		const proc = Bun.spawn([command, ...args], {
+			cwd,
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
 
-	// Register crash recovery - remove client on process exit
-	proc.exited.then(() => {
-		clients.delete(key);
-	});
+		const client: LspClient = {
+			name: key,
+			cwd,
+			process: proc,
+			config,
+			requestId: 0,
+			diagnostics: new Map(),
+			openFiles: new Map(),
+			pendingRequests: new Map(),
+			messageBuffer: new Uint8Array(0),
+			isReading: false,
+			lastActivity: Date.now(),
+		};
+		clients.set(key, client);
+
+		// Register crash recovery - remove client on process exit
+		proc.exited.then(() => {
+			clients.delete(key);
+			clientLocks.delete(key);
+		});
 
-	// Start background message reader
-	startMessageReader(client);
+		// Start background message reader
+		startMessageReader(client);
+
+		try {
+			// Send initialize request
+			const initResult = (await sendRequest(client, "initialize", {
+				processId: process.pid,
+				rootUri: fileToUri(cwd),
+				rootPath: cwd,
+				capabilities: CLIENT_CAPABILITIES,
+				initializationOptions: config.initOptions ?? {},
+				workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
+			})) as { capabilities?: unknown };
+
+			if (!initResult) {
+				throw new Error("Failed to initialize LSP: no response");
+			}
 
-	try {
-		// Send initialize request
-		const initResult = (await sendRequest(client, "initialize", {
-			processId: process.pid,
-			rootUri: fileToUri(cwd),
-			rootPath: cwd,
-			capabilities: CLIENT_CAPABILITIES,
-			initializationOptions: config.initOptions ?? {},
-			workspaceFolders: [{ uri: fileToUri(cwd), name: cwd.split("/").pop() ?? "workspace" }],
-		})) as { capabilities?: unknown };
-
-		if (!initResult) {
-			throw new Error("Failed to initialize LSP: no response");
-		}
+			client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
 
-		client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
+			// Send initialized notification
+			await sendNotification(client, "initialized", {});
 
-		// Send initialized notification
-		await sendNotification(client, "initialized", {});
+			return client;
+		} catch (err) {
+			// Clean up on initialization failure
+			clients.delete(key);
+			clientLocks.delete(key);
+			proc.kill();
+			throw err;
+		} finally {
+			clientLocks.delete(key);
+		}
+	})();
 
-		return client;
-	} catch (err) {
-		// Clean up on initialization failure
-		clients.delete(key);
-		proc.kill();
-		throw err;
-	}
+	clientLocks.set(key, clientPromise);
+	return clientPromise;
 }
 
 /**
@@ -441,24 +467,49 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string): Prom
  */
 export async function ensureFileOpen(client: LspClient, filePath: string): Promise<void> {
 	const uri = fileToUri(filePath);
+	const lockKey = `${client.name}:${uri}`;
+
+	// Check if file is already open
 	if (client.openFiles.has(uri)) {
 		return;
 	}
 
-	const content = fs.readFileSync(filePath, "utf-8");
-	const languageId = detectLanguageId(filePath);
+	// Check if another operation is already opening this file
+	const existingLock = fileOperationLocks.get(lockKey);
+	if (existingLock) {
+		await existingLock;
+		return;
+	}
 
-	await sendNotification(client, "textDocument/didOpen", {
-		textDocument: {
-			uri,
-			languageId,
-			version: 1,
-			text: content,
-		},
-	});
+	// Lock and open file
+	const openPromise = (async () => {
+		// Double-check after acquiring lock
+		if (client.openFiles.has(uri)) {
+			return;
+		}
 
-	client.openFiles.set(uri, { version: 1, languageId });
-	client.lastActivity = Date.now();
+		const content = fs.readFileSync(filePath, "utf-8");
+		const languageId = detectLanguageId(filePath);
+
+		await sendNotification(client, "textDocument/didOpen", {
+			textDocument: {
+				uri,
+				languageId,
+				version: 1,
+				text: content,
+			},
+		});
+
+		client.openFiles.set(uri, { version: 1, languageId });
+		client.lastActivity = Date.now();
+	})();
+
+	fileOperationLocks.set(lockKey, openPromise);
+	try {
+		await openPromise;
+	} finally {
+		fileOperationLocks.delete(lockKey);
+	}
 }
 
 /**
@@ -467,27 +518,45 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
  */
 export async function refreshFile(client: LspClient, filePath: string): Promise<void> {
 	const uri = fileToUri(filePath);
-	const info = client.openFiles.get(uri);
+	const lockKey = `${client.name}:${uri}`;
 
-	if (!info) {
-		await ensureFileOpen(client, filePath);
-		return;
+	// Check if another operation is in progress
+	const existingLock = fileOperationLocks.get(lockKey);
+	if (existingLock) {
+		await existingLock;
 	}
 
-	const content = fs.readFileSync(filePath, "utf-8");
-	info.version++;
+	// Lock and refresh file
+	const refreshPromise = (async () => {
+		const info = client.openFiles.get(uri);
 
-	await sendNotification(client, "textDocument/didChange", {
-		textDocument: { uri, version: info.version },
-		contentChanges: [{ text: content }],
-	});
+		if (!info) {
+			await ensureFileOpen(client, filePath);
+			return;
+		}
 
-	await sendNotification(client, "textDocument/didSave", {
-		textDocument: { uri },
-		text: content,
-	});
+		const content = fs.readFileSync(filePath, "utf-8");
+		const version = ++info.version;
 
-	client.lastActivity = Date.now();
+		await sendNotification(client, "textDocument/didChange", {
+			textDocument: { uri, version },
+			contentChanges: [{ text: content }],
+		});
+
+		await sendNotification(client, "textDocument/didSave", {
+			textDocument: { uri },
+			text: content,
+		});
+
+		client.lastActivity = Date.now();
+	})();
+
+	fileOperationLocks.set(lockKey, refreshPromise);
+	try {
+		await refreshPromise;
+	} finally {
+		fileOperationLocks.delete(lockKey);
+	}
 }
 
 /**
@@ -519,7 +588,9 @@ export function shutdownClient(key: string): void {
  * Send an LSP request and wait for response.
  */
 export async function sendRequest(client: LspClient, method: string, params: unknown): Promise<unknown> {
+	// Atomically increment and capture request ID
 	const id = ++client.requestId;
+
 	const request: LspJsonRpcRequest = {
 		jsonrpc: "2.0",
 		id,

package/src/core/tools/lsp/config.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { extname, join } from "node:path";
-import type { ServerConfig } from "./types.js";
+import type { ServerConfig } from "./types";
 
 export interface LspConfig {
 	servers: Record<string, ServerConfig>;

package/src/core/tools/lsp/edits.ts

@@ -1,7 +1,7 @@
 import { mkdir, rename, rm } from "node:fs/promises";
 import path from "node:path";
-import type { CreateFile, DeleteFile, RenameFile, TextDocumentEdit, TextEdit, WorkspaceEdit } from "./types.js";
-import { uriToFile } from "./utils.js";
+import type { CreateFile, DeleteFile, RenameFile, TextDocumentEdit, TextEdit, WorkspaceEdit } from "./types";
+import { uriToFile } from "./utils";
 
 // =============================================================================
 // Text Edit Application

package/src/core/tools/lsp/index.ts

@@ -1,8 +1,9 @@
 import * as fs from "node:fs";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { Theme } from "../../../modes/interactive/theme/theme.js";
-import { resolveToCwd } from "../path-utils.js";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+import { logger } from "../../logger";
+import { resolveToCwd } from "../path-utils";
 import {
 	ensureFileOpen,
 	getActiveClients,
@@ -11,11 +12,11 @@ import {
 	refreshFile,
 	sendRequest,
 	setIdleTimeout,
-} from "./client.js";
-import { getServerForFile, getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config.js";
-import { applyTextEdits, applyWorkspaceEdit } from "./edits.js";
-import { renderCall, renderResult } from "./render.js";
-import * as rustAnalyzer from "./rust-analyzer.js";
+} from "./client";
+import { getServerForFile, getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
+import { applyTextEdits, applyWorkspaceEdit } from "./edits";
+import { renderCall, renderResult } from "./render";
+import * as rustAnalyzer from "./rust-analyzer";
 import {
 	type CallHierarchyIncomingCall,
 	type CallHierarchyItem,
@@ -35,7 +36,7 @@ import {
 	type SymbolInformation,
 	type TextEdit,
 	type WorkspaceEdit,
-} from "./types.js";
+} from "./types";
 import {
 	extractHoverText,
 	fileToUri,
@@ -48,10 +49,10 @@ import {
 	sleep,
 	symbolKindToIcon,
 	uriToFile,
-} from "./utils.js";
+} from "./utils";
 
-export type { LspServerStatus } from "./client.js";
-export type { LspToolDetails } from "./types.js";
+export type { LspServerStatus } from "./client";
+export type { LspToolDetails } from "./types";
 
 /** Result from warming up LSP servers */
 export interface LspWarmupResult {
@@ -273,7 +274,8 @@ async function runWorkspaceDiagnostics(
 				const formatted = collected.slice(0, 50).map((d) => formatDiagnostic(d.diagnostic, d.filePath));
 				const more = collected.length > 50 ? `\n  ... and ${collected.length - 50} more` : "";
 				return { output: `${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}${more}`, projectType };
-			} catch (e) {
+			} catch (err) {
+				logger.debug("LSP diagnostics failed, falling back to shell", { error: String(err) });
 				// Fall through to shell command
 			}
 		}
@@ -305,7 +307,7 @@ async function runWorkspaceDiagnostics(
 		// Limit output length
 		const lines = combined.split("\n");
 		if (lines.length > 50) {
-			return { output: lines.slice(0, 50).join("\n") + `\n... and ${lines.length - 50} more lines`, projectType };
+			return { output: `${lines.slice(0, 50).join("\n")}\n... and ${lines.length - 50} more lines`, projectType };
 		}
 
 		return { output: combined, projectType };

package/src/core/tools/lsp/render.ts

@@ -11,8 +11,8 @@
 import type { AgentToolResult, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
 import { Text } from "@oh-my-pi/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
-import type { Theme } from "../../../modes/interactive/theme/theme.js";
-import type { LspParams, LspToolDetails } from "./types.js";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+import type { LspParams, LspToolDetails } from "./types";
 
 // =============================================================================
 // Tree Drawing Characters

package/src/core/tools/lsp/rust-analyzer.ts

@@ -1,6 +1,6 @@
-import { sendNotification, sendRequest } from "./client.js";
-import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types.js";
-import { fileToUri } from "./utils.js";
+import { sendNotification, sendRequest } from "./client";
+import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types";
+import { fileToUri } from "./utils";
 
 /**
  * Wait for specified milliseconds.

package/src/core/tools/lsp/utils.ts

@@ -8,7 +8,7 @@ import type {
 	SymbolKind,
 	TextEdit,
 	WorkspaceEdit,
-} from "./types.js";
+} from "./types";
 
 // =============================================================================
 // Language Detection

package/src/core/tools/notebook.ts

@@ -1,6 +1,6 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
-import { resolveToCwd } from "./path-utils.js";
+import { resolveToCwd } from "./path-utils";
 
 const notebookSchema = Type.Object({
 	action: Type.Union([Type.Literal("edit"), Type.Literal("insert"), Type.Literal("delete")], {