@oh-my-pi/pi-coding-agent 3.21.0 → 3.25.0

package/src/core/tools/index.ts

@@ -1,14 +1,15 @@
 export { type AskToolDetails, askTool, createAskTool } from "./ask";
-export { type BashToolDetails, bashTool, createBashTool } from "./bash";
-export { createEditTool, type EditToolOptions, editTool } from "./edit";
+export { type BashToolDetails, createBashTool } from "./bash";
+export { createCompleteTool } from "./complete";
+export { createEditTool } from "./edit";
 // Exa MCP tools (22 tools)
 export { exaTools } from "./exa/index";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
-export { createFindTool, type FindToolDetails, findTool } from "./find";
+export { createFindTool, type FindToolDetails } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
 export { createGitTool, type GitToolDetails, gitTool } from "./git";
-export { createGrepTool, type GrepToolDetails, grepTool } from "./grep";
-export { createLsTool, type LsToolDetails, lsTool } from "./ls";
+export { createGrepTool, type GrepToolDetails } from "./grep";
+export { createLsTool, type LsToolDetails } from "./ls";
 export {
 	createLspTool,
 	type FileDiagnosticsResult,
@@ -20,14 +21,14 @@ export {
 	lspTool,
 	warmupLspServers,
 } from "./lsp/index";
-export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./notebook";
-export { createOutputTool, type OutputToolDetails, outputTool } from "./output";
-export { createReadTool, type ReadToolDetails, type ReadToolOptions, readTool } from "./read";
-export { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
-export { createRulebookTool, filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
+export { createNotebookTool, type NotebookToolDetails } from "./notebook";
+export { createOutputTool, type OutputToolDetails } from "./output";
+export { createReadTool, type ReadToolDetails } from "./read";
+export { reportFindingTool, submitReviewTool } from "./review";
+export { filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
 export type { TruncationResult } from "./truncate";
-export { createWebFetchTool, type WebFetchToolDetails, webFetchCustomTool, webFetchTool } from "./web-fetch";
+export { createWebFetchTool, type WebFetchToolDetails } from "./web-fetch";
 export {
 	companyWebSearchTools,
 	createWebSearchTool,
@@ -47,247 +48,116 @@ export {
 	webSearchLinkedinTool,
 	webSearchTool,
 } from "./web-search/index";
-export { createWriteTool, type WriteToolDetails, type WriteToolOptions, writeTool } from "./write";
+export { createWriteTool, type WriteToolDetails } from "./write";
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-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 { createGitTool, gitTool } from "./git";
-import { createGrepTool, grepTool } from "./grep";
-import { createLsTool, lsTool } from "./ls";
-import { createLspTool, createLspWritethrough, 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";
+import type { Rule } from "../../capability/rule";
+import type { EventBus } from "../event-bus";
+import { createAskTool } from "./ask";
+import { createBashTool } from "./bash";
+import { createCompleteTool } from "./complete";
+import { createEditTool } from "./edit";
+import { createFindTool } from "./find";
+import { createGitTool } from "./git";
+import { createGrepTool } from "./grep";
+import { createLsTool } from "./ls";
+import { createLspTool } from "./lsp/index";
+import { createNotebookTool } from "./notebook";
+import { createOutputTool } from "./output";
+import { createReadTool } from "./read";
+import { reportFindingTool, submitReviewTool } from "./review";
+import { createRulebookTool } from "./rulebook";
+import { createTaskTool } from "./task/index";
+import { createWebFetchTool } from "./web-fetch";
+import { createWebSearchTool } from "./web-search/index";
+import { createWriteTool } from "./write";
 
 /** Tool type (AgentTool from pi-ai) */
 export type Tool = AgentTool<any, any, any>;
 
-/** Context for tools that need session information */
-export interface SessionContext {
+/** Session context for tool factories */
+export interface ToolSession {
+	/** Current working directory */
+	cwd: string;
+	/** Whether UI is available */
+	hasUI: boolean;
+	/** Rulebook rules */
+	rulebookRules: Rule[];
+	/** Event bus for tool/extension communication */
+	eventBus?: EventBus;
+	/** Output schema for structured completion (subagents) */
+	outputSchema?: unknown;
+	/** Whether to include the complete tool by default */
+	requireCompleteTool?: boolean;
+	/** Get session file */
 	getSessionFile: () => string | null;
+	/** Get session spawns */
+	getSessionSpawns: () => string | null;
+	/** Settings manager (optional) */
+	settings?: {
+		getImageAutoResize(): boolean;
+		getLspFormatOnWrite(): boolean;
+		getLspDiagnosticsOnWrite(): boolean;
+		getLspDiagnosticsOnEdit(): boolean;
+		getEditFuzzyMatch(): boolean;
+		getGitToolEnabled(): boolean;
+		getBashInterceptorEnabled(): boolean;
+	};
 }
 
-/** Options for creating coding tools */
-export interface CodingToolsOptions {
-	/** Whether to fetch LSP diagnostics after write tool writes files (default: true) */
-	lspDiagnosticsOnWrite?: boolean;
-	/** Whether to fetch LSP diagnostics after edit tool edits files (default: false) */
-	lspDiagnosticsOnEdit?: boolean;
-	/** Whether to format files using LSP after write tool writes (default: true) */
-	lspFormatOnWrite?: boolean;
-	/** Whether to accept high-confidence fuzzy matches in edit tool (default: true) */
-	editFuzzyMatch?: boolean;
-	/** Whether to auto-resize images to 2000x2000 max in read tool (default: true) */
-	readAutoResizeImages?: boolean;
-	/** Set of tool names available to the agent (for cross-tool awareness) */
-	availableTools?: Set<string>;
-}
-
-// Factory function type
-type ToolFactory = (cwd: string, sessionContext?: SessionContext, options?: CodingToolsOptions) => Tool | Promise<Tool>;
-
-// Tool definitions: static tools and their factory functions
-const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
-	ask: { tool: askTool, create: createAskTool },
-	read: {
-		tool: readTool,
-		create: (cwd, _ctx, options) => createReadTool(cwd, { autoResizeImages: options?.readAutoResizeImages ?? true }),
-	},
-	bash: { tool: bashTool, create: createBashTool },
-	edit: {
-		tool: editTool,
-		create: (cwd, _ctx, options) => {
-			const enableDiagnostics = options?.lspDiagnosticsOnEdit ?? false;
-			const enableFormat = options?.lspFormatOnWrite ?? true;
-			const writethrough = createLspWritethrough(cwd, {
-				enableFormat,
-				enableDiagnostics,
-			});
-			return createEditTool(cwd, { fuzzyMatch: options?.editFuzzyMatch ?? true, writethrough });
-		},
-	},
-	write: {
-		tool: writeTool,
-		create: (cwd, _ctx, options) => {
-			const enableFormat = options?.lspFormatOnWrite ?? true;
-			const enableDiagnostics = options?.lspDiagnosticsOnWrite ?? true;
-			const writethrough = createLspWritethrough(cwd, {
-				enableFormat,
-				enableDiagnostics,
-			});
-			return createWriteTool(cwd, { writethrough });
-		},
-	},
-	grep: { tool: grepTool, create: createGrepTool },
-	find: { tool: findTool, create: createFindTool },
-	git: { tool: gitTool, create: createGitTool },
-	ls: { tool: lsTool, create: createLsTool },
-	lsp: { tool: lspTool, create: createLspTool },
-	notebook: { tool: notebookTool, create: createNotebookTool },
-	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 },
+type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
+
+export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
+	ask: createAskTool,
+	bash: createBashTool,
+	edit: createEditTool,
+	find: createFindTool,
+	git: createGitTool,
+	grep: createGrepTool,
+	ls: createLsTool,
+	lsp: createLspTool,
+	notebook: createNotebookTool,
+	output: createOutputTool,
+	read: createReadTool,
+	rulebook: createRulebookTool,
+	task: createTaskTool,
+	web_fetch: createWebFetchTool,
+	web_search: createWebSearchTool,
+	write: createWriteTool,
 };
 
-export type ToolName = keyof typeof toolDefs;
-
-// Tools that require UI (excluded when hasUI is false)
-const uiToolNames: ToolName[] = ["ask"];
-
-// Tool sets defined by name (base sets, without UI-only tools)
-export const baseCodingToolNames: ToolName[] = [
-	"read",
-	"bash",
-	"edit",
-	"write",
-	"grep",
-	"find",
-	"git",
-	"ls",
-	"lsp",
-	"notebook",
-	"output",
-	"task",
-	"web_fetch",
-	"web_search",
-];
-const baseReadOnlyToolNames: ToolName[] = ["read", "grep", "find", "ls"];
-
-// Default tools for full access mode (using process.cwd(), no UI)
-export const codingTools: Tool[] = baseCodingToolNames.map((name) => toolDefs[name].tool);
-
-// Read-only tools for exploration without modification (using process.cwd(), no UI)
-export const readOnlyTools: Tool[] = baseReadOnlyToolNames.map((name) => toolDefs[name].tool);
-
-// All available tools (using process.cwd(), no UI)
-export const allTools = Object.fromEntries(Object.entries(toolDefs).map(([name, def]) => [name, def.tool])) as Record<
-	ToolName,
-	Tool
->;
-
-/**
- * Create coding tools configured for a specific working directory.
- * @param cwd - Working directory for tools
- * @param hasUI - Whether UI is available (includes ask tool if true)
- * @param sessionContext - Optional session context for tools that need it
- * @param options - Options for tool configuration
- */
-export async function createCodingTools(
-	cwd: string,
-	hasUI = false,
-	sessionContext?: SessionContext,
-	options?: CodingToolsOptions,
-): Promise<Tool[]> {
-	const names = hasUI ? [...baseCodingToolNames, ...uiToolNames] : baseCodingToolNames;
-	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	return Promise.all(names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools)));
-}
-
-/**
- * Create read-only tools configured for a specific working directory.
- * @param cwd - Working directory for tools
- * @param hasUI - Whether UI is available (includes ask tool if true)
- * @param sessionContext - Optional session context for tools that need it
- * @param options - Options for tool configuration
- */
-export async function createReadOnlyTools(
-	cwd: string,
-	hasUI = false,
-	sessionContext?: SessionContext,
-	options?: CodingToolsOptions,
-): Promise<Tool[]> {
-	const names = hasUI ? [...baseReadOnlyToolNames, ...uiToolNames] : baseReadOnlyToolNames;
-	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	return Promise.all(names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools)));
-}
-
-/**
- * Create all tools configured for a specific working directory.
- * @param cwd - Working directory for tools
- * @param sessionContext - Optional session context for tools that need it
- * @param options - Options for tool configuration
- */
-export async function createAllTools(
-	cwd: string,
-	sessionContext?: SessionContext,
-	options?: CodingToolsOptions,
-): Promise<Record<ToolName, Tool>> {
-	const names = Object.keys(toolDefs);
-	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	const entries = await Promise.all(
-		Object.entries(toolDefs).map(async ([name, def]) => [
-			name,
-			await def.create(cwd, sessionContext, optionsWithTools),
-		]),
-	);
-	return Object.fromEntries(entries) as Record<ToolName, Tool>;
-}
-
-/**
- * Wrap a bash tool with interception that redirects common patterns to specialized tools.
- * This helps prevent LLMs from falling back to shell commands when better tools exist.
- *
- * @param bashTool - The bash tool to wrap
- * @param availableTools - Set of tool names that are available (for context-aware blocking)
- * @returns Wrapped bash tool with interception
- */
-export function wrapBashWithInterception(bashTool: Tool, availableTools: Set<string>): Tool {
-	const originalExecute = bashTool.execute;
-
-	return {
-		...bashTool,
-		execute: async (toolCallId, params, signal, onUpdate, context) => {
-			const command = (params as { command: string }).command;
-
-			// Check for forbidden patterns
-			const interception = checkBashInterception(command, availableTools);
-			if (interception.block) {
-				throw new Error(interception.message);
-			}
+export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
+	complete: createCompleteTool,
+	report_finding: () => reportFindingTool,
+	submit_review: () => submitReviewTool,
+};
 
-			// Check for simple ls that should use ls tool
-			const lsInterception = checkSimpleLsInterception(command, availableTools);
-			if (lsInterception.block) {
-				throw new Error(lsInterception.message);
-			}
-
-			// Pass through to original bash tool
-			return originalExecute(toolCallId, params, signal, onUpdate, context);
-		},
-	};
-}
+export type ToolName = keyof typeof BUILTIN_TOOLS;
 
 /**
- * Apply bash interception to a set of tools.
- * Finds the bash tool and wraps it with interception based on other available tools.
- *
- * @param tools - Array of tools to process
- * @returns Tools with bash interception applied
+ * Create tools from BUILTIN_TOOLS registry.
  */
-export function applyBashInterception(tools: Tool[]): Tool[] {
-	const toolNames = new Set(tools.map((t) => t.name));
+export async function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]> {
+	const includeComplete = session.requireCompleteTool === true;
+	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
+	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
+	if (includeComplete && requestedTools && !requestedTools.includes("complete")) {
+		requestedTools.push("complete");
+	}
 
-	// If bash isn't in the tools, nothing to do
-	if (!toolNames.has("bash")) {
-		return tools;
+	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) : []),
+			];
+	const results = await Promise.all(entries.map(([, factory]) => factory(session)));
+	const tools = results.filter((t): t is Tool => t !== null);
+
+	if (requestedTools) {
+		const allowed = new Set(requestedTools);
+		return tools.filter((tool) => allowed.has(tool.name));
 	}
 
-	return tools.map((tool) => {
-		if (tool.name === "bash") {
-			return wrapBashWithInterception(tool, toolNames);
-		}
-		return tool;
-	});
+	return tools;
 }

package/src/core/tools/jtd-to-json-schema.ts

@@ -0,0 +1,274 @@
+/**
+ * Convert JSON Type Definition (JTD) to JSON Schema.
+ *
+ * JTD (RFC 8927) is a simpler schema format. This converter allows users to
+ * write schemas in JTD and have them converted to JSON Schema for model APIs.
+ *
+ * @see https://jsontypedef.com/
+ * @see https://datatracker.ietf.org/doc/html/rfc8927
+ */
+
+type JTDPrimitive =
+   | "boolean"
+   | "string"
+   | "timestamp"
+   | "float32"
+   | "float64"
+   | "int8"
+   | "uint8"
+   | "int16"
+   | "uint16"
+   | "int32"
+   | "uint32";
+
+interface JTDType {
+   type: JTDPrimitive;
+}
+
+interface JTDEnum {
+   enum: string[];
+}
+
+interface JTDElements {
+   elements: JTDSchema;
+}
+
+interface JTDValues {
+   values: JTDSchema;
+}
+
+interface JTDProperties {
+   properties?: Record<string, JTDSchema>;
+   optionalProperties?: Record<string, JTDSchema>;
+}
+
+interface JTDDiscriminator {
+   discriminator: string;
+   mapping: Record<string, JTDProperties>;
+}
+
+interface JTDRef {
+   ref: string;
+}
+
+interface 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",
+};
+
+function isJTDType(schema: unknown): schema is JTDType {
+   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;
+}
+
+function isJTDElements(schema: unknown): schema is JTDElements {
+   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;
+}
+
+function isJTDProperties(schema: unknown): schema is JTDProperties {
+   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;
+}
+
+function isJTDRef(schema: unknown): schema is JTDRef {
+   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 {};
+}
+
+/**
+ * Detect if a schema is JTD format (vs JSON Schema).
+ *
+ * JTD schemas use: type (primitives), properties, optionalProperties, elements, values, enum, discriminator, ref
+ * 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;
+}
+
+/**
+ * Convert JTD schema to JSON Schema.
+ * If already JSON Schema, returns as-is.
+ */
+export function jtdToJsonSchema(schema: unknown): unknown {
+   if (!isJTDSchema(schema)) {
+      return schema;
+   }
+   return convertSchema(schema);
+}