@oh-my-pi/pi-coding-agent 3.25.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/jtd-to-json-schema.ts

@@ -9,211 +9,199 @@
  */
 
 type JTDPrimitive =
-   | "boolean"
-   | "string"
-   | "timestamp"
-   | "float32"
-   | "float64"
-   | "int8"
-   | "uint8"
-   | "int16"
-   | "uint16"
-   | "int32"
-   | "uint32";
+	| "boolean"
+	| "string"
+	| "timestamp"
+	| "float32"
+	| "float64"
+	| "int8"
+	| "uint8"
+	| "int16"
+	| "uint16"
+	| "int32"
+	| "uint32";
 
 interface JTDType {
-   type: JTDPrimitive;
+	type: JTDPrimitive;
 }
 
 interface JTDEnum {
-   enum: string[];
+	enum: string[];
 }
 
 interface JTDElements {
-   elements: JTDSchema;
+	elements: JTDSchema;
 }
 
 interface JTDValues {
-   values: JTDSchema;
+	values: JTDSchema;
 }
 
 interface JTDProperties {
-   properties?: Record<string, JTDSchema>;
-   optionalProperties?: Record<string, JTDSchema>;
+	properties?: Record<string, JTDSchema>;
+	optionalProperties?: Record<string, JTDSchema>;
 }
 
 interface JTDDiscriminator {
-   discriminator: string;
-   mapping: Record<string, JTDProperties>;
+	discriminator: string;
+	mapping: Record<string, JTDProperties>;
 }
 
 interface JTDRef {
-   ref: string;
+	ref: string;
 }
 
 interface JTDEmpty {}
 
-type JTDSchema =
-   | JTDType
-   | JTDEnum
-   | JTDElements
-   | JTDValues
-   | JTDProperties
-   | JTDDiscriminator
-   | JTDRef
-   | JTDEmpty;
+type JTDSchema = JTDType | JTDEnum | JTDElements | JTDValues | JTDProperties | JTDDiscriminator | JTDRef | JTDEmpty;
 
 const primitiveMap: Record<JTDPrimitive, string> = {
-   boolean: "boolean",
-   string: "string",
-   timestamp: "string", // ISO 8601
-   float32: "number",
-   float64: "number",
-   int8: "integer",
-   uint8: "integer",
-   int16: "integer",
-   uint16: "integer",
-   int32: "integer",
-   uint32: "integer",
+	boolean: "boolean",
+	string: "string",
+	timestamp: "string", // ISO 8601
+	float32: "number",
+	float64: "number",
+	int8: "integer",
+	uint8: "integer",
+	int16: "integer",
+	uint16: "integer",
+	int32: "integer",
+	uint32: "integer",
 };
 
 function isJTDType(schema: unknown): schema is JTDType {
-   return typeof schema === "object" && schema !== null && "type" in schema;
+	return typeof schema === "object" && schema !== null && "type" in schema;
 }
 
 function isJTDEnum(schema: unknown): schema is JTDEnum {
-   return typeof schema === "object" && schema !== null && "enum" in schema;
+	return typeof schema === "object" && schema !== null && "enum" in schema;
 }
 
 function isJTDElements(schema: unknown): schema is JTDElements {
-   return typeof schema === "object" && schema !== null && "elements" in schema;
+	return typeof schema === "object" && schema !== null && "elements" in schema;
 }
 
 function isJTDValues(schema: unknown): schema is JTDValues {
-   return typeof schema === "object" && schema !== null && "values" in schema;
+	return typeof schema === "object" && schema !== null && "values" in schema;
 }
 
 function isJTDProperties(schema: unknown): schema is JTDProperties {
-   return (
-      typeof schema === "object" &&
-      schema !== null &&
-      ("properties" in schema || "optionalProperties" in schema)
-   );
+	return typeof schema === "object" && schema !== null && ("properties" in schema || "optionalProperties" in schema);
 }
 
 function isJTDDiscriminator(schema: unknown): schema is JTDDiscriminator {
-   return typeof schema === "object" && schema !== null && "discriminator" in schema;
+	return typeof schema === "object" && schema !== null && "discriminator" in schema;
 }
 
 function isJTDRef(schema: unknown): schema is JTDRef {
-   return typeof schema === "object" && schema !== null && "ref" in schema;
+	return typeof schema === "object" && schema !== null && "ref" in schema;
 }
 
 function convertSchema(schema: unknown): unknown {
-   if (schema === null || typeof schema !== "object") {
-      return {};
-   }
-
-   // Type form: { type: "string" } → { type: "string" }
-   if (isJTDType(schema)) {
-      const jsonType = primitiveMap[schema.type as JTDPrimitive];
-      if (!jsonType) {
-         return { type: schema.type };
-      }
-      const result: Record<string, unknown> = { type: jsonType };
-      // Add format for timestamp
-      if (schema.type === "timestamp") {
-         result.format = "date-time";
-      }
-      return result;
-   }
-
-   // Enum form: { enum: ["a", "b"] } → { enum: ["a", "b"] }
-   if (isJTDEnum(schema)) {
-      return { enum: schema.enum };
-   }
-
-   // Elements form: { elements: { type: "string" } } → { type: "array", items: ... }
-   if (isJTDElements(schema)) {
-      return {
-         type: "array",
-         items: convertSchema(schema.elements),
-      };
-   }
-
-   // Values form: { values: { type: "string" } } → { type: "object", additionalProperties: ... }
-   if (isJTDValues(schema)) {
-      return {
-         type: "object",
-         additionalProperties: convertSchema(schema.values),
-      };
-   }
-
-   // Properties form: { properties: {...}, optionalProperties: {...} }
-   if (isJTDProperties(schema)) {
-      const properties: Record<string, unknown> = {};
-      const required: string[] = [];
-
-      // Required properties
-      if (schema.properties) {
-         for (const [key, value] of Object.entries(schema.properties)) {
-            properties[key] = convertSchema(value);
-            required.push(key);
-         }
-      }
-
-      // Optional properties
-      if (schema.optionalProperties) {
-         for (const [key, value] of Object.entries(schema.optionalProperties)) {
-            properties[key] = convertSchema(value);
-         }
-      }
-
-      const result: Record<string, unknown> = {
-         type: "object",
-         properties,
-         additionalProperties: false,
-      };
-
-      if (required.length > 0) {
-         result.required = required;
-      }
-
-      return result;
-   }
-
-   // Discriminator form: { discriminator: "type", mapping: { ... } }
-   if (isJTDDiscriminator(schema)) {
-      const oneOf: unknown[] = [];
-
-      for (const [tag, props] of Object.entries(schema.mapping)) {
-         const converted = convertSchema(props) as Record<string, unknown>;
-         // Add the discriminator property
-         const properties = (converted.properties || {}) as Record<string, unknown>;
-         properties[schema.discriminator] = { const: tag };
-
-         const required = ((converted.required as string[]) || []).slice();
-         if (!required.includes(schema.discriminator)) {
-            required.push(schema.discriminator);
-         }
-
-         oneOf.push({
-            ...converted,
-            properties,
-            required,
-         });
-      }
-
-      return { oneOf };
-   }
-
-   // Ref form: { ref: "MyType" } → { $ref: "#/$defs/MyType" }
-   if (isJTDRef(schema)) {
-      return { $ref: `#/$defs/${schema.ref}` };
-   }
-
-   // Empty form: {} → {} (accepts anything)
-   return {};
+	if (schema === null || typeof schema !== "object") {
+		return {};
+	}
+
+	// Type form: { type: "string" } → { type: "string" }
+	if (isJTDType(schema)) {
+		const jsonType = primitiveMap[schema.type as JTDPrimitive];
+		if (!jsonType) {
+			return { type: schema.type };
+		}
+		const result: Record<string, unknown> = { type: jsonType };
+		// Add format for timestamp
+		if (schema.type === "timestamp") {
+			result.format = "date-time";
+		}
+		return result;
+	}
+
+	// Enum form: { enum: ["a", "b"] } → { enum: ["a", "b"] }
+	if (isJTDEnum(schema)) {
+		return { enum: schema.enum };
+	}
+
+	// Elements form: { elements: { type: "string" } } → { type: "array", items: ... }
+	if (isJTDElements(schema)) {
+		return {
+			type: "array",
+			items: convertSchema(schema.elements),
+		};
+	}
+
+	// Values form: { values: { type: "string" } } → { type: "object", additionalProperties: ... }
+	if (isJTDValues(schema)) {
+		return {
+			type: "object",
+			additionalProperties: convertSchema(schema.values),
+		};
+	}
+
+	// Properties form: { properties: {...}, optionalProperties: {...} }
+	if (isJTDProperties(schema)) {
+		const properties: Record<string, unknown> = {};
+		const required: string[] = [];
+
+		// Required properties
+		if (schema.properties) {
+			for (const [key, value] of Object.entries(schema.properties)) {
+				properties[key] = convertSchema(value);
+				required.push(key);
+			}
+		}
+
+		// Optional properties
+		if (schema.optionalProperties) {
+			for (const [key, value] of Object.entries(schema.optionalProperties)) {
+				properties[key] = convertSchema(value);
+			}
+		}
+
+		const result: Record<string, unknown> = {
+			type: "object",
+			properties,
+			additionalProperties: false,
+		};
+
+		if (required.length > 0) {
+			result.required = required;
+		}
+
+		return result;
+	}
+
+	// Discriminator form: { discriminator: "type", mapping: { ... } }
+	if (isJTDDiscriminator(schema)) {
+		const oneOf: unknown[] = [];
+
+		for (const [tag, props] of Object.entries(schema.mapping)) {
+			const converted = convertSchema(props) as Record<string, unknown>;
+			// Add the discriminator property
+			const properties = (converted.properties || {}) as Record<string, unknown>;
+			properties[schema.discriminator] = { const: tag };
+
+			const required = ((converted.required as string[]) || []).slice();
+			if (!required.includes(schema.discriminator)) {
+				required.push(schema.discriminator);
+			}
+
+			oneOf.push({
+				...converted,
+				properties,
+				required,
+			});
+		}
+
+		return { oneOf };
+	}
+
+	// Ref form: { ref: "MyType" } → { $ref: "#/$defs/MyType" }
+	if (isJTDRef(schema)) {
+		return { $ref: `#/$defs/${schema.ref}` };
+	}
+
+	// Empty form: {} → {} (accepts anything)
+	return {};
 }
 
 /**
@@ -223,43 +211,33 @@ function convertSchema(schema: unknown): unknown {
  * JSON Schema uses: type: "object", type: "array", items, additionalProperties, etc.
  */
 export function isJTDSchema(schema: unknown): boolean {
-   if (schema === null || typeof schema !== "object") {
-      return false;
-   }
-
-   const obj = schema as Record<string, unknown>;
-
-   // JTD-specific keywords
-   if ("elements" in obj) return true;
-   if ("values" in obj) return true;
-   if ("optionalProperties" in obj) return true;
-   if ("discriminator" in obj) return true;
-   if ("ref" in obj) return true;
-
-   // JTD type primitives (JSON Schema doesn't have int32, float64, etc.)
-   if ("type" in obj) {
-      const jtdPrimitives = [
-         "timestamp",
-         "float32",
-         "float64",
-         "int8",
-         "uint8",
-         "int16",
-         "uint16",
-         "int32",
-         "uint32",
-      ];
-      if (jtdPrimitives.includes(obj.type as string)) {
-         return true;
-      }
-   }
-
-   // JTD properties form without type: "object" (JSON Schema requires it)
-   if ("properties" in obj && !("type" in obj)) {
-      return true;
-   }
-
-   return false;
+	if (schema === null || typeof schema !== "object") {
+		return false;
+	}
+
+	const obj = schema as Record<string, unknown>;
+
+	// JTD-specific keywords
+	if ("elements" in obj) return true;
+	if ("values" in obj) return true;
+	if ("optionalProperties" in obj) return true;
+	if ("discriminator" in obj) return true;
+	if ("ref" in obj) return true;
+
+	// JTD type primitives (JSON Schema doesn't have int32, float64, etc.)
+	if ("type" in obj) {
+		const jtdPrimitives = ["timestamp", "float32", "float64", "int8", "uint8", "int16", "uint16", "int32", "uint32"];
+		if (jtdPrimitives.includes(obj.type as string)) {
+			return true;
+		}
+	}
+
+	// JTD properties form without type: "object" (JSON Schema requires it)
+	if ("properties" in obj && !("type" in obj)) {
+		return true;
+	}
+
+	return false;
 }
 
 /**
@@ -267,8 +245,8 @@ export function isJTDSchema(schema: unknown): boolean {
  * If already JSON Schema, returns as-is.
  */
 export function jtdToJsonSchema(schema: unknown): unknown {
-   if (!isJTDSchema(schema)) {
-      return schema;
-   }
-   return convertSchema(schema);
+	if (!isJTDSchema(schema)) {
+		return schema;
+	}
+	return convertSchema(schema);
 }

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;