@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/src/tools/match-line-format.ts

@@ -0,0 +1,20 @@
+/**
+ * Format a single line of match output for grep/ast-grep style results.
+ *
+ * Matched lines are prefixed with `*`; context lines are prefixed with a single
+ * space so line numbers align in column. In hashline mode the line uses the
+ * editable `LINE:content` shape under a snapshot-tag header; in plain mode it
+ * keeps the legacy `LINE|content` display-only shape. Line numbers are never padded.
+ */
+export function formatMatchLine(
+	lineNumber: number,
+	line: string,
+	isMatch: boolean,
+	options: { useHashLines: boolean },
+): string {
+	const marker = isMatch ? "*" : " ";
+	if (options.useHashLines) {
+		return `${marker}${lineNumber}:${line}`;
+	}
+	return `${marker}${lineNumber}|${line}`;
+}

package/src/tools/mcp.ts

@@ -0,0 +1,309 @@
+/**
+ * TUI rendering for MCP tools.
+ *
+ * Provides structured display of MCP tool calls and results,
+ * showing args and output in JSON tree format similar to task tool.
+ */
+import { type Component, Markdown } from "../index";
+
+import type { RenderResultOptions } from "./renderer";
+import { getMarkdownTheme, type Theme } from "../theme/theme";
+import {
+	formatArgsInline,
+	JSON_TREE_MAX_DEPTH_COLLAPSED,
+	JSON_TREE_MAX_DEPTH_EXPANDED,
+	JSON_TREE_MAX_LINES_COLLAPSED,
+	JSON_TREE_MAX_LINES_EXPANDED,
+	JSON_TREE_SCALAR_LEN_COLLAPSED,
+	JSON_TREE_SCALAR_LEN_EXPANDED,
+	renderJsonTreeLines,
+} from "./json-tree";
+import { formatStyledTruncationWarning, stripOutputNotice } from "./output-meta";
+import { formatExpandHint, truncateToWidth } from "../render/render-utils";
+import { formatOutputPaneLines, styleToolOutputLine } from "../render/output-pane";
+import type { StatusLineOptions } from "../render/status-line";
+import { plainToolCard, type ToolCardPhase } from "../render/tool-card";
+
+/** Expanded Args tree shared by the MCP result cards. */
+function buildMcpArgsSection(args: Record<string, unknown>, theme: Theme): readonly string[] {
+	const lines: string[] = [theme.fg("dim", "Args")];
+	const tree = renderJsonTreeLines(
+		args,
+		theme,
+		JSON_TREE_MAX_DEPTH_EXPANDED,
+		JSON_TREE_MAX_LINES_EXPANDED,
+		JSON_TREE_SCALAR_LEN_EXPANDED,
+	);
+	lines.push(...tree.lines);
+	if (tree.truncated) lines.push(theme.fg("dim", "…"));
+	lines.push("");
+	return lines;
+}
+
+/**
+ * Render MCP tool call.
+ */
+export function renderMCPCall(args: Record<string, unknown>, theme: Theme, label: string): Component {
+	return plainToolCard(
+		theme,
+		({ contentWidth }) => {
+			const body: string[] = [];
+			if (args && typeof args === "object" && Object.keys(args).length > 0) {
+				// Inline preview budgeted against the render width, leaving room for
+				// the ` └─ ` connector prefix instead of a fixed cap.
+				const inlineBudget = Math.max(20, contentWidth - Bun.stringWidth(theme.tree.last) - 2);
+				const preview = formatArgsInline(args, inlineBudget);
+				if (preview) {
+					body.push(` ${theme.fg("dim", theme.tree.last)} ${theme.fg("dim", preview)}`);
+				}
+			}
+
+			return {
+				status: { icon: "pending", title: label },
+				phase: "pending",
+				body,
+				applyBg: false,
+			};
+		},
+		{ paddingX: 0, paddingY: 0 },
+	);
+}
+
+/** Render an MCP status/args prefix followed by Markdown-aware text output. */
+function renderMarkdownMCPResult(
+	result: { details?: MCPToolDetails; isError?: boolean },
+	trimmedOutput: string,
+	truncationWarning: string | null,
+	options: RenderResultOptions,
+	theme: Theme,
+	args?: Record<string, unknown>,
+): Component {
+	const markdown = new Markdown(trimmedOutput, 0, 0, getMarkdownTheme(), {
+		color: text => theme.fg("toolOutput", text),
+	});
+	return plainToolCard(
+		theme,
+		({ contentWidth }) => {
+			const isError = result.isError ?? result.details?.isError ?? false;
+			const title = result.details ? `${result.details.serverName}/${result.details.mcpToolName}` : "MCP";
+			const body: string[] = [];
+			if (options.expanded && args && Object.keys(args).length > 0) {
+				body.push(...buildMcpArgsSection(args, theme));
+			}
+
+			const rendered = markdown.render(Math.max(1, contentWidth));
+			body.push(
+				...formatOutputPaneLines(
+					{
+						lines: rendered,
+						expanded: options.expanded,
+						collapsedMaxLines: 4,
+						expandedMaxLines: 12,
+						showExpandHintWhenUncapped: true,
+					},
+					theme,
+				).lines,
+			);
+			if (truncationWarning) body.push(truncationWarning);
+			const status: StatusLineOptions = options.isPartial
+				? {
+						icon: options.spinnerFrame !== undefined ? "running" : "pending",
+						spinnerFrame: options.spinnerFrame,
+						title,
+					}
+				: isError
+					? { icon: "error", title }
+					: { iconOverride: theme.styledSymbol("tool.mcp", "accent"), title };
+			const phase: ToolCardPhase = options.isPartial ? "partial" : isError ? "error" : "success";
+			return {
+				status,
+				phase,
+				body,
+				applyBg: false,
+			};
+		},
+		{ paddingX: 0, paddingY: 0 },
+	);
+}
+
+/**
+ * Render MCP tool result.
+ */
+export function renderMCPResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: MCPToolDetails; isError?: boolean },
+	options: RenderResultOptions,
+	theme: Theme,
+	args?: Record<string, unknown>,
+): Component {
+	const { expanded } = options;
+	const textContent = (result.content ?? [])
+		.filter(block => block.type === "text")
+		.map(block => block.text ?? "")
+		.filter(text => text.length > 0)
+		.join("\n\n");
+	const trimmedOutput = stripOutputNotice(textContent, result.details?.meta).trimEnd();
+	const truncationWarning = result.details?.meta?.truncation
+		? formatStyledTruncationWarning(result.details.meta, theme)
+		: null;
+	let parsedOutput: unknown;
+	let isJsonOutput = false;
+	if (trimmedOutput.startsWith("{") || trimmedOutput.startsWith("[")) {
+		try {
+			parsedOutput = JSON.parse(trimmedOutput);
+			isJsonOutput = true;
+		} catch {
+			// Non-JSON text beginning with a bracket is still eligible for Markdown.
+		}
+	}
+	if (trimmedOutput && renderMarkdownResults && !isJsonOutput) {
+		return renderMarkdownMCPResult(result, trimmedOutput, truncationWarning, options, theme, args);
+	}
+	return plainToolCard(
+		theme,
+		({ contentWidth }) => {
+			const isError = result.isError ?? result.details?.isError ?? false;
+			const title = result.details ? `${result.details.serverName}/${result.details.mcpToolName}` : "MCP";
+			const status: StatusLineOptions = options.isPartial
+				? {
+						icon: options.spinnerFrame !== undefined ? "running" : "pending",
+						spinnerFrame: options.spinnerFrame,
+						title,
+					}
+				: isError
+					? { icon: "error", title }
+					: { iconOverride: theme.styledSymbol("tool.mcp", "accent"), title };
+			const phase: ToolCardPhase = options.isPartial ? "partial" : isError ? "error" : "success";
+			const body: string[] = [];
+
+			// Args section (when expanded)
+			if (expanded && args && typeof args === "object" && Object.keys(args).length > 0) {
+				body.push(...buildMcpArgsSection(args, theme));
+			}
+
+			// Output section. The body and spill metadata are normalized before
+			// component selection so the opt-in Markdown path can use its own renderer.
+
+			if (!trimmedOutput) {
+				body.push(theme.fg("dim", "(no output)"));
+				return { status, phase, body, applyBg: false };
+			}
+
+			// Preserve the existing structured JSON renderer regardless of the
+			// Markdown preference; JSON trees remain more useful than styled source.
+			if (isJsonOutput) {
+				const maxDepth = expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
+				const maxLines = expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
+				const maxScalarLen = expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
+				const tree = renderJsonTreeLines(parsedOutput, theme, maxDepth, maxLines, maxScalarLen);
+
+				if (tree.lines.length > 0) {
+					body.push(...tree.lines);
+					if (!expanded) {
+						body.push(formatExpandHint(theme, expanded, true));
+					} else if (tree.truncated) {
+						body.push(theme.fg("dim", "…"));
+					}
+					if (truncationWarning) body.push(truncationWarning);
+					return { status, phase, body, applyBg: false };
+				}
+			}
+
+			// Raw text output, capped to the first rows with an expand hint while collapsed.
+			body.push(
+				...formatOutputPaneLines(
+					{
+						lines: trimmedOutput.split("\n"),
+						expanded,
+						collapsedMaxLines: 4,
+						expandedMaxLines: 12,
+						styleLine: line => truncateToWidth(styleToolOutputLine(line, theme), contentWidth),
+						showExpandHintWhenUncapped: true,
+					},
+					theme,
+				).lines,
+			);
+
+			if (truncationWarning) body.push(truncationWarning);
+			return { status, phase, body, applyBg: false };
+		},
+		{ paddingX: 0, paddingY: 0 },
+	);
+}
+
+import type { OutputMeta } from "./output-meta";
+
+let renderMarkdownResults = false;
+
+/** Set whether plain MCP text results render as Markdown. */
+export function setMcpRenderMarkdownResults(enabled: boolean): void {
+	renderMarkdownResults = enabled;
+}
+
+/** Content types in tool results */
+export interface MCPTextContent {
+	type: "text";
+	text: string;
+}
+
+/** Base64-encoded image returned by an MCP tool. */
+export interface MCPImageContent {
+	type: "image";
+	data: string; // base64
+	mimeType: string;
+}
+
+/** Embedded text or binary resource returned by an MCP tool. */
+export interface MCPResourceContent {
+	type: "resource";
+	resource: {
+		uri: string;
+		mimeType?: string;
+		text?: string;
+		blob?: string;
+	};
+}
+
+/** Supported MCP result content blocks retained in display metadata. */
+export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
+
+/** Details included in MCP tool results for rendering */
+export interface MCPToolDetails {
+	/** Server name */
+	serverName: string;
+	/** Original MCP tool name */
+	mcpToolName: string;
+	/** Whether the call resulted in an error */
+	isError?: boolean;
+	/** Raw content from MCP response */
+	rawContent?: MCPContent[];
+	/** Structured metadata from the MCP response */
+	mcpMeta?: Record<string, unknown>;
+	/** Provider ID (e.g., "claude", "mcp-json") */
+	provider?: string;
+	/** Provider display name (e.g., "Claude Code", "MCP Config") */
+	providerName?: string;
+	/** Structured output metadata (set by the spill wrapper when output is truncated to an artifact). */
+	meta?: OutputMeta;
+}
+
+/** Registry prefix every minted MCP tool name carries. */
+export const MCP_TOOL_NAME_PREFIX = "mcp__";
+
+/**
+ * Parse an MCP tool name back to server and tool components.
+ *
+ * Note: This returns the normalized tool name (with server prefix stripped).
+ * The original MCP tool name may have had the server name as a prefix.
+ */
+export function parseMCPToolName(name: string): { serverName: string; toolName: string } | null {
+	if (!name.startsWith(MCP_TOOL_NAME_PREFIX)) return null;
+
+	const rest = name.slice(MCP_TOOL_NAME_PREFIX.length);
+	const underscoreIdx = rest.indexOf("_");
+	if (underscoreIdx === -1) return null;
+
+	return {
+		serverName: rest.slice(0, underscoreIdx),
+		toolName: rest.slice(underscoreIdx + 1),
+	};
+}

package/src/tools/memory.ts

@@ -0,0 +1,220 @@
+import type { ToolRenderer } from "./renderer";
+/**
+ * Inline TUI renderers for the long-term memory tools (`retain`, `recall`,
+ * `reflect`).
+ *
+ * These keep the transcript terse — one status line plus, for `retain`, one
+ * `Remember: …` line per stored item — instead of the generic JSON arg tree,
+ * which exploded multi-line memory blobs into an unreadable wall. The tool
+ * container is a transparent passthrough, so these renderers stay frameless:
+ * a status line with a couple of dim bullets reads far cleaner than boxing a
+ * one-line memory note.
+ */
+import type { Component } from "../index";
+import { Text } from "../index";
+import type { RenderResultOptions } from "./renderer";
+import type { Theme } from "../theme/theme";
+import { Ellipsis, renderStatusLine, truncateToWidth } from "../render";
+import {
+	createCachedComponent,
+	formatErrorMessage,
+	formatExpandHint,
+	PREVIEW_LIMITS,
+	replaceTabs,
+	type ToolUIStatus,
+} from "../render/render-utils";
+
+// Each stored memory renders as `<bullet> <content>`; the bullet glyph comes
+// from the active theme (`•` by default, a nerd-font dot under nerd themes).
+
+interface RetainRenderArgs {
+	items?: unknown;
+}
+
+interface QueryRenderArgs {
+	query?: string;
+}
+
+function retainContents(args: RetainRenderArgs | undefined): string[] {
+	const items = args?.items;
+	if (!Array.isArray(items)) return [];
+
+	const contents: string[] = [];
+	for (const item of items) {
+		if (!item || typeof item !== "object" || !("content" in item) || typeof item.content !== "string") continue;
+		const content = replaceTabs(item.content.trim());
+		if (content.length > 0) contents.push(content);
+	}
+	return contents;
+}
+
+function resultText(result: { content?: Array<{ type: string; text?: string }> }): string {
+	return (result.content?.find(c => c.type === "text")?.text ?? "").trim();
+}
+
+/** Single-line query header used by `recall`/`reflect` calls and results. */
+function queryHeader(
+	title: string,
+	query: string | undefined,
+	icon: ToolUIStatus,
+	theme: Theme,
+	meta?: string[],
+	iconOverride?: string,
+): string {
+	const trimmed = replaceTabs((query ?? "").trim());
+	const description = trimmed ? truncateToWidth(trimmed, 80, Ellipsis.Unicode) : undefined;
+	return renderStatusLine({ icon, iconOverride, title, description, meta }, theme);
+}
+
+function retainComponent(contents: string[], header: string, getExpanded: () => boolean, theme: Theme): Component {
+	return createCachedComponent(getExpanded, (width, expanded) => {
+		const lines = [header];
+		const limit = expanded ? contents.length : PREVIEW_LIMITS.COLLAPSED_ITEMS;
+		const shown = contents.slice(0, limit);
+		const bullet = theme.format.bullet;
+		const contentWidth = Math.max(8, width - 2 - Bun.stringWidth(bullet) - 1);
+		for (const content of shown) {
+			const value = truncateToWidth(content, contentWidth, Ellipsis.Unicode);
+			lines.push(`  ${theme.fg("muted", bullet)} ${theme.fg("toolOutput", value)}`);
+		}
+		const remaining = contents.length - shown.length;
+		if (remaining > 0) {
+			lines.push(`  ${theme.fg("dim", `… ${remaining} more`)} ${formatExpandHint(theme, expanded, true)}`);
+		}
+		return lines.map(line => truncateToWidth(line, width, Ellipsis.Omit));
+	});
+}
+
+/** Render retained memory items and their storage summary. */
+export const retainToolRenderer = {
+	inline: true,
+	mergeCallAndResult: true,
+	renderCall(args: RetainRenderArgs, options: RenderResultOptions, theme: Theme): Component {
+		const contents = retainContents(args);
+		const header = renderStatusLine({ icon: "pending", title: "Retain" }, theme);
+		return retainComponent(contents, header, () => options.expanded, theme);
+	},
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: { count?: number }; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: RetainRenderArgs,
+	): Component {
+		if (result.isError) {
+			return new Text(formatErrorMessage(resultText(result) || "Retain failed", theme), 0, 0);
+		}
+		const contents = retainContents(args);
+		// `summary` is the tool's own "N memories stored/queued." line; drop the
+		// trailing period so it reads cleanly as a status meta segment.
+		const summary = resultText(result).replace(/\.$/, "");
+		const header = renderStatusLine(
+			{
+				iconOverride: theme.styledSymbol("tool.memory", "accent"),
+				title: "Retain",
+				meta: summary ? [summary] : undefined,
+			},
+			theme,
+		);
+		return retainComponent(contents, header, () => options.expanded, theme);
+	},
+} satisfies ToolRenderer<RetainRenderArgs, MemoryRetainDetails>;
+
+/** Render recalled memories with an expandable body. */
+export const recallToolRenderer = {
+	inline: true,
+	mergeCallAndResult: true,
+	renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component {
+		return new Text(queryHeader("Recall", args.query, "pending", theme), 0, 0);
+	},
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: QueryRenderArgs,
+	): Component {
+		if (result.isError) {
+			return new Text(formatErrorMessage(resultText(result) || "Recall failed", theme), 0, 0);
+		}
+		const text = resultText(result);
+		const match = text.match(/^Found (\d+) relevant/);
+		const found = match ? Number(match[1]) : 0;
+		const meta = [found > 0 ? `${found} found` : "no matches"];
+		const header =
+			found > 0
+				? queryHeader("Recall", args?.query, "success", theme, meta, theme.styledSymbol("tool.memory", "accent"))
+				: queryHeader("Recall", args?.query, "warning", theme, meta);
+		if (found === 0) {
+			return new Text(header, 0, 0);
+		}
+		// Collapsed view is the header alone; expand to inspect the recalled
+		// memories without dumping the whole block into the transcript.
+		const body = text.replace(/^[^\n]*\n+/, "");
+		return createCachedComponent(
+			() => options.expanded,
+			(width, expanded) => {
+				const lines = [header];
+				if (expanded) {
+					const bodyLines = body.split("\n").slice(0, PREVIEW_LIMITS.OUTPUT_EXPANDED);
+					for (const line of bodyLines) {
+						lines.push(`  ${theme.fg("muted", replaceTabs(line))}`);
+					}
+				} else {
+					lines.push(`  ${formatExpandHint(theme, false, true)}`);
+				}
+				return lines.map(line => truncateToWidth(line, width, Ellipsis.Omit));
+			},
+		);
+	},
+} satisfies ToolRenderer<QueryRenderArgs, unknown>;
+
+/** Render synthesized memory reflections. */
+export const reflectToolRenderer = {
+	inline: true,
+	mergeCallAndResult: true,
+	renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component {
+		return new Text(queryHeader("Reflect", args.query, "pending", theme), 0, 0);
+	},
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: QueryRenderArgs,
+	): Component {
+		if (result.isError) {
+			return new Text(formatErrorMessage(resultText(result) || "Reflect failed", theme), 0, 0);
+		}
+		const header = queryHeader(
+			"Reflect",
+			args?.query,
+			"success",
+			theme,
+			undefined,
+			theme.styledSymbol("tool.memory", "accent"),
+		);
+		const answer = resultText(result);
+		const answerLines = answer.split("\n").filter(line => line.trim().length > 0);
+		return createCachedComponent(
+			() => options.expanded,
+			(width, expanded) => {
+				const limit = expanded ? PREVIEW_LIMITS.OUTPUT_EXPANDED : PREVIEW_LIMITS.OUTPUT_COLLAPSED;
+				const shown = answerLines.slice(0, limit);
+				const lines = [header];
+				for (const line of shown) {
+					lines.push(`  ${theme.fg("toolOutput", replaceTabs(line))}`);
+				}
+				const remaining = answerLines.length - shown.length;
+				if (remaining > 0) {
+					lines.push(
+						`  ${theme.fg("dim", `… ${remaining} more lines`)} ${formatExpandHint(theme, expanded, true)}`,
+					);
+				}
+				return lines.map(line => truncateToWidth(line, width, Ellipsis.Omit));
+			},
+		);
+	},
+} satisfies ToolRenderer<QueryRenderArgs, unknown>;
+
+/** Number of memories accepted by retain. */
+export interface MemoryRetainDetails {
+	count: number;
+}