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

package/src/apps/cleanse-board.ts

@@ -0,0 +1,341 @@
+/**
+ * Live status board for `omp cleanse`.
+ *
+ * Interactive terminals get a transient board repainted in place: a phase
+ * spinner (model resolution, checker discovery), one row per running checker,
+ * and one row per repair subagent showing its latest intent, current tool,
+ * tool count, and elapsed time from {@link AgentProgress} snapshots. Finished
+ * work is promoted to permanent scrollback lines as it settles.
+ *
+ * Non-TTY output keeps the original plain-line protocol
+ * (`[start]`/`[done]`/`[fail]`), so scripted callers see unchanged output.
+ */
+import { formatDuration, formatNumber } from "@oh-my-pi/pi-utils";
+import { sanitizeDisplaySingleLine } from "../overlays/extensions/display-text";
+import { truncateToWidth } from "../utils";
+import { renderProgressBar, type ProgressBarStyle } from "../components/progress-bar";
+import { fgOrPlain, theme } from "../theme/theme";
+import { createLiveBoard, type LiveBoardOutput } from "../chrome/live-board";
+import type { AgentProgress } from "../tools/task";
+
+/** Checker identity shown in live rows and verdicts. */
+export interface CleanseCheckerDescriptor {
+	id: string;
+	label: string;
+}
+
+/** Checker result fields consumed by the verdict line. */
+export interface CleanseCheckResult extends CleanseCheckerDescriptor {
+	diagnostics: readonly unknown[];
+}
+
+/** Repair workload fields displayed in agent rows. */
+export interface CleanseAssignment {
+	index: number;
+	groups: readonly { file?: string }[];
+	weight: number;
+}
+
+/** Completion fields displayed when a repair agent settles. */
+export interface CleanseAgentOutcome {
+	name: string;
+	success: boolean;
+	error?: string;
+	resolvedModel?: string;
+}
+
+const BAR_WIDTH = 16;
+const ACTIVITY_WIDTH = 96;
+const ERROR_WIDTH = 300;
+
+const REPAIR_BAR_STYLE: ProgressBarStyle = {
+	filled: "█",
+	empty: "░",
+	styleFilled: text => fgOrPlain("accent", text),
+	styleEmpty: text => fgOrPlain("dim", text),
+};
+
+/** Rendering surface for one `omp cleanse` run. */
+export interface CleanseStatusBoard {
+	readonly interactive: boolean;
+	/** Print a permanent line above the live area (plain write when non-TTY). */
+	log(text: string): void;
+	/** Show a transient spinner line; `undefined` clears it. Non-TTY prints the text once. */
+	phase(text: string | undefined): void;
+	checkerStarted(checker: CleanseCheckerDescriptor): void;
+	checkerFinished(check: CleanseCheckResult, durationMs: number): void;
+	/** End the repair phase and drop its live rows before verification. */
+	repairFinished(): void;
+	agentStarted(name: string, assignment: CleanseAssignment): void;
+	agentProgress(name: string, progress: AgentProgress): void;
+	agentFinished(outcome: CleanseAgentOutcome, assignment: CleanseAssignment): void;
+	/** Clear the live area and restore the cursor. Idempotent. */
+	close(): void;
+}
+
+interface RunningChecker {
+	label: string;
+	startedAt: number;
+}
+
+interface RunningAgent {
+	assignment: CleanseAssignment;
+	startedAt: number;
+	progress?: AgentProgress;
+}
+
+/**
+ * Live-view state for one cleanse run, shared by the CLI stdout board and the
+ * interactive-mode overlay panel so both surfaces render identical rows.
+ *
+ * Mutators mirror {@link CleanseStatusBoard}; the finish mutators return the
+ * permanent line the surface should log above the live area.
+ */
+export class CleanseBoardModel {
+	#phaseText: string | undefined;
+	readonly #checkers = new Map<string, RunningChecker>();
+	readonly #agents = new Map<string, RunningAgent>();
+	/** Lifetime token/cost totals per agent; survives row removal for the header sums. */
+	readonly #totals = new Map<string, { tokens: number; cost: number }>();
+	#repairTotal = 0;
+	#repairDone = 0;
+	#repairStartedAt = 0;
+
+	phase(text: string | undefined): void {
+		this.#phaseText = text;
+	}
+
+	checkerStarted(checker: CleanseCheckerDescriptor): void {
+		this.#checkers.set(checker.id, { label: checker.label, startedAt: Date.now() });
+	}
+
+	/** Drop the checker's live row and build its permanent verdict line. */
+	checkerFinished(check: CleanseCheckResult, durationMs: number): string {
+		this.#checkers.delete(check.id);
+		const count = check.diagnostics.length;
+		const verdict =
+			count === 0 ? fgOrPlain("success", "clean") : fgOrPlain("warning", `${count} issue${count === 1 ? "" : "s"}`);
+		const glyph = count === 0 ? fgOrPlain("success", "✓") : fgOrPlain("warning", "●");
+		return `${glyph} ${check.label} ${verdict} ${fgOrPlain("dim", `· ${formatDuration(durationMs)}`)}`;
+	}
+
+	repairFinished(): void {
+		this.#repairTotal = 0;
+		this.#repairDone = 0;
+		this.#agents.clear();
+	}
+
+	agentStarted(name: string, assignment: CleanseAssignment): void {
+		if (this.#repairStartedAt === 0) this.#repairStartedAt = Date.now();
+		this.#repairTotal += 1;
+		this.#agents.set(name, { assignment, startedAt: Date.now() });
+	}
+
+	agentProgress(name: string, progress: AgentProgress): void {
+		this.#totals.set(name, { tokens: progress.tokens, cost: progress.cost });
+		const agent = this.#agents.get(name);
+		if (agent) agent.progress = progress;
+	}
+
+	/** Drop the agent's live row, advance the repair bar, and build its permanent outcome line. */
+	agentFinished(outcome: CleanseAgentOutcome, assignment: CleanseAssignment): string {
+		const agent = this.#agents.get(outcome.name);
+		this.#agents.delete(outcome.name);
+		this.#repairDone = Math.min(this.#repairDone + 1, this.#repairTotal);
+		return renderOutcomeLine(outcome, assignment, agent, this.#totals.get(outcome.name));
+	}
+
+	/** Render the transient live rows for the current spinner frame. */
+	renderLive(spinner: string): string[] {
+		const lines: string[] = [];
+		if (this.#phaseText) lines.push(`${fgOrPlain("warning", spinner)} ${this.#phaseText}`);
+		for (const checker of this.#checkers.values()) {
+			const elapsed = formatDuration(Date.now() - checker.startedAt);
+			lines.push(`${fgOrPlain("warning", spinner)} ${checker.label} ${fgOrPlain("dim", `· ${elapsed}`)}`);
+		}
+		if (this.#repairTotal > 0) {
+			lines.push(
+				renderWaveHeader(
+					spinner,
+					this.#repairTotal,
+					this.#repairDone,
+					this.#agents.size,
+					this.#totals,
+					this.#repairStartedAt,
+				),
+			);
+			const rows = [...this.#agents.entries()].sort(
+				(left, right) => left[1].assignment.index - right[1].assignment.index,
+			);
+			for (const [name, agent] of rows) lines.push(renderAgentRow(spinner, name, agent));
+		}
+		return lines;
+	}
+}
+
+/** Create the cleanse status board bound to `output` (default `process.stdout`). */
+export function createCleanseStatusBoard(
+	output: LiveBoardOutput = process.stdout,
+	errors: LiveBoardOutput = process.stderr,
+): CleanseStatusBoard {
+	const model = new CleanseBoardModel();
+	const board = createLiveBoard(spinner => model.renderLive(spinner), output);
+
+	return {
+		interactive: board.interactive,
+		log: board.log,
+		phase(text) {
+			if (!board.interactive) {
+				if (text) output.write(`${text}\n`);
+				return;
+			}
+			model.phase(text);
+			board.repaint();
+		},
+		checkerStarted(checker) {
+			if (!board.interactive) return;
+			model.checkerStarted(checker);
+			board.repaint();
+		},
+		checkerFinished(check, durationMs) {
+			board.log(model.checkerFinished(check, durationMs));
+		},
+		repairFinished() {
+			model.repairFinished();
+			board.repaint();
+		},
+		agentStarted(name, assignment) {
+			if (!board.interactive) {
+				const files = assignment.groups.map(group => group.file ?? "<project>").join(", ");
+				output.write(`[start] ${name}: ${files} (weight ${assignment.weight})\n`);
+				return;
+			}
+			model.agentStarted(name, assignment);
+			board.repaint();
+		},
+		agentProgress(name, progress) {
+			model.agentProgress(name, progress);
+		},
+		agentFinished(outcome, assignment) {
+			if (!board.interactive) {
+				model.agentFinished(outcome, assignment);
+				if (outcome.success) {
+					output.write(`[done] ${outcome.name}${outcome.resolvedModel ? ` (${outcome.resolvedModel})` : ""}\n`);
+				} else {
+					const message = truncateToWidth(
+						sanitizeDisplaySingleLine(outcome.error ?? "subagent failed")
+							.replace(/\s+/g, " ")
+							.trim(),
+						ERROR_WIDTH,
+					);
+					errors.write(`[fail] ${outcome.name}: ${message}\n`);
+				}
+				return;
+			}
+			board.log(model.agentFinished(outcome, assignment));
+		},
+		close: board.close,
+	};
+}
+
+function renderWaveHeader(
+	spinner: string,
+	total: number,
+	done: number,
+	running: number,
+	totals: ReadonlyMap<string, { tokens: number; cost: number }>,
+	startedAt: number,
+): string {
+	const bar = renderProgressBar(done, BAR_WIDTH, {
+		min: 0,
+		max: total,
+		style: REPAIR_BAR_STYLE,
+	});
+	let tokens = 0;
+	let cost = 0;
+	for (const entry of totals.values()) {
+		tokens += entry.tokens;
+		cost += entry.cost;
+	}
+	const parts = [`${done}/${total}`];
+	if (running > 0) parts.push(`${running} running`);
+	if (tokens > 0) parts.push(`${formatNumber(tokens)} tok`);
+	if (cost > 0) parts.push(formatCost(cost));
+	parts.push(formatDuration(Date.now() - startedAt));
+	return `${fgOrPlain("accent", spinner)} Repairing [${bar}] ${parts.join(fgOrPlain("dim", " · "))}`;
+}
+
+function renderAgentRow(spinner: string, agentName: string, agent: RunningAgent): string {
+	const label = agentName.replace(/^Cleanse/, "");
+	const meta: string[] = [];
+	const toolCount = agent.progress?.toolCount ?? 0;
+	if (toolCount > 0) meta.push(`${toolCount} tool${toolCount === 1 ? "" : "s"}`);
+	meta.push(formatDuration(Date.now() - agent.startedAt));
+	return (
+		`${fgOrPlain("warning", spinner)} ${theme ? theme.bold(label) : label} ${compactFiles(agent.assignment)} ` +
+		`${fgOrPlain("dim", "·")} ${agentActivity(agent.progress)} ${fgOrPlain("dim", `· ${meta.join(" · ")}`)}`
+	);
+}
+
+function renderOutcomeLine(
+	outcome: CleanseAgentOutcome,
+	assignment: CleanseAssignment,
+	agent: RunningAgent | undefined,
+	total: { tokens: number; cost: number } | undefined,
+): string {
+	const files = compactFiles(assignment);
+	if (!outcome.success) {
+		const message = truncateToWidth(
+			sanitizeDisplaySingleLine(outcome.error ?? "subagent failed")
+				.replace(/\s+/g, " ")
+				.trim(),
+			ERROR_WIDTH,
+		);
+		return `${fgOrPlain("error", "✗")} ${outcome.name} ${files} ${fgOrPlain("error", message)}`;
+	}
+	const meta: string[] = [];
+	const toolCount = agent?.progress?.toolCount ?? 0;
+	if (toolCount > 0) meta.push(`${toolCount} tool${toolCount === 1 ? "" : "s"}`);
+	if (total && total.tokens > 0) meta.push(`${formatNumber(total.tokens)} tok`);
+	if (agent) meta.push(formatDuration(Date.now() - agent.startedAt));
+	const suffix = meta.length > 0 ? ` ${fgOrPlain("dim", `· ${meta.join(" · ")}`)}` : "";
+	return `${fgOrPlain("success", "✓")} ${outcome.name} ${files}${suffix}`;
+}
+
+/** Latest human-readable activity for a repair agent row. */
+function agentActivity(progress: AgentProgress | undefined): string {
+	if (!progress) return fgOrPlain("dim", "starting");
+	if (progress.retryState) {
+		return fgOrPlain(
+			"warning",
+			`rate-limited · retry ${progress.retryState.attempt}/${progress.retryState.maxAttempts}`,
+		);
+	}
+	const intent = truncateToWidth(
+		sanitizeDisplaySingleLine(progress.lastIntent ?? "")
+			.replace(/\s+/g, " ")
+			.trim(),
+		ACTIVITY_WIDTH,
+	);
+	if (progress.currentTool) {
+		const args = truncateToWidth(
+			sanitizeDisplaySingleLine(progress.currentToolArgs ?? "")
+				.replace(/\s+/g, " ")
+				.trim(),
+			ACTIVITY_WIDTH,
+		);
+		const tool = fgOrPlain("dim", args ? `${progress.currentTool} ${args}` : progress.currentTool);
+		return intent ? `${intent} ${tool}` : tool;
+	}
+	return intent || fgOrPlain("dim", "thinking");
+}
+
+function compactFiles(assignment: CleanseAssignment): string {
+	const files = assignment.groups.map(group => group.file ?? "<project>");
+	const first = files[0] ?? "<project>";
+	return files.length > 1 ? `${first} +${files.length - 1}` : first;
+}
+
+function formatCost(cost: number): string {
+	return `$${cost >= 0.095 ? cost.toFixed(2) : cost.toFixed(3)}`;
+}

package/src/apps/cleanse-picker.ts

@@ -0,0 +1,57 @@
+/**
+ * Standalone TUI pickers for `omp cleanse`.
+ *
+ * One-shot {@link selectStandaloneItem} and {@link promptStandaloneText}
+ * prompts, resolved on select/submit/cancel so the command can keep writing
+ * plain stdout afterwards.
+ */
+import { type SelectItem } from "../components/select-list";
+import { promptStandaloneText, selectStandaloneItem } from "./standalone-picker";
+
+/** Checker metadata presented by the target picker. */
+export interface CleanseCheckerChoice {
+	id: string;
+	label: string;
+	language: string;
+	command: string;
+}
+
+/** Selected checker scope or free-form repair request. */
+export type CleanseTargetChoice =
+	| { kind: "all" }
+	| { kind: "checker"; id: string }
+	| { kind: "request"; request: string }
+	| { kind: "cancel" };
+
+/** Pick between running every discovered checker, one specific checker, or a free-form request. */
+export async function pickCleanseTarget(checkers: readonly CleanseCheckerChoice[]): Promise<CleanseTargetChoice> {
+	const items: SelectItem[] = [
+		{
+			value: "all",
+			label: `Run all ${checkers.length} discovered checker${checkers.length === 1 ? "" : "s"}`,
+		},
+		...checkers.map(checker => ({
+			value: `checker:${checker.id}`,
+			label: checker.label,
+			description: `${checker.language} — ${checker.command}`,
+		})),
+		{
+			value: "request",
+			label: "Describe what to fix…",
+			description: "A discovery agent figures out the command to run",
+		},
+	];
+	const selection = await selectStandaloneItem("Select what to cleanse:", items, { maxVisible: 12 });
+	if (selection === null) return { kind: "cancel" };
+	if (selection === "all") return { kind: "all" };
+	if (selection === "request") {
+		const request = await promptCleanseRequest();
+		return request === null ? { kind: "cancel" } : { kind: "request", request };
+	}
+	return { kind: "checker", id: selection.slice("checker:".length) };
+}
+
+/** One-shot text prompt for a free-form cleanse request; `null` when cancelled or left empty. */
+export async function promptCleanseRequest(): Promise<string | null> {
+	return promptStandaloneText('Describe what to detect and fix (e.g. "ts errors"):');
+}

package/src/apps/debug/log-formatting.ts

@@ -0,0 +1,53 @@
+import { sanitizeDisplayText } from "../../overlays/extensions/display-text";
+import { wrapTextWithAnsi } from "../../render/render-utils";
+
+/** Sanitize and wrap an expanded log entry into display rows. */
+export function formatDebugLogExpandedLines(line: string, maxWidth: number): string[] {
+	const normalized = sanitizeDisplayText(line);
+	const width = Math.max(1, maxWidth);
+
+	if (normalized.length === 0) {
+		return [""];
+	}
+
+	return normalized.split("\n").flatMap(segment => wrapTextWithAnsi(segment, width));
+}
+
+/** Read a valid timestamp from a structured log entry. */
+export function parseDebugLogTimestampMs(line: string): number | undefined {
+	try {
+		const parsed: unknown = JSON.parse(line);
+		if (!parsed || typeof parsed !== "object") {
+			return undefined;
+		}
+
+		const timestamp = (parsed as { timestamp?: unknown }).timestamp;
+		if (typeof timestamp !== "string") {
+			return undefined;
+		}
+
+		const timestampMs = Date.parse(timestamp);
+		return Number.isFinite(timestampMs) ? timestampMs : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Read a finite process identifier from a structured log entry. */
+export function parseDebugLogPid(line: string): number | undefined {
+	try {
+		const parsed: unknown = JSON.parse(line);
+		if (!parsed || typeof parsed !== "object") {
+			return undefined;
+		}
+
+		const pid = (parsed as { pid?: unknown }).pid;
+		if (typeof pid !== "number") {
+			return undefined;
+		}
+
+		return Number.isFinite(pid) ? pid : undefined;
+	} catch {
+		return undefined;
+	}
+}