@oh-my-pi/pi-tui 18.2.5 → 18.2.7

package/src/theme/mermaid-cache.ts

@@ -1,11 +1,12 @@
-import { type MermaidAsciiRenderOptions, renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils/mermaid-ascii";
+import type { MermaidRenderOptions } from "@oh-my-pi/pi-natives";
+import { renderMermaidAsciiSafe } from "@oh-my-pi/pi-utils/mermaid-ascii";
 
 /**
  * Options controlling how fenced Mermaid source is resolved to terminal ASCII.
  * Extends the raw render options (theme, color mode, spacing, `useAscii`) with a
  * viewport-fitting hint.
  */
-export interface MermaidResolveOptions extends MermaidAsciiRenderOptions {
+export interface MermaidResolveOptions extends MermaidRenderOptions {
 	/**
 	 * Maximum display width (terminal columns) the diagram should occupy. A
 	 * layout that overflows this width is re-rendered in the perpendicular
@@ -34,7 +35,7 @@ function asciiDisplayWidth(ascii: string): number {
 
 function renderVariant(
 	source: string,
-	baseOptions: MermaidAsciiRenderOptions,
+	baseOptions: MermaidRenderOptions,
 	baseKey: string,
 	direction: "TD" | "LR" | null,
 ): string | null {
@@ -57,7 +58,7 @@ export function resolveMermaidAscii(source: string, options?: MermaidResolveOpti
 
 	const { maxWidth, ...rest } = options ?? {};
 	// Default to uncolored output; callers opt into a themed palette explicitly.
-	const baseOptions: MermaidAsciiRenderOptions = { colorMode: "none", ...rest };
+	const baseOptions: MermaidRenderOptions = { colorMode: "none", ...rest };
 	const baseKey = JSON.stringify(baseOptions);
 
 	const base = renderVariant(normalizedSource, baseOptions, baseKey, null);

package/src/tools/eval.ts

@@ -139,15 +139,16 @@ function getRenderCells(args: EvalRenderArgs | undefined): EvalRenderCell[] {
 type AgentEventStatus = "pending" | "running" | "completed" | "failed" | "aborted";
 
 /**
- * Append or replace a status event. `agent` events are progress snapshots keyed
- * by `id`, so they coalesce in place (preserving first-seen order); every other
- * op is a discrete action and simply appends. Keeps the persisted event list
- * bounded even when a subagent emits hundreds of throttled progress ticks.
+ * Append or replace a status event. `agent` and `judge_batch` events are
+ * progress snapshots keyed by `id`, so they coalesce in place (preserving
+ * first-seen order); every other op is a discrete action and simply appends.
+ * Keeps the persisted event list bounded even when a subagent or batch emits
+ * hundreds of throttled progress ticks.
  */
 export function upsertStatusEvent(events: EvalStatusEvent[], event: EvalStatusEvent): void {
-	if (event.op === "agent" && typeof event.id === "string") {
-		const id = event.id;
-		const idx = events.findIndex(e => e.op === "agent" && e.id === id);
+	if ((event.op === "agent" || event.op === "judge_batch") && typeof event.id === "string") {
+		const { op, id } = event;
+		const idx = events.findIndex(e => e.op === op && e.id === id);
 		if (idx >= 0) {
 			events[idx] = event;
 			return;
@@ -351,6 +352,12 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 				parts.push(data.action === "create" ? `${data.count} agent(s)` : `${data.count} item(s)`);
 			}
 			break;
+		case "judge_batch":
+			parts.push(`${data.action} ${data.id}`);
+			parts.push(`${data.done ?? 0}/${data.total ?? 0}`);
+			if (data.failed) parts.push(`${data.failed} failed`);
+			if (data.model) parts.push(String(data.model));
+			break;
 		case "wc":
 			parts.push(`${data.lines}L ${data.words}W ${data.chars}C`);
 			break;

package/src/tools/find.ts

@@ -0,0 +1,255 @@
+/**
+ * Transcript renderer for the `find` tool (semantic grep). Hits are ranked
+ * strongest first; each row carries a score gauge, the hyperlinked file, and
+ * its strongest verified line ranges with a verbatim snippet.
+ */
+import * as path from "node:path";
+import { formatDuration, formatNumber } from "@oh-my-pi/pi-utils";
+import { renderProgressBar } from "../components/progress-bar";
+import { Text } from "../components/text";
+import { Ellipsis, fileHyperlink, getTreeBranch, renderStatusLine, renderTreeList, truncateToWidth } from "../render";
+import {
+	createCachedComponent,
+	formatCount,
+	formatEmptyMessage,
+	formatErrorMessage,
+	PREVIEW_LIMITS,
+	replaceTabs,
+} from "../render/render-utils";
+import type { Theme, ThemeColor } from "../theme/theme";
+import type { Component } from "../tui";
+import type { OutputMeta } from "./output-meta";
+import type { RenderResultOptions, ToolRenderer } from "./renderer";
+
+/** A verified line range with its yes-probability and a one-line preview. */
+export interface FindRange {
+	start: number;
+	end: number;
+	p: number;
+	snippet: string;
+}
+
+/** A file whose verified passages cleared the threshold; `ranges` are merged positive spans, strongest first. */
+export interface FindHit {
+	/** Display path relative to {@link FindToolDetails.cwd}. */
+	rel: string;
+	/** Filename judgment, when the name batch answered. */
+	nameScore?: number;
+	/** Best verified passage probability. */
+	contentScore: number;
+	ranges: FindRange[];
+	/** Lines of content actually judged, and whether the file held more. */
+	linesSeen: number;
+	truncated: boolean;
+}
+
+/** Search accounting reported alongside the hits. */
+export interface FindStats {
+	/** Eligible files under the root. */
+	listed: number;
+	requests: number;
+	errors: number;
+	/** Entries judged by name. */
+	judged: number;
+	/** Files whose content was read and sent. */
+	filesRead: number;
+	fileBytes: number;
+	inputTokens: number;
+	outputTokens: number;
+	cost: number;
+	apiMs: number;
+	windowsJudged: number;
+	windowsPruned: number;
+	mapCards: number;
+	/** Distinct request failures, phase-prefixed. */
+	failures: string[];
+}
+
+/** Display metadata for find tool results. */
+export interface FindToolDetails {
+	query: string;
+	/** Lexical keywords actually used: derived from the query plus `grep_keywords`. */
+	keywords: string[];
+	/** Verified-passage probability at or above which a file is a hit. */
+	threshold: number;
+	hits: FindHit[];
+	stats: FindStats;
+	elapsedMs: number;
+	/** Session cwd; hit paths are relative to it. */
+	cwd: string;
+	/** Display form of the searched directory when narrower than cwd. */
+	scopePath?: string;
+	meta?: OutputMeta;
+}
+
+interface FindRenderArgs {
+	query?: string;
+	grep_keywords?: string[];
+	path?: string;
+}
+
+/** Cells in the per-hit score gauge. */
+const GAUGE_WIDTH = 6;
+/** Hits shown before expansion. */
+const COLLAPSED_HITS = 5;
+/** Ranges shown per hit: one collapsed, three expanded. */
+const RANGES_COLLAPSED = 1;
+const RANGES_EXPANDED = 3;
+/** Score at or above which a hit renders as strong / plausible. */
+const STRONG = 0.7;
+const PLAUSIBLE = 0.4;
+
+function scoreColor(p: number): ThemeColor {
+	return p >= STRONG ? "success" : p >= PLAUSIBLE ? "warning" : "muted";
+}
+
+function gauge(p: number, theme: Theme): string {
+	const color = scoreColor(p);
+	return renderProgressBar(p, GAUGE_WIDTH, {
+		style: {
+			filled: theme.symbol("progress.filled"),
+			empty: theme.symbol("progress.empty"),
+			styleFilled: text => theme.fg(color, text),
+			styleEmpty: text => theme.fg("dim", text),
+		},
+	});
+}
+
+function renderHit(hit: FindHit, rangeLimit: number, cwd: string | undefined, theme: Theme): string[] {
+	const absPath = cwd === undefined ? undefined : path.join(cwd, hit.rel);
+	const link = (text: string, line?: number) =>
+		absPath === undefined ? text : fileHyperlink(absPath, text, { line });
+	const coverage = hit.truncated ? `${hit.linesSeen} lines judged, partial` : `${hit.linesSeen} lines judged`;
+	const lines = [
+		`${gauge(hit.contentScore, theme)} ${theme.fg(scoreColor(hit.contentScore), hit.contentScore.toFixed(2))} ${link(theme.fg("accent", hit.rel))} ${theme.fg("dim", coverage)}`,
+	];
+	const ranges = [...hit.ranges].sort((a, b) => b.p - a.p || a.start - b.start).slice(0, rangeLimit);
+	ranges.forEach((range, index) => {
+		const span = range.start === range.end ? String(range.start) : `${range.start}-${range.end}`;
+		const ref = link(theme.fg("muted", `:${span}`), range.start);
+		const snippet = theme.fg("toolOutput", replaceTabs(range.snippet.trim()));
+		const branch = theme.fg("dim", getTreeBranch(index === ranges.length - 1, theme));
+		lines.push(`  ${branch} ${ref} ${theme.fg("dim", range.p.toFixed(2))} ${snippet}`);
+	});
+	return lines;
+}
+
+function quoteQuery(query: string | undefined): string | undefined {
+	return query === undefined ? undefined : `"${query}"`;
+}
+
+/** Render find calls and results in the transcript. */
+export const findToolRenderer = {
+	renderCall(args: FindRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
+		const keywords = args.grep_keywords ?? [];
+		const meta = keywords.length > 0 ? [keywords.join(" ")] : [];
+		if (args.path) meta.push(`in ${args.path}`);
+		const text = renderStatusLine(
+			{
+				icon: "pending",
+				spinnerFrame: options.spinnerFrame,
+				title: "Find",
+				titleColor: "toolTitle",
+				description: quoteQuery(args.query),
+				meta,
+			},
+			uiTheme,
+		);
+		return new Text(text, 1, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: FindToolDetails; isError?: boolean },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		args?: FindRenderArgs,
+	): Component {
+		const details = result.details;
+		const text = result.content?.find(c => c.type === "text")?.text ?? "";
+
+		if (result.isError) {
+			return new Text(formatErrorMessage(text || "Unknown error", uiTheme), 1, 0);
+		}
+
+		// Streaming progress: the tool reports the phase it is in.
+		if (options.isPartial || details === undefined) {
+			const header = renderStatusLine(
+				{
+					icon: "pending",
+					spinnerFrame: options.spinnerFrame,
+					title: "Find",
+					titleColor: "toolTitle",
+					description: quoteQuery(args?.query ?? details?.query),
+					meta: text ? [text] : [],
+				},
+				uiTheme,
+			);
+			return new Text(header, 1, 0);
+		}
+
+		const { hits, stats, threshold } = details;
+		const description = quoteQuery(details.query);
+		const scope = details.scopePath === undefined ? [] : [`in ${details.scopePath}`];
+		const meta = [
+			formatCount("hit", hits.length),
+			...scope,
+			`${stats.filesRead} files read`,
+			`τ ${threshold.toFixed(2)}`,
+			`${formatNumber(stats.inputTokens)} tokens`,
+			`$${stats.cost.toFixed(4)}`,
+			formatDuration(details.elapsedMs),
+		];
+		if (stats.errors > 0) meta.push(uiTheme.fg("warning", `${stats.errors} failed`));
+
+		if (hits.length === 0) {
+			const emptyMeta = ["0 hits", ...scope, `$${stats.cost.toFixed(4)}`, formatDuration(details.elapsedMs)];
+			if (stats.errors > 0) emptyMeta.push(uiTheme.fg("warning", `${stats.errors} failed`));
+			const header = renderStatusLine(
+				{ icon: "warning", title: "Find", titleColor: "toolTitle", description, meta: emptyMeta },
+				uiTheme,
+			);
+			const lines = [header, formatEmptyMessage("No relevant passages found", uiTheme)];
+			for (const failure of stats.failures) lines.push(uiTheme.fg("warning", failure));
+			return new Text(lines.join("\n"), 1, 0);
+		}
+
+		const header = renderStatusLine(
+			{
+				iconOverride: uiTheme.fg("toolTitle", uiTheme.symbol("icon.search")),
+				title: "Find",
+				titleColor: "toolTitle",
+				description,
+				meta,
+			},
+			uiTheme,
+		);
+
+		return createCachedComponent(
+			() => options.expanded,
+			(width, expanded) => {
+				const hitLines = renderTreeList(
+					{
+						items: hits,
+						expanded,
+						maxCollapsed: COLLAPSED_HITS,
+						maxCollapsedLines: PREVIEW_LIMITS.EXPANDED_LINES,
+						itemType: "hit",
+						renderItem: hit =>
+							renderHit(hit, expanded ? RANGES_EXPANDED : RANGES_COLLAPSED, details.cwd, uiTheme),
+					},
+					uiTheme,
+				);
+				const extra: string[] = [];
+				if (expanded) {
+					extra.push(uiTheme.fg("dim", `keywords: ${details.keywords.join(", ")}`));
+					for (const failure of stats.failures) extra.push(uiTheme.fg("warning", failure));
+				}
+				return [header, ...hitLines, ...extra].map(line => truncateToWidth(line, width, Ellipsis.Omit));
+			},
+			{ paddingX: 1 },
+		);
+	},
+	mergeCallAndResult: true,
+	animatedPendingPreview: true,
+	animatedPartialResult: true,
+} satisfies ToolRenderer<FindRenderArgs, FindToolDetails>;

package/src/tools/hub.ts

@@ -870,6 +870,8 @@ export function launchRenderResult(
 								: "Wait timed out.",
 						),
 					);
+				} else if (details && params.pattern && details.matched === undefined) {
+					body.push(theme.fg("warning", `Process exited before output pattern /${params.pattern}/ matched.`));
 				}
 				break;
 			}

package/src/tools/index.ts

@@ -10,6 +10,7 @@ import { bashToolRenderer } from "./bash";
 import { debugToolRenderer } from "./debug";
 import { editToolRenderer } from "./edit";
 import { evalToolRenderer } from "./eval";
+import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./github";
 import { globToolRenderer } from "./glob";
 import { goalToolRenderer } from "./goal";
@@ -40,6 +41,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	eval: evalToolRenderer,
 	edit: editToolRenderer,
 	apply_patch: editToolRenderer,
+	find: findToolRenderer,
 	glob: globToolRenderer,
 	grep: grepToolRenderer,
 	lsp: lspToolRenderer,

package/src/tools/web-search.ts

@@ -290,6 +290,11 @@ export const SEARCH_PROVIDER_OPTIONS = [
 		description:
 			"Grok web search via xAI Responses API (uses SuperGrok/X Premium+ OAuth via /login xai-oauth, or XAI_API_KEY)",
 	},
+	{
+		value: "openrouter",
+		label: "OpenRouter",
+		description: "OpenRouter plugins-based web search with model-selected grounding",
+	},
 	{ value: "zai", label: "Z.AI", description: "Calls Z.AI webSearchPrime MCP" },
 	{ value: "exa", label: "Exa", description: "API via /login exa or EXA_API_KEY; explicit keyless fallback via MCP" },
 	{ value: "tinyfish", label: "TinyFish", description: "Requires TINYFISH_API_KEY" },

package/src/tui.ts

@@ -1257,6 +1257,13 @@ export class TUI extends Container {
 			if (!supported && isInsideHerdr() && status === 0) return;
 			this.#setSynchronizedOutput(supported);
 		});
+		// Icons painted before the Glyph Protocol registration landed may sit in
+		// the terminal as tofu; a full repaint re-emits them against the glossary.
+		this.terminal.onGlyphProtocolReport?.(supported => {
+			if (!supported || this.#stopped) return;
+			this.invalidate();
+			this.requestRender(true);
+		});
 		this.terminal.start(
 			data => this.#handleInput(data),
 			() => {

package/dist/types/prompt/magic-keyword-boundary.d.ts

@@ -1,9 +0,0 @@
-/**
- * Build a case-sensitive magic-keyword matcher for prose punctuation boundaries.
- *
- * Sentence punctuation and quotes may touch the keyword, but letters, digits,
- * underscores, slashes, backslashes, hyphens, file-extension dots, symbol
- * references (`foo::keyword`), and immediate call parentheses (`keyword()`)
- * keep the occurrence embedded in code rather than prose.
- */
-export declare function magicKeywordRegex(keyword: string, flags?: string): RegExp;

package/dist/types/prompt/orchestrate.d.ts

@@ -1,13 +0,0 @@
-import { type KeywordHighlighter } from "./gradient-highlight.js";
-/**
- * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
- * prose-delimited) in prose — never inside a code block, inline code span,
- * or XML/HTML section.
- */
-export declare function containsOrchestrate(text: string): boolean;
-/**
- * Highlight every standalone "orchestrate" in `text` for editor display with a
- * cool teal→violet gradient (hue 150..280), visually distinct from ultrathink's
- * full-spectrum rainbow.
- */
-export declare const highlightOrchestrate: KeywordHighlighter;

package/dist/types/prompt/ultrathink.d.ts

@@ -1,13 +0,0 @@
-import { type KeywordHighlighter } from "./gradient-highlight.js";
-/**
- * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
- * prose-delimited) in prose — never inside a code block, inline code span,
- * or XML/HTML section.
- */
-export declare function containsUltrathink(text: string): boolean;
-/**
- * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
- * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
- * gradient resolves smoothly regardless of casing or match length.
- */
-export declare const highlightUltrathink: KeywordHighlighter;

package/dist/types/prompt/workflow.d.ts

@@ -1,13 +0,0 @@
-import { type KeywordHighlighter } from "./gradient-highlight.js";
-/**
- * Whether `text` contains the standalone keyword "workflowz"
- * (lowercase, prose-delimited) in prose — never inside a code block, inline
- * code span, or XML/HTML section.
- */
-export declare function containsWorkflow(text: string): boolean;
-/**
- * Highlight every standalone "workflowz" in `text` for editor display
- * with a warm amber→green gradient (hue 30..150), visually distinct from
- * ultrathink's rainbow and orchestrate's teal→violet.
- */
-export declare const highlightWorkflow: KeywordHighlighter;

package/src/prompt/magic-keyword-boundary.ts

@@ -1,23 +0,0 @@
-/** Characters that bind a magic keyword into an identifier or path segment. */
-const LEFT_BOUNDARY = String.raw`(?<![\p{L}\p{N}_./\\-])(?<!::)`;
-
-/** Characters that cannot immediately follow a standalone magic keyword. */
-const RIGHT_BOUNDARY = String.raw`(?![\p{L}\p{N}_/\\-])(?!\.[\p{L}\p{N}_-])(?!\()`;
-
-/** Escape a literal string for safe insertion into a RegExp source. */
-function escapeRegExp(value: string): string {
-	return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-}
-
-/**
- * Build a case-sensitive magic-keyword matcher for prose punctuation boundaries.
- *
- * Sentence punctuation and quotes may touch the keyword, but letters, digits,
- * underscores, slashes, backslashes, hyphens, file-extension dots, symbol
- * references (`foo::keyword`), and immediate call parentheses (`keyword()`)
- * keep the occurrence embedded in code rather than prose.
- */
-export function magicKeywordRegex(keyword: string, flags = ""): RegExp {
-	const normalizedFlags = flags.includes("u") ? flags : `${flags}u`;
-	return new RegExp(`${LEFT_BOUNDARY}${escapeRegExp(keyword)}${RIGHT_BOUNDARY}`, normalizedFlags);
-}

package/src/prompt/orchestrate.ts

@@ -1,26 +0,0 @@
-import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
-import { magicKeywordRegex } from "./magic-keyword-boundary";
-import { keywordInProse } from "./markdown-prose";
-
-const ORCHESTRATE_WORD = magicKeywordRegex("orchestrate");
-
-/**
- * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
- * prose-delimited) in prose — never inside a code block, inline code span,
- * or XML/HTML section.
- */
-export function containsOrchestrate(text: string): boolean {
-	return keywordInProse(text, ORCHESTRATE_WORD);
-}
-
-/**
- * Highlight every standalone "orchestrate" in `text` for editor display with a
- * cool teal→violet gradient (hue 150..280), visually distinct from ultrathink's
- * full-spectrum rainbow.
- */
-export const highlightOrchestrate: KeywordHighlighter = createGradientHighlighter({
-	probe: /orchestrate/,
-	highlight: magicKeywordRegex("orchestrate", "g"),
-	stops: 14,
-	hue: t => 150 + t * 130,
-});

package/src/prompt/ultrathink.ts

@@ -1,26 +0,0 @@
-import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
-import { magicKeywordRegex } from "./magic-keyword-boundary";
-import { keywordInProse } from "./markdown-prose";
-
-const ULTRATHINK_WORD = magicKeywordRegex("ultrathink");
-
-/**
- * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
- * prose-delimited) in prose — never inside a code block, inline code span,
- * or XML/HTML section.
- */
-export function containsUltrathink(text: string): boolean {
-	return keywordInProse(text, ULTRATHINK_WORD);
-}
-
-/**
- * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
- * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
- * gradient resolves smoothly regardless of casing or match length.
- */
-export const highlightUltrathink: KeywordHighlighter = createGradientHighlighter({
-	probe: /ultrathink/,
-	highlight: magicKeywordRegex("ultrathink", "g"),
-	stops: 14,
-	hue: t => t * 330,
-});

package/src/prompt/workflow.ts

@@ -1,26 +0,0 @@
-import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
-import { magicKeywordRegex } from "./magic-keyword-boundary";
-import { keywordInProse } from "./markdown-prose";
-
-const WORKFLOW_WORD = magicKeywordRegex("workflowz");
-
-/**
- * Whether `text` contains the standalone keyword "workflowz"
- * (lowercase, prose-delimited) in prose — never inside a code block, inline
- * code span, or XML/HTML section.
- */
-export function containsWorkflow(text: string): boolean {
-	return keywordInProse(text, WORKFLOW_WORD);
-}
-
-/**
- * Highlight every standalone "workflowz" in `text` for editor display
- * with a warm amber→green gradient (hue 30..150), visually distinct from
- * ultrathink's rainbow and orchestrate's teal→violet.
- */
-export const highlightWorkflow: KeywordHighlighter = createGradientHighlighter({
-	probe: /workflowz/,
-	highlight: magicKeywordRegex("workflowz", "g"),
-	stops: 14,
-	hue: t => 30 + t * 120,
-});