@oh-my-pi/pi-coding-agent 3.34.0 → 3.36.0

package/src/core/tools/bash.ts

@@ -14,6 +14,9 @@ import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } fr
 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)" })),
+	workdir: Type.Optional(
+		Type.String({ description: "Working directory for the command (default: current directory)" }),
+	),
 });
 
 export interface BashToolDetails {
@@ -29,7 +32,7 @@ export function createBashTool(session: ToolSession): AgentTool<typeof bashSchem
 		parameters: bashSchema,
 		execute: async (
 			_toolCallId: string,
-			{ command, timeout }: { command: string; timeout?: number },
+			{ command, timeout, workdir }: { command: string; timeout?: number; workdir?: string },
 			signal?: AbortSignal,
 			onUpdate?,
 			ctx?: AgentToolContext,
@@ -53,7 +56,7 @@ export function createBashTool(session: ToolSession): AgentTool<typeof bashSchem
 			let currentOutput = "";
 
 			const result = await executeBash(command, {
-				cwd: session.cwd,
+				cwd: workdir ?? session.cwd,
 				timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
 				signal,
 				onChunk: (chunk) => {
@@ -117,6 +120,7 @@ export function createBashTool(session: ToolSession): AgentTool<typeof bashSchem
 interface BashRenderArgs {
 	command?: string;
 	timeout?: number;
+	workdir?: string;
 }
 
 interface BashRenderContext {
@@ -132,7 +136,11 @@ export const bashToolRenderer = {
 	renderCall(args: BashRenderArgs, uiTheme: Theme): Component {
 		const ui = createToolUIKit(uiTheme);
 		const command = args.command || uiTheme.format.ellipsis;
-		const text = ui.title(`$ ${command}`);
+		const prompt = uiTheme.fg("accent", "$");
+		const cmdText = args.workdir
+			? `${prompt} ${uiTheme.fg("dim", `cd ${args.workdir} &&`)} ${command}`
+			: `${prompt} ${command}`;
+		const text = ui.title(cmdText);
 		return new Text(text, 0, 0);
 	},
 

package/src/core/tools/calculator.ts

@@ -0,0 +1,500 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import calculatorDescription from "../../prompts/tools/calculator.md" with { type: "text" };
+import type { RenderResultOptions } from "../custom-tools/types";
+import { untilAborted } from "../utils";
+import type { ToolSession } from "./index";
+import {
+	formatCount,
+	formatEmptyMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	PREVIEW_LIMITS,
+	TRUNCATE_LENGTHS,
+	truncate,
+} from "./render-utils";
+
+// =============================================================================
+// Token Types
+// =============================================================================
+
+/** Supported arithmetic operators (** is exponentiation). */
+type Operator = "+" | "-" | "*" | "/" | "%" | "**";
+
+/**
+ * Lexer token variants:
+ * - number: parsed numeric value with original string for error messages
+ * - operator: arithmetic operator
+ * - paren: grouping parenthesis
+ */
+type Token =
+	| { type: "number"; value: number; raw: string }
+	| { type: "operator"; value: Operator }
+	| { type: "paren"; value: "(" | ")" };
+
+const calculatorSchema = Type.Object({
+	calculations: Type.Array(
+		Type.Object({
+			expression: Type.String({ description: "Math expression to evaluate" }),
+			prefix: Type.String({ description: "Text to prepend to the result" }),
+			suffix: Type.String({ description: "Text to append to the result" }),
+		}),
+		{ description: "List of calculations to evaluate", minItems: 1 },
+	),
+});
+
+export interface CalculatorToolDetails {
+	results: Array<{ expression: string; value: number; output: string }>;
+}
+
+// =============================================================================
+// Character classification helpers for numeric literal parsing
+// =============================================================================
+
+function isDigit(ch: string): boolean {
+	return ch >= "0" && ch <= "9";
+}
+
+function isHexDigit(ch: string): boolean {
+	return (ch >= "0" && ch <= "9") || (ch >= "a" && ch <= "f") || (ch >= "A" && ch <= "F");
+}
+
+function isBinaryDigit(ch: string): boolean {
+	return ch === "0" || ch === "1";
+}
+
+function isOctalDigit(ch: string): boolean {
+	return ch >= "0" && ch <= "7";
+}
+
+// =============================================================================
+// Tokenizer
+// =============================================================================
+
+/**
+ * Tokenize a math expression into numbers, operators, and parentheses.
+ *
+ * Number formats supported:
+ * - Decimal: 123, 3.14, .5
+ * - Scientific: 1e10, 2.5E-3
+ * - Hexadecimal: 0xFF
+ * - Binary: 0b1010
+ * - Octal: 0o755
+ */
+function tokenizeExpression(expression: string): Token[] {
+	const tokens: Token[] = [];
+	let i = 0;
+
+	while (i < expression.length) {
+		const ch = expression[i];
+
+		// Skip whitespace
+		if (ch.trim() === "") {
+			i += 1;
+			continue;
+		}
+
+		if (ch === "(" || ch === ")") {
+			tokens.push({ type: "paren", value: ch });
+			i += 1;
+			continue;
+		}
+
+		// Check ** before single * to handle exponentiation
+		if (ch === "*" && expression[i + 1] === "*") {
+			tokens.push({ type: "operator", value: "**" });
+			i += 2;
+			continue;
+		}
+
+		if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%") {
+			tokens.push({ type: "operator", value: ch });
+			i += 1;
+			continue;
+		}
+
+		// Number parsing: starts with digit or decimal point followed by digit
+		const next = expression[i + 1];
+		const numberStart = isDigit(ch) || (ch === "." && next !== undefined && isDigit(next));
+		if (!numberStart) {
+			throw new Error(`Invalid character "${ch}" in expression`);
+		}
+
+		const start = i;
+
+		// Handle prefixed literals (0x, 0b, 0o)
+		if (ch === "0" && next !== undefined) {
+			const prefix = next.toLowerCase();
+			if (prefix === "x" || prefix === "b" || prefix === "o") {
+				i += 2; // Skip "0x" / "0b" / "0o"
+				let hasDigit = false;
+				while (i < expression.length) {
+					const digit = expression[i];
+					const valid =
+						prefix === "x" ? isHexDigit(digit) : prefix === "b" ? isBinaryDigit(digit) : isOctalDigit(digit);
+					if (!valid) break;
+					hasDigit = true;
+					i += 1;
+				}
+
+				if (!hasDigit) {
+					throw new Error(`Invalid numeric literal starting at "${expression.slice(start, i)}"`);
+				}
+
+				const raw = expression.slice(start, i);
+				const value = Number(raw); // JS Number() handles 0x/0b/0o natively
+				if (!Number.isFinite(value)) {
+					throw new Error(`Invalid number "${raw}"`);
+				}
+				tokens.push({ type: "number", value, raw });
+				continue;
+			}
+		}
+
+		// Parse decimal number: integer part
+		let hasDigits = false;
+		while (i < expression.length && isDigit(expression[i])) {
+			hasDigits = true;
+			i += 1;
+		}
+
+		// Fractional part
+		if (expression[i] === ".") {
+			i += 1;
+			while (i < expression.length && isDigit(expression[i])) {
+				hasDigits = true;
+				i += 1;
+			}
+		}
+
+		if (!hasDigits) {
+			throw new Error(`Invalid number starting at "${expression.slice(start, i + 1)}"`);
+		}
+
+		// Scientific notation exponent (e.g., 1e10, 2.5E-3)
+		if (expression[i] === "e" || expression[i] === "E") {
+			i += 1;
+			if (expression[i] === "+" || expression[i] === "-") {
+				i += 1;
+			}
+
+			let hasExponentDigits = false;
+			while (i < expression.length && isDigit(expression[i])) {
+				hasExponentDigits = true;
+				i += 1;
+			}
+
+			if (!hasExponentDigits) {
+				throw new Error(`Invalid exponent in "${expression.slice(start, i)}"`);
+			}
+		}
+
+		const raw = expression.slice(start, i);
+		const value = Number(raw);
+		if (!Number.isFinite(value)) {
+			throw new Error(`Invalid number "${raw}"`);
+		}
+		tokens.push({ type: "number", value, raw });
+	}
+
+	return tokens;
+}
+
+// =============================================================================
+// Recursive Descent Parser
+// =============================================================================
+
+/**
+ * Recursive descent parser for arithmetic expressions.
+ *
+ * Operator precedence (lowest to highest):
+ *   1. Addition, subtraction (+, -)
+ *   2. Multiplication, division, modulo (*, /, %)
+ *   3. Unary plus/minus (+x, -x)
+ *   4. Exponentiation (**)
+ *   5. Parentheses and literals
+ *
+ * Each precedence level has its own parse method. Lower precedence methods
+ * call higher precedence methods, building the AST implicitly through
+ * the call stack.
+ */
+class ExpressionParser {
+	private index = 0;
+
+	constructor(private readonly tokens: Token[]) {}
+
+	/** Parse the full expression and ensure all tokens are consumed. */
+	parse(): number {
+		const value = this.parseExpression();
+		if (this.index < this.tokens.length) {
+			throw new Error("Unexpected token in expression");
+		}
+		return value;
+	}
+
+	/**
+	 * Parse addition and subtraction (lowest precedence).
+	 * Left-associative: 1 - 2 - 3 = (1 - 2) - 3
+	 */
+	private parseExpression(): number {
+		let value = this.parseTerm();
+		while (true) {
+			if (this.matchOperator("+")) {
+				value += this.parseTerm();
+				continue;
+			}
+			if (this.matchOperator("-")) {
+				value -= this.parseTerm();
+				continue;
+			}
+			break;
+		}
+		return value;
+	}
+
+	/**
+	 * Parse multiplication, division, and modulo.
+	 * Left-associative: 8 / 4 / 2 = (8 / 4) / 2
+	 */
+	private parseTerm(): number {
+		let value = this.parseUnary();
+		while (true) {
+			if (this.matchOperator("*")) {
+				value *= this.parseUnary();
+				continue;
+			}
+			if (this.matchOperator("/")) {
+				value /= this.parseUnary();
+				continue;
+			}
+			if (this.matchOperator("%")) {
+				value %= this.parseUnary();
+				continue;
+			}
+			break;
+		}
+		return value;
+	}
+
+	/**
+	 * Parse unary + and - operators.
+	 * Recursive to handle chained unary: --x, +-x
+	 */
+	private parseUnary(): number {
+		if (this.matchOperator("+")) {
+			return this.parseUnary();
+		}
+		if (this.matchOperator("-")) {
+			return -this.parseUnary();
+		}
+		return this.parsePower();
+	}
+
+	/**
+	 * Parse exponentiation operator.
+	 * Right-associative: 2 ** 3 ** 2 = 2 ** (3 ** 2) = 512
+	 * Achieved by recursive call to parsePower for the right operand.
+	 */
+	private parsePower(): number {
+		let value = this.parsePrimary();
+		if (this.matchOperator("**")) {
+			value = value ** this.parsePower(); // Right-associative via recursion
+		}
+		return value;
+	}
+
+	/**
+	 * Parse primary expressions: number literals and parenthesized subexpressions.
+	 * Parentheses restart parsing at lowest precedence (parseExpression).
+	 */
+	private parsePrimary(): number {
+		const token = this.peek();
+		if (!token) {
+			throw new Error("Unexpected end of expression");
+		}
+
+		if (token.type === "number") {
+			this.index += 1;
+			return token.value;
+		}
+
+		if (token.type === "paren" && token.value === "(") {
+			this.index += 1;
+			const value = this.parseExpression(); // Reset to lowest precedence
+			if (!this.matchParen(")")) {
+				throw new Error("Missing closing parenthesis");
+			}
+			return value;
+		}
+
+		throw new Error("Unexpected token in expression");
+	}
+
+	/** Consume operator if it matches, advancing the token index. */
+	private matchOperator(value: Operator): boolean {
+		const token = this.tokens[this.index];
+		if (token && token.type === "operator" && token.value === value) {
+			this.index += 1;
+			return true;
+		}
+		return false;
+	}
+
+	/** Consume parenthesis if it matches, advancing the token index. */
+	private matchParen(value: "(" | ")"): boolean {
+		const token = this.tokens[this.index];
+		if (token && token.type === "paren" && token.value === value) {
+			this.index += 1;
+			return true;
+		}
+		return false;
+	}
+
+	/** Look at current token without consuming it. */
+	private peek(): Token | undefined {
+		return this.tokens[this.index];
+	}
+}
+
+// =============================================================================
+// Expression Evaluator
+// =============================================================================
+
+/**
+ * Evaluate a math expression string and return the numeric result.
+ *
+ * Pipeline: expression string -> tokens -> parse tree (implicit) -> value
+ *
+ * @throws Error on syntax errors, empty expressions, or non-finite results (Infinity, NaN)
+ */
+function evaluateExpression(expression: string): number {
+	const tokens = tokenizeExpression(expression);
+	if (tokens.length === 0) {
+		throw new Error("Expression is empty");
+	}
+	const parser = new ExpressionParser(tokens);
+	const value = parser.parse();
+	if (!Number.isFinite(value)) {
+		throw new Error("Expression result is not a finite number");
+	}
+	// Normalize -0 to 0 for consistent output
+	return Object.is(value, -0) ? 0 : value;
+}
+
+function formatResult(value: number): string {
+	return String(value);
+}
+
+export function createCalculatorTool(_session: ToolSession): AgentTool<typeof calculatorSchema> {
+	return {
+		name: "calc",
+		label: "Calc",
+		description: calculatorDescription,
+		parameters: calculatorSchema,
+		execute: async (
+			_toolCallId: string,
+			{ calculations }: { calculations: Array<{ expression: string; prefix: string; suffix: string }> },
+			signal?: AbortSignal,
+		) => {
+			return untilAborted(signal, async () => {
+				const results = calculations.map((calc) => {
+					const value = evaluateExpression(calc.expression);
+					const output = `${calc.prefix}${formatResult(value)}${calc.suffix}`;
+					return { expression: calc.expression, value, output };
+				});
+
+				const outputText = results.map((result) => result.output).join("\n");
+				return {
+					content: [{ type: "text", text: outputText }],
+					details: { results },
+				};
+			});
+		},
+	};
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface CalculatorRenderArgs {
+	calculations?: Array<{ expression: string; prefix?: string; suffix?: string }>;
+}
+
+const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+
+/**
+ * TUI renderer for calculator tool calls and results.
+ * Handles both collapsed (preview) and expanded (full) display modes.
+ */
+export const calculatorToolRenderer = {
+	/**
+	 * Render the tool call header showing the first expression and count.
+	 * Format: "Calc <expression> (N calcs)"
+	 */
+	renderCall(args: CalculatorRenderArgs, uiTheme: Theme): Component {
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Calc"));
+		const count = args.calculations?.length ?? 0;
+		const firstExpression = args.calculations?.[0]?.expression;
+		let text = label;
+		if (firstExpression) {
+			text += ` ${uiTheme.fg("accent", truncate(firstExpression, TRUNCATE_LENGTHS.TITLE, "..."))}`;
+		}
+		const meta: string[] = [];
+		if (count > 0) meta.push(formatCount("calc", count));
+		text += formatMeta(meta, uiTheme);
+		return new Text(text, 0, 0);
+	},
+
+	/**
+	 * Render calculation results as a tree list.
+	 * Collapsed mode shows first N items with expand hint; expanded shows all.
+	 */
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: CalculatorToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
+
+		// Prefer structured details; fall back to parsing text content
+		let outputs = details?.results?.map((entry) => entry.output) ?? [];
+		if (outputs.length === 0 && textContent.trim()) {
+			outputs = textContent.split("\n").filter((line) => line.trim().length > 0);
+		}
+
+		if (outputs.length === 0) {
+			return new Text(formatEmptyMessage("No results", uiTheme), 0, 0);
+		}
+
+		// Limit visible items in collapsed mode
+		const maxItems = expanded ? outputs.length : Math.min(outputs.length, COLLAPSED_LIST_LIMIT);
+		const hasMore = outputs.length > maxItems;
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const summary = uiTheme.fg("dim", formatCount("result", outputs.length));
+		const expandHint = formatExpandHint(expanded, hasMore, uiTheme);
+		let text = `${icon} ${summary}${expandHint}`;
+
+		// Render each result as a tree branch
+		for (let i = 0; i < maxItems; i += 1) {
+			const isLast = i === maxItems - 1 && !hasMore;
+			const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+			text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("toolOutput", outputs[i])}`;
+		}
+
+		// Show overflow indicator for collapsed mode
+		if (hasMore) {
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+				"muted",
+				formatMoreItems(outputs.length - maxItems, "result", uiTheme),
+			)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

package/src/core/tools/edit.ts

@@ -229,6 +229,7 @@ function formatMetadataLine(lineCount: number | null, language: string | undefin
 }
 
 export const editToolRenderer = {
+	mergeCallAndResult: true,
 	renderCall(args: EditRenderArgs, uiTheme: Theme): Component {
 		const ui = createToolUIKit(uiTheme);
 		const rawPath = args.file_path || args.path || "";

package/src/core/tools/grep.ts

@@ -196,7 +196,7 @@ export function createGrepTool(session: ToolSession): AgentTool<typeof grepSchem
 					args.push("--type", type);
 				}
 
-				args.push(pattern, searchPath);
+				args.push("--", pattern, searchPath);
 
 				const child: Subprocess = Bun.spawn([rgPath, ...args], {
 					stdin: "ignore",

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

@@ -20,6 +20,7 @@ describe("createTools", () => {
 
 		// Core tools should always be present
 		expect(names).toContain("bash");
+		expect(names).toContain("calc");
 		expect(names).toContain("read");
 		expect(names).toContain("edit");
 		expect(names).toContain("write");
@@ -162,6 +163,7 @@ describe("createTools", () => {
 		const expectedTools = [
 			"ask",
 			"bash",
+			"calc",
 			"ssh",
 			"edit",
 			"find",

package/src/core/tools/index.ts

@@ -1,5 +1,6 @@
 export { type AskToolDetails, askTool, createAskTool } from "./ask";
 export { type BashToolDetails, createBashTool } from "./bash";
+export { type CalculatorToolDetails, createCalculatorTool } from "./calculator";
 export { createCompleteTool } from "./complete";
 export { createEditTool } from "./edit";
 // Exa MCP tools (22 tools)
@@ -57,6 +58,7 @@ import type { EventBus } from "../event-bus";
 import type { BashInterceptorRule } from "../settings-manager";
 import { createAskTool } from "./ask";
 import { createBashTool } from "./bash";
+import { createCalculatorTool } from "./calculator";
 import { createCompleteTool } from "./complete";
 import { createEditTool } from "./edit";
 import { createFindTool } from "./find";
@@ -98,6 +100,8 @@ export interface ToolSession {
 	getSessionSpawns: () => string | null;
 	/** Get resolved model string if explicitly set for this session */
 	getModelString?: () => string | undefined;
+	/** Get the current session model string, regardless of how it was chosen */
+	getActiveModelString?: () => string | undefined;
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
@@ -117,6 +121,7 @@ type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ask: createAskTool,
 	bash: createBashTool,
+	calc: createCalculatorTool,
 	ssh: createSshTool,
 	edit: createEditTool,
 	find: createFindTool,

package/src/core/tools/renderers.ts

@@ -9,6 +9,7 @@ import type { Theme } from "../../modes/interactive/theme/theme";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { askToolRenderer } from "./ask";
 import { bashToolRenderer } from "./bash";
+import { calculatorToolRenderer } from "./calculator";
 import { editToolRenderer } from "./edit";
 import { findToolRenderer } from "./find";
 import { grepToolRenderer } from "./grep";
@@ -31,11 +32,13 @@ type ToolRenderer = {
 		theme: Theme,
 		args?: unknown,
 	) => Component;
+	mergeCallAndResult?: boolean;
 };
 
 export const toolRenderers: Record<string, ToolRenderer> = {
 	ask: askToolRenderer as ToolRenderer,
 	bash: bashToolRenderer as ToolRenderer,
+	calc: calculatorToolRenderer as ToolRenderer,
 	edit: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,
 	grep: grepToolRenderer as ToolRenderer,

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

@@ -135,7 +135,12 @@ export async function createTaskTool(
 			const startTime = Date.now();
 			const { agents, projectAgentsDir } = await discoverAgents(session.cwd);
 			const { agent: agentName, context, model, output: outputSchema } = params;
-			const modelOverride = model ?? session.getModelString?.();
+
+			const isDefaultModelAlias = (value: string | undefined): boolean => {
+				if (!value) return true;
+				const normalized = value.trim().toLowerCase();
+				return normalized === "default" || normalized === "pi/default" || normalized === "omp/default";
+			};
 
 			// Validate agent exists
 			const agent = getAgent(agents, agentName);
@@ -156,6 +161,10 @@ export async function createTaskTool(
 				};
 			}
 
+			const shouldInheritSessionModel = model === undefined && isDefaultModelAlias(agent.model);
+			const sessionModel = shouldInheritSessionModel ? session.getActiveModelString?.() : undefined;
+			const modelOverride = model ?? sessionModel ?? session.getModelString?.();
+
 			// Handle empty or missing tasks
 			if (!params.tasks || params.tasks.length === 0) {
 				return {

package/src/core/tools/task/model-resolver.ts

@@ -8,7 +8,7 @@
  *   - Fuzzy match: "opus" → "p-anthropic/claude-opus-4-5"
  *   - Comma fallback: "gpt, opus" → tries gpt first, then opus
  *   - "default" → undefined (use system default)
- *   - "omp/slow" → configured slow model from settings
+ *   - "omp/slow" or "pi/slow" → configured slow model from settings
  */
 
 import { type Settings, settingsCapability } from "../../../capability/settings";
@@ -145,9 +145,10 @@ export function resolveModelPattern(pattern: string | undefined, availableModels
 		.filter(Boolean);
 
 	for (const p of patterns) {
-		// Handle omp/<role> aliases - looks up role in settings.modelRoles
-		if (p.toLowerCase().startsWith("omp/")) {
-			const role = p.slice(4); // Remove "omp/" prefix
+		// Handle omp/<role> or pi/<role> aliases - looks up role in settings.modelRoles
+		const lower = p.toLowerCase();
+		if (lower.startsWith("omp/") || lower.startsWith("pi/")) {
+			const role = lower.startsWith("omp/") ? p.slice(4) : p.slice(3);
 			const resolved = resolveOmpAlias(role, models);
 			if (resolved) return resolved;
 			continue; // Role not configured, try next pattern