@oh-my-pi/pi-tui 18.4.2 → 18.4.4

package/src/tools/github.ts

@@ -1,5 +1,11 @@
-import type { ToolRenderer } from "./renderer";
+import type { NativeToolView, ToolRenderer, ToolRenderResult } from "./renderer";
 import { type Component, padding, Text, visibleWidth } from "../index";
+import type { TspTone } from "@oh-my-pi/pi-wire";
+import { ansi, compact, item, list, md, node, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorView, noteText, toolHead } from "./native-view";
 import type { RenderResultOptions } from "./renderer";
 import type { Theme, ThemeColor } from "../theme/theme";
 import { outputBlockContentWidth, renderStatusLine } from "../render";
@@ -50,36 +56,41 @@ function formatOpTitle(op: string | undefined): string {
 	return "GitHub";
 }
 
-function extractIssueId(value: string | undefined): string | undefined {
+type FitText = (value: string, width: number) => string;
+
+/** Native views keep full values: the terminal truncates headers itself. */
+const KEEP_TEXT: FitText = value => value;
+
+function extractIssueId(value: string | undefined, fit: FitText = truncateVisualWidth): string | undefined {
 	if (!value) return undefined;
 	const trimmed = value.trim();
 	if (!trimmed) return undefined;
 	if (/^\d+$/.test(trimmed)) return `#${trimmed}`;
 	const match = trimmed.match(/\/(?:issues|pull)\/(\d+)/);
 	if (match) return `#${match[1]}`;
-	return truncateVisualWidth(trimmed, TRUNCATE_LENGTHS.SHORT);
+	return fit(trimmed, TRUNCATE_LENGTHS.SHORT);
 }
 
-function formatPrIdentifier(pr: string | string[] | undefined): string | undefined {
+function formatPrIdentifier(pr: string | string[] | undefined, fit: FitText = truncateVisualWidth): string | undefined {
 	if (pr === undefined) return undefined;
 	if (Array.isArray(pr)) {
-		const parts = pr.map(p => extractIssueId(p)).filter((p): p is string => p !== undefined);
+		const parts = pr.map(p => extractIssueId(p, fit)).filter((p): p is string => p !== undefined);
 		if (parts.length === 0) return undefined;
 		if (parts.length > 3) {
 			return `${parts.slice(0, 3).join(", ")}, +${parts.length - 3} more`;
 		}
 		return parts.join(", ");
 	}
-	return extractIssueId(pr);
+	return extractIssueId(pr, fit);
 }
 
-function buildOpMeta(args: GithubToolRenderArgs): string[] {
+function buildOpMeta(args: GithubToolRenderArgs, fit: FitText = truncateVisualWidth): string[] {
 	const meta: string[] = [];
 	const op = args.op;
 	switch (op) {
 		case "pr_checkout":
 		case "pr_push": {
-			const id = formatPrIdentifier(args.pr);
+			const id = formatPrIdentifier(args.pr, fit);
 			if (id) meta.push(id);
 			else if (args.branch) meta.push(args.branch);
 			if (args.repo) meta.push(args.repo);
@@ -89,12 +100,12 @@ function buildOpMeta(args: GithubToolRenderArgs): string[] {
 		case "search_prs":
 		case "search_code":
 		case "search_commits": {
-			if (args.query) meta.push(truncateVisualWidth(args.query, TRUNCATE_LENGTHS.CONTENT));
+			if (args.query) meta.push(fit(args.query, TRUNCATE_LENGTHS.CONTENT));
 			if (args.repo) meta.push(args.repo);
 			break;
 		}
 		case "search_repos": {
-			if (args.query) meta.push(truncateVisualWidth(args.query, TRUNCATE_LENGTHS.CONTENT));
+			if (args.query) meta.push(fit(args.query, TRUNCATE_LENGTHS.CONTENT));
 			break;
 		}
 		case "repo_view": {
@@ -410,6 +421,79 @@ function renderWatchCall(args: GithubToolRenderArgs, options: RenderResultOption
 	return new Text(`${header}\n${wait}`, 0, 0);
 }
 
+function jobTone(job: GhRunWatchJobDetails): TspTone {
+	if (job.conclusion && SUCCESS_CONCLUSIONS.has(job.conclusion)) return "success";
+	if (job.conclusion && FAILURE_CONCLUSIONS.has(job.conclusion)) return "error";
+	if (job.status && RUNNING_STATUSES.has(job.status)) return "warning";
+	return "muted";
+}
+
+/** One workflow run: a section headed by workflow + branch/sha + id, listing its jobs. */
+function describeRun(run: GhRunWatchRunDetails): NativeNode {
+	const metaParts = getRunMeta(run);
+	const head = [span(plainText(getRunLabel(run)), "accent")];
+	metaParts.forEach((part, index) => {
+		head.push(span("  "), span(plainText(part), index === metaParts.length - 1 ? "muted" : "text"));
+	});
+	const jobs =
+		run.jobs.length === 0
+			? noteText("waiting for workflow jobs...")
+			: list(
+					run.jobs.map(job => {
+						const tone = jobTone(job);
+						return item(`${job.id}`, {
+							label: [span(plainText(job.name), tone)],
+							tone,
+							icon: tone === "success" ? "check" : undefined,
+							value: job.durationSeconds !== undefined ? [span(`${job.durationSeconds}s`, tone)] : undefined,
+						});
+					}),
+				);
+	return node("section", { head }, [jobs], `run:${run.id}`);
+}
+
+function describeWatch(watch: GhRunWatchViewDetails, isError: boolean): NativeToolView {
+	const runs: NativeChild[] = [];
+	if (watch.mode === "run" && watch.run) runs.push(describeRun(watch.run));
+	else if (watch.mode === "commit") {
+		const commitRuns = watch.runs ?? [];
+		if (commitRuns.length === 0) runs.push(noteText("waiting for workflow runs..."));
+		for (const run of commitRuns) runs.push(describeRun(run));
+	}
+	const failed = (watch.failedLogs ?? []).flatMap((entry): NativeChild[] => {
+		const context = entry.workflowName ? `${entry.workflowName}  #${entry.runId}` : `run #${entry.runId}`;
+		const title = text([span(plainText(entry.jobName), "error"), span(`  ${plainText(context)}`, "muted")]);
+		if (!entry.available || !entry.tail) return [title, noteText("log tail unavailable")];
+		return [title, ansi(entry.tail, { follow: true, preview: { lines: PREVIEW_LIMITS.OUTPUT_COLLAPSED } })];
+	});
+	return {
+		head: toolHead("GitHub Run Watch", getWatchHeader(watch)),
+		tone: isError ? "error" : undefined,
+		body: compact([
+			watch.note ? noteText(watch.note) : undefined,
+			...runs,
+			failed.length > 0
+				? node("section", { head: [span("failed logs", "error")], tone: "error" }, failed, "failed")
+				: undefined,
+		]),
+	};
+}
+
+function describeFallback(result: ToolRenderResult<GhToolDetails>, args: GithubToolRenderArgs): NativeToolView {
+	const output = extractText(result.content).trim();
+	const title = formatOpTitle(args.op);
+	const meta = buildOpMeta(args, KEEP_TEXT);
+	if (result.isError === true) return errorView(title, output || "request failed", ...meta);
+	if (!output) return { head: toolHead(title, ...meta), tone: "warning", body: [noteText("no output")] };
+	return {
+		head: toolHead(title, ...meta),
+		body: [md(plainText(output))],
+		preview: { lines: PREVIEW_LIMITS.OUTPUT_EXPANDED },
+	};
+}
+
+const githubResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Render GitHub operations and live workflow status. */
 export const githubToolRenderer = {
 	// No animatedPendingPreview: renderCall materializes plain Text components
@@ -483,6 +567,31 @@ export const githubToolRenderer = {
 		return renderFallbackComponent(result, options, uiTheme, args ?? {});
 	},
 
+	describeCall(args: GithubToolRenderArgs): NativeToolView {
+		const op = typeof args.op === "string" && args.op.trim().length > 0 ? args.op.trim() : undefined;
+		if (op !== "run_watch") {
+			return { head: toolHead(formatOpTitle(op), ...buildOpMeta({ ...args, op }, KEEP_TEXT)) };
+		}
+		const runId = typeof args.run === "string" && args.run.trim().length > 0 ? args.run.trim() : undefined;
+		const branch = typeof args.branch === "string" && args.branch.trim().length > 0 ? args.branch.trim() : undefined;
+		return {
+			head: toolHead("GitHub Run Watch", runId ? `#${runId}` : (branch ?? "current HEAD")),
+			body: [noteText("waiting for workflow data...")],
+		};
+	},
+
+	describeResult(
+		result: ToolRenderResult<GhToolDetails>,
+		options: RenderResultOptions,
+		args?: GithubToolRenderArgs,
+	): NativeToolView | undefined {
+		const watch = result.details?.watch;
+		const deps = [args?.op, options.isPartial, watch?.state, watch?.pollCount];
+		return githubResultMemo.get(result, deps, () =>
+			watch ? describeWatch(watch, result.isError === true) : describeFallback(result, args ?? {}),
+		);
+	},
+
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<GithubToolRenderArgs, GhToolDetails>;
 

package/src/tools/glob.ts

@@ -1,6 +1,9 @@
 import type { Component } from "../tui";
 import { Text } from "../components/text";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions, ToolRenderer } from "./renderer";
+import { col, compact, keyed, node, row, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { fileHref, fileRow, footnoteText, inlineErrorView, resultText } from "./native-view";
 import { type Theme } from "../theme/theme";
 import type { OutputMeta } from "./output-meta";
 import type { TruncationResult } from "./streaming-output";
@@ -56,6 +59,51 @@ function globStatusIcon(uiTheme: Theme): string {
 	return uiTheme.fg("toolTitle", uiTheme.symbol("icon.search"));
 }
 
+/** Most files a native glob lists as rows; more wrap as chips (§7.3 glob). */
+const NATIVE_LIST_MAX = 6;
+/** Collapsed clamp: the whole ≤ 6-row list, or about six rows of chips. */
+const NATIVE_PREVIEW_LINES = 8;
+
+/**
+ * Native glob files: 22px path rows when there are few, else a wrap of
+ * chips (glyph and name, the full path in the tooltip). Paths link when the
+ * search `cwd` is known.
+ */
+function describeGlobFiles(files: readonly string[], cwd: string | undefined): NativeNode {
+	const links = files.map(file => (cwd && !file.endsWith("/") ? fileHref(path.resolve(cwd, file)) : undefined));
+	if (files.length <= NATIVE_LIST_MAX) {
+		return col(
+			files.map((file, i) => fileRow(file, { href: links[i] })),
+			{ role: "omp.tool.files", gap: "none" },
+		);
+	}
+	return row(
+		files.map((file, i) => {
+			const isDir = file.endsWith("/");
+			const name = path.basename(file) + (isDir ? "/" : "");
+			const link = links[i];
+			return keyed(
+				row(
+					[
+						node("icon", { name: isDir ? "folder" : "file" }),
+						text([span(name, "strong", link ? { href: link } : undefined)], { wrap: "none" }),
+					],
+					{ role: "omp.tool.chip", gap: "xs", align: "center", title: file },
+				),
+				file,
+			);
+		}),
+		{ role: "omp.tool.files", gap: "xs", wrap: true },
+	);
+}
+
+/** Native glob head: the pattern, then `meta` (the result counts, or the call's `limit`). */
+function globNativeHead(args: GlobRenderArgs | undefined, meta: readonly string[] = []): NativeToolHead {
+	const parts = [...meta];
+	if (meta.length === 0 && args?.limit !== undefined) parts.push(`limit:${args.limit}`);
+	return { title: "Glob", target: formatGlobRenderPaths(args) || "*", targetKind: "pattern", meta: parts };
+}
+
 /** Render glob calls and results in the transcript. */
 export const globToolRenderer = {
 	inline: true,
@@ -209,5 +257,72 @@ export const globToolRenderer = {
 			{ paddingX: 1 },
 		);
 	},
+	describeCall(args: GlobRenderArgs): NativeToolView {
+		return { tool: globNativeHead(args), inline: true };
+	},
+
+	/**
+	 * Inline (§7.3 glob): `Glob “pattern”  5 files`, then the files as rows
+	 * (≤ 6) or a wrap of chips; one quiet footnote for limits and skipped paths.
+	 */
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: GlobToolDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		args?: GlobRenderArgs,
+	): NativeToolView {
+		const details = result.details;
+		if (result.isError || details?.error) {
+			return inlineErrorView(globNativeHead(args), details?.error || resultText(result) || "Unknown error");
+		}
+		if (details?.fileCount === undefined) {
+			const textContent = resultText(result);
+			if (
+				!textContent.trim() ||
+				textContent.includes("No files matching") ||
+				textContent.includes("No files found")
+			) {
+				return { tool: globNativeHead(args, ["0 files"]), tone: "warning", inline: true };
+			}
+			const lines = textContent.split("\n").filter(l => l.trim());
+			return {
+				tool: globNativeHead(args, [formatCount("file", lines.length)]),
+				inline: true,
+				body: [describeGlobFiles(lines, undefined)],
+				preview: { lines: NATIVE_PREVIEW_LINES },
+			};
+		}
+		const truncation = details.truncation ?? details.meta?.truncation;
+		const limits = details.meta?.limits;
+		const truncated = Boolean(details.truncated || truncation || details.resultLimitReached || limits?.resultLimit);
+		const missingPaths = details.missingPaths ?? [];
+		const missingNote = missingPaths.length > 0 ? `skipped missing: ${missingPaths.join(", ")}` : undefined;
+		const scope = details.scopePath ? `in ${details.scopePath}` : undefined;
+		if (details.fileCount === 0) {
+			const foot = footnoteText(compact([missingNote]));
+			return {
+				// `truncated` on an empty result means the scan timed out mid-walk.
+				tool: { ...globNativeHead(args, compact(["0 files", scope])), note: truncated ? "timed out" : undefined },
+				tone: "warning",
+				inline: true,
+				body: foot ? [foot] : undefined,
+			};
+		}
+		const reasons: string[] = [];
+		if (details.resultLimitReached) reasons.push(`limit ${details.resultLimitReached} results`);
+		if (limits?.resultLimit) reasons.push(`limit ${limits.resultLimit.reached} results`);
+		if (truncation) reasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
+		const artifactId = truncation && "artifactId" in truncation ? truncation.artifactId : undefined;
+		if (artifactId) reasons.push(formatFullOutputReference(artifactId));
+		const head = globNativeHead(args, compact([formatCount("file", details.fileCount), scope]));
+		return {
+			tool: truncated ? { ...head, badges: [{ text: "truncated", tone: "warning" }] } : head,
+			inline: true,
+			body: compact<NativeChild>([
+				describeGlobFiles(details.files ?? [], details.cwd),
+				footnoteText(compact([reasons.length > 0 && `truncated: ${reasons.join(", ")}`, missingNote])),
+			]),
+			preview: { lines: NATIVE_PREVIEW_LINES },
+		};
+	},
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<GlobRenderArgs, GlobToolDetails>;

package/src/tools/goal.ts

@@ -4,7 +4,11 @@ import type { Theme, ThemeColor } from "../theme/theme";
 import { formatDuration, formatErrorDetail, formatNumber, TRUNCATE_LENGTHS } from "../render/render-utils";
 import { renderStatusLine, truncateToWidth } from "../render/index";
 import { framedToolCard } from "../render/tool-card";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { TspSpan } from "@oh-my-pi/pi-wire";
+import { compact, node, span, text } from "../native/describe";
+import { OwnerMemo } from "../native/memo";
+import { errorView, noteText, resultText, toolHead } from "./native-view";
+import type { NativeToolView, RenderResultOptions, ToolRenderer, ToolRenderResult } from "./renderer";
 /** Lifecycle state of a tracked goal. */
 export type GoalStatus = "active" | "paused" | "budget-limited" | "complete" | "dropped";
 
@@ -64,6 +68,39 @@ interface GoalRenderArgs {
 	token_budget?: number;
 }
 
+function describeGoalResult(result: ToolRenderResult<GoalToolDetails>, args?: GoalRenderArgs): NativeToolView {
+	const details = result.details;
+	const description = describeOp(details?.op ?? args?.op);
+	if (result.isError) return errorView("Goal", resultText(result) || "Goal tool failed", description);
+	const goal = details?.goal ?? null;
+	if (!goal) return { head: toolHead("Goal", description, "no active goal"), tone: "warning" };
+
+	const head = [
+		...toolHead("Goal", description),
+		span(" "),
+		span(goal.status, `${goalBadgeColor(goal.status)} strong`),
+	];
+	const used = formatNumber(goal.tokensUsed);
+	const left = goal.tokenBudget !== undefined ? Math.max(0, goal.tokenBudget - goal.tokensUsed) : 0;
+	const tokens =
+		goal.tokenBudget !== undefined
+			? `${used} / ${formatNumber(goal.tokenBudget)} tokens (${formatNumber(left)} left)`
+			: `${used} tokens`;
+	const meta = [tokens];
+	if (goal.timeUsedSeconds > 0) meta.push(`${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`);
+	const report = details?.completionBudgetReport;
+	return {
+		head,
+		body: compact([
+			text([span(`"${goal.objective.trim()}"`, "muted")], { wrap: "word" }),
+			text([span(meta.join(" · "), "dim")], { wrap: "word" }),
+			report ? node("section", { head: [span("Report", "toolTitle")] }, [noteText(report)], "report") : undefined,
+		]),
+	};
+}
+
+const goalResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Renders goal creation, status, and lifecycle results. */
 export const goalToolRenderer = {
 	renderCall(args: GoalRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
@@ -149,5 +186,23 @@ export const goalToolRenderer = {
 		}));
 	},
 
+	describeCall(args: GoalRenderArgs): NativeToolView {
+		const head: TspSpan[] = toolHead("Goal", describeOp(args.op));
+		const objective = args.objective?.trim();
+		if (args.op === "create" && objective) head.push(span(" "), span(`"${objective}"`, "muted"));
+		if (args.op === "create" && args.token_budget !== undefined) {
+			head.push(span(" "), span(`budget ${formatNumber(args.token_budget)}`, "muted"));
+		}
+		return { head };
+	},
+
+	describeResult(
+		result: ToolRenderResult<GoalToolDetails>,
+		_options: RenderResultOptions,
+		args?: GoalRenderArgs,
+	): NativeToolView | undefined {
+		return goalResultMemo.get(result, [args?.op], () => describeGoalResult(result, args));
+	},
+
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<GoalRenderArgs, GoalToolDetails>;

package/src/tools/grep.ts

@@ -1,6 +1,10 @@
 import type { Component } from "../tui";
 import { Text } from "../components/text";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolHead, NativeToolView, RenderResultOptions, ToolRenderer } from "./renderer";
+import { getLanguageFromPath } from "../lang-from-path";
+import { compact } from "../native/describe";
+import type { NativeChild } from "../native/node";
+import { footnoteText, inlineErrorView, resultText } from "./native-view";
 import { type Theme } from "../theme/theme";
 import type { OutputMeta } from "./output-meta";
 import type { TruncationResult } from "./streaming-output";
@@ -24,7 +28,7 @@ import {
 	PREVIEW_LIMITS,
 	replaceTabs,
 } from "../render/render-utils";
-import { classifyGroupedLines, groupLineIndicesByBlank } from "./grouped-file-output";
+import { classifyGroupedLines, describeGroupedOutput, groupLineIndicesByBlank } from "./grouped-file-output";
 
 /** Display metadata for grep tool results. */
 export interface GrepToolDetails {
@@ -79,6 +83,9 @@ const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
  * whose matches span the whole file can't dump its entire length. */
 const EXPANDED_TEXT_LIMIT = PREVIEW_LIMITS.EXPANDED_LINES * 2;
 
+/** Files a collapsed native grep shows (§7.3). */
+const NATIVE_COLLAPSED_FILES = 2;
+
 const SEARCH_CODE_FRAME_LINE_RE = /^\s*\*?(\d+)│/;
 
 function searchScopeMeta(details: GrepToolDetails | undefined): string | undefined {
@@ -381,5 +388,79 @@ export const grepToolRenderer = {
 			{ paddingX: 1 },
 		);
 	},
+	describeCall(args: GrepRenderArgs): NativeToolView {
+		return { tool: grepNativeHead(args), inline: true };
+	},
+
+	/**
+	 * Inline (§7.3 grep): `Grep “pattern”  5 matches · 2 files  in src`, then
+	 * the matches grouped by file; collapsed shows the first two files.
+	 */
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: GrepToolDetails; isError?: boolean },
+		options: RenderResultOptions,
+		args?: GrepRenderArgs,
+	): NativeToolView {
+		const details = result.details;
+		if (result.isError || details?.error) {
+			return inlineErrorView(grepNativeHead(args), details?.error || resultText(result) || "Unknown error");
+		}
+		const textContent = details?.displayContent ?? resultText(result);
+		const missing = details?.missingPaths ?? [];
+		const missingNote = missing.length > 0 ? `skipped missing: ${missing.join(", ")}` : undefined;
+		const scope = details?.scopePath ? `in ${details.scopePath}` : undefined;
+		const hasDetailedData = details?.matchCount !== undefined || details?.fileCount !== undefined;
+		const matchCount = details?.matchCount ?? 0;
+		if (
+			(!hasDetailedData && (!textContent || textContent === "No matches found")) ||
+			(hasDetailedData && matchCount === 0)
+		) {
+			const foot = footnoteText(compact([missingNote]));
+			return {
+				tool: grepNativeHead(args, compact(["0 matches", scope])),
+				tone: "warning",
+				inline: true,
+				body: foot ? [foot] : undefined,
+			};
+		}
+		const truncated = Boolean(
+			details?.truncated || details?.meta?.truncation || details?.meta?.limits?.columnTruncated,
+		);
+		const fileCount = details?.fileCount ?? 0;
+		const counts = hasDetailedData
+			? `${formatCount("match", matchCount)} · ${formatCount("file", fileCount)}`
+			: undefined;
+		const head = grepNativeHead(args, compact([counts, scope]));
+		const hiddenFiles = options.expanded ? 0 : Math.max(0, fileCount - NATIVE_COLLAPSED_FILES);
+		const foot = footnoteText(
+			compact([hiddenFiles > 0 && formatCount("more file", hiddenFiles), missingNote]),
+			details?.meta,
+		);
+		return {
+			tool: truncated ? { ...head, badges: [{ text: "truncated", tone: "warning" }] } : head,
+			inline: true,
+			body: compact<NativeChild>([
+				...describeGroupedOutput(textContent.split("\n"), {
+					lang: getLanguageFromPath,
+					maxFiles: options.expanded ? undefined : NATIVE_COLLAPSED_FILES,
+				}),
+				foot,
+			]),
+			preview: { lines: PREVIEW_LIMITS.EXPANDED_LINES },
+		};
+	},
 	mergeCallAndResult: true,
 } satisfies ToolRenderer<GrepRenderArgs, GrepToolDetails>;
+
+/** Native grep head: the pattern, then the result `meta` or, before a result, the scope/flag arguments. */
+function grepNativeHead(args: GrepRenderArgs | undefined, meta?: readonly string[]): NativeToolHead {
+	const parts = meta ? [...meta] : [];
+	if (!meta && args) {
+		const paths = toPathList(args.path ?? args.paths);
+		if (paths.length) parts.push(`in ${paths.join(", ")}`);
+		if (args.case === false) parts.push("case:insensitive");
+		if (args.gitignore === false) parts.push("gitignore:false");
+		if (args.skip !== undefined && args.skip > 0) parts.push(`skip:${args.skip}`);
+	}
+	return { title: "Grep", target: args?.pattern || "?", targetKind: "pattern", meta: parts };
+}