@nghyane/arcane 0.1.13 → 0.1.15

package/src/tools/read.ts

@@ -8,11 +8,8 @@ import { Text } from "@nghyane/arcane-tui";
 import { ptree, untilAborted } from "@nghyane/arcane-utils";
 import { getRemoteDir } from "@nghyane/arcane-utils/dirs";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import { computeLineHash } from "../patch/hashline";
-import readDescription from "../prompts/tools/read.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import {
 	DEFAULT_MAX_BYTES,
@@ -22,18 +19,17 @@ import {
 	truncateHead,
 	truncateStringToBytesFromStart,
 } from "../session/streaming-output";
-import { renderCodeCell, renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { getLanguageFromPath, type Theme } from "../theme/theme";
+import { renderStatusLine } from "../tui";
+import { formatAge, formatCount, formatErrorMessage, shortenPath } from "../ui/render-utils";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { detectSupportedImageMimeTypeFromFile } from "../utils/mime";
 import { ensureTool } from "../utils/tools-manager";
 import { applyListLimit } from "./list-limit";
-import type { OutputMeta } from "./output-meta";
+import { type OutputMeta, toolResult } from "./output-meta";
 import { resolveReadPath, resolveToCwd } from "./path-utils";
-import { formatAge, shortenPath, wrapBrackets } from "./render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
-import { toolResult } from "./tool-result";
 
 // Document types convertible via markitdown
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);
@@ -512,9 +508,9 @@ async function convertWithMarkitdown(
 }
 
 const readSchema = Type.Object({
-	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
-	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
-	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+	path: Type.String({ description: "File path (relative or absolute)" }),
+	offset: Type.Optional(Type.Number({ description: "Start reading from this line number (1-indexed)" })),
+	limit: Type.Optional(Type.Number({ description: "Max number of lines to read" })),
 });
 
 export type ReadToolInput = Static<typeof readSchema>;
@@ -534,23 +530,17 @@ type ReadParams = ReadToolInput;
  * Reads files with support for images, documents (via markitdown), and text.
  * Directories return a formatted listing with modification times.
  */
-export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
+export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails, Theme> {
 	readonly name = "read";
 	readonly label = "Read";
-	readonly description: string;
+	description = "Read file contents, list directories, or view images";
 	readonly parameters = readSchema;
 	readonly nonAbortable = true;
 
 	readonly #autoResizeImages: boolean;
 
 	constructor(private readonly session: ToolSession) {
-		const displayMode = resolveFileDisplayMode(session);
 		this.#autoResizeImages = session.settings.get("images.autoResize");
-		this.description = renderPromptTemplate(readDescription, {
-			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
-			IS_HASHLINE_MODE: displayMode.hashLines,
-			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
-		});
 	}
 
 	async execute(
@@ -1063,20 +1053,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		return resultBuilder.done();
 	}
-}
-
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
-interface ReadRenderArgs {
-	path?: string;
-	file_path?: string;
-	offset?: number;
-	limit?: number;
-}
 
-export const readToolRenderer = {
 	renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const rawPath = args.file_path || args.path || "";
 		const filePath = shortenPath(rawPath);
@@ -1092,102 +1069,42 @@ export const readToolRenderer = {
 
 		const text = renderStatusLine({ icon: "pending", title: "Read", description: pathDisplay }, uiTheme);
 		return new Text(text, 0, 0);
-	},
+	}
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: ReadToolDetails },
+		result: { content: Array<{ type: string; text?: string }>; details?: ReadToolDetails; isError?: boolean },
 		_options: RenderResultOptions,
 		uiTheme: Theme,
 		args?: ReadRenderArgs,
 	): Component {
-		const details = result.details;
-		const contentText = result.content?.find(c => c.type === "text")?.text ?? "";
-		const imageContent = result.content?.find(c => c.type === "image");
 		const rawPath = args?.file_path || args?.path || "";
 		const filePath = shortenPath(rawPath);
-		const lang = getLanguageFromPath(rawPath);
 
-		const warningLines: string[] = [];
-		const truncation = details?.meta?.truncation;
-		const fallback = details?.truncation;
-		if (details?.resolvedPath) {
-			warningLines.push(uiTheme.fg("dim", wrapBrackets(`Resolved path: ${details.resolvedPath}`, uiTheme)));
-		}
-		if (truncation) {
-			let warning: string;
-			if (fallback?.firstLineExceedsLimit) {
-				warning = `First line exceeds ${formatBytes(fallback.maxBytes ?? DEFAULT_MAX_BYTES)} limit`;
-			} else if (truncation.truncatedBy === "lines") {
-				warning = `Truncated: ${truncation.outputLines} of ${truncation.totalLines} lines (${DEFAULT_MAX_LINES} line limit)`;
-			} else {
-				const maxBytes = fallback?.maxBytes ?? DEFAULT_MAX_BYTES;
-				warning = `Truncated: ${truncation.outputLines} lines (${formatBytes(maxBytes)} limit)`;
-			}
-			if (truncation.artifactId) {
-				warning += `. Full output: artifact://${truncation.artifactId}`;
-			}
-			warningLines.push(uiTheme.fg("warning", wrapBrackets(warning, uiTheme)));
+		if (result.isError) {
+			const errorText = result.content?.find(c => c.type === "text")?.text || "Unknown error";
+			return new Text(formatErrorMessage(errorText, uiTheme), 0, 0);
 		}
 
-		if (imageContent) {
-			const header = renderStatusLine(
-				{ icon: "success", title: "Read", description: filePath || rawPath || "image" },
-				uiTheme,
-			);
-			const detailLines = contentText ? contentText.split("\n").map(line => uiTheme.fg("toolOutput", line)) : [];
-			const lines = [...detailLines, ...warningLines];
-			const outputBlock = new CachedOutputBlock();
-			return {
-				render: (width: number) =>
-					outputBlock.render(
-						{
-							header,
-							state: "success",
-							sections: [
-								{
-									label: uiTheme.fg("toolTitle", "Details"),
-									lines: lines.length > 0 ? lines : [uiTheme.fg("dim", "(image)")],
-								},
-							],
-							width,
-						},
-						uiTheme,
-					),
-				invalidate: () => outputBlock.invalidate(),
-			};
-		}
+		const details = result.details;
+		const meta: string[] = [];
+		const contentText = result.content?.find(c => c.type === "text")?.text ?? "";
+		const lineCount = contentText ? contentText.split("\n").length : 0;
+		if (lineCount > 0) meta.push(formatCount("line", lineCount));
+		const lang = getLanguageFromPath(rawPath);
+		if (lang) meta.push(lang);
+		if (details?.meta?.truncation) meta.push(uiTheme.fg("warning", "truncated"));
 
-		let title = filePath ? `Read ${filePath}` : "Read";
-		if (args?.offset !== undefined || args?.limit !== undefined) {
-			const startLine = args.offset ?? 1;
-			const endLine = args.limit !== undefined ? startLine + args.limit - 1 : "";
-			title += `:${startLine}${endLine ? `-${endLine}` : ""}`;
-		}
-		let cachedWidth: number | undefined;
-		let cachedLines: string[] | undefined;
-		return {
-			render: (width: number) => {
-				if (cachedLines && cachedWidth === width) return cachedLines;
-				cachedLines = renderCodeCell(
-					{
-						code: contentText,
-						language: lang,
-						title,
-						status: "complete",
-						output: warningLines.length > 0 ? warningLines.join("\n") : undefined,
-						expanded: true,
-						width,
-					},
-					uiTheme,
-				);
-				cachedWidth = width;
-				return cachedLines;
-			},
-			invalidate: () => {
-				cachedWidth = undefined;
-				cachedLines = undefined;
-			},
-		};
-	},
-	mergeCallAndResult: true,
-};
+		const text = renderStatusLine(
+			{ icon: "success", title: "Read", description: filePath || rawPath || "file", meta },
+			uiTheme,
+		);
+		return new Text(text, 0, 0);
+	}
+}
+
+interface ReadRenderArgs {
+	path?: string;
+	file_path?: string;
+	offset?: number;
+	limit?: number;
+}

package/src/tools/reviewer-tool.ts

@@ -1,23 +1,10 @@
 import { Type } from "@sinclair/typebox";
-import reviewerDescription from "../prompts/tools/reviewer.md" with { type: "text" };
-import { createSubagentTool } from "./subagent-tool";
+import type { SubagentConfig } from "./subagent-tool";
 
 const schema = Type.Object({
-	diff_description: Type.String({
-		description:
-			'A description or command identifying the diff to review. Examples: "uncommitted changes", "last commit", "PR #42", "changes against main branch".',
-	}),
-	files: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "Specific file paths to focus the review on. If omitted, all changed files are reviewed.",
-		}),
-	),
-	instructions: Type.Optional(
-		Type.String({
-			description:
-				'Additional guidance for the reviewer. Examples: "Focus on error handling", "Check for race conditions".',
-		}),
-	),
+	diff_description: Type.String({ description: "Description of the diff or change to review" }),
+	files: Type.Optional(Type.Array(Type.String(), { description: "Specific files to focus the review on" })),
+	instructions: Type.Optional(Type.String({ description: "Additional review instructions" })),
 });
 
 function buildTask(p: Record<string, unknown>): string {
@@ -28,14 +15,25 @@ function buildTask(p: Record<string, unknown>): string {
 	return parts.join("\n");
 }
 
-export const ReviewerTool = createSubagentTool({
+export const reviewerConfig: SubagentConfig<typeof schema.properties> = {
 	name: "code_review",
 	label: "Code Review",
 	agent: "reviewer",
 	schema,
-	descriptionTemplate: reviewerDescription,
 	progressText: "Reviewing code...",
 	tmpPrefix: "arc-review-",
 	buildTask,
-	buildDescription: p => `Review: ${(p.diff_description as string).slice(0, 60)}`,
-});
+	buildDescription: p => String(p.diff_description ?? "").slice(0, 80),
+	buildContextLine: p => {
+		const parts: string[] = [];
+		const files = p.files as string[] | undefined;
+		if (files?.length) parts.push(`${files.length} file${files.length > 1 ? "s" : ""}`);
+		if (p.instructions) parts.push(String(p.instructions).slice(0, 50));
+		return parts.length > 0 ? parts.join(" · ") : null;
+	},
+	toolDescription: [
+		"Code review specialist — spawns reviewer agent on a diff.",
+		'Pass diff_description (e.g. "uncommitted changes", "last commit"), optionally files and instructions.',
+	].join(" "),
+	passContext: false,
+};

package/src/tools/search-code.ts

@@ -0,0 +1,128 @@
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	RenderResultOptions,
+} from "@nghyane/arcane-agent";
+import type { Component } from "@nghyane/arcane-tui";
+import { Text } from "@nghyane/arcane-tui";
+import { Type } from "@sinclair/typebox";
+import type { Theme } from "../theme/theme";
+import { renderStatusLine } from "../tui";
+import { formatCount, formatErrorMessage, truncateToWidth } from "../ui/render-utils";
+import { GrepAppProvider, type SearchCodeSource } from "../web/search/providers/grep";
+import { renderSearchCall, type SearchRenderDetails } from "../web/search/render";
+
+const grepProvider = new GrepAppProvider();
+
+const searchCodeSchema = Type.Object({
+	query: Type.String({ description: "Search query or code pattern" }),
+	regexp: Type.Optional(Type.Boolean({ description: "Treat query as regex" })),
+	language: Type.Optional(Type.String({ description: "Filter by programming language" })),
+	repo: Type.Optional(Type.String({ description: "Filter by repository (owner/repo)" })),
+	limit: Type.Optional(Type.Number({ description: "Max number of results" })),
+});
+
+interface SearchCodeToolParams {
+	query: string;
+	regexp?: boolean;
+	language?: string;
+	repo?: string;
+	limit?: number;
+}
+
+export class SearchCodeTool implements AgentTool<typeof searchCodeSchema, SearchRenderDetails, Theme> {
+	readonly name = "search_code";
+	readonly label = "Code Search";
+	readonly description = "Search source code across public GitHub repositories via grep.app";
+	readonly parameters = searchCodeSchema;
+	readonly renderCall = renderSearchCall;
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: SearchRenderDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		theme: Theme,
+		args?: SearchCodeToolParams,
+	): Component {
+		if (result.isError || result.details?.error) {
+			const errorText =
+				result.details?.error || result.content?.find(c => c.type === "text")?.text || "Unknown error";
+			return new Text(formatErrorMessage(errorText, theme), 0, 0);
+		}
+		const query = args?.query ? truncateToWidth(args.query, 60) : "code";
+		const sourceCount = result.details?.response?.sources?.length ?? 0;
+		return new Text(
+			renderStatusLine(
+				{
+					icon: sourceCount > 0 ? "success" : "warning",
+					title: "Code Search",
+					description: `"${query}"`,
+					meta: [formatCount("result", sourceCount)],
+				},
+				theme,
+			),
+			0,
+			0,
+		);
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: SearchCodeToolParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<SearchRenderDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<SearchRenderDetails>> {
+		try {
+			const response = await grepProvider.search({
+				query: params.query,
+				regexp: params.regexp,
+				language: params.language,
+				repo: params.repo,
+				limit: params.limit,
+			});
+
+			const parts: string[] = [];
+			if (response.sources.length === 0) {
+				parts.push("No code results found.");
+			} else {
+				const header = response.total
+					? `Found ${response.sources.length} of ${response.total} total matches across public GitHub repos.`
+					: `Found ${response.sources.length} code result(s) across public GitHub repos.`;
+				parts.push(header);
+
+				if (response.topLanguages && response.topLanguages.length > 0) {
+					parts.push(`Top languages: ${response.topLanguages.map(l => `${l.val} (${l.count})`).join(", ")}`);
+				}
+				if (response.topRepos && response.topRepos.length > 0) {
+					parts.push(`Top repos: ${response.topRepos.map(r => `${r.val} (${r.count})`).join(", ")}`);
+				}
+				parts.push("");
+
+				for (const source of response.sources as SearchCodeSource[]) {
+					const matchInfo = source.matchCount ? ` (${source.matchCount} matches)` : "";
+					parts.push(`### ${source.title}${matchInfo}`);
+					parts.push(source.url);
+					if (source.snippet) {
+						const lineInfo = source.lineNumbers?.[0] ? `L${source.lineNumbers[0]}` : "";
+						parts.push(`\`\`\`${lineInfo}\n${source.snippet}\n\`\`\``);
+					}
+					parts.push("");
+				}
+			}
+
+			return {
+				content: [{ type: "text" as const, text: parts.join("\n") }],
+				details: { response, error: undefined },
+			};
+		} catch (error) {
+			const message = `Code search failed: ${error instanceof Error ? error.message : String(error)}`;
+
+			return {
+				content: [{ type: "text" as const, text: message }],
+				details: { response: { provider: "grep" as const, sources: [] }, error: message },
+			};
+		}
+	}
+}

package/src/tools/ssh.ts

@@ -4,29 +4,25 @@ import { Text } from "@nghyane/arcane-tui";
 import { type Static, Type } from "@sinclair/typebox";
 import type { SSHHost } from "../capability/ssh";
 import { sshCapability } from "../capability/ssh";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import { loadCapability } from "../discovery";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import sshDescriptionBase from "../prompts/tools/ssh.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES } from "../session/streaming-output";
 import type { SSHHostInfo } from "../ssh/connection-manager";
 import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
+import type { Theme } from "../theme/theme";
 import { renderStatusLine } from "../tui";
-import { CachedOutputBlock } from "../tui/output-block";
+import { formatClickHint, replaceTabs } from "../ui/render-utils";
 import type { ToolSession } from ".";
-import type { OutputMeta } from "./output-meta";
+import { type OutputMeta, toolResult } from "./output-meta";
 import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
-import { formatBytes, wrapBrackets } from "./render-utils";
 import { ToolError } from "./tool-errors";
-import { toolResult } from "./tool-result";
 
 const sshSchema = Type.Object({
-	host: Type.String({ description: "Host name from managed SSH config or discovered ssh.json files" }),
-	command: Type.String({ description: "Command to execute on the remote host" }),
-	cwd: Type.Optional(Type.String({ description: "Remote working directory (optional)" })),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 60)" })),
+	host: Type.String({ description: "SSH host alias (from ~/.ssh/config)" }),
+	command: Type.String({ description: "Shell command to execute on the remote host" }),
+	cwd: Type.Optional(Type.String({ description: "Working directory on the remote host" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds" })),
 });
 
 export interface SSHToolDetails {
@@ -60,12 +56,9 @@ async function formatHostEntry(host: SSHHost): Promise<string> {
 }
 
 async function formatDescription(hosts: SSHHost[]): Promise<string> {
-	const baseDescription = renderPromptTemplate(sshDescriptionBase);
-	if (hosts.length === 0) {
-		return baseDescription;
-	}
+	if (hosts.length === 0) return "";
 	const hostList = (await Promise.all(hosts.map(formatHostEntry))).join("\n");
-	return `${baseDescription}\n\nAvailable hosts:\n${hostList}`;
+	return `Available hosts:\n${hostList}`;
 }
 
 function quoteRemotePath(value: string): string {
@@ -119,7 +112,7 @@ async function loadHosts(session: ToolSession): Promise<{
 
 type SshToolParams = Static<typeof sshSchema>;
 
-export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
+export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails, Theme> {
 	readonly name = "ssh";
 	readonly label = "SSH";
 	readonly parameters = sshSchema;
@@ -193,6 +186,62 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 
 		return resultBuilder.done();
 	}
+
+	renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const host = args.host || "…";
+		const command = args.command || "…";
+		const text = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}] $ ${command}` }, uiTheme);
+		return new Text(text, 0, 0);
+	}
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: SSHToolDetails },
+		options: RenderResultOptions & { renderContext?: SshRenderContext },
+		uiTheme: Theme,
+		args?: SshRenderArgs,
+	): Component {
+		const host = args?.host || "…";
+		const command = args?.command || "…";
+		const cmdText = `[${host}] $ ${command}`;
+		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+		const output = textContent.trimEnd();
+		const outputLines = output ? output.split("\n") : [];
+		const total = outputLines.length;
+		const truncation = result.details?.meta?.truncation;
+		const isError = false;
+
+		const meta: string[] = [];
+		if (total > 0) meta.push(`${total} lines`);
+
+		const header = renderStatusLine(
+			{ icon: isError ? "error" : "success", title: "SSH", description: cmdText, meta },
+			uiTheme,
+		);
+
+		const TAIL = 4;
+		const expanded = options.expanded;
+		const showAll = isError || expanded;
+		const displayLines = showAll ? outputLines : outputLines.slice(-TAIL);
+		const skipped = total - displayLines.length;
+
+		const bodyLines: string[] = [];
+		if (skipped > 0) {
+			bodyLines.push(uiTheme.fg("dim", `… (${skipped} earlier lines)`));
+		}
+		const hasTruncation = Boolean(truncation);
+		for (let i = 0; i < displayLines.length; i++) {
+			bodyLines.push(uiTheme.fg("toolOutput", replaceTabs(displayLines[i])));
+		}
+		if (hasTruncation) {
+			bodyLines.push(uiTheme.fg("warning", "output truncated"));
+		}
+		if (!showAll && skipped > 0) {
+			bodyLines.push(formatClickHint(uiTheme));
+		}
+
+		const lines = bodyLines.length > 0 ? [header, ...bodyLines] : [header];
+		return new Text(lines.join("\n"), 0, 0);
+	}
 }
 
 export async function loadSshTool(session: ToolSession): Promise<SshTool | null> {
@@ -209,118 +258,10 @@ export async function loadSshTool(session: ToolSession): Promise<SshTool | null>
 	return new SshTool(session, hostNames, hostsByName, description);
 }
 
-// =============================================================================
-// TUI Renderer
-// =============================================================================
-
 interface SshRenderArgs {
 	host?: string;
 	command?: string;
 	timeout?: number;
 }
 
-interface SshRenderContext {
-	/** Visual lines for truncated output (pre-computed by tool-execution) */
-	visualLines?: string[];
-	/** Number of lines skipped */
-	skippedCount?: number;
-	/** Total visual lines */
-	totalVisualLines?: number;
-}
-
-export const sshToolRenderer = {
-	renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const host = args.host || "…";
-		const command = args.command || "…";
-		const text = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}] $ ${command}` }, uiTheme);
-		return new Text(text, 0, 0);
-	},
-
-	renderResult(
-		result: {
-			content: Array<{ type: string; text?: string }>;
-			details?: SSHToolDetails;
-		},
-		options: RenderResultOptions & { renderContext?: SshRenderContext },
-		uiTheme: Theme,
-		args?: SshRenderArgs,
-	): Component {
-		const details = result.details;
-		const host = args?.host || "…";
-		const command = args?.command || "…";
-		const header = renderStatusLine(
-			{ icon: "success", title: "SSH", description: `[${host}] $ ${command}` },
-			uiTheme,
-		);
-		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-		const truncation = details?.meta?.truncation;
-		const outputBlock = new CachedOutputBlock();
-
-		return {
-			render: (width: number): string[] => {
-				// REACTIVE: read mutable options at render time
-				const { expanded, renderContext } = options;
-				const output = textContent.trimEnd();
-				const outputLines: string[] = [];
-
-				if (output) {
-					if (expanded) {
-						outputLines.push(...output.split("\n").map(line => uiTheme.fg("toolOutput", line)));
-					} else if (renderContext?.visualLines) {
-						const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
-						if (skippedCount > 0) {
-							outputLines.push(
-								uiTheme.fg(
-									"dim",
-									`… (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
-								),
-							);
-						}
-						const styledVisual = visualLines.map(line =>
-							line.includes("\x1b[") ? line : uiTheme.fg("toolOutput", line),
-						);
-						outputLines.push(...styledVisual);
-					} else {
-						const outputLinesRaw = output.split("\n");
-						const maxLines = 5;
-						const displayLines = outputLinesRaw.slice(0, maxLines);
-						const remaining = outputLinesRaw.length - maxLines;
-						outputLines.push(...displayLines.map(line => uiTheme.fg("toolOutput", line)));
-						if (remaining > 0) {
-							outputLines.push(uiTheme.fg("dim", `… (${remaining} more lines) (ctrl+o to expand)`));
-						}
-					}
-				}
-
-				if (truncation) {
-					const warnings: string[] = [];
-					if (truncation.artifactId) {
-						warnings.push(`Full output: artifact://${truncation.artifactId}`);
-					}
-					if (truncation.truncatedBy === "lines") {
-						warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
-					} else {
-						warnings.push(
-							`Truncated: ${truncation.outputLines} lines shown (${formatBytes(truncation.outputBytes)} limit)`,
-						);
-					}
-					outputLines.push(uiTheme.fg("warning", wrapBrackets(warnings.join(". "), uiTheme)));
-				}
-
-				return outputBlock.render(
-					{
-						header,
-						state: "success",
-						sections: [{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
-						width,
-					},
-					uiTheme,
-				);
-			},
-			invalidate: () => {
-				outputBlock.invalidate();
-			},
-		};
-	},
-	mergeCallAndResult: true,
-};
+interface SshRenderContext {}