@leing2021/super-pi 0.21.0 → 0.22.1

package/extensions/subagent/prompt-template-bridge.ts

@@ -0,0 +1,400 @@
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
+export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request";
+export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started";
+export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response";
+export const PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = "prompt-template:subagent:update";
+export const PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = "prompt-template:subagent:cancel";
+
+export interface PromptTemplateDelegationTask {
+	agent: string;
+	task: string;
+	model?: string;
+	cwd?: string;
+}
+
+export interface PromptTemplateDelegationParallelResult {
+	agent: string;
+	messages: unknown[];
+	isError: boolean;
+	errorText?: string;
+}
+
+export interface PromptTemplateDelegationRequest {
+	requestId: string;
+	agent: string;
+	task: string;
+	tasks?: PromptTemplateDelegationTask[];
+	context: "fresh" | "fork";
+	model: string;
+	cwd: string;
+	worktree?: boolean;
+}
+
+export interface PromptTemplateDelegationResponse extends PromptTemplateDelegationRequest {
+	messages: unknown[];
+	parallelResults?: PromptTemplateDelegationParallelResult[];
+	contentText?: string;
+	isError: boolean;
+	errorText?: string;
+}
+
+export interface PromptTemplateDelegationTaskProgress {
+	index?: number;
+	agent: string;
+	status?: string;
+	currentTool?: string;
+	currentToolArgs?: string;
+	recentOutput?: string;
+	recentOutputLines?: string[];
+	recentTools?: Array<{ tool: string; args: string }>;
+	model?: string;
+	toolCount?: number;
+	durationMs?: number;
+	tokens?: number;
+}
+
+export interface PromptTemplateDelegationUpdate {
+	requestId: string;
+	currentTool?: string;
+	currentToolArgs?: string;
+	recentOutput?: string;
+	recentOutputLines?: string[];
+	recentTools?: Array<{ tool: string; args: string }>;
+	model?: string;
+	toolCount?: number;
+	durationMs?: number;
+	tokens?: number;
+	taskProgress?: PromptTemplateDelegationTaskProgress[];
+}
+
+export interface PromptTemplateBridgeEvents {
+	on(event: string, handler: (data: unknown) => void): (() => void) | void;
+	emit(event: string, data: unknown): void;
+}
+
+interface PromptTemplateBridgeResult {
+	isError?: boolean;
+	content?: unknown;
+	details?: {
+		results?: Array<{
+			agent?: string;
+			messages?: unknown[];
+			finalOutput?: string;
+			exitCode?: number;
+			error?: string;
+			model?: string;
+		}>;
+		progress?: Array<{
+			index?: number;
+			agent?: string;
+			status?: string;
+			currentTool?: string;
+			currentToolArgs?: string;
+			recentOutput?: string[];
+			recentTools?: Array<{ tool?: string; args?: string }>;
+			toolCount?: number;
+			durationMs?: number;
+			tokens?: number;
+		}>;
+	};
+}
+
+export interface PromptTemplateBridgeOptions<Ctx extends { cwd?: string }> {
+	events: PromptTemplateBridgeEvents;
+	getContext: () => Ctx | null;
+	execute: (
+		requestId: string,
+		request: PromptTemplateDelegationRequest,
+		signal: AbortSignal,
+		ctx: Ctx,
+		onUpdate: (result: PromptTemplateBridgeResult) => void,
+	) => Promise<PromptTemplateBridgeResult>;
+}
+
+function parseDelegationTasks(tasks: unknown): PromptTemplateDelegationTask[] {
+	if (!Array.isArray(tasks)) return [];
+	const parsed: PromptTemplateDelegationTask[] = [];
+	for (const item of tasks) {
+		if (!item || typeof item !== "object") return [];
+		const value = item as Partial<PromptTemplateDelegationTask>;
+		if (typeof value.agent !== "string" || !value.agent.trim()) return [];
+		if (typeof value.task !== "string" || !value.task.trim()) return [];
+		const model = typeof value.model === "string" && value.model.trim().length > 0 ? value.model : undefined;
+		const cwd = typeof value.cwd === "string" && value.cwd.trim().length > 0 ? value.cwd : undefined;
+		parsed.push({
+			agent: value.agent,
+			task: value.task,
+			...(model ? { model } : {}),
+			...(cwd ? { cwd } : {}),
+		});
+	}
+	return parsed;
+}
+
+export function parsePromptTemplateRequest(data: unknown): PromptTemplateDelegationRequest | undefined {
+	if (!data || typeof data !== "object") return undefined;
+	const value = data as Partial<PromptTemplateDelegationRequest> & { tasks?: unknown };
+	if (typeof value.requestId !== "string" || !value.requestId) return undefined;
+	if (typeof value.model !== "string" || !value.model) return undefined;
+	if (typeof value.cwd !== "string" || !value.cwd) return undefined;
+	if (value.context !== "fresh" && value.context !== "fork") return undefined;
+	const tasks = parseDelegationTasks(value.tasks);
+	const worktree = value.worktree === true ? true : undefined;
+	const hasSingle =
+		typeof value.agent === "string" &&
+		value.agent.length > 0 &&
+		typeof value.task === "string" &&
+		value.task.length > 0;
+	if (!hasSingle && tasks.length === 0) return undefined;
+
+	const fallbackTask = tasks[0];
+	return {
+		requestId: value.requestId,
+		agent: hasSingle ? value.agent : fallbackTask!.agent,
+		task: hasSingle ? value.task : fallbackTask!.task,
+		...(tasks.length > 0 ? { tasks } : {}),
+		context: value.context,
+		model: value.model,
+		cwd: value.cwd,
+		...(worktree ? { worktree } : {}),
+	};
+}
+
+export function firstTextContent(content: unknown): string | undefined {
+	if (!Array.isArray(content)) return undefined;
+	for (const part of content) {
+		if (!part || typeof part !== "object") continue;
+		if ((part as { type?: string }).type !== "text") continue;
+		const text = (part as { text?: unknown }).text;
+		if (typeof text === "string" && text.trim()) return text.trim();
+	}
+	return undefined;
+}
+
+function filterRecentOutput(lines: string[] | undefined): string[] | undefined {
+	if (!lines || lines.length === 0) return undefined;
+	const filtered = lines.filter((line) => typeof line === "string" && line.trim() && line.trim() !== "(running...)");
+	if (filtered.length === 0) return undefined;
+	return filtered;
+}
+
+function sanitizeRecentTools(
+	tools: Array<{ tool?: string; args?: string }> | undefined,
+): Array<{ tool: string; args: string }> | undefined {
+	if (!tools || tools.length === 0) return undefined;
+	const sanitized = tools.flatMap((entry) => {
+		if (typeof entry.tool !== "string" || entry.tool.trim().length === 0) return [];
+		return [{
+			tool: entry.tool,
+			args: typeof entry.args === "string" ? entry.args : String(entry.args ?? ""),
+		}];
+	});
+	return sanitized.length > 0 ? sanitized : undefined;
+}
+
+function resolveProgressModel(
+	update: PromptTemplateBridgeResult,
+	entry: { index?: number; agent?: string },
+): string | undefined {
+	const results = update.details?.results;
+	if (!results || results.length === 0) return undefined;
+	if (typeof entry.index === "number" && entry.index >= 0) {
+		const byIndex = results[entry.index];
+		if (typeof byIndex?.model === "string") return byIndex.model;
+	}
+	if (entry.agent) {
+		const byAgent = results.find((result) => result.agent === entry.agent && typeof result.model === "string");
+		if (byAgent?.model) return byAgent.model;
+	}
+	const firstWithModel = results.find((result) => typeof result.model === "string");
+	return firstWithModel?.model;
+}
+
+function buildDelegationMessages(result: { messages?: unknown[]; finalOutput?: string }, fallbackText?: string): unknown[] {
+	if (Array.isArray(result.messages) && result.messages.length > 0) return result.messages;
+	const text = typeof result.finalOutput === "string" && result.finalOutput.trim().length > 0
+		? result.finalOutput.trim()
+		: fallbackText;
+	if (!text) return [];
+	return [{ role: "assistant", content: [{ type: "text", text }] }];
+}
+
+function toDelegationUpdate(requestId: string, update: PromptTemplateBridgeResult): PromptTemplateDelegationUpdate | undefined {
+	const progress = update.details?.progress?.[0];
+	const taskProgress = update.details?.progress?.map((entry) => {
+		const lastOutput = entry.recentOutput?.[entry.recentOutput.length - 1];
+		const safeLastOutput =
+			typeof lastOutput === "string" && lastOutput.trim() && lastOutput !== "(running...)"
+				? lastOutput
+				: undefined;
+		return {
+			index: entry.index,
+			agent: entry.agent ?? "delegate",
+			status: entry.status,
+			currentTool: entry.currentTool,
+			currentToolArgs: entry.currentToolArgs,
+			recentOutput: safeLastOutput,
+			recentOutputLines: filterRecentOutput(entry.recentOutput),
+			recentTools: sanitizeRecentTools(entry.recentTools),
+			model: resolveProgressModel(update, entry),
+			toolCount: entry.toolCount,
+			durationMs: entry.durationMs,
+			tokens: entry.tokens,
+		};
+	});
+	if (!progress && (!taskProgress || taskProgress.length === 0)) return undefined;
+	const lastOutput = progress?.recentOutput?.[progress.recentOutput.length - 1];
+	const safeLastOutput =
+		typeof lastOutput === "string" && lastOutput.trim() && lastOutput !== "(running...)"
+			? lastOutput
+			: undefined;
+	return {
+		requestId,
+		currentTool: progress?.currentTool,
+		currentToolArgs: progress?.currentToolArgs,
+		recentOutput: safeLastOutput,
+		recentOutputLines: filterRecentOutput(progress?.recentOutput),
+		recentTools: sanitizeRecentTools(progress?.recentTools),
+		model: progress ? resolveProgressModel(update, progress) : undefined,
+		toolCount: progress?.toolCount,
+		durationMs: progress?.durationMs,
+		tokens: progress?.tokens,
+		taskProgress,
+	};
+}
+
+export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: string }>(
+	options: PromptTemplateBridgeOptions<Ctx>,
+): {
+	cancelAll: () => void;
+	dispose: () => void;
+} {
+	const controllers = new Map<string, AbortController>();
+	const pendingCancels = new Set<string>();
+	const subscriptions: Array<() => void> = [];
+
+	const subscribe = (event: string, handler: (data: unknown) => void): void => {
+		const unsubscribe = options.events.on(event, handler);
+		if (typeof unsubscribe === "function") subscriptions.push(unsubscribe);
+	};
+
+	subscribe(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, (data) => {
+		if (!data || typeof data !== "object") return;
+		const requestId = (data as { requestId?: unknown }).requestId;
+		if (typeof requestId !== "string") return;
+		const controller = controllers.get(requestId);
+		if (controller) {
+			controller.abort();
+			return;
+		}
+		pendingCancels.add(requestId);
+	});
+
+	subscribe(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, async (data) => {
+		const request = parsePromptTemplateRequest(data);
+		if (!request) return;
+
+		const ctx = options.getContext();
+		if (!ctx) {
+			const response: PromptTemplateDelegationResponse = {
+				...request,
+				messages: [],
+				isError: true,
+				errorText: "No active extension context for delegated subagent execution.",
+			};
+			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			return;
+		}
+
+		const controller = new AbortController();
+		controllers.set(request.requestId, controller);
+
+		if (pendingCancels.delete(request.requestId)) {
+			controller.abort();
+			const response: PromptTemplateDelegationResponse = {
+				...request,
+				messages: [],
+				isError: true,
+				errorText: "Delegated prompt cancelled.",
+			};
+			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			controllers.delete(request.requestId);
+			return;
+		}
+
+		options.events.emit(PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, { requestId: request.requestId });
+
+		try {
+			const result = await options.execute(
+				request.requestId,
+				request,
+				controller.signal,
+				ctx,
+				(update) => {
+					const payload = toDelegationUpdate(request.requestId, update);
+					if (!payload) return;
+					options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
+				},
+			);
+			const contentText = firstTextContent(result.content);
+			const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
+			const parallelResults = request.tasks
+				? request.tasks.map<PromptTemplateDelegationParallelResult>((task, index) => {
+					const step = result.details?.results?.[index];
+					if (!step) {
+						return {
+							agent: task.agent,
+							messages: [],
+							isError: true,
+							errorText: "Missing result for delegated parallel task.",
+						};
+					}
+					const exitCode = typeof step.exitCode === "number" ? step.exitCode : undefined;
+					const errorText = step.error;
+					return {
+						agent: step.agent ?? task.agent,
+						messages: buildDelegationMessages(step),
+						isError: (exitCode !== undefined && exitCode !== 0) || !!errorText,
+						errorText: errorText || undefined,
+					};
+				})
+				: undefined;
+			const response: PromptTemplateDelegationResponse = {
+				...request,
+				messages,
+				...(parallelResults ? { parallelResults } : {}),
+				...(contentText ? { contentText } : {}),
+				isError: result.isError === true,
+				errorText: result.isError ? contentText : undefined,
+			};
+			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+		} catch (error) {
+			const response: PromptTemplateDelegationResponse = {
+				...request,
+				messages: [],
+				isError: true,
+				errorText: error instanceof Error ? error.message : String(error),
+			};
+			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+		} finally {
+			controllers.delete(request.requestId);
+		}
+	});
+
+	return {
+		cancelAll: () => {
+			for (const controller of controllers.values()) {
+				controller.abort();
+			}
+			controllers.clear();
+			pendingCancels.clear();
+		},
+		dispose: () => {
+			for (const unsubscribe of subscriptions) unsubscribe();
+			subscriptions.length = 0;
+			pendingCancels.clear();
+		},
+	};
+}

package/extensions/subagent/prompts/gather-context-and-clarify.md

@@ -0,0 +1,13 @@
+---
+description: Use subagents to gather context, then ask clarifying questions
+---
+
+Based on our discussion and my intent, launch focused context-gathering subagents before planning or implementing.
+
+Use `scout` to inspect the relevant local files, existing patterns, constraints, tests, and likely integration points. Use `researcher` when external docs, recent sources, ecosystem context, or primary evidence would improve the answer.
+
+Give each subagent a specific meta prompt. Ask them to return concise findings plus the remaining clarification questions that matter for implementation confidence.
+
+After they return, synthesize what we know and use the `interview` tool to ask me the unresolved questions needed to reach a shared understanding.
+
+$@

package/extensions/subagent/prompts/parallel-cleanup.md

@@ -0,0 +1,42 @@
+---
+description: Parallel cleanup review
+---
+
+Launch two fresh-context reviewer subagents for an adversarial cleanup review of the current work. Reviewers must inspect the repository, relevant instructions, and current diff directly from files and commands. Do not rely on this prompt as a substitute for reading the code.
+
+Reviewer 1: deslop pass.
+
+Ask this reviewer to look for AI-slop patterns in the changed scope:
+- comments that restate code, placeholder text, stale rationale, or debug leftovers;
+- defensive checks that hide useful errors, return vague defaults, or validate trusted internal data after a real boundary was already crossed;
+- type escapes, broad casts, duplicated type definitions, or object-bag typing where a local source-of-truth type exists;
+- style drift from nearby non-slop code and project instructions;
+- generated-sounding docs, changelog text, UI copy, status text, or test names;
+- pass-through wrappers, dead helpers, duplicate helper signatures, duplicated test harness setup, or abstractions that do not enforce an invariant;
+- UI or CLI copy that is noisy, vague, brittle, or makes the user do extra interpretation.
+
+Tell this reviewer to treat tool output and slop-scan-style findings as leads, not verdicts. It should flag only concrete issues in the requested scope with evidence, severity, file/line references, and the smallest safe fix.
+
+Reviewer 2: verbosity pass.
+
+Ask this reviewer to look for needless verbosity in code, tests, docs, status text, grouped messages, receipts, and changelog wording:
+- single-use helpers that merely paraphrase an expression;
+- temporary variables that only name obvious expressions;
+- nested returns or branches that can become direct returns without hiding intent;
+- multi-line cleanup scaffolding that can use a local direct pattern while preserving cleanup semantics;
+- repeated boilerplate that can use an existing local fixture or a small local helper;
+- tests that restate formatter details already covered at a cheaper layer;
+- prose that says the same thing twice, sounds generic, or buries the important rule.
+
+Tell this reviewer that shorter is only better when it is clearer and preserves behavior, error signals, cleanup semantics, useful invariants, and local style.
+
+Both reviewers are review-only. They must not edit files unless I explicitly ask for a writer pass. Their response should be review feedback, not a context summary. Ask them to return concise, evidence-backed findings with file/line references and suggested fixes.
+
+While reviewers run, do your own narrow inspection if useful. After they return, synthesize the feedback into:
+- fixes worth doing now;
+- optional improvements;
+- feedback to ignore or defer, with a short reason.
+
+Do not blindly apply every reviewer suggestion. Ask before applying fixes unless I already told you to address review feedback.
+
+$@

package/extensions/subagent/prompts/parallel-research.md

@@ -0,0 +1,50 @@
+---
+description: Parallel subagents research
+---
+
+Launch parallel research subagents to build a grounded answer to the current question or decision.
+
+Use fresh context, not forked context, unless I explicitly ask for forked context. Researchers and scouts should inspect sources directly instead of relying on the main conversation history.
+
+Use a combination of `researcher` and `scout` subagents:
+- Use `researcher` for web, docs, standards, ecosystem, recent changes, benchmarks, and primary-source evidence.
+- Use `scout` for local codebase context, existing implementation patterns, repo constraints, and files that would be affected.
+
+Give each subagent a distinct angle. Unless I specify angles, use these three:
+
+1. External evidence
+   Use `researcher` to find current, authoritative sources: official docs, specs, release notes, benchmarks, issue threads, or primary explanations.
+
+2. Local code context
+   Use `scout` to inspect the repository for relevant files, existing patterns, constraints, tests, and likely integration points.
+
+3. Practical tradeoffs
+   Use `researcher` or `scout`, whichever fits the question, to compare options, risks, edge cases, maintenance cost, and what would be easiest to validate.
+
+Adapt the angles when the question calls for it:
+- Library/API questions: include official docs and recent examples.
+- Architecture decisions: include local module boundaries, dependency direction, and migration cost.
+- Debugging questions: include likely failure modes, local call paths, and exact error evidence.
+- UI/product questions: include user flow, accessibility, design precedent, and implementation constraints.
+- Time-sensitive topics: include a recent-developments angle and prefer 2026/2025 sources.
+
+Prefer two or three strong subagents over many vague ones. The parent agent should frame the question and assign angles; the child agents should research or scout, not invent broad plans.
+
+Ask each subagent to return concise findings with evidence:
+- file paths and line ranges for local findings
+- source links for external findings
+- confidence level and gaps
+- recommended next step or decision implication
+
+Do not ask subagents to edit files. This is a research pass only unless I explicitly ask for implementation.
+
+After the subagents return, synthesize the answer into:
+- what we know
+- what the local codebase implies
+- tradeoffs and risks
+- gaps or assumptions
+- the recommended next move
+
+If findings disagree, call out the disagreement instead of smoothing it over.
+
+$@

package/extensions/subagent/prompts/parallel-review.md

@@ -0,0 +1,40 @@
+---
+description: Parallel subagents review
+---
+
+Launch parallel reviewers for an adversarial review of the current work.
+
+Use fresh context, not forked context, unless I explicitly ask for forked context. Reviewers should inspect the repository, relevant instructions, and current diff directly from files and commands. Do not rely on the main conversation history.
+
+Give each reviewer a distinct angle. Generate the angles dynamically from the user's intent, the plan, the implemented code, and the current diff. If I specify angles, use mine. Otherwise, choose the highest-value review angles for this specific work.
+
+These are examples, not fixed defaults:
+
+1. Correctness and regressions
+   Check whether the change satisfies the request, preserves existing behavior, handles edge cases, and avoids hidden runtime failures.
+
+2. Tests and validation
+   Check whether tests or validation were added at the right layer, whether assertions are meaningful, and whether the chosen verification commands are enough.
+
+3. Simplicity and maintainability
+   Check for unnecessary complexity, duplicate structure, single-use wrappers, brittle abstractions, confusing names, verbosity, and cleanup that is clearly worth doing.
+
+Choose or adapt angles when the work calls for it:
+- TypeScript-heavy changes: include type safety, source-of-truth types, casts, and error-boundary discipline.
+- UI-heavy changes: include UX, accessibility, copy, and visual quality.
+- Security-sensitive changes: include unsafe input/output handling, auth boundaries, privacy, and data exposure.
+- Docs-heavy changes: include clarity, accuracy, completeness, reader flow, and non-robotic prose.
+- Large multi-file changes: consider a fourth reviewer for structural friction, module boundaries, and testability.
+
+Prefer three strong reviewers over many vague reviewers.
+
+Give every reviewer a specific task prompt naming its angle. Ask reviewers to return concise, evidence-backed findings with file/line references and suggested fixes. The response should be review feedback, not a context summary. Reviewers must not edit files unless I explicitly ask for a writer pass.
+
+While reviewers run, do your own narrow inspection if useful. After they return, synthesize the feedback into:
+- fixes worth doing now
+- optional improvements
+- feedback to ignore or defer, with a short reason
+
+Do not blindly apply every reviewer suggestion. Ask before applying fixes unless I already told you to address review feedback.
+
+$@

package/extensions/subagent/render-helpers.ts

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2025 Nico Bailon
+// SPDX-License-Identifier: MIT
+// Source: https://github.com/nicobailon/pi-subagents
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+function fuzzyScore(query: string, text: string): number {
+	const lq = query.toLowerCase();
+	const lt = text.toLowerCase();
+	if (lt.includes(lq)) return 100 + (lq.length / lt.length) * 50;
+	let score = 0;
+	let qi = 0;
+	let consecutive = 0;
+	for (let i = 0; i < lt.length && qi < lq.length; i++) {
+		if (lt[i] === lq[qi]) {
+			score += 10 + consecutive;
+			consecutive += 5;
+			qi++;
+		} else {
+			consecutive = 0;
+		}
+	}
+	return qi === lq.length ? score : 0;
+}
+
+export function fuzzyFilter<T extends { name: string; description: string; model?: string }>(items: T[], query: string): T[] {
+	const q = query.trim();
+	if (!q) return items;
+	return items
+		.map((item) => ({ item, score: Math.max(fuzzyScore(q, item.name), fuzzyScore(q, item.description) * 0.8, fuzzyScore(q, item.model ?? "") * 0.6) }))
+		.filter((x) => x.score > 0)
+		.sort((a, b) => b.score - a.score)
+		.map((x) => x.item);
+}
+
+export function pad(s: string, len: number): string {
+	const vis = visibleWidth(s);
+	return s + " ".repeat(Math.max(0, len - vis));
+}
+
+export function row(content: string, width: number, theme: Theme): string {
+	const innerW = width - 2;
+	const singleLine = content.replace(/[\r\n]+/g, " ").replace(/\t/g, "  ");
+	const clipped = truncateToWidth(singleLine, innerW);
+	return theme.fg("border", "│") + pad(clipped, innerW) + theme.fg("border", "│");
+}
+
+export function renderHeader(text: string, width: number, theme: Theme): string {
+	const innerW = width - 2;
+	const padLen = Math.max(0, innerW - visibleWidth(text));
+	const padLeft = Math.floor(padLen / 2);
+	const padRight = padLen - padLeft;
+	return (
+		theme.fg("border", "╭" + "─".repeat(padLeft)) +
+		theme.fg("accent", text) +
+		theme.fg("border", "─".repeat(padRight) + "╮")
+	);
+}
+
+export function formatPath(filePath: string): string {
+	const home = process.env.HOME;
+	if (home && filePath.startsWith(home)) return `~${filePath.slice(home.length)}`;
+	return filePath;
+}
+
+export function formatScrollInfo(above: number, below: number): string {
+	let info = "";
+	if (above > 0) info += `↑ ${above} more`;
+	if (below > 0) info += `${info ? "  " : ""}↓ ${below} more`;
+	return info;
+}
+
+export function renderFooter(text: string, width: number, theme: Theme): string {
+	const innerW = width - 2;
+	const padLen = Math.max(0, innerW - visibleWidth(text));
+	const padLeft = Math.floor(padLen / 2);
+	const padRight = padLen - padLeft;
+	return (
+		theme.fg("border", "╰" + "─".repeat(padLeft)) +
+		theme.fg("dim", text) +
+		theme.fg("border", "─".repeat(padRight) + "╯")
+	);
+}