ubume 0.1.0

package/src/ui/render/diffRenderer.ts

@@ -0,0 +1,116 @@
+import { sanitizeTerminalOutput } from "../../core/terminal/terminalSanitize.js";
+
+export type DiffRenderLineType = "file" | "hunk" | "add" | "remove" | "context" | "meta";
+
+export interface DiffRenderLine {
+  type: DiffRenderLineType;
+  text: string;
+}
+
+export interface DiffRenderOptions {
+  force?: boolean;
+}
+
+const DIFF_GIT_HEADER_PATTERN = /^diff --git\s+/;
+const HUNK_HEADER_PATTERN = /^@@\s+-\d+(?:,\d+)?\s+\+\d+(?:,\d+)?\s*@@/;
+const INDEX_HEADER_PATTERN = /^index\s+\S+\.\.\S+/;
+const OLD_FILE_HEADER_PATTERN = /^---\s+\S+/;
+const NEW_FILE_HEADER_PATTERN = /^\+\+\+\s+\S+/;
+const ADD_LINE_PATTERN = /^\+(?!\+\+)/;
+const REMOVE_LINE_PATTERN = /^-(?!--)/;
+
+function normalizeDiffText(text: string): string {
+  return sanitizeTerminalOutput(text, { preserveTabs: false, tabSize: 2 })
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n");
+}
+
+function getDiffLines(text: string): string[] {
+  return normalizeDiffText(text)
+    .split("\n")
+    .map((line) => line.trimEnd());
+}
+
+function trimBlankEdges(lines: string[]): string[] {
+  let start = 0;
+  let end = lines.length;
+
+  while (start < end && lines[start]?.trim() === "") start += 1;
+  while (end > start && lines[end - 1]?.trim() === "") end -= 1;
+
+  return lines.slice(start, end);
+}
+
+function hasPairedFileHeaders(lines: readonly string[]): boolean {
+  return lines.some((line) => OLD_FILE_HEADER_PATTERN.test(line))
+    && lines.some((line) => NEW_FILE_HEADER_PATTERN.test(line));
+}
+
+function hasStrongDiffSignal(lines: readonly string[]): boolean {
+  return lines.some((line) =>
+    DIFF_GIT_HEADER_PATTERN.test(line)
+    || HUNK_HEADER_PATTERN.test(line)
+    || INDEX_HEADER_PATTERN.test(line)
+  ) || hasPairedFileHeaders(lines);
+}
+
+function hasRealChangeLine(lines: readonly string[]): boolean {
+  return lines.some((line) => ADD_LINE_PATTERN.test(line) || REMOVE_LINE_PATTERN.test(line));
+}
+
+function shouldRenderUnifiedDiff(lines: readonly string[], options: DiffRenderOptions = {}): boolean {
+  if (lines.length < 2) return false;
+  if (options.force) {
+    return hasStrongDiffSignal(lines) || hasRealChangeLine(lines);
+  }
+  return hasStrongDiffSignal(lines) && hasRealChangeLine(lines);
+}
+
+export function classifyDiffLine(line: string): DiffRenderLineType {
+  if (DIFF_GIT_HEADER_PATTERN.test(line) || OLD_FILE_HEADER_PATTERN.test(line) || NEW_FILE_HEADER_PATTERN.test(line)) {
+    return "file";
+  }
+
+  if (HUNK_HEADER_PATTERN.test(line) || line.startsWith("@@")) {
+    return "hunk";
+  }
+
+  if (ADD_LINE_PATTERN.test(line)) {
+    return "add";
+  }
+
+  if (REMOVE_LINE_PATTERN.test(line)) {
+    return "remove";
+  }
+
+  if (INDEX_HEADER_PATTERN.test(line) || line.startsWith("\\ No newline")) {
+    return "meta";
+  }
+
+  return "context";
+}
+
+export function isUnifiedDiff(text: string, options: DiffRenderOptions = {}): boolean {
+  return shouldRenderUnifiedDiff(trimBlankEdges(getDiffLines(text)), options);
+}
+
+export function renderUnifiedDiff(text: string, options: DiffRenderOptions = {}): DiffRenderLine[] {
+  const lines = trimBlankEdges(getDiffLines(text));
+  if (lines.length === 0) {
+    return [];
+  }
+
+  if (!shouldRenderUnifiedDiff(lines, options)) {
+    return [];
+  }
+
+  return lines.map((line) => ({
+    type: classifyDiffLine(line),
+    text: line,
+  }));
+}
+
+export function maybeRenderDiff(text: string, options: DiffRenderOptions = {}): DiffRenderLine[] | null {
+  const rendered = renderUnifiedDiff(text, options);
+  return rendered.length > 0 ? rendered : null;
+}

package/src/ui/render/logoVariants.ts

@@ -0,0 +1,113 @@
+import { getTextWidth } from "./textLayout.js";
+
+// ─── Logo constants ───────────────────────────────────────────────────────────
+// Each variant is an array of exact terminal rows.
+//
+// IMPORTANT: Never apply `bold` when rendering these rows. Bold rendering of
+// Unicode full-block (█) and box-drawing (╔═╗╝) characters causes per-glyph
+// width/stroke differences in most terminal fonts (Ptyxis, GNOME Terminal,
+// VS Code), producing visible gaps between characters that should be flush.
+// The companion `wrap="truncate"` rule keeps each row on exactly one terminal
+// line regardless of the surrounding Ink flex layout.
+
+// Canonical Ubume brand wordmark — the ██ block art is the authoritative
+// large logo for wide/max layouts.
+export const UBUME_WORDMARK = [
+  "██╗   ██╗██████╗ ██╗   ██╗███╗   ███╗███████╗",
+  "██║   ██║██╔══██╗██║   ██║████╗ ████║██╔════╝",
+  "██║   ██║██████╔╝██║   ██║██╔████╔██║█████╗  ",
+  "██║   ██║██╔══██╗██║   ██║██║╚██╔╝██║██╔══╝  ",
+  "╚██████╔╝██████╔╝╚██████╔╝██║ ╚═╝ ██║███████╗",
+  " ╚═════╝ ╚═════╝  ╚═════╝ ╚═╝     ╚═╝╚══════╝",
+].join("\n");
+
+export const CODEXA_WORDMARK = UBUME_WORDMARK;
+
+/** 6-row ANSI Shadow block-char logo. Requires cols ≥ LOGO_LARGE_MIN_COLS. */
+export const LOGO_LARGE: readonly string[] = UBUME_WORDMARK.split("\n");
+
+/** 4-row pure-ASCII art logo. Requires cols ≥ LOGO_MEDIUM_MIN_COLS. */
+export const LOGO_MEDIUM: readonly string[] = [
+  " _   _ ____  _   _ __  __ _____ ",
+  "| | | | __ )| | | |  \\/  | ____|",
+  "| |_| |  _ \\| |_| | |\\/| |  _|  ",
+  " \\___/|____/ \\___/|_|  |_|_____|",
+];
+
+/** 1-row compact logo. Requires cols ≥ LOGO_COMPACT_MIN_COLS. */
+export const LOGO_COMPACT: readonly string[] = [
+  "✦ UBUME",
+];
+
+// ─── Breakpoints ──────────────────────────────────────────────────────────────
+
+// Aligned with MEDIUM_HEADER_MIN_COLUMNS so any side-by-side-capable terminal
+// shows the canonical block wordmark instead of the thin ASCII fallback.
+export const LOGO_LARGE_MIN_COLS = 72;
+export const LOGO_MEDIUM_MIN_COLS = 72;
+export const LOGO_COMPACT_MIN_COLS = 48;
+
+// Minimum terminal rows each variant needs to render without crowding out the
+// metadata + composer. A wide-but-short terminal (e.g. VS Code's bottom panel)
+// must step DOWN to a smaller logo instead of dropping straight to text-only.
+export const LOGO_LARGE_MIN_ROWS = 35;
+export const LOGO_MEDIUM_MIN_ROWS = 16;
+export const LOGO_COMPACT_MIN_ROWS = 12;
+
+const LOGO_VARIANTS: readonly { logo: readonly string[]; minCols: number; minRows: number }[] = [
+  { logo: LOGO_LARGE, minCols: LOGO_LARGE_MIN_COLS, minRows: LOGO_LARGE_MIN_ROWS },
+  { logo: LOGO_MEDIUM, minCols: LOGO_MEDIUM_MIN_COLS, minRows: LOGO_MEDIUM_MIN_ROWS },
+  { logo: LOGO_COMPACT, minCols: LOGO_COMPACT_MIN_COLS, minRows: LOGO_COMPACT_MIN_ROWS },
+];
+
+// ─── Selection ────────────────────────────────────────────────────────────────
+
+function isNoLogoEnv(): boolean {
+  return process.env["UBUME_NO_ASCII_LOGO"] === "1" || process.env["CODEXA_NO_ASCII_LOGO"] === "1";
+}
+
+function isCompactLogoEnv(): boolean {
+  return process.env["UBUME_COMPACT_LOGO"] === "1" || process.env["CODEXA_COMPACT_LOGO"] === "1";
+}
+
+/**
+ * Returns the best logo variant for the given terminal column count.
+ *
+ * Env overrides:
+ *   UBUME_NO_ASCII_LOGO=1 / CODEXA_NO_ASCII_LOGO=1  → always text-only (empty array)
+ *   UBUME_COMPACT_LOGO=1  / CODEXA_COMPACT_LOGO=1   → always compact single-line logo
+ */
+export function selectLogoVariant(cols: number): readonly string[] {
+  if (isNoLogoEnv()) return [];
+  if (isCompactLogoEnv()) return LOGO_COMPACT;
+  if (cols >= LOGO_LARGE_MIN_COLS) return LOGO_LARGE;
+  if (cols >= LOGO_COMPACT_MIN_COLS) return LOGO_COMPACT;
+  return [];
+}
+
+/**
+ * Returns the largest logo variant that fits BOTH the available columns and
+ * rows. Unlike {@link selectLogoVariant} (columns-only), this degrades a
+ * too-tall logo to a shorter one before falling back to text-only — so a
+ * wide-but-short terminal keeps a logo instead of collapsing to a flat line.
+ * Returns an empty array only when even the 1-row compact logo cannot fit.
+ *
+ * Honours the same env overrides as {@link selectLogoVariant}.
+ */
+export function selectLogoVariantForViewport(cols: number, rows: number): readonly string[] {
+  if (isNoLogoEnv()) return [];
+  if (isCompactLogoEnv()) {
+    return rows >= LOGO_COMPACT_MIN_ROWS ? LOGO_COMPACT : [];
+  }
+  for (const variant of LOGO_VARIANTS) {
+    if (cols >= variant.minCols && rows >= variant.minRows) {
+      return variant.logo;
+    }
+  }
+  return [];
+}
+
+/** Returns the visual column width of the widest row in a logo variant. */
+export function getLogoWidth(logo: readonly string[]): number {
+  return logo.reduce((max, line) => Math.max(max, getTextWidth(line)), 0);
+}

package/src/ui/render/modeDisplay.ts

@@ -0,0 +1,52 @@
+import { formatModeLabel } from "../../config/settings.js";
+import type { Theme } from "../theme.js";
+
+export interface ModeDisplaySpec {
+  label: string;
+  ringGlyph: string;
+  ringColor: string;
+  ringFill: string;
+  iconColor: string;
+  labelColor: string;
+  labelBold: boolean;
+  ringBold: boolean;
+}
+
+export function getModeDisplaySpec(mode: string, theme: Theme): ModeDisplaySpec {
+  switch (mode) {
+    case "full-auto":
+      return {
+        label: formatModeLabel(mode),
+        ringGlyph: "◉",
+        ringColor: theme.warning,
+        ringFill: theme.border,
+        iconColor: theme.warning,
+        labelColor: theme.text,
+        labelBold: true,
+        ringBold: true,
+      };
+    case "auto-edit":
+      return {
+        label: formatModeLabel(mode),
+        ringGlyph: "◎",
+        ringColor: theme.borderFocused,
+        ringFill: theme.surfaceMuted,
+        iconColor: theme.prompt,
+        labelColor: theme.text,
+        labelBold: true,
+        ringBold: false,
+      };
+    case "suggest":
+    default:
+      return {
+        label: formatModeLabel(mode),
+        ringGlyph: "○",
+        ringColor: theme.success,
+        ringFill: theme.surfaceMuted,
+        iconColor: theme.success,
+        labelColor: theme.textMuted,
+        labelBold: false,
+        ringBold: false,
+      };
+  }
+}

package/src/ui/render/outputPipeline.ts

@@ -0,0 +1,64 @@
+import { isNoiseLine } from "../../core/providers/codexTranscript.js";
+import { sanitizeTerminalOutput } from "../../core/terminal/terminalSanitize.js";
+import { parseMarkdown, type Segment } from "./Markdown.js";
+
+/**
+ * Sanitize: Strip ANSI escape sequences and non-printable control characters.
+ * Removes known UI chrome bleed (e.g. box drawing characters) before rendering.
+ *
+ * Note on diff colours: Diff colouring in this app is applied at the React/Ink
+ * rendering layer via getDiffTone() tones, NOT via raw ANSI escape sequences.
+ * This means sanitizeTerminalOutput() can safely strip all raw ANSI here —
+ * the correct theme colours are re-applied by buildCodePanelRows/buildMarkdownRows
+ * in timelineMeasure.ts. There is no need to preserve SGR codes at this stage.
+ */
+export function sanitizeOutput(raw: string): string {
+  if (!raw) return "";
+  const clean = sanitizeTerminalOutput(raw, { preserveTabs: false, tabSize: 2 });
+  return clean;
+}
+
+/**
+ * Sanitize streamed chunks directly (delegates to sanitizeOutput).
+ */
+export function sanitizeStreamChunk(chunk: string): string {
+  return sanitizeOutput(chunk);
+}
+
+/**
+ * Normalize: Normalizes text formatting for the box wrappers.
+ * Replaces CRLF with LF and collapses excessive blank lines to prevent
+ * vertical stretching and layout popping.
+ */
+export function normalizeOutput(clean: string): string {
+  let normalized = clean.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  // Collapse excessive vertical whitespace (4+ newlines into 3)
+  normalized = normalized.replace(/\n{4,}/g, "\n\n\n");
+
+  // Remove lines that are purely known noise prefixes
+  const lines = normalized.split("\n");
+  const filteredLines = lines.filter((line) => !isNoiseLine(line));
+
+  return filteredLines.join("\n");
+}
+
+/**
+ * Classify: Segments the normalized string into typed semantic blocks
+ * such as prose, code blocks, diffs, lists, and headers.
+ *
+ * Diff colouring is applied at render time via getDiffTone() in
+ * timelineMeasure.ts, which maps each diff line to a TimelineTone that
+ * the theme system resolves to the correct terminal colour.
+ */
+export function classifyOutput(normalized: string): Segment[] {
+  return parseMarkdown(normalized);
+}
+
+/**
+ * Format For Box: Intentional pass-through — segments are returned as-is.
+ * Width-fitting is handled downstream by the layout engine in timelineMeasure.ts.
+ * This function exists as a named pipeline stage for clarity and future extension.
+ */
+export function formatForBox(classified: Segment[], boxWidth: number): Segment[] {
+  return classified;
+}

package/src/ui/render/runtimeDisplay.ts

@@ -0,0 +1,128 @@
+import { formatModeLabel, formatReasoningLabel } from "../../config/settings.js";
+import type { RuntimeSummary } from "../../config/runtimeConfig.js";
+import type { CodexModelCapability } from "../../core/models/codexModelCapabilities.js";
+import type { ModelSpec } from "../../core/models/modelSpecs.js";
+import type { ModelContextMetadata } from "../../core/providerRuntime/contextMetadata.js";
+import { contextMetadataToModelSpec, formatContextCompact } from "../../core/providerRuntime/contextMetadata.js";
+import type { ActiveProviderRoute } from "../../core/providerRuntime/types.js";
+import { getAntigravityModelLabel } from "../../core/providerRuntime/antigravity.js";
+import { CODEXA_NATIVE_MODEL_ID } from "../../core/providerRuntime/codexaNative.js";
+
+export interface ActiveRuntimeDisplayInput {
+  route: ActiveProviderRoute;
+  reasoningLevel: string;
+  mode: string;
+  tokensUsed: number;
+  modelCapability?: CodexModelCapability | null;
+  contextMetadata?: ModelContextMetadata | null;
+}
+
+export interface ActiveRuntimeDisplay {
+  providerLabel: string;
+  modelDisplay: string;
+  footerModelDisplay: string;
+  contextDisplay: string;
+  modeLabel: string;
+  modelSpec: ModelSpec;
+}
+
+const PROVIDER_DISPLAY: Record<string, string> = {
+  openai: "OpenAI Codex CLI",
+  anthropic: "Claude Code CLI",
+  google: "Gemini CLI",
+  mistral: "Mistral Vibe CLI",
+  local: "Local",
+  "codexa-native": "Codexa Native",
+  "codexa-cupy": "Codexa Native",
+  antigravity: "Antigravity CLI",
+};
+
+function formatContextLimit(value: number): string {
+  if (value >= 1_000_000) {
+    const millions = value / 1_000_000;
+    return Number.isInteger(millions) || Math.abs(millions - 1.048576) < 0.000001
+      ? `${Math.round(millions)}M`
+      : `${millions.toFixed(1)}M`;
+  }
+  return formatContextCompact(value);
+}
+
+function formatUsedTokens(value: number): string {
+  return formatContextCompact(value).replace(/k$/, "K");
+}
+
+function isContextForRoute(metadata: ModelContextMetadata | null | undefined, route: ActiveProviderRoute): metadata is ModelContextMetadata {
+  return metadata?.providerId === route.providerId && metadata.modelId === route.modelId;
+}
+
+function getModelLabel(route: ActiveProviderRoute, capability?: CodexModelCapability | null): string {
+  if (route.providerId === "anthropic") {
+    return capability?.label ?? route.modelId;
+  }
+  if (route.providerId === "antigravity") {
+    return getAntigravityModelLabel(route.modelId);
+  }
+  if (route.providerId === "codexa-native") {
+    // Older persisted routes may still contain the 900M checkpoint directory
+    // name; the user-facing Codexa Native model is the canonical 1B SFT v2 ID.
+    return CODEXA_NATIVE_MODEL_ID;
+  }
+  if (route.providerId === "codexa-cupy") {
+    return route.modelId;
+  }
+  return route.modelId;
+}
+
+export function buildActiveRuntimeDisplay({
+  route,
+  reasoningLevel,
+  mode,
+  tokensUsed,
+  modelCapability = null,
+  contextMetadata = null,
+}: ActiveRuntimeDisplayInput): ActiveRuntimeDisplay {
+  const providerLabel = PROVIDER_DISPLAY[route.providerId] ?? route.providerId;
+  const rawReasoning = route.providerId === "antigravity"
+    ? route.reasoning
+    : route.reasoning ?? reasoningLevel;
+  // Local runtimes own their reasoning behavior; Ubume cannot adjust it.
+  // Do not present the global fallback as if it were an active Local setting.
+  const reasoning = route.providerId !== "local" && rawReasoning
+    ? formatReasoningLabel(rawReasoning)
+    : null;
+  const modelLabel = getModelLabel(route, modelCapability);
+  const validContextMetadata = isContextForRoute(contextMetadata, route) ? contextMetadata : null;
+  const contextDisplay = validContextMetadata?.contextLength != null
+    ? `${formatUsedTokens(tokensUsed)} / ${validContextMetadata.confidence === "estimated" ? "~" : ""}${formatContextLimit(validContextMetadata.contextLength)}`
+    : "Unknown";
+  const modelSpec = contextMetadataToModelSpec(validContextMetadata ?? {
+    providerId: route.providerId,
+    modelId: route.modelId,
+    contextLength: null,
+    source: "unknown",
+    confidence: "unknown",
+    error: "Context length unavailable for this model.",
+  });
+
+  return {
+    providerLabel,
+    modelDisplay: reasoning
+      ? `${providerLabel} / ${modelLabel} / reasoning: ${reasoning}`
+      : `${providerLabel} / ${modelLabel}`,
+    footerModelDisplay: reasoning
+      ? `${providerLabel} / ${modelLabel} (${reasoning})`
+      : `${providerLabel} / ${modelLabel}`,
+    contextDisplay,
+    modeLabel: formatModeLabel(mode),
+    modelSpec,
+  };
+}
+
+export function runtimeDisplayToSummary(display: ActiveRuntimeDisplay, base: RuntimeSummary): RuntimeSummary {
+  return {
+    ...base,
+    providerLabel: display.providerLabel,
+    modelLabel: display.modelDisplay,
+    contextLabel: display.contextDisplay,
+  };
+}

package/src/ui/render/terminalAnswerFormat.ts

@@ -0,0 +1,128 @@
+const MARKDOWN_LINK_RE = /!?\[([^\]\n]+)\]\(([^)\n]+)\)/g;
+const FILE_URL_RE = /\bfile:\/\/\/?[^\s`"'<>)]*/gi;
+const WINDOWS_ABSOLUTE_PATH_RE = /\b[A-Za-z]:[\\/][^\n`"'<>)]*?\.(?:tsx?|jsx?|md|json|ya?ml|toml|css|html|py|txt|mjs|cjs)(?:#L\d+(?:-L?\d+)?)?/g;
+const UNIX_ABSOLUTE_PATH_RE = /(?:^|[\s(])((?:\/Users|\/home|\/workspace|\/workspaces|\/mnt\/[a-z])\/[^\n`"'<>)]*?\.(?:tsx?|jsx?|md|json|ya?ml|toml|css|html|py|txt|mjs|cjs)(?:#L\d+(?:-L?\d+)?)?)/g;
+
+const PATH_ROOT_SEGMENTS = new Set([
+  ".github",
+  "app",
+  "bin",
+  "components",
+  "docs",
+  "lib",
+  "pages",
+  "preview",
+  "scripts",
+  "src",
+  "test",
+  "tests",
+]);
+
+const ROOT_FILE_RE = /^(?:README|CHANGELOG|LICENSE|SECURITY|package|tsconfig|vite\.config|next\.config|bun\.lock)(?:\.[a-z0-9]+)?$/i;
+
+function decodePath(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function stripLinkLabelMarkdown(label: string): string {
+  return label.trim().replace(/^`([^`]+)`$/, "$1").replace(/^\*\*([^*]+)\*\*$/, "$1");
+}
+
+function splitLineAnchor(value: string): { path: string; lineSuffix: string } {
+  const anchorMatch = /#L(\d+)(?:-L?(\d+))?$/i.exec(value);
+  if (!anchorMatch) {
+    return { path: value, lineSuffix: "" };
+  }
+
+  const start = anchorMatch[1]!;
+  const end = anchorMatch[2];
+  return {
+    path: value.slice(0, anchorMatch.index),
+    lineSuffix: end ? `:${start}-${end}` : `:${start}`,
+  };
+}
+
+function normalizeLocalPathPathname(rawPath: string): { path: string; lineSuffix: string } {
+  let value = rawPath.trim();
+  value = value.replace(/^<|>$/g, "");
+  value = value.replace(/^file:(?:\/\/)?/i, "");
+  value = value.replace(/^\/([A-Za-z]:[\\/])/, "$1");
+  value = decodePath(value);
+  value = value.replace(/\\/g, "/");
+  value = value.replace(/[?#][^#]*$/, (suffix) => suffix.startsWith("#L") ? suffix : "");
+  return splitLineAnchor(value);
+}
+
+function looksLikeLocalTarget(target: string): boolean {
+  const trimmed = target.trim();
+  return /^file:/i.test(trimmed)
+    || /^[A-Za-z]:[\\/]/.test(trimmed)
+    || /^\/(?:Users|home|workspace|workspaces|mnt\/[a-z])\//i.test(trimmed);
+}
+
+function looksLikePathLabel(label: string): boolean {
+  return /[\\/]/.test(label) || /^[\w.-]+\.[A-Za-z0-9]+(?::\d+(?:-\d+)?)?$/.test(label);
+}
+
+export function formatLocalPathForTerminal(rawPath: string): string {
+  if (/^https?:\/\//i.test(rawPath.trim())) {
+    return rawPath;
+  }
+
+  const { path, lineSuffix } = normalizeLocalPathPathname(rawPath);
+  const segments = path.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return path + lineSuffix;
+  }
+
+  const rootIndex = segments.findIndex((segment) => PATH_ROOT_SEGMENTS.has(segment));
+  if (rootIndex >= 0) {
+    return segments.slice(rootIndex).join("/") + lineSuffix;
+  }
+
+  const fileName = segments[segments.length - 1]!;
+  if (ROOT_FILE_RE.test(fileName)) {
+    return fileName + lineSuffix;
+  }
+
+  return segments.slice(-1).join("/") + lineSuffix;
+}
+
+function formatLocalMarkdownLink(label: string, target: string): string {
+  const cleanLabel = stripLinkLabelMarkdown(label);
+  const compactTarget = formatLocalPathForTerminal(target);
+  const lineSuffix = /(:\d+(?:-\d+)?)$/.exec(compactTarget)?.[1] ?? "";
+
+  if (looksLikePathLabel(cleanLabel)) {
+    const compactLabel = formatLocalPathForTerminal(cleanLabel);
+    return lineSuffix && !compactLabel.endsWith(lineSuffix)
+      ? `${compactLabel}${lineSuffix}`
+      : compactLabel;
+  }
+
+  return cleanLabel ? `${cleanLabel} (${compactTarget})` : compactTarget;
+}
+
+export function formatTerminalAnswerInline(text: string): string {
+  if (!text) return text;
+
+  let formatted = text.replace(MARKDOWN_LINK_RE, (full, label: string, target: string) => {
+    if (!looksLikeLocalTarget(target)) {
+      return full;
+    }
+    return formatLocalMarkdownLink(label, target);
+  });
+
+  formatted = formatted.replace(FILE_URL_RE, (match) => formatLocalPathForTerminal(match));
+  formatted = formatted.replace(WINDOWS_ABSOLUTE_PATH_RE, (match) => formatLocalPathForTerminal(match));
+  formatted = formatted.replace(UNIX_ABSOLUTE_PATH_RE, (full, path: string) => {
+    const prefix = full.slice(0, full.length - path.length);
+    return `${prefix}${formatLocalPathForTerminal(path)}`;
+  });
+
+  return formatted;
+}