@oh-my-pi/pi-coding-agent 3.20.1 → 3.24.0

package/src/core/tools/grep.ts

@@ -1,11 +1,27 @@
 import { readFileSync, type Stats, 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";
+import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import type { Subprocess } from "bun";
+import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import grepDescription from "../../prompts/tools/grep.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
+import type { RenderResultOptions } from "../custom-tools/types";
+import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
+import {
+	formatCount,
+	formatEmptyMessage,
+	formatErrorMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	formatScope,
+	formatTruncationSuffix,
+	PREVIEW_LIMITS,
+} from "./render-utils";
 import {
 	DEFAULT_MAX_BYTES,
 	formatSize,
@@ -64,7 +80,7 @@ export interface GrepToolDetails {
 	error?: string;
 }
 
-export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
+export function createGrepTool(session: ToolSession): AgentTool<typeof grepSchema> {
 	return {
 		name: "grep",
 		label: "Grep",
@@ -112,9 +128,9 @@ export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
 				throw new Error("ripgrep (rg) is not available and could not be downloaded");
 			}
 
-			const searchPath = resolveToCwd(searchDir || ".", cwd);
+			const searchPath = resolveToCwd(searchDir || ".", session.cwd);
 			const scopePath = (() => {
-				const relative = nodePath.relative(cwd, searchPath).replace(/\\/g, "/");
+				const relative = nodePath.relative(session.cwd, searchPath).replace(/\\/g, "/");
 				return relative.length === 0 ? "." : relative;
 			})();
 			let searchStat: Stats;
@@ -580,5 +596,169 @@ export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
 	};
 }
 
-/** Default grep tool using process.cwd() - for backwards compatibility */
-export const grepTool = createGrepTool(process.cwd());
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface GrepRenderArgs {
+	pattern: string;
+	path?: string;
+	glob?: string;
+	type?: string;
+	ignoreCase?: boolean;
+	caseSensitive?: boolean;
+	literal?: boolean;
+	multiline?: boolean;
+	context?: number;
+	limit?: number;
+	outputMode?: string;
+}
+
+const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
+
+export const grepToolRenderer = {
+	renderCall(args: GrepRenderArgs, uiTheme: Theme): Component {
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Grep"));
+		let text = `${label} ${uiTheme.fg("accent", args.pattern || "?")}`;
+
+		const meta: string[] = [];
+		if (args.path) meta.push(`in ${args.path}`);
+		if (args.glob) meta.push(`glob:${args.glob}`);
+		if (args.type) meta.push(`type:${args.type}`);
+		if (args.outputMode && args.outputMode !== "files_with_matches") meta.push(`mode:${args.outputMode}`);
+		if (args.caseSensitive) {
+			meta.push("case:sensitive");
+		} else if (args.ignoreCase) {
+			meta.push("case:insensitive");
+		}
+		if (args.literal) meta.push("literal");
+		if (args.multiline) meta.push("multiline");
+		if (args.context !== undefined) meta.push(`context:${args.context}`);
+		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
+
+		text += formatMeta(meta, uiTheme);
+
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+
+		if (details?.error) {
+			return new Text(formatErrorMessage(details.error, uiTheme), 0, 0);
+		}
+
+		const hasDetailedData = details?.matchCount !== undefined || details?.fileCount !== undefined;
+
+		if (!hasDetailedData) {
+			const textContent = result.content?.find((c) => c.type === "text")?.text;
+			if (!textContent || textContent === "No matches found") {
+				return new Text(formatEmptyMessage("No matches found", uiTheme), 0, 0);
+			}
+
+			const lines = textContent.split("\n").filter((line) => line.trim() !== "");
+			const maxLines = expanded ? lines.length : Math.min(lines.length, COLLAPSED_TEXT_LIMIT);
+			const displayLines = lines.slice(0, maxLines);
+			const remaining = lines.length - maxLines;
+			const hasMore = remaining > 0;
+
+			const icon = uiTheme.styledSymbol("status.success", "success");
+			const summary = formatCount("item", lines.length);
+			const expandHint = formatExpandHint(expanded, hasMore, uiTheme);
+			let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
+
+			for (let i = 0; i < displayLines.length; i++) {
+				const isLast = i === displayLines.length - 1 && remaining === 0;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("toolOutput", displayLines[i])}`;
+			}
+
+			if (remaining > 0) {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "item", uiTheme))}`;
+			}
+
+			return new Text(text, 0, 0);
+		}
+
+		const matchCount = details?.matchCount ?? 0;
+		const fileCount = details?.fileCount ?? 0;
+		const mode = details?.mode ?? "files_with_matches";
+		const truncated = details?.truncated ?? details?.truncation?.truncated ?? false;
+		const files = details?.files ?? [];
+
+		if (matchCount === 0) {
+			return new Text(formatEmptyMessage("No matches found", uiTheme), 0, 0);
+		}
+
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const summaryParts =
+			mode === "files_with_matches"
+				? [formatCount("file", fileCount)]
+				: [formatCount("match", matchCount), formatCount("file", fileCount)];
+		const summaryText = summaryParts.join(uiTheme.sep.dot);
+		const scopeLabel = formatScope(details?.scopePath, uiTheme);
+
+		const fileEntries: Array<{ path: string; count?: number }> = details?.fileMatches?.length
+			? details.fileMatches.map((entry) => ({ path: entry.path, count: entry.count }))
+			: files.map((path) => ({ path }));
+		const maxFiles = expanded ? fileEntries.length : Math.min(fileEntries.length, COLLAPSED_LIST_LIMIT);
+		const hasMoreFiles = fileEntries.length > maxFiles;
+		const expandHint = formatExpandHint(expanded, hasMoreFiles, uiTheme);
+
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${scopeLabel}${expandHint}`;
+
+		const truncationReasons: string[] = [];
+		if (details?.matchLimitReached) {
+			truncationReasons.push(`limit ${details.matchLimitReached} matches`);
+		}
+		if (details?.headLimitReached) {
+			truncationReasons.push(`head limit ${details.headLimitReached}`);
+		}
+		if (details?.truncation?.truncated) {
+			truncationReasons.push("size limit");
+		}
+		if (details?.linesTruncated) {
+			truncationReasons.push("line length");
+		}
+
+		const hasTruncation = truncationReasons.length > 0;
+
+		if (fileEntries.length > 0) {
+			for (let i = 0; i < maxFiles; i++) {
+				const entry = fileEntries[i];
+				const isLast = i === maxFiles - 1 && !hasMoreFiles && !hasTruncation;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				const isDir = entry.path.endsWith("/");
+				const entryPath = isDir ? entry.path.slice(0, -1) : entry.path;
+				const lang = isDir ? undefined : getLanguageFromPath(entryPath);
+				const entryIcon = isDir
+					? uiTheme.fg("accent", uiTheme.icon.folder)
+					: uiTheme.fg("muted", uiTheme.getLangIcon(lang));
+				const countLabel =
+					entry.count !== undefined
+						? ` ${uiTheme.fg("dim", `(${entry.count} match${entry.count !== 1 ? "es" : ""})`)}`
+						: "";
+				text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry.path)}${countLabel}`;
+			}
+
+			if (hasMoreFiles) {
+				const moreFilesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
+				text += `\n ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
+					"muted",
+					formatMoreItems(fileEntries.length - maxFiles, "file", uiTheme),
+				)}`;
+			}
+		}
+
+		if (hasTruncation) {
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

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

@@ -0,0 +1,180 @@
+import { describe, expect, it } from "bun:test";
+import { BUILTIN_TOOLS, createTools, HIDDEN_TOOLS, type ToolSession } from "./index";
+
+function createTestSession(overrides: Partial<ToolSession> = {}): ToolSession {
+	return {
+		cwd: "/tmp/test",
+		hasUI: false,
+		rulebookRules: [],
+		getSessionFile: () => null,
+		getSessionSpawns: () => "*",
+		...overrides,
+	};
+}
+
+describe("createTools", () => {
+	it("creates all builtin tools by default", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		// Core tools should always be present
+		expect(names).toContain("bash");
+		expect(names).toContain("read");
+		expect(names).toContain("edit");
+		expect(names).toContain("write");
+		expect(names).toContain("grep");
+		expect(names).toContain("find");
+		expect(names).toContain("ls");
+		expect(names).toContain("lsp");
+		expect(names).toContain("notebook");
+		expect(names).toContain("task");
+		expect(names).toContain("output");
+		expect(names).toContain("web_fetch");
+		expect(names).toContain("web_search");
+	});
+
+	it("respects requested tool subset", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session, ["read", "write"]);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toEqual(["read", "write"]);
+	});
+
+	it("includes hidden tools when explicitly requested", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session, ["report_finding"]);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toEqual(["report_finding"]);
+	});
+
+	it("excludes ask tool when hasUI is false", async () => {
+		const session = createTestSession({ hasUI: false });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("ask");
+	});
+
+	it("includes ask tool when hasUI is true", async () => {
+		const session = createTestSession({ hasUI: true });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("ask");
+	});
+
+	it("excludes rulebook tool when no rules provided", async () => {
+		const session = createTestSession({ rulebookRules: [] });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("rulebook");
+	});
+
+	it("includes rulebook tool when rules provided", async () => {
+		const session = createTestSession({
+			rulebookRules: [
+				{
+					path: "/test/rule.md",
+					name: "Test Rule",
+					content: "Test content",
+					description: "A test rule",
+					_source: { provider: "test", providerName: "Test", path: "/test", level: "project" },
+				},
+			],
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("rulebook");
+	});
+
+	it("excludes git tool when disabled in settings", async () => {
+		const session = createTestSession({
+			settings: {
+				getImageAutoResize: () => true,
+				getLspFormatOnWrite: () => true,
+				getLspDiagnosticsOnWrite: () => true,
+				getLspDiagnosticsOnEdit: () => false,
+				getEditFuzzyMatch: () => true,
+				getGitToolEnabled: () => false,
+				getBashInterceptorEnabled: () => true,
+			},
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).not.toContain("git");
+	});
+
+	it("includes git tool when enabled in settings", async () => {
+		const session = createTestSession({
+			settings: {
+				getImageAutoResize: () => true,
+				getLspFormatOnWrite: () => true,
+				getLspDiagnosticsOnWrite: () => true,
+				getLspDiagnosticsOnEdit: () => false,
+				getEditFuzzyMatch: () => true,
+				getGitToolEnabled: () => true,
+				getBashInterceptorEnabled: () => true,
+			},
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("git");
+	});
+
+	it("includes git tool when no settings provided (default enabled)", async () => {
+		const session = createTestSession({ settings: undefined });
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("git");
+	});
+
+	it("always includes output tool when task tool is present", async () => {
+		const session = createTestSession();
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		// Both should be present together
+		expect(names).toContain("task");
+		expect(names).toContain("output");
+	});
+
+	it("BUILTIN_TOOLS contains all expected tools", () => {
+		const expectedTools = [
+			"ask",
+			"bash",
+			"edit",
+			"find",
+			"git",
+			"grep",
+			"ls",
+			"lsp",
+			"notebook",
+			"output",
+			"read",
+			"rulebook",
+			"task",
+			"web_fetch",
+			"web_search",
+			"write",
+		];
+
+		for (const tool of expectedTools) {
+			expect(BUILTIN_TOOLS).toHaveProperty(tool);
+		}
+
+		// Ensure we haven't missed any
+		expect(Object.keys(BUILTIN_TOOLS).sort()).toEqual(expectedTools.sort());
+	});
+
+	it("HIDDEN_TOOLS contains review tools", () => {
+		expect(Object.keys(HIDDEN_TOOLS).sort()).toEqual(["report_finding", "submit_review"]);
+	});
+});