@oh-my-pi/pi-coding-agent 3.30.0 → 3.31.0

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

@@ -110,6 +110,8 @@ describe("createTools", () => {
 				getEditFuzzyMatch: () => true,
 				getGitToolEnabled: () => false,
 				getBashInterceptorEnabled: () => true,
+				getBashInterceptorSimpleLsEnabled: () => true,
+				getBashInterceptorRules: () => [],
 			},
 		});
 		const tools = await createTools(session);
@@ -128,6 +130,8 @@ describe("createTools", () => {
 				getEditFuzzyMatch: () => true,
 				getGitToolEnabled: () => true,
 				getBashInterceptorEnabled: () => true,
+				getBashInterceptorSimpleLsEnabled: () => true,
+				getBashInterceptorRules: () => [],
 			},
 		});
 		const tools = await createTools(session);
@@ -183,6 +187,6 @@ describe("createTools", () => {
 	});
 
 	it("HIDDEN_TOOLS contains review tools", () => {
-		expect(Object.keys(HIDDEN_TOOLS).sort()).toEqual(["complete", "report_finding", "submit_review"]);
+		expect(Object.keys(HIDDEN_TOOLS).sort()).toEqual(["complete", "report_finding"]);
 	});
 });

package/src/core/tools/index.ts

@@ -18,13 +18,12 @@ export {
 	type LspServerStatus,
 	type LspToolDetails,
 	type LspWarmupResult,
-	lspTool,
 	warmupLspServers,
 } from "./lsp/index";
 export { createNotebookTool, type NotebookToolDetails } from "./notebook";
 export { createOutputTool, type OutputToolDetails } from "./output";
 export { createReadTool, type ReadToolDetails } from "./read";
-export { reportFindingTool, submitReviewTool } from "./review";
+export { reportFindingTool, type SubmitReviewDetails } from "./review";
 export { filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
 export type { TruncationResult } from "./truncate";
@@ -53,6 +52,7 @@ export { createWriteTool, type WriteToolDetails } from "./write";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Rule } from "../../capability/rule";
 import type { EventBus } from "../event-bus";
+import type { BashInterceptorRule } from "../settings-manager";
 import { createAskTool } from "./ask";
 import { createBashTool } from "./bash";
 import { createCompleteTool } from "./complete";
@@ -65,7 +65,7 @@ import { createLspTool } from "./lsp/index";
 import { createNotebookTool } from "./notebook";
 import { createOutputTool } from "./output";
 import { createReadTool } from "./read";
-import { reportFindingTool, submitReviewTool } from "./review";
+import { reportFindingTool } from "./review";
 import { createRulebookTool } from "./rulebook";
 import { createTaskTool } from "./task/index";
 import { createWebFetchTool } from "./web-fetch";
@@ -102,6 +102,8 @@ export interface ToolSession {
 		getEditFuzzyMatch(): boolean;
 		getGitToolEnabled(): boolean;
 		getBashInterceptorEnabled(): boolean;
+		getBashInterceptorSimpleLsEnabled(): boolean;
+		getBashInterceptorRules(): BashInterceptorRule[];
 	};
 }
 
@@ -129,7 +131,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 	complete: createCompleteTool,
 	report_finding: () => reportFindingTool,
-	submit_review: () => submitReviewTool,
 };
 
 export type ToolName = keyof typeof BUILTIN_TOOLS;
@@ -147,10 +148,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 
 	const entries = requestedTools
 		? requestedTools.filter((name) => name in allTools).map((name) => [name, allTools[name]] as const)
-		: [
-				...Object.entries(BUILTIN_TOOLS),
-				...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : []),
-			];
+		: [...Object.entries(BUILTIN_TOOLS), ...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : [])];
 	const results = await Promise.all(entries.map(([, factory]) => factory(session)));
 	const tools = results.filter((t): t is Tool => t !== null);
 

package/src/core/tools/ls.ts

@@ -1,4 +1,3 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
 import nodePath from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
@@ -53,23 +52,25 @@ export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
 				const dirPath = resolveToCwd(path || ".", session.cwd);
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
 
-				// Check if path exists
-				if (!existsSync(dirPath)) {
+				// Check if path exists and is a directory
+				let dirStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
+				try {
+					dirStat = await Bun.file(dirPath).stat();
+				} catch {
 					throw new Error(`Path not found: ${dirPath}`);
 				}
 
-				// Check if path is a directory
-				const stat = statSync(dirPath);
-				if (!stat.isDirectory()) {
+				if (!dirStat.isDirectory()) {
 					throw new Error(`Not a directory: ${dirPath}`);
 				}
 
 				// Read directory entries
 				let entries: string[];
 				try {
-					entries = readdirSync(dirPath);
-				} catch (e: any) {
-					throw new Error(`Cannot read directory: ${e.message}`);
+					entries = await Array.fromAsync(new Bun.Glob("*").scan({ cwd: dirPath, dot: true, onlyFiles: false }));
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					throw new Error(`Cannot read directory: ${message}`);
 				}
 
 				// Sort alphabetically (case-insensitive)
@@ -82,6 +83,7 @@ export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
 				let fileCount = 0;
 
 				for (const entry of entries) {
+					signal?.throwIfAborted();
 					if (results.length >= effectiveLimit) {
 						entryLimitReached = true;
 						break;
@@ -92,7 +94,7 @@ export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
 					let age = "";
 
 					try {
-						const entryStat = statSync(fullPath);
+						const entryStat = await Bun.file(fullPath).stat();
 						if (entryStat.isDirectory()) {
 							suffix = "/";
 							dirCount += 1;

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

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { logger } from "../../logger";
 import { applyWorkspaceEdit } from "./edits";
 import type {
 	Diagnostic,
@@ -266,6 +267,7 @@ async function startMessageReader(client: LspClient): Promise<void> {
 					if (message.method === "textDocument/publishDiagnostics" && message.params) {
 						const params = message.params as { uri: string; diagnostics: Diagnostic[] };
 						client.diagnostics.set(params.uri, params.diagnostics);
+						client.diagnosticsVersion += 1;
 					}
 				}
 
@@ -363,7 +365,7 @@ async function sendResponse(
 	try {
 		await writeMessage(client.process.stdin as import("bun").FileSink, response);
 	} catch (err) {
-		console.error(`[LSP] Failed to respond to ${method}: ${err}`);
+		logger.error("LSP failed to respond.", { method, error: String(err) });
 	}
 }
 
@@ -408,6 +410,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string): Prom
 			config,
 			requestId: 0,
 			diagnostics: new Map(),
+			diagnosticsVersion: 0,
 			openFiles: new Map(),
 			pendingRequests: new Map(),
 			messageBuffer: new Uint8Array(0),
@@ -516,9 +519,15 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
  * Sync in-memory content to the LSP client without reading from disk.
  * Use this to provide instant feedback during edits before the file is saved.
  */
-export async function syncContent(client: LspClient, filePath: string, content: string): Promise<void> {
+export async function syncContent(
+	client: LspClient,
+	filePath: string,
+	content: string,
+	signal?: AbortSignal,
+): Promise<void> {
 	const uri = fileToUri(filePath);
 	const lockKey = `${client.name}:${uri}`;
+	signal?.throwIfAborted();
 
 	const existingLock = fileOperationLocks.get(lockKey);
 	if (existingLock) {
@@ -534,6 +543,7 @@ export async function syncContent(client: LspClient, filePath: string, content:
 		if (!info) {
 			// Open file with provided content instead of reading from disk
 			const languageId = detectLanguageId(filePath);
+			signal?.throwIfAborted();
 			await sendNotification(client, "textDocument/didOpen", {
 				textDocument: {
 					uri,
@@ -548,6 +558,7 @@ export async function syncContent(client: LspClient, filePath: string, content:
 		}
 
 		const version = ++info.version;
+		signal?.throwIfAborted();
 		await sendNotification(client, "textDocument/didChange", {
 			textDocument: { uri, version },
 			contentChanges: [{ text: content }],
@@ -567,11 +578,12 @@ export async function syncContent(client: LspClient, filePath: string, content:
  * Notify LSP that a file was saved.
  * Assumes content was already synced via syncContent - just sends didSave.
  */
-export async function notifySaved(client: LspClient, filePath: string): Promise<void> {
+export async function notifySaved(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void> {
 	const uri = fileToUri(filePath);
 	const info = client.openFiles.get(uri);
 	if (!info) return; // File not open, nothing to notify
 
+	signal?.throwIfAborted();
 	await sendNotification(client, "textDocument/didSave", {
 		textDocument: { uri },
 	});
@@ -653,9 +665,18 @@ 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> {
+export async function sendRequest(
+	client: LspClient,
+	method: string,
+	params: unknown,
+	signal?: AbortSignal,
+): Promise<unknown> {
 	// Atomically increment and capture request ID
 	const id = ++client.requestId;
+	if (signal?.aborted) {
+		const reason = signal.reason instanceof Error ? signal.reason : new Error("Operation aborted");
+		return Promise.reject(reason);
+	}
 
 	const request: LspJsonRpcRequest = {
 		jsonrpc: "2.0",
@@ -667,22 +688,49 @@ export async function sendRequest(client: LspClient, method: string, params: unk
 	client.lastActivity = Date.now();
 
 	return new Promise((resolve, reject) => {
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		const cleanup = () => {
+			if (signal) {
+				signal.removeEventListener("abort", abortHandler);
+			}
+		};
+		const abortHandler = () => {
+			if (client.pendingRequests.has(id)) {
+				client.pendingRequests.delete(id);
+			}
+			if (timeout) clearTimeout(timeout);
+			cleanup();
+			const reason = signal?.reason instanceof Error ? signal.reason : new Error("Operation aborted");
+			reject(reason);
+		};
+
 		// Set timeout
-		const timeout = setTimeout(() => {
+		timeout = setTimeout(() => {
 			if (client.pendingRequests.has(id)) {
 				client.pendingRequests.delete(id);
-				reject(new Error(`LSP request ${method} timed out`));
+				const err = new Error(`LSP request ${method} timed out`);
+				cleanup();
+				reject(err);
 			}
 		}, 30000);
+		if (signal) {
+			signal.addEventListener("abort", abortHandler, { once: true });
+			if (signal.aborted) {
+				abortHandler();
+				return;
+			}
+		}
 
 		// Register pending request with timeout wrapper
 		client.pendingRequests.set(id, {
 			resolve: (result) => {
-				clearTimeout(timeout);
+				if (timeout) clearTimeout(timeout);
+				cleanup();
 				resolve(result);
 			},
 			reject: (err) => {
-				clearTimeout(timeout);
+				if (timeout) clearTimeout(timeout);
+				cleanup();
 				reject(err);
 			},
 			method,
@@ -690,8 +738,9 @@ export async function sendRequest(client: LspClient, method: string, params: unk
 
 		// Write request
 		writeMessage(client.process.stdin as import("bun").FileSink, request).catch((err) => {
-			clearTimeout(timeout);
+			if (timeout) clearTimeout(timeout);
 			client.pendingRequests.delete(id);
+			cleanup();
 			reject(err);
 		});
 	});