@pi-unipi/unipi 2.6.1 → 2.6.2

package/packages/utility/src/diff/renderer.ts

@@ -1,395 +0,0 @@
-/**
- * @pi-unipi/utility — Diff Renderer
- *
- * ANSI diff rendering: split (side-by-side) and unified (stacked) views.
- * Includes ANSI utilities, background injection, and adaptive wrapping.
- *
- * IMPORTANT: All output lines must be truncated to terminal width
- * to prevent TUI crashes. Use fit() or truncateToTermWidth()
- * before pushing lines.
- */
-
-import type { ParsedDiff, DiffLine } from "./parser.js";
-import type { DiffColors } from "./theme.js";
-import { hexToBgAnsi, hexToFgAnsi } from "./theme.js";
-import { hlBlock, detectLanguage } from "./highlighter.js";
-import { truncateToWidth as piTruncateToWidth, visibleWidth as piVisibleWidth } from "@earendil-works/pi-tui";
-
-// ─── Constants ──────────────────────────────────────────────────────────────────
-
-/** Maximum preview lines shown inline */
-export const MAX_PREVIEW_LINES = 60;
-
-/** Maximum total render lines */
-export const MAX_RENDER_LINES = 150;
-
-/** Minimum terminal width for split view */
-export const SPLIT_MIN_WIDTH = 150;
-
-/** Minimum code column width in split view */
-export const SPLIT_MIN_CODE_WIDTH = 60;
-
-// ─── ANSI Utilities ─────────────────────────────────────────────────────────────
-
-/**
- * Strip all ANSI escape sequences from a string.
- */
-export function strip(s: string): string {
-  // eslint-disable-next-line no-control-regex
-  return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
-}
-
-/**
- * Get the visible width of a string (excluding ANSI escapes).
- * Delegates to pi-tui's ANSI-aware implementation for correctness.
- */
-export function visibleWidth(s: string): number {
-  return piVisibleWidth(s);
-}
-
-/**
- * Fit a string to a target width, padding or truncating as needed.
- * Uses pi-tui's ANSI-aware truncation for correctness.
- */
-export function fit(s: string, targetWidth: number): string {
-  const vw = visibleWidth(s);
-  if (vw === targetWidth) return s;
-  if (vw > targetWidth) {
-    return piTruncateToWidth(s, targetWidth, "");
-  }
-  // Pad
-  return s + " ".repeat(targetWidth - vw);
-}
-
-/**
- * Wrap an ANSI string to a maximum width.
- * Returns an array of wrapped lines.
- */
-export function wrapAnsi(s: string, maxWidth: number): string[] {
-  if (visibleWidth(s) <= maxWidth) return [s];
-
-  const lines: string[] = [];
-  let current = "";
-  let currentWidth = 0;
-  let ansiState = "";
-
-  // Process character by character
-  let i = 0;
-  while (i < s.length) {
-    if (s[i] === "\x1b") {
-      // Collect ANSI sequence
-      let seq = "\x1b";
-      i++;
-      while (i < s.length && s[i] !== "m") {
-        seq += s[i];
-        i++;
-      }
-      if (i < s.length) {
-        seq += "m";
-        i++;
-      }
-      ansiState = seq;
-      current += seq;
-    } else {
-      const char = s[i];
-      const code = char.codePointAt(0)!;
-      const charWidth = (code >= 0x4e00 && code <= 0x9fff) || code > 0xffff ? 2 : 1;
-
-      if (currentWidth + charWidth > maxWidth) {
-        lines.push(current + "\x1b[0m");
-        current = ansiState;
-        currentWidth = 0;
-      }
-      current += char;
-      currentWidth += charWidth;
-      i++;
-    }
-  }
-
-  if (strip(current).length > 0) {
-    lines.push(current);
-  }
-
-  return lines.length > 0 ? lines : [""];
-}
-
-/**
- * Get the current ANSI state (active escape sequences) at the end of a string.
- */
-export function ansiState(s: string): string {
-  // Find the last reset or the last escape sequence
-  const lastReset = s.lastIndexOf("\x1b[0m");
-  const lastEsc = s.lastIndexOf("\x1b[");
-
-  if (lastEsc < 0) return "";
-  // If reset is at the end (or after last escape), state is cleared
-  if (lastReset >= lastEsc) return "";
-
-  // Extract the sequence
-  const match = s.substring(lastEsc).match(/^\x1b\[[0-9;]*[a-zA-Z]/);
-  return match ? match[0] : "";
-}
-
-/**
- * Format a line number with fixed width.
- */
-export function lnum(n: number | null, width: number = 4): string {
-  if (n === null) return " ".repeat(width);
-  return n.toString().padStart(width, " ");
-}
-
-/**
- * Generate a stripe pattern for alternating rows.
- */
-export function stripes(line: string, even: boolean): string {
-  const dim = "\x1b[2m";
-  const reset = "\x1b[0m";
-  return even ? `${dim}·${reset} ${line}` : ` ${line}`;
-}
-
-// ─── Terminal Width ─────────────────────────────────────────────────────────────
-
-/**
- * Get terminal width, with fallback.
- */
-export function termW(): number {
-  try {
-    return process.stdout.columns || 80;
-  } catch {
-    return 80;
-  }
-}
-
-/**
- * Truncate a line to terminal width using pi-tui's ANSI-aware truncation.
- * Prevents TUI crash when rendered lines exceed terminal width.
- * Accounts for rendering overhead from Box nesting (~6 chars).
- */
-export function truncateToTermWidth(line: string): string {
-  const maxW = Math.max(20, termW() - 6);
-  if (piVisibleWidth(line) <= maxW) return line;
-  return piTruncateToWidth(line, maxW, "…");
-}
-
-// ─── Background Injection ───────────────────────────────────────────────────────
-
-/**
- * Composite diff background colors under Shiki syntax foregrounds.
- *
- * Takes an ANSI-highlighted line and injects a background color
- * at the specified character ranges.
- *
- * @param ansiLine - ANSI-highlighted line from Shiki
- * @param ranges - Character ranges to apply background to [{start, end}]
- * @param baseBg - Base background color for the line
- * @param hlBg - Highlight background color for the ranges
- */
-export function injectBg(
-  ansiLine: string,
-  ranges: Array<{ start: number; end: number }>,
-  baseBg: string,
-  hlBg: string,
-): string {
-  if (ranges.length === 0) {
-    return `${hexToBgAnsi(baseBg)}${ansiLine}\x1b[0m`;
-  }
-
-  // For simplicity, apply the highlight background to the whole line
-  // if any ranges are specified. Character-level injection is complex
-  // and would require parsing the ANSI stream.
-  return `${hexToBgAnsi(hlBg)}${ansiLine}\x1b[0m`;
-}
-
-// ─── Adaptive Wrap ──────────────────────────────────────────────────────────────
-
-/**
- * Wrap rows adaptively, preserving line structure.
- * Returns the wrapped rows with line continuation indicators.
- */
-export function adaptiveWrapRows(rows: string[], maxWidth: number): string[] {
-  const result: string[] = [];
-  for (const row of rows) {
-    if (visibleWidth(row) <= maxWidth) {
-      result.push(row);
-    } else {
-      const wrapped = wrapAnsi(row, maxWidth);
-      for (let i = 0; i < wrapped.length; i++) {
-        result.push(i === 0 ? wrapped[i] : `  ${wrapped[i]}`);
-      }
-    }
-  }
-  return result;
-}
-
-// ─── Split View Heuristic ───────────────────────────────────────────────────────
-
-/**
- * Determine whether to use split (side-by-side) view.
- * Falls back to unified on narrow terminals or when wrap ratio is too high.
- *
- * @param diff - The parsed diff
- * @param tw - Terminal width
- * @param max - Maximum render lines
- */
-export function shouldUseSplit(diff: ParsedDiff, tw: number, max: number): boolean {
-  // Too narrow for split
-  if (tw < SPLIT_MIN_WIDTH) return false;
-
-  // Calculate code column widths
-  const codeWidth = Math.floor((tw - 6) / 2); // 6 chars for padding/line numbers
-  if (codeWidth < SPLIT_MIN_CODE_WIDTH) return false;
-
-  // Check if any lines would wrap in split mode
-  const maxContentWidth = Math.max(
-    ...diff.lines
-      .filter((l) => l.type !== "hunk")
-      .map((l) => l.content.length),
-    0,
-  );
-
-  // If lines are too long, unified is better
-  if (maxContentWidth > codeWidth * 1.5) return false;
-
-  return true;
-}
-
-// ─── Renderers ──────────────────────────────────────────────────────────────────
-
-/**
- * Render a diff in unified (stacked single-column) view.
- *
- * @param diff - Parsed diff
- * @param language - Shiki language for syntax highlighting
- * @param max - Maximum lines to render
- * @param dc - Diff colors
- */
-export function renderUnified(
-  diff: ParsedDiff,
-  language: string,
-  max: number,
-  dc: DiffColors,
-): string {
-  const lines: string[] = [];
-  const totalLines = Math.min(diff.lines.length, max);
-  const truncated = diff.lines.length > max;
-
-  const addBg = hexToBgAnsi(dc.addBg);
-  const remBg = hexToBgAnsi(dc.remBg);
-  const addFg = hexToFgAnsi(dc.addFg);
-  const remFg = hexToFgAnsi(dc.remFg);
-  const hunkFg = hexToFgAnsi(dc.hunkFg);
-  const headerFg = hexToFgAnsi(dc.headerFg);
-  const reset = "\x1b[0m";
-
-  for (let i = 0; i < totalLines; i++) {
-    const line = diff.lines[i];
-
-    switch (line.type) {
-      case "hunk":
-        lines.push(truncateToTermWidth(`${hunkFg}${line.content}${reset}`));
-        break;
-      case "add":
-        lines.push(truncateToTermWidth(`${addBg}${addFg}+${reset}${addBg} ${lnum(null, 4)} ${lnum(line.newLine, 4)} │ ${line.content}${reset}`));
-        break;
-      case "remove":
-        lines.push(truncateToTermWidth(`${remBg}${remFg}-${reset}${remBg} ${lnum(line.oldLine, 4)} ${lnum(null, 4)} │ ${line.content}${reset}`));
-        break;
-      case "context":
-        lines.push(truncateToTermWidth(` ${headerFg}${lnum(line.oldLine, 4)} ${lnum(line.newLine, 4)}${reset} │ ${line.content}`));
-        break;
-    }
-  }
-
-  if (truncated) {
-    lines.push(`${headerFg}... (${diff.lines.length - max} more lines)${reset}`);
-  }
-
-  return lines.join("\n");
-}
-
-/**
- * Render a diff in split (side-by-side) view.
- * Auto-falls back to unified on narrow terminals.
- *
- * @param diff - Parsed diff
- * @param language - Shiki language for syntax highlighting
- * @param max - Maximum lines to render
- * @param dc - Diff colors
- */
-export function renderSplit(
-  diff: ParsedDiff,
-  language: string,
-  max: number,
-  dc: DiffColors,
-): string {
-  const tw = termW();
-
-  // Auto-fallback to unified
-  if (!shouldUseSplit(diff, tw, max)) {
-    return renderUnified(diff, language, max, dc);
-  }
-
-  const lines: string[] = [];
-  const codeWidth = Math.floor((tw - 12) / 2); // 12 chars for line nums, separators, padding
-  const totalLines = Math.min(diff.lines.length, max);
-  const truncated = diff.lines.length > max;
-
-  const addBg = hexToBgAnsi(dc.addBg);
-  const remBg = hexToBgAnsi(dc.remBg);
-  const addFg = hexToFgAnsi(dc.addFg);
-  const remFg = hexToFgAnsi(dc.remFg);
-  const hunkFg = hexToFgAnsi(dc.hunkFg);
-  const headerFg = hexToFgAnsi(dc.headerFg);
-  const reset = "\x1b[0m";
-
-  // Group lines into left (old) and right (new) columns
-  // Build the left and right columns for each visual line
-  const leftLines: string[] = [];
-  const rightLines: string[] = [];
-
-  for (let i = 0; i < totalLines; i++) {
-    const line = diff.lines[i];
-
-    switch (line.type) {
-      case "hunk": {
-        // Hunk header spans both columns
-        const padded = `  ${hunkFg}${line.content}${reset}`;
-        const halfWidth = Math.floor(tw / 2);
-        leftLines.push(fit(padded, halfWidth));
-        rightLines.push("");
-        break;
-      }
-      case "add": {
-        // Left: empty; Right: added line
-        leftLines.push(`${headerFg}${" ".repeat(codeWidth)}${reset}`);
-        rightLines.push(`${addBg}${addFg}+${reset}${addBg} ${lnum(line.newLine, 4)} │ ${fit(line.content, codeWidth - 8)}${reset}`);
-        break;
-      }
-      case "remove": {
-        // Left: removed line; Right: empty
-        leftLines.push(`${remBg}${remFg}-${reset}${remBg} ${lnum(line.oldLine, 4)} │ ${fit(line.content, codeWidth - 8)}${reset}`);
-        rightLines.push(`${headerFg}${" ".repeat(codeWidth)}${reset}`);
-        break;
-      }
-      case "context": {
-        // Both columns show the same context line
-        leftLines.push(`${headerFg}${lnum(line.oldLine, 4)}${reset} │ ${fit(line.content, codeWidth - 7)}`);
-        rightLines.push(`${headerFg}${lnum(line.newLine, 4)}${reset} │ ${fit(line.content, codeWidth - 7)}`);
-        break;
-      }
-    }
-  }
-
-  // Combine left and right columns
-  for (let i = 0; i < leftLines.length; i++) {
-    const left = leftLines[i];
-    const right = rightLines[i];
-    lines.push(truncateToTermWidth(`${left} │ ${right}`));
-  }
-
-  if (truncated) {
-    lines.push(`${headerFg}... (${diff.lines.length - max} more lines)${reset}`);
-  }
-
-  return lines.join("\n");
-}

package/packages/utility/src/diff/theme.ts

@@ -1,316 +0,0 @@
-/**
- * @pi-unipi/utility — Diff Theme System
- *
- * Color presets, resolution chain, and hex ↔ ANSI conversion for diff rendering.
- *
- * Resolution chain: env vars → per-color overrides → preset → auto-derive → hardcoded
- */
-
-import { readDiffSettings, type DiffSettings } from "./settings.js";
-
-// ─── Types ──────────────────────────────────────────────────────────────────────
-
-/** Diff color configuration */
-export interface DiffColors {
-  /** Background for added lines */
-  addBg: string;
-  /** Foreground for added line content */
-  addFg: string;
-  /** Background for removed lines */
-  remBg: string;
-  /** Foreground for removed line content */
-  remFg: string;
-  /** Background for added word-level highlights */
-  addWordBg: string;
-  /** Background for removed word-level highlights */
-  remWordBg: string;
-  /** Hunk header foreground */
-  hunkFg: string;
-  /** Header info foreground */
-  headerFg: string;
-}
-
-/** Diff theme preset */
-export interface DiffPreset {
-  name: string;
-  description: string;
-  colors: DiffColors;
-}
-
-/** An ANSI color code (e.g. "\x1b[38;2;255;0;0m") */
-type AnsiColor = string;
-
-// ─── Built-in Presets ───────────────────────────────────────────────────────────
-
-const PRESETS: Record<string, DiffPreset> = {
-  default: {
-    name: "default",
-    description: "Classic green/red diff colors",
-    colors: {
-      addBg: "#1a3a1a",
-      addFg: "#b5e8b5",
-      remBg: "#3a1a1a",
-      remFg: "#e8b5b5",
-      addWordBg: "#2d5a2d",
-      remWordBg: "#5a2d2d",
-      hunkFg: "#8888ff",
-      headerFg: "#888888",
-    },
-  },
-  midnight: {
-    name: "midnight",
-    description: "Deep blue-tinted diff colors",
-    colors: {
-      addBg: "#0a2a3a",
-      addFg: "#a5d8e8",
-      remBg: "#3a0a1a",
-      remFg: "#e8a5c5",
-      addWordBg: "#1a4a5a",
-      remWordBg: "#5a1a3a",
-      hunkFg: "#6688cc",
-      headerFg: "#666688",
-    },
-  },
-  subtle: {
-    name: "subtle",
-    description: "Muted, low-contrast diff colors",
-    colors: {
-      addBg: "#1e2e1e",
-      addFg: "#a0b8a0",
-      remBg: "#2e1e1e",
-      remFg: "#b8a0a0",
-      addWordBg: "#2a3a2a",
-      remWordBg: "#3a2a2a",
-      hunkFg: "#7777aa",
-      headerFg: "#777777",
-    },
-  },
-  neon: {
-    name: "neon",
-    description: "High-contrast vivid diff colors",
-    colors: {
-      addBg: "#003300",
-      addFg: "#66ff66",
-      remBg: "#330000",
-      remFg: "#ff6666",
-      addWordBg: "#005500",
-      remWordBg: "#550000",
-      hunkFg: "#6666ff",
-      headerFg: "#999999",
-    },
-  },
-};
-
-// ─── Preset Access ──────────────────────────────────────────────────────────────
-
-/**
- * Get a diff preset by name. Falls back to "default" if not found.
- */
-export function getPreset(name: string): DiffPreset {
-  return PRESETS[name] ?? PRESETS.default;
-}
-
-/**
- * Get all available preset names.
- */
-export function getPresetNames(): string[] {
-  return Object.keys(PRESETS);
-}
-
-/**
- * Get all presets with their metadata.
- */
-export function getAllPresets(): DiffPreset[] {
-  return Object.values(PRESETS);
-}
-
-// ─── Hex ↔ ANSI Conversion ──────────────────────────────────────────────────────
-
-/**
- * Parse a hex color string (#RRGGBB or #RGB) to [r, g, b].
- */
-export function hexToRgb(hex: string): [number, number, number] {
-  let h = hex.replace(/^#/, "");
-  if (h.length === 3) {
-    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
-  }
-  const r = parseInt(h.substring(0, 2), 16);
-  const g = parseInt(h.substring(2, 4), 16);
-  const b = parseInt(h.substring(4, 6), 16);
-  return [r, g, b];
-}
-
-/**
- * Convert [r, g, b] to hex string (#RRGGBB).
- */
-export function rgbToHex(r: number, g: number, b: number): string {
-  const toHex = (n: number) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
-  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-}
-
-/**
- * Convert a hex color to ANSI 24-bit foreground escape.
- */
-export function hexToFgAnsi(hex: string): AnsiColor {
-  const [r, g, b] = hexToRgb(hex);
-  return `\x1b[38;2;${r};${g};${b}m`;
-}
-
-/**
- * Convert a hex color to ANSI 24-bit background escape.
- */
-export function hexToBgAnsi(hex: string): AnsiColor {
-  const [r, g, b] = hexToRgb(hex);
-  return `\x1b[48;2;${r};${g};${b}m`;
-}
-
-/**
- * Extract hex color from an ANSI 24-bit foreground escape sequence.
- * Returns null if not a 24-bit color.
- */
-export function ansiFgToHex(ansi: string): string | null {
-  const match = ansi.match(/\x1b\[38;2;(\d+);(\d+);(\d+)m/);
-  if (!match) return null;
-  return rgbToHex(parseInt(match[1]), parseInt(match[2]), parseInt(match[3]));
-}
-
-/**
- * Extract hex color from an ANSI 24-bit background escape sequence.
- * Returns null if not a 24-bit color.
- */
-export function ansiBgToHex(ansi: string): string | null {
-  const match = ansi.match(/\x1b\[48;2;(\d+);(\d+);(\d+)m/);
-  if (!match) return null;
-  return rgbToHex(parseInt(match[1]), parseInt(match[2]), parseInt(match[3]));
-}
-
-// ─── Color Resolution ───────────────────────────────────────────────────────────
-
-/**
- * Load the diff configuration from settings.
- */
-export function loadDiffConfig(): DiffSettings {
-  return readDiffSettings();
-}
-
-/**
- * Mix a foreground color with a background color at a given ratio.
- * Used for auto-deriving diff backgrounds from pi theme accents.
- */
-export function mixColors(fg: string, bg: string, ratio: number): string {
-  const [fr, fg_, fb] = hexToRgb(fg);
-  const [br, bg_, bb] = hexToRgb(bg);
-  const r = Math.round(fr * ratio + br * (1 - ratio));
-  const g = Math.round(fg_ * ratio + bg_ * (1 - ratio));
-  const b = Math.round(fb * ratio + bb * (1 - ratio));
-  return rgbToHex(r, g, b);
-}
-
-/**
- * Auto-derive diff background colors from a pi theme.
- * Mixes accent/success/error colors with a base background.
- */
-export function autoDeriveBgFromTheme(theme: any): DiffColors | null {
-  try {
-    // Try to get theme colors from pi's Theme object
-    const baseBg = theme?.colors?.customMessageBg || theme?.colors?.background || "#1a1a2e";
-    const successColor = theme?.colors?.toolSuccess || theme?.colors?.success || "#22c55e";
-    const errorColor = theme?.colors?.toolError || theme?.colors?.error || "#ef4444";
-
-    return {
-      addBg: mixColors(successColor, baseBg, 0.15),
-      addFg: mixColors(successColor, "#ffffff", 0.7),
-      remBg: mixColors(errorColor, baseBg, 0.15),
-      remFg: mixColors(errorColor, "#ffffff", 0.7),
-      addWordBg: mixColors(successColor, baseBg, 0.25),
-      remWordBg: mixColors(errorColor, baseBg, 0.25),
-      hunkFg: "#8888ff",
-      headerFg: "#888888",
-    };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check if a value looks like a hex color.
- */
-function isHexColor(v: string): boolean {
-  return /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(v);
-}
-
-/**
- * Resolve diff colors using the full chain:
- * env vars → per-color overrides → preset → auto-derive → hardcoded
- *
- * @param theme - Optional pi Theme object for auto-derivation
- */
-export function resolveDiffColors(theme?: any): DiffColors {
-  const config = loadDiffConfig();
-  const preset = getPreset(config.theme);
-
-  // Start with preset colors
-  let colors = { ...preset.colors };
-
-  // Layer: auto-derive from pi theme (if available)
-  if (theme) {
-    const derived = autoDeriveBgFromTheme(theme);
-    if (derived) {
-      // Auto-derived colors fill in where preset has defaults
-      colors = {
-        addBg: colors.addBg || derived.addBg,
-        addFg: colors.addFg || derived.addFg,
-        remBg: colors.remBg || derived.remBg,
-        remFg: colors.remFg || derived.remFg,
-        addWordBg: colors.addWordBg || derived.addWordBg,
-        remWordBg: colors.remWordBg || derived.remWordBg,
-        hunkFg: colors.hunkFg || derived.hunkFg,
-        headerFg: colors.headerFg || derived.headerFg,
-      };
-    }
-  }
-
-  // Layer: environment variable overrides
-  const envMap: Record<string, keyof DiffColors> = {
-    DIFF_ADD_BG: "addBg",
-    DIFF_ADD_FG: "addFg",
-    DIFF_REM_BG: "remBg",
-    DIFF_REM_FG: "remFg",
-    DIFF_ADD_WORD_BG: "addWordBg",
-    DIFF_REM_WORD_BG: "remWordBg",
-    DIFF_HUNK_FG: "hunkFg",
-    DIFF_HEADER_FG: "headerFg",
-  };
-
-  for (const [envKey, colorKey] of Object.entries(envMap)) {
-    const envVal = process.env[envKey];
-    if (envVal && isHexColor(envVal)) {
-      colors[colorKey] = envVal;
-    }
-  }
-
-  // Layer: per-color overrides from settings (if we add diffColors to settings later)
-  // Currently deferred — spec says "Out of Scope"
-
-  return colors;
-}
-
-/**
- * Apply the diff palette to create ANSI escape functions.
- * Returns an object with helper functions for coloring diff output.
- */
-export function applyDiffPalette(theme?: any) {
-  const colors = resolveDiffColors(theme);
-
-  return {
-    colors,
-    addBg: (s: string) => `${hexToBgAnsi(colors.addBg)}${s}\x1b[0m`,
-    addFg: (s: string) => `${hexToFgAnsi(colors.addFg)}${s}\x1b[0m`,
-    remBg: (s: string) => `${hexToBgAnsi(colors.remBg)}${s}\x1b[0m`,
-    remFg: (s: string) => `${hexToFgAnsi(colors.remFg)}${s}\x1b[0m`,
-    addWordBg: (s: string) => `${hexToBgAnsi(colors.addWordBg)}${s}\x1b[0m`,
-    remWordBg: (s: string) => `${hexToBgAnsi(colors.remWordBg)}${s}\x1b[0m`,
-    hunkFg: (s: string) => `${hexToFgAnsi(colors.hunkFg)}${s}\x1b[0m`,
-    headerFg: (s: string) => `${hexToFgAnsi(colors.headerFg)}${s}\x1b[0m`,
-  };
-}