@oh-my-pi/pi-coding-agent 0.1.0

package/src/core/tools/ask.ts

@@ -0,0 +1,193 @@
+/**
+ * Ask Tool - Interactive user prompting during execution
+ *
+ * Use this tool when you need to ask the user questions during execution.
+ * This allows you to:
+ *   1. Gather user preferences or requirements
+ *   2. Clarify ambiguous instructions
+ *   3. Get decisions on implementation choices as you work
+ *   4. Offer choices to the user about what direction to take
+ *
+ * Usage notes:
+ *   - Users will always be able to select "Other" to provide custom text input
+ *   - Use multi: true to allow multiple answers to be selected for a question
+ *   - If you recommend a specific option, make that the first option in the list
+ *     and add "(Recommended)" at the end of the label
+ */
+
+import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { theme } from "../../modes/interactive/theme/theme";
+import askDescription from "../../prompts/tools/ask.md" with { type: "text" };
+
+// =============================================================================
+// Types
+// =============================================================================
+
+const OptionItem = Type.Object({
+	label: Type.String({ description: "Display label for this option" }),
+});
+
+const askSchema = Type.Object({
+	question: Type.String({ description: "The question to ask the user" }),
+	options: Type.Array(OptionItem, {
+		description: "Available options for the user to choose from.",
+		minItems: 1,
+	}),
+	multi: Type.Optional(
+		Type.Boolean({
+			description: "Allow multiple options to be selected (default: false)",
+			default: false,
+		}),
+	),
+});
+
+export interface AskToolDetails {
+	question: string;
+	options: string[];
+	multi: boolean;
+	selectedOptions: string[];
+	customInput?: string;
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const OTHER_OPTION = "Other (type your own)";
+function getDoneOptionLabel(): string {
+	return `${theme.status.success} Done selecting`;
+}
+
+// =============================================================================
+// Tool Implementation
+// =============================================================================
+
+export function createAskTool(_cwd: string): AgentTool<typeof askSchema, AskToolDetails> {
+	return {
+		name: "ask",
+		label: "Ask",
+		description: askDescription,
+		parameters: askSchema,
+
+		async execute(
+			_toolCallId: string,
+			params: { question: string; options: Array<{ label: string }>; multi?: boolean },
+			_signal?: AbortSignal,
+			_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
+			context?: AgentToolContext,
+		) {
+			const { question, options, multi = false } = params;
+			const optionLabels = options.map((o) => o.label);
+			const doneLabel = getDoneOptionLabel();
+
+			// Headless fallback - return error if no UI available
+			if (!context?.hasUI || !context.ui) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Error: User prompt requires interactive mode",
+						},
+					],
+					details: {
+						question,
+						options: optionLabels,
+						multi,
+						selectedOptions: [],
+					},
+				};
+			}
+
+			const { ui } = context;
+			let selectedOptions: string[] = [];
+			let customInput: string | undefined;
+
+			if (multi) {
+				// Multi-select: show checkboxes in the label to indicate selection state
+				const selected = new Set<string>();
+
+				while (true) {
+					// Build options with checkbox indicators
+					const opts: string[] = [];
+
+					// Add "Done" option if any selected
+					if (selected.size > 0) {
+						opts.push(doneLabel);
+					}
+
+					// Add all options with checkbox prefix
+					for (const opt of optionLabels) {
+						const checkbox = selected.has(opt) ? theme.checkbox.checked : theme.checkbox.unchecked;
+						opts.push(`${checkbox} ${opt}`);
+					}
+
+					// Add "Other" option
+					opts.push(OTHER_OPTION);
+
+					const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
+					const choice = await ui.select(`${prefix}${question}`, opts);
+
+					if (choice === undefined || choice === doneLabel) break;
+
+					if (choice === OTHER_OPTION) {
+						const input = await ui.input("Enter your response:");
+						if (input) customInput = input;
+						break;
+					}
+
+					// Toggle selection - extract the actual option name
+					const checkedPrefix = `${theme.checkbox.checked} `;
+					const uncheckedPrefix = `${theme.checkbox.unchecked} `;
+					let opt: string | undefined;
+					if (choice.startsWith(checkedPrefix)) {
+						opt = choice.slice(checkedPrefix.length);
+					} else if (choice.startsWith(uncheckedPrefix)) {
+						opt = choice.slice(uncheckedPrefix.length);
+					}
+					if (opt) {
+						if (selected.has(opt)) {
+							selected.delete(opt);
+						} else {
+							selected.add(opt);
+						}
+					}
+				}
+				selectedOptions = Array.from(selected);
+			} else {
+				// Single select with "Other" option
+				const choice = await ui.select(question, [...optionLabels, OTHER_OPTION]);
+				if (choice === OTHER_OPTION) {
+					const input = await ui.input("Enter your response:");
+					if (input) customInput = input;
+				} else if (choice) {
+					selectedOptions = [choice];
+				}
+			}
+
+			const details: AskToolDetails = {
+				question,
+				options: optionLabels,
+				multi,
+				selectedOptions,
+				customInput,
+			};
+
+			let responseText: string;
+			if (customInput) {
+				responseText = `User provided custom input: ${customInput}`;
+			} else if (selectedOptions.length > 0) {
+				responseText = multi
+					? `User selected: ${selectedOptions.join(", ")}`
+					: `User selected: ${selectedOptions[0]}`;
+			} else {
+				responseText = "User cancelled the selection";
+			}
+
+			return { content: [{ type: "text" as const, text: responseText }], details };
+		},
+	};
+}
+
+/** Default ask tool using process.cwd() - for backwards compatibility (no UI) */
+export const askTool = createAskTool(process.cwd());

package/src/core/tools/bash-interceptor.ts

@@ -0,0 +1,120 @@
+/**
+ * Bash intent interceptor - redirects common shell patterns to proper tools.
+ *
+ * When an LLM calls bash with patterns like `grep`, `cat`, `find`, etc.,
+ * this interceptor provides helpful error messages directing them to use
+ * the specialized tools instead.
+ */
+
+export interface InterceptionResult {
+	/** If true, the bash command should be blocked */
+	block: boolean;
+	/** Error message to return instead of executing */
+	message?: string;
+	/** Suggested tool to use instead */
+	suggestedTool?: string;
+}
+
+/**
+ * Patterns that should NEVER use bash when specialized tools exist.
+ * Each pattern maps to a helpful error message.
+ */
+const forbiddenPatterns: Array<{
+	pattern: RegExp;
+	tool: string;
+	message: string;
+}> = [
+	// File reading
+	{
+		pattern: /^\s*(cat|head|tail|less|more)\s+/,
+		tool: "read",
+		message: "Use the `read` tool instead of cat/head/tail. It provides better context and handles binary files.",
+	},
+	// Content search (grep variants)
+	{
+		pattern: /^\s*(grep|rg|ripgrep|ag|ack)\s+/,
+		tool: "grep",
+		message: "Use the `grep` tool instead of grep/rg. It respects .gitignore and provides structured output.",
+	},
+	// File finding
+	{
+		pattern: /^\s*(find|fd|locate)\s+.*(-name|-iname|-type|--type|-glob)/,
+		tool: "find",
+		message: "Use the `find` tool instead of find/fd. It respects .gitignore and is faster for glob patterns.",
+	},
+	// In-place file editing
+	{
+		pattern: /^\s*sed\s+(-i|--in-place)/,
+		tool: "edit",
+		message: "Use the `edit` tool instead of sed -i. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: /^\s*perl\s+.*-[pn]?i/,
+		tool: "edit",
+		message: "Use the `edit` tool instead of perl -i. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: /^\s*awk\s+.*-i\s+inplace/,
+		tool: "edit",
+		message: "Use the `edit` tool instead of awk -i inplace. It provides diff preview and fuzzy matching.",
+	},
+	// File creation via redirection (but allow legitimate uses like piping)
+	{
+		pattern: /^\s*(echo|printf|cat\s*<<)\s+.*[^|]>\s*\S/,
+		tool: "write",
+		message: "Use the `write` tool instead of echo/cat redirection. It handles encoding and provides confirmation.",
+	},
+];
+
+/**
+ * Check if a bash command should be intercepted.
+ *
+ * @param command The bash command to check
+ * @param availableTools Set of tool names that are available
+ * @returns InterceptionResult indicating if the command should be blocked
+ */
+export function checkBashInterception(command: string, availableTools: Set<string>): InterceptionResult {
+	// Normalize command for pattern matching
+	const normalizedCommand = command.trim();
+
+	for (const { pattern, tool, message } of forbiddenPatterns) {
+		// Only block if the suggested tool is actually available
+		if (!availableTools.has(tool)) {
+			continue;
+		}
+
+		if (pattern.test(normalizedCommand)) {
+			return {
+				block: true,
+				message: `❌ Blocked: ${message}\n\nOriginal command: ${command}`,
+				suggestedTool: tool,
+			};
+		}
+	}
+
+	return { block: false };
+}
+
+/**
+ * Check if a command is a simple directory listing that should use `ls` tool.
+ * Only applies to bare `ls` without complex flags.
+ */
+export function checkSimpleLsInterception(command: string, availableTools: Set<string>): InterceptionResult {
+	if (!availableTools.has("ls")) {
+		return { block: false };
+	}
+
+	// Match simple ls commands (ls, ls -la, ls /path, etc.)
+	// Don't intercept complex pipes or commands
+	const simpleLsPattern = /^\s*ls(\s+(-[a-zA-Z]+\s*)*)?(\s+[^|;&]+)?\s*$/;
+
+	if (simpleLsPattern.test(command.trim())) {
+		return {
+			block: true,
+			message: `Use the \`ls\` tool instead of bash ls. It provides structured output.\n\nOriginal command: ${command}`,
+			suggestedTool: "ls",
+		};
+	}
+
+	return { block: false };
+}

package/src/core/tools/bash.ts

@@ -0,0 +1,91 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import bashDescription from "../../prompts/tools/bash.md" with { type: "text" };
+import { executeBash } from "../bash-executor";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
+
+const bashSchema = Type.Object({
+	command: Type.String({ description: "Bash command to execute" }),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+
+export interface BashToolDetails {
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+export function createBashTool(cwd: string): AgentTool<typeof bashSchema> {
+	return {
+		name: "bash",
+		label: "Bash",
+		description: bashDescription,
+		parameters: bashSchema,
+		execute: async (
+			_toolCallId: string,
+			{ command, timeout }: { command: string; timeout?: number },
+			signal?: AbortSignal,
+			onUpdate?,
+		) => {
+			// Track output for streaming updates
+			let currentOutput = "";
+
+			const result = await executeBash(command, {
+				cwd,
+				timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
+				signal,
+				onChunk: (chunk) => {
+					currentOutput += chunk;
+					if (onUpdate) {
+						const truncation = truncateTail(currentOutput);
+						onUpdate({
+							content: [{ type: "text", text: truncation.content || "" }],
+							details: {
+								truncation: truncation.truncated ? truncation : undefined,
+							},
+						});
+					}
+				},
+			});
+
+			// Handle errors
+			if (result.cancelled) {
+				throw new Error(result.output || "Command aborted");
+			}
+
+			// Apply tail truncation for final output
+			const truncation = truncateTail(result.output);
+			let outputText = truncation.content || "(no output)";
+
+			let details: BashToolDetails | undefined;
+
+			if (truncation.truncated) {
+				details = {
+					truncation,
+					fullOutputPath: result.fullOutputPath,
+				};
+
+				const startLine = truncation.totalLines - truncation.outputLines + 1;
+				const endLine = truncation.totalLines;
+
+				if (truncation.lastLinePartial) {
+					const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
+					outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
+				} else if (truncation.truncatedBy === "lines") {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
+				} else {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
+				}
+			}
+
+			if (result.exitCode !== 0 && result.exitCode !== undefined) {
+				outputText += `\n\nCommand exited with code ${result.exitCode}`;
+				throw new Error(outputText);
+			}
+
+			return { content: [{ type: "text", text: outputText }], details };
+		},
+	};
+}
+
+/** Default bash tool using process.cwd() - for backwards compatibility */
+export const bashTool = createBashTool(process.cwd());

package/src/core/tools/context.ts

@@ -0,0 +1,32 @@
+import type { AgentToolContext } from "@oh-my-pi/pi-agent-core";
+import type { CustomToolContext } from "../custom-tools/types";
+import type { HookUIContext } from "../hooks/types";
+
+declare module "@oh-my-pi/pi-agent-core" {
+	interface AgentToolContext extends CustomToolContext {
+		ui?: HookUIContext;
+		hasUI?: boolean;
+	}
+}
+
+export interface ToolContextStore {
+	getContext(): AgentToolContext;
+	setUIContext(uiContext: HookUIContext, hasUI: boolean): void;
+}
+
+export function createToolContextStore(getBaseContext: () => CustomToolContext): ToolContextStore {
+	let uiContext: HookUIContext | undefined;
+	let hasUI = false;
+
+	return {
+		getContext: () => ({
+			...getBaseContext(),
+			ui: uiContext,
+			hasUI,
+		}),
+		setUIContext: (context, uiAvailable) => {
+			uiContext = context;
+			hasUI = uiAvailable;
+		},
+	};
+}