@iowarp/clio-coder 0.3.0 → 0.3.1

package/src/interactive/renderers/code-ink.ts

@@ -0,0 +1,420 @@
+import { type ClioToken, clioTheme } from "../theme/index.js";
+
+/**
+ * Code ink: quiet syntax highlighting for fenced code blocks. Code inside a
+ * fence is quoted material, not UI state, so it borrows exactly four existing
+ * tokens and nothing else: comments render dim, string literals success,
+ * language keywords reason, and numeric literals info. Everything else,
+ * including identifiers, types, function names, and punctuation, stays plain.
+ * The mapping is closed to extension. When the lexer is unsure it leaves text
+ * plain: under-highlighting is correct behavior, mis-highlighting is a defect.
+ */
+
+type InkKind = "comment" | "string" | "keyword" | "number";
+
+const INK_TOKEN: Record<InkKind, ClioToken> = {
+	comment: "dim",
+	string: "success",
+	keyword: "reason",
+	number: "info",
+};
+
+/**
+ * Lexer state carried from one line to the next inside a single fence. Only
+ * constructs that legally span lines carry: block comments in the ts family,
+ * template literals in the ts family, and triple-quoted strings in python.
+ */
+type Carry = { kind: "none" } | { kind: "blockComment" } | { kind: "template" } | { kind: "triple"; quote: string };
+
+interface Span {
+	start: number;
+	end: number;
+	kind: InkKind;
+}
+
+interface LangSpec {
+	lineComment: string | null;
+	/** Bash comments start only at the line head or after whitespace, so `${#x}` stays plain. */
+	commentNeedsBoundary: boolean;
+	blockComments: boolean;
+	templates: boolean;
+	triples: boolean;
+	quotes: string;
+	/** Dim a leading `$ ` shell prompt so pasted terminal sessions read as sessions. */
+	shellPrompt: boolean;
+	keywords: ReadonlySet<string>;
+}
+
+const TS_KEYWORDS: ReadonlySet<string> = new Set([
+	"abstract",
+	"as",
+	"async",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"declare",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"from",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"of",
+	"private",
+	"protected",
+	"public",
+	"readonly",
+	"return",
+	"satisfies",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"type",
+	"typeof",
+	"undefined",
+	"var",
+	"void",
+	"while",
+	"yield",
+]);
+
+const PYTHON_KEYWORDS: ReadonlySet<string> = new Set([
+	"False",
+	"None",
+	"True",
+	"and",
+	"as",
+	"assert",
+	"async",
+	"await",
+	"break",
+	"class",
+	"continue",
+	"def",
+	"del",
+	"elif",
+	"else",
+	"except",
+	"finally",
+	"for",
+	"from",
+	"global",
+	"if",
+	"import",
+	"in",
+	"is",
+	"lambda",
+	"nonlocal",
+	"not",
+	"or",
+	"pass",
+	"raise",
+	"return",
+	"try",
+	"while",
+	"with",
+	"yield",
+]);
+
+const BASH_KEYWORDS: ReadonlySet<string> = new Set([
+	"case",
+	"coproc",
+	"do",
+	"done",
+	"elif",
+	"else",
+	"esac",
+	"fi",
+	"for",
+	"function",
+	"if",
+	"in",
+	"select",
+	"then",
+	"time",
+	"until",
+	"while",
+]);
+
+const JSON_KEYWORDS: ReadonlySet<string> = new Set(["true", "false", "null"]);
+
+const TS_SPEC: LangSpec = {
+	lineComment: "//",
+	commentNeedsBoundary: false,
+	blockComments: true,
+	templates: true,
+	triples: false,
+	quotes: `"'`,
+	shellPrompt: false,
+	keywords: TS_KEYWORDS,
+};
+
+const JSON_SPEC: LangSpec = {
+	lineComment: null,
+	commentNeedsBoundary: false,
+	blockComments: false,
+	templates: false,
+	triples: false,
+	quotes: `"`,
+	shellPrompt: false,
+	keywords: JSON_KEYWORDS,
+};
+
+const BASH_SPEC: LangSpec = {
+	lineComment: "#",
+	commentNeedsBoundary: true,
+	blockComments: false,
+	templates: false,
+	triples: false,
+	quotes: `"'`,
+	shellPrompt: true,
+	keywords: BASH_KEYWORDS,
+};
+
+const PYTHON_SPEC: LangSpec = {
+	lineComment: "#",
+	commentNeedsBoundary: false,
+	blockComments: false,
+	templates: false,
+	triples: true,
+	quotes: `"'`,
+	shellPrompt: false,
+	keywords: PYTHON_KEYWORDS,
+};
+
+/**
+ * The supported fence tags are the five languages the design doc names plus
+ * their obvious full-word spellings. Every other tag, and no tag, means plain.
+ */
+function resolveSpec(tag: string): LangSpec | "diff" | null {
+	switch (tag) {
+		case "ts":
+		case "tsx":
+		case "js":
+		case "jsx":
+		case "typescript":
+		case "javascript":
+			return TS_SPEC;
+		case "json":
+			return JSON_SPEC;
+		case "bash":
+		case "sh":
+		case "shell":
+			return BASH_SPEC;
+		case "python":
+		case "py":
+			return PYTHON_SPEC;
+		case "diff":
+			return "diff";
+		default:
+			return null;
+	}
+}
+
+const NUMBER_RE = /^(?:0[xX][0-9a-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?n?)/;
+
+function isIdentPart(ch: string): boolean {
+	return ch.length === 1 && /[A-Za-z0-9_$]/.test(ch);
+}
+
+function isIdentStart(ch: string): boolean {
+	return ch.length === 1 && /[A-Za-z_$]/.test(ch);
+}
+
+/** Index of the closing quote, honoring backslash escapes when the language has them. */
+function findQuoteEnd(line: string, from: number, quote: string, allowEscapes: boolean): number {
+	for (let i = from; i < line.length; i++) {
+		const ch = line[i] ?? "";
+		if (allowEscapes && ch === "\\") {
+			i += 1;
+			continue;
+		}
+		if (ch === quote) return i;
+	}
+	return -1;
+}
+
+function scanLine(line: string, spec: LangSpec, carry: Carry): { spans: Span[]; carry: Carry } {
+	const spans: Span[] = [];
+	let i = 0;
+
+	if (carry.kind === "blockComment") {
+		const close = line.indexOf("*/");
+		if (close < 0) {
+			if (line.length > 0) spans.push({ start: 0, end: line.length, kind: "comment" });
+			return { spans, carry };
+		}
+		spans.push({ start: 0, end: close + 2, kind: "comment" });
+		i = close + 2;
+	} else if (carry.kind === "template") {
+		const close = findQuoteEnd(line, 0, "`", true);
+		if (close < 0) {
+			if (line.length > 0) spans.push({ start: 0, end: line.length, kind: "string" });
+			return { spans, carry };
+		}
+		spans.push({ start: 0, end: close + 1, kind: "string" });
+		i = close + 1;
+	} else if (carry.kind === "triple") {
+		const close = line.indexOf(carry.quote);
+		if (close < 0) {
+			if (line.length > 0) spans.push({ start: 0, end: line.length, kind: "string" });
+			return { spans, carry };
+		}
+		spans.push({ start: 0, end: close + carry.quote.length, kind: "string" });
+		i = close + carry.quote.length;
+	}
+
+	while (i < line.length) {
+		const ch = line[i] ?? "";
+		const prev = i > 0 ? (line[i - 1] ?? "") : "";
+		if (
+			spec.lineComment !== null &&
+			line.startsWith(spec.lineComment, i) &&
+			(!spec.commentNeedsBoundary || i === 0 || /\s/.test(prev))
+		) {
+			spans.push({ start: i, end: line.length, kind: "comment" });
+			break;
+		}
+		if (spec.blockComments && line.startsWith("/*", i)) {
+			const close = line.indexOf("*/", i + 2);
+			if (close < 0) {
+				spans.push({ start: i, end: line.length, kind: "comment" });
+				return { spans, carry: { kind: "blockComment" } };
+			}
+			spans.push({ start: i, end: close + 2, kind: "comment" });
+			i = close + 2;
+			continue;
+		}
+		if (spec.triples && (line.startsWith('"""', i) || line.startsWith("'''", i))) {
+			const quote = line.slice(i, i + 3);
+			const close = line.indexOf(quote, i + 3);
+			if (close < 0) {
+				spans.push({ start: i, end: line.length, kind: "string" });
+				return { spans, carry: { kind: "triple", quote } };
+			}
+			spans.push({ start: i, end: close + 3, kind: "string" });
+			i = close + 3;
+			continue;
+		}
+		if (spec.templates && ch === "`") {
+			const close = findQuoteEnd(line, i + 1, "`", true);
+			if (close < 0) {
+				spans.push({ start: i, end: line.length, kind: "string" });
+				return { spans, carry: { kind: "template" } };
+			}
+			spans.push({ start: i, end: close + 1, kind: "string" });
+			i = close + 1;
+			continue;
+		}
+		if (ch.length === 1 && spec.quotes.includes(ch)) {
+			// Bash single quotes take no escapes; everything else honors backslash.
+			const allowEscapes = !(spec.shellPrompt && ch === "'");
+			const close = findQuoteEnd(line, i + 1, ch, allowEscapes);
+			// An unterminated single-line string colors to the end of the line and
+			// does not carry: only templates and triples legally span lines.
+			const end = close < 0 ? line.length : close + 1;
+			spans.push({ start: i, end, kind: "string" });
+			i = end;
+			continue;
+		}
+		if (/\d/.test(ch) && !isIdentPart(prev)) {
+			const match = NUMBER_RE.exec(line.slice(i));
+			if (match) {
+				spans.push({ start: i, end: i + match[0].length, kind: "number" });
+				i += match[0].length;
+				continue;
+			}
+		}
+		if (isIdentStart(ch)) {
+			let end = i + 1;
+			while (end < line.length && isIdentPart(line[end] ?? "")) end += 1;
+			const word = line.slice(i, end);
+			// A word reached through a property access is a member name, never a
+			// language keyword, so `token.type` and `promise.catch` stay plain.
+			if (spec.keywords.has(word) && prev !== ".") {
+				spans.push({ start: i, end, kind: "keyword" });
+			}
+			i = end;
+			continue;
+		}
+		i += 1;
+	}
+	return { spans, carry: { kind: "none" } };
+}
+
+function paintLine(line: string, spans: ReadonlyArray<Span>, theme: ReturnType<typeof clioTheme>): string {
+	if (spans.length === 0) return line;
+	let out = "";
+	let cursor = 0;
+	for (const span of spans) {
+		if (span.start > cursor) out += line.slice(cursor, span.start);
+		out += theme.fg(INK_TOKEN[span.kind], line.slice(span.start, span.end));
+		cursor = span.end;
+	}
+	if (cursor < line.length) out += line.slice(cursor);
+	return out;
+}
+
+/**
+ * Diff fences color by what a line does, not what it lexes as: added lines
+ * success, removed lines error, hunk headers dim. The `+++`/`---` file headers
+ * are neither added nor removed content, so they stay plain.
+ */
+function inkDiffLine(line: string, theme: ReturnType<typeof clioTheme>): string {
+	if (line.startsWith("@@")) return theme.fg("dim", line);
+	if (line.startsWith("+++") || line.startsWith("---")) return line;
+	if (line.startsWith("+")) return theme.fg("success", line);
+	if (line.startsWith("-")) return theme.fg("error", line);
+	return line;
+}
+
+/**
+ * Style the raw lines of one fenced code block for the given fence language
+ * tag. This is the only module that composes code color; every consumer feeds
+ * fences through here and nothing post-processes the result.
+ */
+export function codeInk(lang: string | undefined, lines: ReadonlyArray<string>): string[] {
+	const spec = resolveSpec((lang ?? "").trim().toLowerCase());
+	if (spec === null) return [...lines];
+	const theme = clioTheme();
+	if (spec === "diff") return lines.map((line) => inkDiffLine(line, theme));
+	let carry: Carry = { kind: "none" };
+	const out: string[] = [];
+	for (const line of lines) {
+		if (spec.shellPrompt && carry.kind === "none" && line.startsWith("$ ")) {
+			const rest = line.slice(2);
+			const scanned = scanLine(rest, spec, carry);
+			carry = scanned.carry;
+			out.push(`${theme.fg("dim", "$")} ${paintLine(rest, scanned.spans, theme)}`);
+			continue;
+		}
+		const scanned = scanLine(line, spec, carry);
+		carry = scanned.carry;
+		out.push(paintLine(line, scanned.spans, theme));
+	}
+	return out;
+}

package/src/interactive/renderers/compaction-summary.ts

@@ -0,0 +1,112 @@
+/**
+ * Renderers for CompactionSummary session entries (Phase 12 slice 12c).
+ *
+ * Two output shapes live here:
+ *   1. `renderCompactionSummaryLine` is the inline one-liner chat-loop
+ *      emits after an auto-compaction or `/compact` run. It uses the same
+ *      `[context engine] <stage>:` shape as the observation-mask notice.
+ *   2. `renderCompactionSummaryEntry` renders a persisted
+ *      `CompactionSummaryEntry` as a framed, indented block the chat panel
+ *      can splice into a replayed transcript. The block visually marks the
+ *      compaction boundary so a resumed or forked session opens with a
+ *      clear "here is the summary; the real conversation starts below"
+ *      delimiter rather than reading as ordinary chat.
+ *
+ * Pure functions: no TUI dependency beyond pi-tui's Markdown renderer and
+ * the shared ANSI wrap helper. Callers read `SessionEntry` from disk and
+ * splice the returned `string[]` into chat-panel's render loop.
+ */
+
+import type { CompactionSummaryEntry } from "../../domains/session/entries.js";
+import { Markdown, type MarkdownTheme, wrapTextWithAnsi } from "../../engine/tui.js";
+import { clioTheme, markdownTheme, screenTitle } from "../theme/index.js";
+
+const LABEL = "compaction summary";
+const BODY_INDENT = "  ";
+
+const theme = clioTheme();
+const COMPACTION_SUMMARY_THEME: MarkdownTheme = markdownTheme(theme);
+
+export interface CompactionSummaryLineInput {
+	/** How many entries the summarization prompt consumed. */
+	messagesSummarized: number;
+	/** Final length in characters of the generated summary text. */
+	summaryChars: number;
+	/** Estimated context tokens before compaction. */
+	tokensBefore: number;
+	/** True when the cut fell mid-turn; callers may want to annotate. */
+	isSplitTurn?: boolean;
+}
+
+/**
+ * One-line notice the `/compact` handler writes to stdout. Example:
+ *   [context engine] llm_summary: 42 messages summarized to 1823 chars; ~31420 tokens before
+ * Split-turn runs carry a `(split turn)` suffix so the user knows the cut
+ * landed mid-turn and upstream context may need a re-read.
+ */
+export function renderCompactionSummaryLine(input: CompactionSummaryLineInput): string {
+	const tail = input.isSplitTurn ? " (split turn)" : "";
+	return `[context engine] llm_summary: ${input.messagesSummarized} messages summarized to ${input.summaryChars} chars; ~${input.tokensBefore} tokens before${tail}`;
+}
+
+export interface RenderCompactionSummaryOptions {
+	/** Override the default markdown theme. Defaults to the local theme above. */
+	theme?: MarkdownTheme;
+	/** Drop the `[compaction summary]` header so the caller can draw its own label. */
+	hideLabel?: boolean;
+}
+
+/**
+ * Render a single header line announcing a compaction boundary. Format:
+ *   [compaction summary] ~12345 tokens before → cont. at turn <id>
+ * Used on its own for placeholder replays and as the first line of
+ * `renderCompactionSummaryEntry` when the body is included too.
+ */
+function renderCompactionSummaryHeader(entry: CompactionSummaryEntry, width: number): string[] {
+	const label = screenTitle(theme, `[${LABEL}]`);
+	const tokens = Number.isFinite(entry.tokensBefore) ? entry.tokensBefore.toLocaleString() : "0";
+	const trigger = entry.trigger ? ` via ${entry.trigger}` : "";
+	const meta = theme.fg("dim", `~${tokens} tokens before, cont. at turn ${entry.firstKeptTurnId}${trigger}`);
+	return wrapTextWithAnsi(`${label} ${meta}`, width);
+}
+
+/**
+ * Render a persisted CompactionSummary entry as a framed, indented block
+ * suitable for chat-panel's render loop. Returns `[]` when the entry has no
+ * summary text so an empty entry does not punch a blank block into the
+ * chat.
+ *
+ * Layout:
+ *   [compaction summary] ~12345 tokens before, cont. at turn <firstKeptTurnId>
+ *     <markdown body line 1>
+ *     <markdown body line 2>
+ *     ...
+ *
+ * `width` is the usable chat-pane width; the body is rendered at
+ * `width - BODY_INDENT.length` so the indent never forces a line past the
+ * pane edge. The Markdown renderer right-pads each line to its requested
+ * width; we trim that trailing pad before applying the indent so visible
+ * width stays within the pane.
+ */
+export function renderCompactionSummaryEntry(
+	entry: CompactionSummaryEntry,
+	width: number,
+	options: RenderCompactionSummaryOptions = {},
+): string[] {
+	const summary = entry.summary.trim();
+	if (summary.length === 0) return [];
+
+	const out: string[] = [];
+	if (!options.hideLabel) {
+		out.push(...renderCompactionSummaryHeader(entry, width));
+	}
+
+	const bodyWidth = Math.max(1, width - BODY_INDENT.length);
+	const theme = options.theme ?? COMPACTION_SUMMARY_THEME;
+	const md = new Markdown(summary, 0, 0, theme);
+	for (const line of md.render(bodyWidth)) {
+		const trimmed = line.replace(/ +$/, "");
+		out.push(`${BODY_INDENT}${trimmed}`);
+	}
+	return out;
+}

package/src/interactive/renderers/diff.ts

@@ -0,0 +1,126 @@
+/**
+ * Pure unified-diff renderer for tool-execution result blocks (Slice B of the
+ * pi-coding-agent parity work). The edit tool emits an `old_string` /
+ * `new_string` pair on `args`; rather than printing the raw confirmation
+ * string, the chat surfaces should show a colored unified diff so the human
+ * supervisor can see exactly what bytes the tool changed.
+ *
+ * This module is intentionally I/O-free and free of pi-* value imports.
+ * `tool-execution.ts` (the chat-panel renderer) calls `renderUnifiedDiff`
+ * with the chat-pane width; the function returns ANSI-styled, width-wrapped
+ * lines ready to splice into the transcript.
+ */
+import { structuredPatch } from "diff";
+import { visibleWidth, wrapTextWithAnsi } from "../../engine/tui.js";
+import { clioTheme } from "../theme/index.js";
+
+export interface DiffRenderInput {
+	oldText: string;
+	newText: string;
+	filename?: string;
+	/** Lines of context around each hunk. Defaults to 3. */
+	context?: number;
+}
+
+const theme = clioTheme();
+const dim = (text: string): string => theme.fg("dim", text);
+const red = (text: string): string => theme.fg("error", text);
+const green = (text: string): string => theme.fg("success", text);
+const cyan = (text: string): string => theme.fg("accent", text);
+
+const DEFAULT_FILENAME = "file";
+const DEFAULT_CONTEXT = 3;
+const NO_CHANGES_LINE = "  (no changes)";
+
+function wrap(line: string, width: number): string[] {
+	return wrapTextWithAnsi(line, width);
+}
+
+function wrapWithPrefix(prefix: string, content: string, width: number, style: (text: string) => string): string[] {
+	const prefixWidth = visibleWidth(prefix);
+	const contentWidth = Math.max(1, width - prefixWidth);
+	const continuation = " ".repeat(prefixWidth);
+	const wrapped = wrapTextWithAnsi(style(content), contentWidth);
+	if (wrapped.length === 0) return [style(prefix)];
+	const out: string[] = [];
+	for (let i = 0; i < wrapped.length; i += 1) {
+		out.push(`${style(i === 0 ? prefix : continuation)}${wrapped[i] ?? ""}`);
+	}
+	return out;
+}
+
+function renderNumberedDiffLine(
+	oldLine: number | null,
+	newLine: number | null,
+	marker: " " | "+" | "-",
+	content: string,
+	lineNumberWidth: number,
+	width: number,
+): string[] {
+	const oldCell = oldLine === null ? " ".repeat(lineNumberWidth) : String(oldLine).padStart(lineNumberWidth);
+	const newCell = newLine === null ? " ".repeat(lineNumberWidth) : String(newLine).padStart(lineNumberWidth);
+	const prefix = `${oldCell} ${newCell} ${marker}`;
+	if (marker === "-") return wrapWithPrefix(prefix, content, width, red);
+	if (marker === "+") return wrapWithPrefix(prefix, content, width, green);
+	return wrapWithPrefix(prefix, content, width, dim);
+}
+
+/**
+ * Render a unified diff between `oldText` and `newText` as ANSI-styled,
+ * width-wrapped lines. Pure: no I/O, no module-level state.
+ *
+ * Output shape:
+ *   --- a/<filename>
+ *   +++ b/<filename>
+ *   @@ -<oldStart>,<oldLines> +<newStart>,<newLines> @@
+ *   ` context line`
+ *   `-removed line`
+ *   `+added line`
+ *
+ * When the two texts are byte-identical, returns a single `(no changes)`
+ * marker (no headers) so the caller renders a tight one-line block instead
+ * of an empty diff.
+ */
+export function renderUnifiedDiff(input: DiffRenderInput, width: number): string[] {
+	const safeWidth = Math.max(1, width);
+	if (input.oldText === input.newText) {
+		return wrap(NO_CHANGES_LINE, safeWidth);
+	}
+
+	const filename = input.filename ?? DEFAULT_FILENAME;
+	const context = input.context ?? DEFAULT_CONTEXT;
+
+	const patch = structuredPatch(filename, filename, input.oldText, input.newText, undefined, undefined, { context });
+
+	const out: string[] = [];
+	out.push(...wrap(dim(`--- a/${filename}`), safeWidth));
+	out.push(...wrap(dim(`+++ b/${filename}`), safeWidth));
+
+	for (const hunk of patch.hunks) {
+		const header = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
+		out.push(...wrap(cyan(header), safeWidth));
+		let oldLine = hunk.oldStart;
+		let newLine = hunk.newStart;
+		const maxOld = hunk.oldStart + Math.max(0, hunk.oldLines - 1);
+		const maxNew = hunk.newStart + Math.max(0, hunk.newLines - 1);
+		const lineNumberWidth = Math.max(1, String(Math.max(maxOld, maxNew)).length);
+		for (const raw of hunk.lines) {
+			const marker = raw.charAt(0);
+			if (marker === "-") {
+				out.push(...renderNumberedDiffLine(oldLine, null, "-", raw.slice(1), lineNumberWidth, safeWidth));
+				oldLine += 1;
+			} else if (marker === "+") {
+				out.push(...renderNumberedDiffLine(null, newLine, "+", raw.slice(1), lineNumberWidth, safeWidth));
+				newLine += 1;
+			} else if (marker === " ") {
+				out.push(...renderNumberedDiffLine(oldLine, newLine, " ", raw.slice(1), lineNumberWidth, safeWidth));
+				oldLine += 1;
+				newLine += 1;
+			} else {
+				out.push(...wrap(dim(raw), safeWidth));
+			}
+		}
+	}
+
+	return out;
+}

package/src/interactive/renderers/notice.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared styling for bracketed transcript notices (replay and system lines
+ * such as `[retry]`, `[model]`, `[thinking]`, `[file ...]`, `[skill]`,
+ * `[checkpoint]`, and `[session]`). The leading bracketed tag renders in dim
+ * and the message body in muted so these lines read as quiet scaffolding rather
+ * than agent output. The `[retry]` tag takes warning instead of dim because a
+ * retry is a real warning state. Lines without a leading bracketed tag are
+ * returned unchanged, so `system:` prefixes and free-form content stay plain.
+ *
+ * Pure: no I/O, no module-level mutable state beyond the shared theme handle.
+ */
+import { clioTheme } from "../theme/index.js";
+
+const theme = clioTheme();
+
+// A leading bracketed tag is `[` then any run of non-`]` characters then `]`,
+// capturing the whole tag (including inner spaces like `[file read]`) and the
+// remainder as the message body.
+const LEADING_TAG = /^(\[[^\]]+\])([\s\S]*)$/u;
+
+export function styleTaggedNotice(line: string): string {
+	const match = LEADING_TAG.exec(line);
+	if (!match) return line;
+	const tag = match[1] ?? "";
+	const body = match[2] ?? "";
+	const styledTag = theme.fg(tag === "[retry]" ? "warning" : "dim", tag);
+	return body.length > 0 ? `${styledTag}${theme.fg("muted", body)}` : styledTag;
+}