@pi-unipi/utility 0.2.6 → 0.2.8

package/src/diff/settings.ts

@@ -0,0 +1,199 @@
+/**
+ * @pi-unipi/utility — Unified Settings Manager
+ *
+ * Manages both badge and diff settings in a single `.unipi/config/util-settings.json` file.
+ * Migrates from legacy `badge.json` on first read.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** Diff rendering settings */
+export interface DiffSettings {
+  /** Enable Shiki-powered diff rendering for write/edit tools */
+  enabled: boolean;
+  /** Diff theme preset: "default" | "midnight" | "subtle" | "neon" */
+  theme: string;
+  /** Shiki syntax theme name */
+  shikiTheme: string;
+  /** Minimum terminal columns for split view */
+  splitMinWidth: number;
+}
+
+/** Badge settings (matches existing BadgeSettings interface) */
+export interface BadgeSettingsSection {
+  autoGen: boolean;
+  badgeEnabled: boolean;
+  agentTool: boolean;
+  generationModel: string;
+}
+
+/** Unified utility settings */
+export interface UtilSettings {
+  badge: BadgeSettingsSection;
+  diff: DiffSettings;
+}
+
+/** Default diff settings */
+const DEFAULT_DIFF_SETTINGS: DiffSettings = {
+  enabled: true,
+  theme: "default",
+  shikiTheme: "github-dark",
+  splitMinWidth: 150,
+};
+
+/** Default badge settings */
+const DEFAULT_BADGE_SETTINGS: BadgeSettingsSection = {
+  autoGen: true,
+  badgeEnabled: true,
+  agentTool: true,
+  generationModel: "inherit",
+};
+
+/** Default unified settings */
+const DEFAULT_SETTINGS: UtilSettings = {
+  badge: { ...DEFAULT_BADGE_SETTINGS },
+  diff: { ...DEFAULT_DIFF_SETTINGS },
+};
+
+/** Config file paths */
+const UTIL_SETTINGS_FILE = ".unipi/config/util-settings.json";
+const BADGE_CONFIG_FILE = ".unipi/config/badge.json";
+
+/**
+ * Get absolute path for a config file relative to cwd.
+ */
+function getConfigPath(file: string): string {
+  return path.resolve(process.cwd(), file);
+}
+
+/**
+ * Read badge.json for migration purposes.
+ * Returns null if file doesn't exist or is malformed.
+ */
+function readLegacyBadgeSettings(): BadgeSettingsSection | null {
+  try {
+    const configPath = getConfigPath(BADGE_CONFIG_FILE);
+    if (!fs.existsSync(configPath)) return null;
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return {
+      autoGen: typeof parsed.autoGen === "boolean" ? parsed.autoGen : DEFAULT_BADGE_SETTINGS.autoGen,
+      badgeEnabled: typeof parsed.badgeEnabled === "boolean" ? parsed.badgeEnabled : DEFAULT_BADGE_SETTINGS.badgeEnabled,
+      agentTool: typeof parsed.agentTool === "boolean" ? parsed.agentTool : DEFAULT_BADGE_SETTINGS.agentTool,
+      generationModel: typeof parsed.generationModel === "string" ? parsed.generationModel : DEFAULT_BADGE_SETTINGS.generationModel,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Atomic write: write to temp file then rename.
+ * Prevents corruption if two instances write simultaneously.
+ */
+function atomicWrite(filePath: string, data: string): void {
+  const tmpPath = filePath + ".tmp";
+  fs.writeFileSync(tmpPath, data, "utf-8");
+  fs.renameSync(tmpPath, filePath);
+}
+
+/**
+ * Read the unified util-settings.json.
+ * On first read, migrates from badge.json if it exists.
+ * Returns defaults if no config exists.
+ */
+export function readUtilSettings(): UtilSettings {
+  try {
+    const configPath = getConfigPath(UTIL_SETTINGS_FILE);
+
+    // Check if unified config exists
+    if (fs.existsSync(configPath)) {
+      const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      return normalizeSettings(parsed);
+    }
+
+    // Migration: import from badge.json if it exists
+    const legacyBadge = readLegacyBadgeSettings();
+    if (legacyBadge) {
+      const migrated: UtilSettings = {
+        badge: legacyBadge,
+        diff: { ...DEFAULT_DIFF_SETTINGS },
+      };
+      writeUtilSettings(migrated);
+      return migrated;
+    }
+
+    // No config at all — return defaults (don't write yet)
+    return { ...DEFAULT_SETTINGS, badge: { ...DEFAULT_BADGE_SETTINGS }, diff: { ...DEFAULT_DIFF_SETTINGS } };
+  } catch {
+    return { ...DEFAULT_SETTINGS, badge: { ...DEFAULT_BADGE_SETTINGS }, diff: { ...DEFAULT_DIFF_SETTINGS } };
+  }
+}
+
+/**
+ * Write the full unified settings to disk.
+ */
+export function writeUtilSettings(settings: UtilSettings): void {
+  try {
+    const configPath = getConfigPath(UTIL_SETTINGS_FILE);
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    atomicWrite(configPath, JSON.stringify(settings, null, 2) + "\n");
+  } catch {
+    // Best effort
+  }
+}
+
+/**
+ * Normalize a parsed JSON object into valid UtilSettings.
+ */
+function normalizeSettings(parsed: any): UtilSettings {
+  return {
+    badge: {
+      autoGen: typeof parsed?.badge?.autoGen === "boolean" ? parsed.badge.autoGen : DEFAULT_BADGE_SETTINGS.autoGen,
+      badgeEnabled: typeof parsed?.badge?.badgeEnabled === "boolean" ? parsed.badge.badgeEnabled : DEFAULT_BADGE_SETTINGS.badgeEnabled,
+      agentTool: typeof parsed?.badge?.agentTool === "boolean" ? parsed.badge.agentTool : DEFAULT_BADGE_SETTINGS.agentTool,
+      generationModel: typeof parsed?.badge?.generationModel === "string" ? parsed.badge.generationModel : DEFAULT_BADGE_SETTINGS.generationModel,
+    },
+    diff: {
+      enabled: typeof parsed?.diff?.enabled === "boolean" ? parsed.diff.enabled : DEFAULT_DIFF_SETTINGS.enabled,
+      theme: typeof parsed?.diff?.theme === "string" ? parsed.diff.theme : DEFAULT_DIFF_SETTINGS.theme,
+      shikiTheme: typeof parsed?.diff?.shikiTheme === "string" ? parsed.diff.shikiTheme : DEFAULT_DIFF_SETTINGS.shikiTheme,
+      splitMinWidth: typeof parsed?.diff?.splitMinWidth === "number" ? parsed.diff.splitMinWidth : DEFAULT_DIFF_SETTINGS.splitMinWidth,
+    },
+  };
+}
+
+/**
+ * Read only the diff settings section.
+ */
+export function readDiffSettings(): DiffSettings {
+  return readUtilSettings().diff;
+}
+
+/**
+ * Write partial diff settings (merged with existing).
+ */
+export function writeDiffSettings(partial: Partial<DiffSettings>): void {
+  const settings = readUtilSettings();
+  settings.diff = { ...settings.diff, ...partial };
+  writeUtilSettings(settings);
+}
+
+/**
+ * Read only the badge settings section.
+ */
+export function readBadgeSettingsFromUtil(): BadgeSettingsSection {
+  return readUtilSettings().badge;
+}
+
+/**
+ * Write partial badge settings (merged with existing).
+ */
+export function writeBadgeSettingsToUtil(partial: Partial<BadgeSettingsSection>): void {
+  const settings = readUtilSettings();
+  settings.badge = { ...settings.badge, ...partial };
+  writeUtilSettings(settings);
+}

package/src/diff/theme.ts

@@ -0,0 +1,319 @@
+/**
+ * @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",
+    },
+  },
+};
+
+/** Hardcoded fallback colors (last resort) */
+const HARDCODED_FALLBACK: DiffColors = PRESETS.default.colors;
+
+// ─── 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`,
+  };
+}