@pi-unipi/utility 2.6.1 → 2.6.2

package/src/cache/ttl-cache.ts

@@ -1,311 +0,0 @@
-/**
- * @pi-unipi/utility — TTL Cache
- *
- * General-purpose TTL cache with memory + SQLite backends.
- */
-
-import type { CacheEntry, CacheBackend, TTLCacheOptions } from "../types.js";
-
-// ─── Memory Backend ──────────────────────────────────────────────────────────
-
-class MemoryBackend<K, V> implements CacheBackend<K, V> {
-  private store = new Map<K, CacheEntry<V>>();
-  private maxEntries: number;
-
-  constructor(maxEntries: number = 1000) {
-    this.maxEntries = maxEntries;
-  }
-
-  async get(key: K): Promise<V | undefined> {
-    const entry = this.store.get(key);
-    if (!entry) return undefined;
-    if (Date.now() > entry.expiresAt) {
-      this.store.delete(key);
-      return undefined;
-    }
-    return entry.value;
-  }
-
-  async set(key: K, value: V, ttlMs: number): Promise<void> {
-    // Evict oldest if at capacity
-    if (this.store.size >= this.maxEntries && !this.store.has(key)) {
-      const firstKey = this.store.keys().next().value;
-      if (firstKey !== undefined) {
-        this.store.delete(firstKey);
-      }
-    }
-
-    const now = Date.now();
-    this.store.set(key, {
-      value,
-      expiresAt: now + ttlMs,
-      createdAt: now,
-    });
-  }
-
-  async has(key: K): Promise<boolean> {
-    const entry = this.store.get(key);
-    if (!entry) return false;
-    if (Date.now() > entry.expiresAt) {
-      this.store.delete(key);
-      return false;
-    }
-    return true;
-  }
-
-  async delete(key: K): Promise<boolean> {
-    return this.store.delete(key);
-  }
-
-  async cleanupExpired(): Promise<number> {
-    const now = Date.now();
-    let count = 0;
-    for (const [key, entry] of this.store) {
-      if (now > entry.expiresAt) {
-        this.store.delete(key);
-        count++;
-      }
-    }
-    return count;
-  }
-
-  async clear(): Promise<void> {
-    this.store.clear();
-  }
-}
-
-// ─── SQLite Backend ──────────────────────────────────────────────────────────
-
-// Minimal sqlite3 type declarations for lazy loading
-interface Sqlite3Db {
-  run(sql: string, callback?: (err: Error | null) => void): Sqlite3Db;
-  run(sql: string, params: unknown[], callback?: (err: Error | null) => void): Sqlite3Db;
-  get(sql: string, params: unknown[], callback: (err: Error | null, row: unknown) => void): Sqlite3Db;
-  close(callback?: (err: Error | null) => void): void;
-}
-
-interface Sqlite3 {
-  Database: new (path: string) => Sqlite3Db;
-}
-
-// Lazy-load sqlite to avoid hard dependency
-let sqlite3: Sqlite3 | null = null;
-let sqliteLoadAttempted = false;
-
-async function loadSqlite(): Promise<Sqlite3 | null> {
-  if (sqliteLoadAttempted) return sqlite3;
-  sqliteLoadAttempted = true;
-  try {
-    // Use dynamic import with type assertion to bypass module resolution
-    const mod = await eval("import('sqlite3')") as { default?: Sqlite3; Database?: unknown } | Sqlite3;
-    if (mod && typeof mod === "object") {
-      // Handle both ESM default export and CJS-style export
-      sqlite3 = (mod as { default?: Sqlite3 }).default ?? (mod as Sqlite3);
-    }
-  } catch {
-    sqlite3 = null;
-  }
-  return sqlite3;
-}
-
-class SQLiteBackend<K, V> implements CacheBackend<K, V> {
-  private db: Sqlite3Db | null = null;
-  private dbPath: string;
-  private ready: Promise<void>;
-
-  constructor(dbPath: string) {
-    this.dbPath = dbPath;
-    this.ready = this.init();
-  }
-
-  private async init(): Promise<void> {
-    const sqlite = await loadSqlite();
-    if (!sqlite) {
-      throw new Error("sqlite3 not available for persistent cache");
-    }
-    this.db = new sqlite.Database(this.dbPath);
-
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run(
-        `CREATE TABLE IF NOT EXISTS cache (
-          key TEXT PRIMARY KEY,
-          value TEXT NOT NULL,
-          expires_at INTEGER NOT NULL,
-          created_at INTEGER NOT NULL
-        )`,
-        (err: Error | null) => (err ? reject(err) : resolve()),
-      );
-    });
-
-    // Create index for fast expiration queries
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run(
-        `CREATE INDEX IF NOT EXISTS idx_expires ON cache(expires_at)`,
-        (err: Error | null) => (err ? reject(err) : resolve()),
-      );
-    });
-  }
-
-  private async ensureReady(): Promise<void> {
-    await this.ready;
-  }
-
-  async get(key: K): Promise<V | undefined> {
-    await this.ensureReady();
-    if (!this.db) return undefined;
-
-    const row = await new Promise<{ value: string; expires_at: number } | undefined>(
-      (resolve, reject) => {
-        this.db!.get(
-          "SELECT value, expires_at FROM cache WHERE key = ?",
-          [String(key)],
-          (err: Error | null, row: unknown) => {
-            if (err) reject(err);
-            else resolve(row as { value: string; expires_at: number } | undefined);
-          },
-        );
-      },
-    );
-
-    if (!row) return undefined;
-    if (Date.now() > row.expires_at) {
-      await this.delete(key);
-      return undefined;
-    }
-
-    try {
-      return JSON.parse(row.value) as V;
-    } catch {
-      return undefined;
-    }
-  }
-
-  async set(key: K, value: V, ttlMs: number): Promise<void> {
-    await this.ensureReady();
-    if (!this.db) return;
-
-    const now = Date.now();
-    const expiresAt = now + ttlMs;
-    const serialized = JSON.stringify(value);
-
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run(
-        `INSERT INTO cache (key, value, expires_at, created_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(key) DO UPDATE SET
-           value = excluded.value,
-           expires_at = excluded.expires_at,
-           created_at = excluded.created_at`,
-        [String(key), serialized, expiresAt, now],
-        (err: Error | null) => (err ? reject(err) : resolve()),
-      );
-    });
-  }
-
-  async has(key: K): Promise<boolean> {
-    const value = await this.get(key);
-    return value !== undefined;
-  }
-
-  async delete(key: K): Promise<boolean> {
-    await this.ensureReady();
-    if (!this.db) return false;
-
-    return new Promise<boolean>((resolve, reject) => {
-      this.db!.run(
-        "DELETE FROM cache WHERE key = ?",
-        [String(key)],
-        function (this: { changes: number }, err: Error | null) {
-          if (err) reject(err);
-          else resolve(this.changes > 0);
-        },
-      );
-    });
-  }
-
-  async cleanupExpired(): Promise<number> {
-    await this.ensureReady();
-    if (!this.db) return 0;
-
-    return new Promise<number>((resolve, reject) => {
-      this.db!.run(
-        "DELETE FROM cache WHERE expires_at <= ?",
-        [Date.now()],
-        function (this: { changes: number }, err: Error | null) {
-          if (err) reject(err);
-          else resolve(this.changes);
-        },
-      );
-    });
-  }
-
-  async clear(): Promise<void> {
-    await this.ensureReady();
-    if (!this.db) return;
-
-    await new Promise<void>((resolve, reject) => {
-      this.db!.run("DELETE FROM cache", (err: Error | null) => (err ? reject(err) : resolve()));
-    });
-  }
-}
-
-// ─── TTL Cache ───────────────────────────────────────────────────────────────
-
-/** Default options */
-const DEFAULTS: Required<TTLCacheOptions> = {
-  persistent: false,
-  dbPath: "",
-  defaultTtlMs: 3600000, // 1 hour
-  maxMemoryEntries: 1000,
-};
-
-/**
- * General-purpose TTL cache with optional SQLite persistence.
- */
-export class TTLCache<K = string, V = unknown> {
-  private backend: CacheBackend<K, V>;
-  private opts: Required<TTLCacheOptions>;
-
-  constructor(options: TTLCacheOptions = {}) {
-    this.opts = { ...DEFAULTS, ...options };
-
-    if (this.opts.persistent) {
-      const dbPath =
-        this.opts.dbPath ||
-        new URL("~/.unipi/cache/ttl-cache.db", import.meta.url).pathname;
-      this.backend = new SQLiteBackend<K, V>(dbPath);
-    } else {
-      this.backend = new MemoryBackend<K, V>(this.opts.maxMemoryEntries);
-    }
-  }
-
-  /** Get a value by key */
-  async get(key: K): Promise<V | undefined> {
-    return this.backend.get(key);
-  }
-
-  /** Set a value with TTL */
-  async set(key: K, value: V, ttlMs?: number): Promise<void> {
-    return this.backend.set(key, value, ttlMs ?? this.opts.defaultTtlMs);
-  }
-
-  /** Check if key exists and is not expired */
-  async has(key: K): Promise<boolean> {
-    return this.backend.has(key);
-  }
-
-  /** Delete a key */
-  async delete(key: K): Promise<boolean> {
-    return this.backend.delete(key);
-  }
-
-  /** Clean up all expired entries */
-  async cleanupExpired(): Promise<number> {
-    return this.backend.cleanupExpired();
-  }
-
-  /** Clear all entries */
-  async clear(): Promise<void> {
-    return this.backend.clear();
-  }
-}

package/src/diff/highlighter.ts

@@ -1,352 +0,0 @@
-/**
- * @pi-unipi/utility — Shiki Highlighter
- *
- * Singleton Shiki ANSI highlighter with LRU cache, language detection,
- * and contrast normalization.
- */
-
-// ─── Constants ──────────────────────────────────────────────────────────────────
-
-/** Maximum number of cached highlight results */
-export const CACHE_LIMIT = 192;
-
-/** Maximum characters to highlight (skip Shiki above this) */
-export const MAX_HL_CHARS = 80_000;
-
-// ─── LRU Cache ──────────────────────────────────────────────────────────────────
-
-/**
- * Simple LRU cache with string keys.
- * Evicts oldest entries when capacity is reached.
- */
-export class LruCache<V> {
-  private map = new Map<string, V>();
-  private capacity: number;
-
-  constructor(capacity: number) {
-    this.capacity = capacity;
-  }
-
-  get(key: string): V | undefined {
-    const value = this.map.get(key);
-    if (value !== undefined) {
-      // Move to end (most recently used)
-      this.map.delete(key);
-      this.map.set(key, value);
-    }
-    return value;
-  }
-
-  set(key: string, value: V): void {
-    if (this.map.has(key)) {
-      this.map.delete(key);
-    } else if (this.map.size >= this.capacity) {
-      // Evict oldest (first entry)
-      const firstKey = this.map.keys().next().value;
-      if (firstKey !== undefined) {
-        this.map.delete(firstKey);
-      }
-    }
-    this.map.set(key, value);
-  }
-
-  has(key: string): boolean {
-    return this.map.has(key);
-  }
-
-  get size(): number {
-    return this.map.size;
-  }
-
-  clear(): void {
-    this.map.clear();
-  }
-}
-
-// ─── Language Detection ─────────────────────────────────────────────────────────
-
-/** File extension → Shiki language mapping */
-export const EXT_LANG: Record<string, string> = {
-  ".ts": "typescript",
-  ".tsx": "tsx",
-  ".js": "javascript",
-  ".jsx": "jsx",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".json": "json",
-  ".jsonc": "jsonc",
-  ".json5": "json5",
-  ".html": "html",
-  ".htm": "html",
-  ".css": "css",
-  ".scss": "scss",
-  ".sass": "sass",
-  ".less": "less",
-  ".md": "markdown",
-  ".mdx": "mdx",
-  ".py": "python",
-  ".rb": "ruby",
-  ".go": "go",
-  ".rs": "rust",
-  ".java": "java",
-  ".kt": "kotlin",
-  ".kts": "kotlin",
-  ".c": "c",
-  ".h": "c",
-  ".cpp": "cpp",
-  ".hpp": "cpp",
-  ".cc": "cpp",
-  ".cs": "csharp",
-  ".swift": "swift",
-  ".php": "php",
-  ".sql": "sql",
-  ".sh": "bash",
-  ".bash": "bash",
-  ".zsh": "bash",
-  ".fish": "fish",
-  ".yaml": "yaml",
-  ".yml": "yaml",
-  ".toml": "toml",
-  ".xml": "xml",
-  ".svg": "xml",
-  ".graphql": "graphql",
-  ".gql": "graphql",
-  ".vue": "vue",
-  ".svelte": "svelte",
-  ".astro": "astro",
-  ".prisma": "prisma",
-  ".dockerfile": "dockerfile",
-  ".tf": "hcl",
-  ".hcl": "hcl",
-  ".lua": "lua",
-  ".r": "r",
-  ".R": "r",
-  ".dart": "dart",
-  ".ex": "elixir",
-  ".exs": "elixir",
-  ".erl": "erlang",
-  ".hrl": "erlang",
-  ".clj": "clojure",
-  ".cljs": "clojure",
-  ".hs": "haskell",
-  ".elm": "elm",
-  ".nim": "nim",
-  ".zig": "zig",
-  ".v": "v",
-  ".jl": "julia",
-  ".ml": "ocaml",
-  ".mli": "ocaml",
-  ".fs": "fsharp",
-  ".fsx": "fsharp",
-  ".fsi": "fsharp",
-};
-
-/**
- * Detect the Shiki language from a file extension.
- * Returns "text" if the extension is unknown.
- */
-export function detectLanguage(extension: string): string {
-  const ext = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
-  return EXT_LANG[ext] ?? "text";
-}
-
-/**
- * Detect language from a file path.
- */
-export function detectLanguageFromPath(filePath: string): string {
-  const ext = filePath.lastIndexOf(".") >= 0 ? filePath.substring(filePath.lastIndexOf(".")) : "";
-  return detectLanguage(ext);
-}
-
-// ─── Contrast Normalization ─────────────────────────────────────────────────────
-
-/**
- * Calculate the relative luminance of a hex color.
- * Used for contrast ratio calculations.
- */
-function relativeLuminance(hex: string): number {
-  const h = hex.replace(/^#/, "");
-  const r = parseInt(h.substring(0, 2), 16) / 255;
-  const g = parseInt(h.substring(2, 4), 16) / 255;
-  const b = parseInt(h.substring(4, 6), 16) / 255;
-
-  const toLinear = (c: number) => (c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
-  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
-}
-
-/**
- * Calculate contrast ratio between two colors.
- */
-function contrastRatio(fg: string, bg: string): number {
-  const l1 = relativeLuminance(fg);
-  const l2 = relativeLuminance(bg);
-  const lighter = Math.max(l1, l2);
-  const darker = Math.min(l1, l2);
-  return (lighter + 0.05) / (darker + 0.05);
-}
-
-/**
- * Extract the foreground color from an ANSI 24-bit escape sequence.
- * Returns the hex color and the full match for replacement.
- */
-function extractAnsiFg(ansi: string): { hex: string; match: string } | null {
-  const match = ansi.match(/\x1b\[38;2;(\d+);(\d+);(\d+)m/);
-  if (!match) return null;
-  const r = parseInt(match[1]);
-  const g = parseInt(match[2]);
-  const b = parseInt(match[3]);
-  const hex = `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
-  return { hex, match: match[0] };
-}
-
-/**
- * Normalize low-contrast Shiki foregrounds against a dark background.
- *
- * Shiki themes sometimes produce foreground colors with poor contrast
- * against diff backgrounds. This function bumps the brightness of any
- * foreground that falls below the minimum contrast ratio.
- *
- * @param ansi - ANSI string with 24-bit color codes
- * @param bgHex - Background hex color to test against (default: dark bg)
- * @param minRatio - Minimum contrast ratio (default: 3.0)
- */
-export function normalizeShikiContrast(
-  ansi: string,
-  bgHex: string = "#1a1a2e",
-  minRatio: number = 3.0,
-): string {
-  // Find all 24-bit foreground sequences
-  const fgRegex = /\x1b\[38;2;\d+;\d+;\d+m/g;
-  let result = ansi;
-  let match: RegExpExecArray | null;
-
-  while ((match = fgRegex.exec(ansi)) !== null) {
-    const fgInfo = extractAnsiFg(match[0] + ansi.substring(match.index + match[0].length));
-    if (!fgInfo) continue;
-
-    const ratio = contrastRatio(fgInfo.hex, bgHex);
-    if (ratio < minRatio) {
-      // Brighten the foreground by mixing with white
-      const [r, g, b] = [
-        parseInt(fgInfo.hex.slice(1, 3), 16),
-        parseInt(fgInfo.hex.slice(3, 5), 16),
-        parseInt(fgInfo.hex.slice(5, 7), 16),
-      ];
-      const factor = minRatio / Math.max(ratio, 0.01);
-      const nr = Math.min(255, Math.round(r + (255 - r) * Math.min(1, factor * 0.5)));
-      const ng = Math.min(255, Math.round(g + (255 - g) * Math.min(1, factor * 0.5)));
-      const nb = Math.min(255, Math.round(b + (255 - b) * Math.min(1, factor * 0.5)));
-      const newFg = `\x1b[38;2;${nr};${ng};${nb}m`;
-      result = result.replace(match[0], newFg);
-    }
-  }
-
-  return result;
-}
-
-// ─── Shiki Highlighter ──────────────────────────────────────────────────────────
-
-/** Shiki highlighter instance (lazy singleton) */
-let shikiHighlighter: import("shiki").Highlighter | null = null;
-let shikiInitPromise: Promise<any> | null = null;
-
-/**
- * Initialize the Shiki highlighter (singleton).
- * Returns the highlighter instance.
- */
-export async function getShikiHighlighter(): Promise<any> {
-  if (shikiHighlighter) return shikiHighlighter;
-  if (shikiInitPromise) return shikiInitPromise;
-
-  shikiInitPromise = (async () => {
-    try {
-      const { createHighlighter } = await import("shiki");
-      shikiHighlighter = await createHighlighter({
-        themes: ["github-dark"],
-        langs: [
-          "typescript", "javascript", "tsx", "jsx", "json", "jsonc",
-          "html", "css", "scss", "markdown", "python", "go", "rust",
-          "java", "c", "cpp", "csharp", "ruby", "php", "swift", "kotlin",
-          "bash", "yaml", "toml", "xml", "sql", "graphql", "vue", "svelte",
-        ],
-      });
-      return shikiHighlighter;
-    } catch {
-      // If Shiki fails to load, return null — we'll use plain text
-      shikiInitPromise = null;
-      return null;
-    }
-  })();
-
-  return shikiInitPromise;
-}
-
-/**
- * Pre-warm the Shiki highlighter.
- * Call this early in the extension lifecycle to avoid first-render delay.
- */
-export async function preWarmHighlighter(): Promise<void> {
-  await getShikiHighlighter();
-}
-
-/** LRU cache for highlighted blocks */
-const hlCache = new LruCache<string[]>(CACHE_LIMIT);
-
-/**
- * Generate a cache key for a code block.
- */
-function hlCacheKey(code: string, language: string): string {
-  // Use first 200 chars + length + language for cache key
-  const prefix = code.substring(0, 200);
-  return `${language}:${code.length}:${prefix}`;
-}
-
-/**
- * Highlight a code block to ANSI using Shiki.
- * Results are cached in an LRU cache (192 entries).
- *
- * @param code - Code to highlight
- * @param language - Shiki language identifier
- * @returns Array of ANSI-highlighted lines, or plain lines if Shiki unavailable
- */
-export async function hlBlock(code: string, language: string): Promise<string[]> {
-  // Skip highlighting for very large content
-  if (code.length > MAX_HL_CHARS) {
-    return code.split("\n");
-  }
-
-  // Check cache
-  const key = hlCacheKey(code, language);
-  const cached = hlCache.get(key);
-  if (cached) return cached;
-
-  // Get highlighter
-  const highlighter = await getShikiHighlighter();
-  if (!highlighter) {
-    // Shiki not available — return plain text
-    return code.split("\n");
-  }
-
-  try {
-    // Highlight with Shiki
-    const ansi = highlighter.codeToANSI(code, {
-      lang: language === "text" ? "text" : language,
-      theme: "github-dark",
-    });
-
-    const lines = ansi.split("\n");
-
-    // Normalize contrast
-    const normalized = lines.map((line: string) => normalizeShikiContrast(line));
-
-    // Cache result
-    hlCache.set(key, normalized);
-
-    return normalized;
-  } catch {
-    // Fallback on error
-    return code.split("\n");
-  }
-}