@agnishc/edb-compact-tools 0.10.6 → 0.10.9

package/src/message-frame.ts

@@ -0,0 +1,73 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+	ASSISTANT_MESSAGE_EMOJIS,
+	OSC133_ZONE_END,
+	OSC133_ZONE_FINAL,
+	OSC133_ZONE_START,
+	USER_MESSAGE_EMOJIS,
+} from "./constants.js";
+import type { CompactTheme } from "./types.js";
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+export function padVisible(text: string, width: number): string {
+	const clipped = truncateToWidth(text, width, "");
+	return `${clipped}${" ".repeat(Math.max(0, width - visibleWidth(clipped)))}`;
+}
+
+export function stripUserZoneMarkers(line: string): string {
+	return line.replaceAll(OSC133_ZONE_START, "").replaceAll(OSC133_ZONE_END, "").replaceAll(OSC133_ZONE_FINAL, "");
+}
+
+export function randomUserMessageMarker(): string {
+	return USER_MESSAGE_EMOJIS[Math.floor(Math.random() * USER_MESSAGE_EMOJIS.length)] ?? "✨";
+}
+
+export function randomAssistantMessageMarker(): string {
+	return ASSISTANT_MESSAGE_EMOJIS[Math.floor(Math.random() * ASSISTANT_MESSAGE_EMOJIS.length)] ?? "🤖";
+}
+
+export function trimVisualBlankLines(lines: string[]): string[] {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && stripUserZoneMarkers(lines[start] ?? "").trim() === "") start++;
+	while (end > start && stripUserZoneMarkers(lines[end - 1] ?? "").trim() === "") end--;
+	return lines.slice(start, end);
+}
+
+// ── Framing ──────────────────────────────────────────────────────
+
+export function frameMessage(
+	lines: string[],
+	width: number,
+	theme: CompactTheme,
+	markerText: string,
+	borderColor: string,
+	markerColor: string,
+): string[] {
+	if (width < 6) return lines;
+	const innerWidth = Math.max(1, width - 2);
+	const border = (text: string) => theme.fg(borderColor, text);
+	const marker = theme.fg(markerColor, markerText);
+	const topFill = Math.max(0, innerWidth - visibleWidth(marker) - 2);
+	const top = `${border("╭─")} ${marker}${border("─".repeat(topFill))}${border("╮")}`;
+	const body = trimVisualBlankLines(lines).map(
+		(line) => `${border("│")}${padVisible(stripUserZoneMarkers(line).trimEnd(), innerWidth)}${border("│")}`,
+	);
+	const bottom = `${border("╰")}${border("─".repeat(innerWidth))}${border("╯")}`;
+	return [`${OSC133_ZONE_START}${top}`, ...body, `${OSC133_ZONE_END}${OSC133_ZONE_FINAL}${bottom}`, ""];
+}
+
+export function frameUserMessage(lines: string[], width: number, theme: CompactTheme, markerText: string): string[] {
+	return frameMessage(lines, width, theme, markerText, "accent", "error");
+}
+
+export function frameAssistantMessage(
+	lines: string[],
+	width: number,
+	theme: CompactTheme,
+	markerText?: string,
+): string[] {
+	const marker = markerText ?? randomAssistantMessageMarker();
+	return frameMessage(lines, width, theme, marker, "border", "toolTitle");
+}

package/src/patches.ts

@@ -0,0 +1,170 @@
+import {
+	AssistantMessageComponent,
+	type ExtensionAPI,
+	ToolExecutionComponent,
+	UserMessageComponent,
+} from "@earendil-works/pi-coding-agent";
+import {
+	ASSISTANT_MESSAGE_MARKER_SYMBOL,
+	ASSISTANT_MESSAGE_PATCH_SYMBOL,
+	TOOL_EXECUTION_PATCH_SYMBOL,
+	USER_MESSAGE_MARKER_SYMBOL,
+	USER_MESSAGE_PATCH_SYMBOL,
+} from "./constants.js";
+import {
+	frameAssistantMessage,
+	frameUserMessage,
+	randomAssistantMessageMarker,
+	randomUserMessageMarker,
+} from "./message-frame.js";
+import { renderCall, renderResult } from "./tool-renderer.js";
+import type { BuiltinTool, BuiltinToolName, CompactTheme } from "./types.js";
+
+// ── Shared state ─────────────────────────────────────────────────
+
+let activeTheme: CompactTheme | undefined;
+
+function fallbackTheme(): CompactTheme {
+	return {
+		fg: (_color: any, text: string) => text,
+		bg: (_color: any, text: string) => text,
+		bold: (text: string) => text,
+	};
+}
+
+// ── Generic tool renderer patch ──────────────────────────────────
+
+export function installGenericToolRendererPatch(pi: ExtensionAPI): void {
+	const proto = ToolExecutionComponent?.prototype as any;
+	if (!proto || proto[TOOL_EXECUTION_PATCH_SYMBOL]) return;
+	const originalGetCallRenderer = proto.getCallRenderer;
+	const originalGetResultRenderer = proto.getResultRenderer;
+	const originalGetRenderShell = proto.getRenderShell;
+	if (
+		typeof originalGetCallRenderer !== "function" ||
+		typeof originalGetResultRenderer !== "function" ||
+		typeof originalGetRenderShell !== "function"
+	) {
+		return;
+	}
+
+	proto.getCallRenderer = function compactFallbackCallRenderer(this: any) {
+		const toolName = typeof this?.toolName === "string" ? this.toolName : "tool";
+		return (args: any, theme: CompactTheme, context: any) => renderCall(toolName, args, theme, context);
+	};
+
+	proto.getResultRenderer = function compactFallbackResultRenderer(this: any) {
+		const toolName = typeof this?.toolName === "string" ? this.toolName : "tool";
+		return (result: any, options: any, theme: CompactTheme, context: any) =>
+			renderResult(toolName, result, options, theme, context);
+	};
+
+	proto.getRenderShell = function compactFallbackRenderShell(this: any) {
+		return "self";
+	};
+
+	proto[TOOL_EXECUTION_PATCH_SYMBOL] = { originalGetCallRenderer, originalGetResultRenderer, originalGetRenderShell };
+	pi.on("session_shutdown", () => {
+		const state = proto[TOOL_EXECUTION_PATCH_SYMBOL];
+		if (!state) return;
+		proto.getCallRenderer = state.originalGetCallRenderer;
+		proto.getResultRenderer = state.originalGetResultRenderer;
+		proto.getRenderShell = state.originalGetRenderShell;
+		delete proto[TOOL_EXECUTION_PATCH_SYMBOL];
+	});
+}
+
+// ── Message renderer patches ─────────────────────────────────────
+
+export function installMessageRenderers(pi: ExtensionAPI): void {
+	const userProto = UserMessageComponent?.prototype as any;
+	if (userProto && !userProto[USER_MESSAGE_PATCH_SYMBOL] && typeof userProto.render === "function") {
+		const originalRender = userProto.render as (width: number) => string[];
+		userProto.render = function compactUserMessageRender(this: any, width: number): string[] {
+			const box = this?.contentBox;
+			if (box) {
+				box.paddingY = 0;
+				box.setBgFn?.(undefined);
+				box.invalidate?.();
+			}
+			const frameWidth = Math.max(1, width - 1);
+			if (!this[USER_MESSAGE_MARKER_SYMBOL]) this[USER_MESSAGE_MARKER_SYMBOL] = randomUserMessageMarker();
+			const rendered = originalRender.call(this, Math.max(1, frameWidth - 2));
+			return frameUserMessage(
+				rendered,
+				frameWidth,
+				activeTheme ?? fallbackTheme(),
+				this[USER_MESSAGE_MARKER_SYMBOL],
+			);
+		};
+		userProto[USER_MESSAGE_PATCH_SYMBOL] = { originalRender };
+	}
+
+	const assistantProto = AssistantMessageComponent?.prototype as any;
+	if (
+		assistantProto &&
+		!assistantProto[ASSISTANT_MESSAGE_PATCH_SYMBOL] &&
+		typeof assistantProto.render === "function"
+	) {
+		const originalRender = assistantProto.render as (width: number) => string[];
+		assistantProto.render = function compactAssistantMessageRender(this: any, width: number): string[] {
+			const rendered = originalRender.call(this, Math.max(1, width - 3));
+			if (this?.hasToolCalls || rendered.length === 0) return rendered;
+			const frameWidth = Math.max(1, width - 1);
+			if (!this[ASSISTANT_MESSAGE_MARKER_SYMBOL])
+				this[ASSISTANT_MESSAGE_MARKER_SYMBOL] = randomAssistantMessageMarker();
+			return frameAssistantMessage(
+				rendered,
+				frameWidth,
+				activeTheme ?? fallbackTheme(),
+				this[ASSISTANT_MESSAGE_MARKER_SYMBOL],
+			);
+		};
+		assistantProto[ASSISTANT_MESSAGE_PATCH_SYMBOL] = { originalRender };
+	}
+
+	pi.on("session_start", (_event, ctx) => {
+		if (ctx.hasUI) activeTheme = ctx.ui.theme as unknown as CompactTheme;
+	});
+	pi.on("session_shutdown", () => {
+		const userState = userProto?.[USER_MESSAGE_PATCH_SYMBOL];
+		if (userState) {
+			userProto.render = userState.originalRender;
+			delete userProto[USER_MESSAGE_PATCH_SYMBOL];
+		}
+		const assistantState = assistantProto?.[ASSISTANT_MESSAGE_PATCH_SYMBOL];
+		if (assistantState) {
+			assistantProto.render = assistantState.originalRender;
+			delete assistantProto[ASSISTANT_MESSAGE_PATCH_SYMBOL];
+		}
+		activeTheme = undefined;
+	});
+}
+
+// ── Delegating tool registration ─────────────────────────────────
+
+export function registerDelegatingTool(
+	pi: ExtensionAPI,
+	name: BuiltinToolName,
+	createTool: (cwd: string) => BuiltinTool,
+): void {
+	const cwd = process.cwd();
+	const original = createTool(cwd);
+	pi.registerTool({
+		name,
+		label: name,
+		description: original.description,
+		promptSnippet: (original as any).promptSnippet,
+		parameters: original.parameters as any,
+		renderShell: "self",
+		async execute(id: string, params: unknown, signal?: AbortSignal, onUpdate?: unknown, ctx?: any) {
+			return createTool(ctx?.cwd ?? cwd).execute(id, params, signal, onUpdate, ctx) as any;
+		},
+		renderCall(args: any, theme: CompactTheme, context: any) {
+			return renderCall(name, args, theme, context);
+		},
+		renderResult(result: any, options: any, theme: CompactTheme, context: any) {
+			return renderResult(name, result, options, theme, context);
+		},
+	} as any);
+}

package/src/text.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { clip, lineCount, oneLine, outputWasTruncated, previewLines, textContent } from "./text.js";
+
+describe("oneLine", () => {
+	it("collapses whitespace", () => {
+		expect(oneLine("hello   world")).toBe("hello world");
+	});
+
+	it("trims edges", () => {
+		expect(oneLine("  hello  ")).toBe("hello");
+	});
+
+	it("handles null and undefined as empty string", () => {
+		expect(oneLine(null)).toBe("");
+		expect(oneLine(undefined)).toBe("");
+	});
+});
+
+describe("clip", () => {
+	it("passes through short text", () => {
+		expect(clip("hello")).toBe("hello");
+	});
+
+	it("truncates long text with ellipsis", () => {
+		expect(clip("a".repeat(150))).toBe(`${"a".repeat(119)}…`);
+	});
+
+	it("respects custom max", () => {
+		expect(clip("hello world", 5)).toBe("hell…");
+	});
+
+	it("handles empty string", () => {
+		expect(clip("")).toBe("");
+	});
+});
+
+describe("lineCount", () => {
+	it("counts lines", () => {
+		expect(lineCount("a\nb\nc")).toBe(3);
+	});
+
+	it("handles CRLF", () => {
+		expect(lineCount("a\r\nb\r\nc")).toBe(3);
+	});
+
+	it("returns 0 for empty", () => {
+		expect(lineCount("")).toBe(0);
+	});
+});
+
+describe("textContent", () => {
+	it("extracts text from content array", () => {
+		const result = {
+			content: [
+				{ type: "text", text: "hello" },
+				{ type: "text", text: "world" },
+			],
+		};
+		expect(textContent(result)).toBe("hello\nworld");
+	});
+
+	it("filters non-text items", () => {
+		const result = {
+			content: [
+				{ type: "text", text: "hello" },
+				{ type: "image", text: "world" },
+			],
+		};
+		expect(textContent(result)).toBe("hello");
+	});
+
+	it("handles missing content", () => {
+		expect(textContent({})).toBe("");
+		expect(textContent(null)).toBe("");
+	});
+
+	it("joins multiple text items", () => {
+		const result = {
+			content: [
+				{ type: "text", text: "line1" },
+				{ type: "text", text: "line2" },
+			],
+		};
+		expect(textContent(result)).toBe("line1\nline2");
+	});
+});
+
+describe("outputWasTruncated", () => {
+	it("detects truncation markers", () => {
+		expect(outputWasTruncated("Output truncated")).toBe(true);
+		expect(outputWasTruncated("Full output saved to: /tmp/out.txt")).toBe(true);
+	});
+
+	it("is case-insensitive", () => {
+		expect(outputWasTruncated("TRUNCATED")).toBe(true);
+	});
+
+	it("returns false for clean output", () => {
+		expect(outputWasTruncated("hello world")).toBe(false);
+	});
+});
+
+describe("previewLines", () => {
+	it("takes head lines by default", () => {
+		const lines = "a\nb\nc\nd\ne".split("\n");
+		const text = lines.join("\n");
+		expect(previewLines(text, "head")).toEqual(["a", "b", "c", "d", "e"]);
+	});
+
+	it("takes tail lines when mode is tail", () => {
+		const text = "a\nb\nc\nd\ne";
+		expect(previewLines(text, "tail", 3)).toEqual(["c", "d", "e"]);
+	});
+
+	it("respects limit", () => {
+		const text = "a\nb\nc\nd\ne";
+		expect(previewLines(text, "head", 3)).toEqual(["a", "b", "c"]);
+	});
+
+	it("clips long lines", () => {
+		const text = "a".repeat(200);
+		expect(previewLines(text, "head", 1)[0]!.length).toBeLessThanOrEqual(121);
+	});
+});

package/src/text.ts

@@ -0,0 +1,34 @@
+import { MAX_COLLAPSED_TEXT, MAX_EXPANDED_LINES, MAX_LINE_CHARS } from "./constants.js";
+
+export function oneLine(value: unknown): string {
+	return String(value ?? "")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+export function clip(text: string, max = MAX_COLLAPSED_TEXT): string {
+	return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text;
+}
+
+export function lineCount(text: string): number {
+	if (!text) return 0;
+	return text.split(/\r?\n/).length;
+}
+
+export function textContent(result: any): string {
+	const content = Array.isArray(result?.content) ? result.content : [];
+	return content
+		.filter((item: any) => item?.type === "text" && typeof item.text === "string")
+		.map((item: any) => item.text)
+		.join("\n");
+}
+
+export function outputWasTruncated(text: string): boolean {
+	return /\btruncated\b|Full output saved to:/i.test(text);
+}
+
+export function previewLines(text: string, mode: "head" | "tail", limit = MAX_EXPANDED_LINES): string[] {
+	const lines = text.replace(/\s+$/g, "").split(/\r?\n/);
+	const selected = mode === "tail" ? lines.slice(-limit) : lines.slice(0, limit);
+	return selected.map((line) => clip(line, MAX_LINE_CHARS));
+}

package/src/tool-block.ts

@@ -0,0 +1,64 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { CompactTheme, ToolBlockKind } from "./types.js";
+
+export class EmptyBlock {
+	render(): string[] {
+		return [];
+	}
+	invalidate(): void {}
+}
+
+export class ToolBlock {
+	constructor(
+		private readonly kind: ToolBlockKind,
+		private readonly lines: string[],
+		private readonly theme: CompactTheme,
+		private readonly colorFn: (text: string) => string,
+	) {}
+
+	render(width: number): string[] {
+		const renderWidth = Math.max(8, width - 1);
+		const separator = this.theme.fg("borderMuted", "─".repeat(Math.max(8, Math.min(32, renderWidth))));
+		const block = this.lines.map((line, index) => {
+			if (this.kind === "call") return this.renderTop(line, renderWidth);
+			if (this.kind === "full" && index === 0) return this.renderTop(line, renderWidth);
+			const isLast = index === this.lines.length - 1;
+			return isLast ? this.renderBottom(line, renderWidth) : this.renderBody(line, renderWidth);
+		});
+		return [separator, "", ...block, ""];
+	}
+
+	invalidate(): void {}
+
+	private color(text: string): string {
+		return this.colorFn(text);
+	}
+
+	private fit(text: string, width: number): string {
+		const clipped = truncateToWidth(text, Math.max(1, width), "");
+		return `${clipped}${" ".repeat(Math.max(0, width - visibleWidth(clipped)))}`;
+	}
+
+	private renderTop(content: string, width: number): string {
+		const prefix = this.color("╭─ ");
+		const suffix = this.color("╮");
+		const innerWidth = Math.max(1, width - 4);
+		const fitted = truncateToWidth(content, innerWidth, "");
+		const fill = this.color("─".repeat(Math.max(0, innerWidth - visibleWidth(fitted))));
+		return `${prefix}${fitted}${fill}${suffix}`;
+	}
+
+	private renderBody(content: string, width: number): string {
+		const innerWidth = Math.max(1, width - 2);
+		return `${this.color("│")}${this.fit(content, innerWidth)}${this.color("│")}`;
+	}
+
+	private renderBottom(content: string, width: number): string {
+		const prefix = this.color("╰─ ");
+		const suffix = this.color("╯");
+		const innerWidth = Math.max(1, width - 4);
+		const fitted = truncateToWidth(content, innerWidth, "");
+		const fill = this.color("─".repeat(Math.max(0, innerWidth - visibleWidth(fitted))));
+		return `${prefix}${fitted}${fill}${suffix}`;
+	}
+}

package/src/tool-meta.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it } from "vitest";
+import { callLabel, isSkillPath, purple, summaryFor, toolColor, toolIcon } from "./tool-meta.js";
+
+describe("isSkillPath", () => {
+	it("detects .agents/skills paths", () => {
+		expect(isSkillPath(".agents/skills/my-skill/SKILL.md")).toBe(true);
+	});
+
+	it("detects .pi/agent/skills paths", () => {
+		expect(isSkillPath(".pi/agent/skills/my-skill/SKILL.md")).toBe(true);
+	});
+
+	it("returns false for regular paths", () => {
+		expect(isSkillPath("/Users/foo/project/src/index.ts")).toBe(false);
+	});
+
+	it("returns false for non-string inputs", () => {
+		expect(isSkillPath(null)).toBe(false);
+		expect(isSkillPath(undefined)).toBe(false);
+		expect(isSkillPath(123)).toBe(false);
+	});
+});
+
+describe("purple", () => {
+	it("wraps text with ANSI purple codes", () => {
+		const result = purple("hello");
+		expect(result).toContain("hello");
+		expect(result).toContain("\x1b[38;5;141m");
+		expect(result).toContain("\x1b[0m");
+	});
+});
+
+describe("toolColor", () => {
+	it("returns bashMode for bash", () => {
+		expect(toolColor("bash")).toBe("bashMode");
+	});
+
+	it("returns toolTitle for read (non-skill)", () => {
+		expect(toolColor("read", { path: "/tmp/foo.ts" })).toBe("toolTitle");
+	});
+
+	it("returns purple for read (skill file)", () => {
+		expect(toolColor("read", { path: ".agents/skills/my-skill/SKILL.md" })).toBe("purple");
+	});
+
+	it("returns success for grep", () => {
+		expect(toolColor("grep")).toBe("success");
+	});
+
+	it("returns accent for find", () => {
+		expect(toolColor("find")).toBe("accent");
+	});
+
+	it("returns warning for ls", () => {
+		expect(toolColor("ls")).toBe("warning");
+	});
+
+	it("returns toolDiffAdded for edit", () => {
+		expect(toolColor("edit")).toBe("toolDiffAdded");
+	});
+
+	it("returns accent for write", () => {
+		expect(toolColor("write")).toBe("accent");
+	});
+
+	it("returns accent for unknown tools", () => {
+		expect(toolColor("unknown_tool")).toBe("accent");
+	});
+});
+
+describe("toolIcon", () => {
+	it("returns correct icon per tool", () => {
+		expect(toolIcon("bash")).toBe("⚙️");
+		expect(toolIcon("read")).toBe("📖");
+		expect(toolIcon("grep")).toBe("🔎");
+		expect(toolIcon("find")).toBe("🧭");
+		expect(toolIcon("ls")).toBe("📁");
+		expect(toolIcon("edit")).toBe("✏️");
+		expect(toolIcon("write")).toBe("📝");
+	});
+
+	it("returns default icon for unknown tools", () => {
+		expect(toolIcon("unknown")).toBe("🧩");
+	});
+});
+
+describe("callLabel", () => {
+	it("returns clipped command for bash", () => {
+		expect(callLabel("bash", { command: "ls -la" })).toBe("ls -la");
+	});
+
+	it("truncates long bash commands", () => {
+		const long = `echo ${"x".repeat(150)}`;
+		const result = callLabel("bash", { command: long });
+		expect(result.length).toBeLessThanOrEqual(143);
+		expect(result.endsWith("…")).toBe(true);
+	});
+
+	it("returns clipped path for read", () => {
+		expect(callLabel("read", { path: "/tmp/foo.ts" })).toBe("/tmp/foo.ts");
+	});
+
+	it("formats grep with path", () => {
+		expect(callLabel("grep", { pattern: "TODO", path: "/src" })).toBe("TODO in /src");
+	});
+
+	it("returns default for grep without path", () => {
+		expect(callLabel("grep", { pattern: "TODO" })).toBe("TODO in .");
+	});
+
+	it("formats find with path", () => {
+		expect(callLabel("find", { path: "/tmp" })).toBe("/tmp");
+	});
+
+	it("formats edit with replacement count", () => {
+		expect(callLabel("edit", { path: "foo.ts", edits: [{}, {}] })).toBe("foo.ts · 2 replacements");
+	});
+
+	it("formats write with bytes", () => {
+		expect(callLabel("write", { path: "foo.ts", content: "hello world" })).toBe("foo.ts · 11 bytes");
+	});
+});
+
+describe("summaryFor", () => {
+	it("formats bash exit code", () => {
+		const result = { content: [{ type: "text", text: "hello\nexit 0" }] };
+		expect(summaryFor("bash", result)).toMatch(/exit 0/);
+	});
+
+	it("shows truncated marker when output was truncated", () => {
+		const result = { content: [{ type: "text", text: "hello\nOutput truncated" }] };
+		expect(summaryFor("bash", result)).toContain("truncated");
+	});
+
+	it("formats read line count", () => {
+		const result = { content: [{ type: "text", text: "line1\nline2\nline3" }] };
+		expect(summaryFor("read", result)).toBe("3 lines");
+	});
+
+	it("formats single line as singular", () => {
+		const result = { content: [{ type: "text", text: "line1" }] };
+		expect(summaryFor("read", result)).toBe("1 line");
+	});
+
+	it("formats ls item count", () => {
+		const result = { content: [{ type: "text", text: "file1\nfile2" }] };
+		expect(summaryFor("ls", result)).toBe("2 items");
+	});
+
+	it("formats edit diff stats", () => {
+		const result = {
+			content: [{ type: "text", text: "done" }],
+			details: { diff: "@@ -1,3 +1,4 @@\n+added1\n+added2\n-removed1\n-removed2" },
+		};
+		expect(summaryFor("edit", result)).toBe("+2 -2");
+	});
+
+	it("falls back to line count for edit without diff", () => {
+		const result = { content: [{ type: "text", text: "a\nb" }] };
+		expect(summaryFor("edit", result)).toBe("2 lines");
+	});
+
+	it("formats write line count", () => {
+		const result = { content: [{ type: "text", text: "line1\nline2" }] };
+		expect(summaryFor("write", result)).toBe("2 lines");
+	});
+
+	it("formats grep result count", () => {
+		const result = { content: [{ type: "text", text: "match1\nmatch2\nmatch3" }] };
+		expect(summaryFor("grep", result)).toBe("3 results");
+	});
+
+	it("formats find result count", () => {
+		const result = { content: [{ type: "text", text: "file1\nfile2\nfile3\nfile4" }] };
+		expect(summaryFor("find", result)).toBe("4 results");
+	});
+
+	it("returns '1 result' for single result", () => {
+		const result = { content: [{ type: "text", text: "only" }] };
+		expect(summaryFor("grep", result)).toBe("1 result");
+	});
+});