@groeponline/pi-wishcraft 0.17.3

package/src/theme/colors.ts

@@ -0,0 +1,60 @@
+export interface AnsiColors {
+  getBgAnsi(r: number, g: number, b: number): string;
+  getFgAnsi(r: number, g: number, b: number): string;
+  getFgAnsi256(code: number): string;
+  reset: string;
+}
+
+export const ansi: AnsiColors = {
+  getBgAnsi: (r, g, b) => `\x1b[48;2;${r};${g};${b}m`,
+  getFgAnsi: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
+  getFgAnsi256: (code) => `\x1b[38;5;${code}m`,
+  reset: "\x1b[0m",
+};
+
+function hexToRgb(hex: string): [number, number, number] {
+  const cleanHex = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (!/^[0-9A-Fa-f]{6}$/.test(cleanHex)) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  const r = parseInt(cleanHex.substring(0, 2), 16);
+  const g = parseInt(cleanHex.substring(2, 4), 16);
+  const b = parseInt(cleanHex.substring(4, 6), 16);
+  return [r, g, b];
+}
+
+export const PALETTE: Record<string, string | number> = {
+  sep: 244,
+  model: "#d787af",
+  path: "#00afaf",
+  gitClean: "#5faf5f",
+  accent: "#febc38",
+  queue: "#febc38",
+};
+
+type ColorName = keyof typeof PALETTE;
+
+const ansiCodeCache = new Map<string, string>();
+
+function buildAnsiCode(val: string | number | undefined): string {
+  if (val === undefined || val === "") return "";
+  if (typeof val === "number") return ansi.getFgAnsi256(val);
+  if (typeof val === "string" && val.startsWith("#")) {
+    const [r, g, b] = hexToRgb(val);
+    return ansi.getFgAnsi(r, g, b);
+  }
+  return "";
+}
+
+for (const key of Object.keys(PALETTE)) {
+  ansiCodeCache.set(key, buildAnsiCode(PALETTE[key]));
+}
+
+export function fgOnly(color: ColorName, text: string): string {
+  const code = ansiCodeCache.get(color as string) ?? "";
+  return code ? `${code}${text}` : text;
+}
+
+export function getFgAnsiCode(color: ColorName): string {
+  return ansiCodeCache.get(color as string) ?? "";
+}

package/src/theme/icons.ts

@@ -0,0 +1,175 @@
+import { loadThemeConfig } from "./theme.ts";
+
+export interface IconSet {
+  pi: string;
+  model: string;
+  folder: string;
+  branch: string;
+  git: string;
+  github: string;
+  gitlab: string;
+  bitbucket: string;
+  tokens: string;
+  context: string;
+  cost: string;
+  time: string;
+  agents: string;
+  cache: string;
+  input: string;
+  output: string;
+  host: string;
+  session: string;
+  auto: string;
+  warning: string;
+  tps: string;
+  ports: string;
+}
+
+export const SEP_DOT: string = " · ";
+
+export const THINKING_TEXT_UNICODE: Record<string, string> = {
+  minimal: "[min]",
+  low: "[low]",
+  medium: "[med]",
+  high: "[high]",
+  xhigh: "[xhi]",
+};
+
+export const THINKING_TEXT_NERD: Record<string, string> = {
+  minimal: "\u{F0E7} min",
+  low: "\u{F10C} low",
+  medium: "\u{F192} med",
+  high: "\u{F111} high",
+  xhigh: "\u{F06D} xhi",
+};
+
+export function getThinkingText(level: string): string | undefined {
+  const map = hasNerdFonts() ? THINKING_TEXT_NERD : THINKING_TEXT_UNICODE;
+  return map[level];
+}
+
+export const NERD_ICONS: IconSet = {
+  pi: "\uE22C",
+  model: "\uEC19",
+  folder: "\uF115",
+  branch: "\uF126",
+  git: "\uF1D3",
+  github: "\uF09B",
+  gitlab: "\uF296",
+  bitbucket: "\uF171",
+  tokens: "\uE26B",
+  context: "\uF1C0",
+  cost: "\uF155",
+  time: "\uF017",
+  agents: "\uF0C0",
+  cache: "\uF1C0",
+  input: "\uF090",
+  output: "\uF08B",
+  host: "\uF109",
+  session: "\uF550",
+  auto: "\u{F0068}",
+  warning: "\uF071",
+  tps: "\uF135",
+  ports: "\uF1E6",
+};
+
+export const ASCII_ICONS: IconSet = {
+  pi: "π",
+  model: "",
+  folder: "dir",
+  branch: "⎇",
+  git: "⎇",
+  github: "⎇",
+  gitlab: "⎇",
+  bitbucket: "⎇",
+  tokens: "⊛",
+  context: "◫",
+  cost: "$",
+  time: "◷",
+  agents: "AG",
+  cache: "cache",
+  input: "in:",
+  output: "out:",
+  host: "host",
+  session: "id",
+  auto: "AC",
+  warning: "!",
+  tps: "⚡",
+  ports: "▣",
+};
+
+function sanitizeUserIconOverrides(value: unknown): Partial<IconSet> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const result: Partial<IconSet> = {};
+  const validKeys = new Set<string>(Object.keys(NERD_ICONS));
+  for (const [key, val] of Object.entries(value)) {
+    if (validKeys.has(key) && typeof val === "string") {
+      result[key as keyof IconSet] = val;
+    }
+  }
+  return result;
+}
+
+export interface SeparatorChars {
+  powerlineLeft: string;
+  powerlineRight: string;
+  powerlineThinLeft: string;
+  powerlineThinRight: string;
+  slash: string;
+  pipe: string;
+  block: string;
+  space: string;
+  asciiLeft: string;
+  asciiRight: string;
+  dot: string;
+}
+
+export const NERD_SEPARATORS: SeparatorChars = {
+  powerlineLeft: "\uE0B0",
+  powerlineRight: "\uE0B2",
+  powerlineThinLeft: "\uE0B1",
+  powerlineThinRight: "\uE0B3",
+  slash: "/",
+  pipe: "|",
+  block: "█",
+  space: " ",
+  asciiLeft: ">",
+  asciiRight: "<",
+  dot: "·",
+};
+
+export const ASCII_SEPARATORS: SeparatorChars = {
+  powerlineLeft: ">",
+  powerlineRight: "<",
+  powerlineThinLeft: "|",
+  powerlineThinRight: "|",
+  slash: "/",
+  pipe: "|",
+  block: "#",
+  space: " ",
+  asciiLeft: ">",
+  asciiRight: "<",
+  dot: ".",
+};
+
+export function hasNerdFonts(): boolean {
+  if (process.env.POWERLINE_NERD_FONTS === "1") return true;
+  if (process.env.POWERLINE_NERD_FONTS === "0") return false;
+  if (process.env.GHOSTTY_RESOURCES_DIR) return true;
+  
+  const currentTerm = (process.env.TERM_PROGRAM || "").toLowerCase();
+  const supported = ["iterm", "wezterm", "kitty", "ghostty", "alacritty"];
+  return supported.some((t) => currentTerm.includes(t));
+}
+
+export function getIcons(): IconSet {
+  const defaults = hasNerdFonts() ? NERD_ICONS : ASCII_ICONS;
+  const config = loadThemeConfig();
+  return { ...defaults, ...sanitizeUserIconOverrides(config.icons) };
+}
+
+export function getSeparatorChars(): SeparatorChars {
+  return hasNerdFonts() ? NERD_SEPARATORS : ASCII_SEPARATORS;
+}

package/src/theme/separators.ts

@@ -0,0 +1,41 @@
+import type {
+  SeparatorDef,
+  StatusLineSeparatorStyle,
+} from "../config/types.ts";
+import { getSeparatorChars } from "./icons.ts";
+
+export function getSeparator(style: StatusLineSeparatorStyle): SeparatorDef {
+  const chars = getSeparatorChars();
+
+  const registry = new Map<string, SeparatorDef>([
+    ["powerline", {
+      left: chars.powerlineLeft,
+      right: chars.powerlineRight,
+      endCaps: {
+        left: chars.powerlineRight,
+        right: chars.powerlineLeft,
+        useBgAsFg: true,
+      },
+    }],
+    ["powerline-thin", {
+      left: chars.powerlineThinLeft,
+      right: chars.powerlineThinRight,
+      endCaps: {
+        left: chars.powerlineRight,
+        right: chars.powerlineLeft,
+        useBgAsFg: true,
+      },
+    }],
+    ["slash", { left: ` ${chars.slash} `, right: ` ${chars.slash} ` }],
+    ["pipe", { left: ` ${chars.pipe} `, right: ` ${chars.pipe} ` }],
+    ["block", { left: chars.block, right: chars.block }],
+    ["none", { left: chars.space, right: chars.space }],
+    ["ascii", { left: chars.asciiLeft, right: chars.asciiRight }],
+    ["dot", { left: chars.dot, right: chars.dot }],
+    ["chevron", { left: "›", right: "‹" }],
+    ["star", { left: "✦", right: "✦" }],
+  ]);
+
+  const definition = registry.get(style) ?? registry.get("powerline-thin")!;
+  return Object.freeze(definition);
+}

package/src/theme/theme.ts

@@ -0,0 +1,211 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getAgentPath } from "../paths/agent-dirs.ts";
+import type {
+  ColorScheme,
+  ColorValue,
+  SemanticColor,
+  ThemeLike,
+} from "../config/types.ts";
+
+export interface PowerlineThemeConfig {
+  colors?: unknown;
+  icons?: unknown;
+}
+
+const DEFAULT_COLORS: Required<ColorScheme> = {
+  model: "#d787af",
+  shellMode: "accent",
+  path: "#00afaf",
+  gitDirty: "warning",
+  gitClean: "success",
+  thinking: "thinkingOff",
+  thinkingMinimal: "thinkingMinimal",
+  thinkingLow: "thinkingLow",
+  thinkingMedium: "thinkingMedium",
+  context: "dim",
+  contextWarn: "warning",
+  contextError: "error",
+  cost: "text",
+  tokens: "muted",
+  queue: "accent",
+  separator: "dim",
+  border: "borderMuted",
+};
+
+const RAINBOW_COLORS = [
+  "#b281d6",
+  "#d787af",
+  "#febc38",
+  "#e4c00f",
+  "#89d281",
+  "#00afaf",
+  "#178fb9",
+  "#b281d6",
+];
+
+const CACHE_LIFETIME_MS = 5000;
+let cachedConfig: PowerlineThemeConfig | null = null;
+let lastCacheUpdate = 0;
+let cacheIdentifier = "";
+
+const loggedErrors = new Set<string>();
+
+function resolvePackageDir(startDir: string): string {
+  let currentDir = startDir;
+  for (let i = 0; i < 6; i++) {
+    if (existsSync(join(currentDir, "package.json"))) return currentDir;
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return startDir;
+}
+
+function getConfigurationPaths(): string[] {
+  const currentFileDir = dirname(fileURLToPath(import.meta.url));
+  const pkgDir = resolvePackageDir(currentFileDir);
+  return [
+    getAgentPath("extensions", "powerline-footer", "theme.json"),
+    join(pkgDir, "theme.json"),
+  ];
+}
+
+function mergeThemeConfig(base: PowerlineThemeConfig, overrides: unknown): PowerlineThemeConfig {
+  if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides)) {
+    return base;
+  }
+  
+  const record = overrides as Record<string, unknown>;
+  return {
+    colors: record.colors !== undefined ? record.colors : base.colors,
+    icons: record.icons !== undefined ? record.icons : base.icons,
+  };
+}
+
+export function loadThemeConfig(): PowerlineThemeConfig {
+  const paths = getConfigurationPaths();
+  const identity = paths.join("|");
+  const time = Date.now();
+
+  if (cachedConfig && cacheIdentifier === identity && time - lastCacheUpdate < CACHE_LIFETIME_MS) {
+    return cachedConfig;
+  }
+
+  let finalConfig: PowerlineThemeConfig = {};
+
+  for (const path of paths) {
+    try {
+      if (existsSync(path)) {
+        const rawContent = readFileSync(path, "utf8");
+        const parsedData = JSON.parse(rawContent);
+        finalConfig = mergeThemeConfig(finalConfig, parsedData);
+        break; // Stop after first successful load
+      }
+    } catch (e: unknown) {
+      if (e instanceof SyntaxError) {
+        console.debug(`[theme] SyntaxError in ${path}:`, e.message);
+      } else if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
+        // File doesn't exist despite existsSync, ignore
+      } else {
+        console.debug(`[theme] Unexpected error reading ${path}:`, e);
+      }
+    }
+  }
+
+  cachedConfig = finalConfig;
+  lastCacheUpdate = time;
+  cacheIdentifier = identity;
+  
+  return finalConfig;
+}
+
+function sanitizeUserColors(rawColors: unknown): ColorScheme {
+  if (typeof rawColors !== "object" || rawColors === null || Array.isArray(rawColors)) return {};
+  
+  const result: ColorScheme = {};
+  for (const key of Object.keys(DEFAULT_COLORS)) {
+    const val = (rawColors as Record<string, unknown>)[key];
+    if (typeof val === "string" && val.trim().length > 0) {
+      result[key as SemanticColor] = val.trim() as ColorValue;
+    }
+  }
+  return result;
+}
+
+export function resolveColor(
+  semantic: SemanticColor,
+  presetColors?: ColorScheme,
+): ColorValue {
+  const config = loadThemeConfig();
+  const userColors = sanitizeUserColors(config.colors);
+  
+  if (userColors[semantic] !== undefined) {
+    return userColors[semantic] as ColorValue;
+  }
+  if (presetColors && presetColors[semantic] !== undefined) {
+    return presetColors[semantic] as ColorValue;
+  }
+  return DEFAULT_COLORS[semantic];
+}
+
+function hexToRgbAnsi(hex: string): string {
+  const cleanHex = hex.replace("#", "");
+  const r = parseInt(cleanHex.substring(0, 2), 16);
+  const g = parseInt(cleanHex.substring(2, 4), 16);
+  const b = parseInt(cleanHex.substring(4, 6), 16);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+export function applyColor(
+  theme: ThemeLike,
+  color: ColorValue,
+  text: string,
+): string {
+  if (typeof color === "string" && /^#[0-9a-fA-F]{6}$/.test(color)) {
+    return `${hexToRgbAnsi(color)}${text}\x1b[0m`;
+  }
+
+  try {
+    return theme.fg(color as ThemeColor, text);
+  } catch (e) {
+    const errorKey = String(color);
+    if (!loggedErrors.has(errorKey)) {
+      loggedErrors.add(errorKey);
+      if (loggedErrors.size > 100) loggedErrors.clear();
+      console.debug(`[theme] Invalid color "${errorKey}". Fallback to text.`, e);
+    }
+    return theme.fg("text", text);
+  }
+}
+
+export function fg(
+  theme: ThemeLike,
+  semantic: SemanticColor,
+  text: string,
+  presetColors?: ColorScheme,
+): string {
+  const c = resolveColor(semantic, presetColors);
+  return applyColor(theme, c, text);
+}
+
+export function rainbow(text: string): string {
+  let output = "";
+  let i = 0;
+  for (const char of text) {
+    if (char === " " || char === ":") {
+      output += char;
+    } else {
+      const hex = RAINBOW_COLORS[i % RAINBOW_COLORS.length];
+      output += hexToRgbAnsi(hex) + char;
+      i++;
+    }
+  }
+  return output + "\x1b[0m";
+}
+
+export function getDefaultColors(): Required<ColorScheme> {
+  return { ...DEFAULT_COLORS };
+}

package/src/tools/graph.ts

@@ -0,0 +1,75 @@
+const BRAILLE_CHAR_BASE = 0x2800;
+
+// Braille dot heights (0-7 for 4 vertical levels in 2 columns)
+const BRAILLE_MAP = [0x40, 0x4, 0x20, 0x2, 0x10, 0x1, 0x80, 0x8];
+
+/**
+ * Render a sequence of numeric data points as a Braille sparkline string.
+ */
+export function renderSparkline(values: number[], width: number = 20): string {
+  if (values.length === 0) return " ".repeat(width);
+
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+
+  // Normalize values to 0..3 range (4 height levels)
+  const normalized = values.map((v) => Math.min(3, Math.floor(((v - min) / range) * 3.99)));
+
+  // Group into pairs for Braille columns (2 values per Braille character)
+  let sparkline = "";
+  const numChars = Math.min(width, Math.ceil(normalized.length / 2));
+
+  for (let i = 0; i < numChars * 2; i += 2) {
+    const leftVal = normalized[i] ?? 0;
+    const rightVal = normalized[i + 1] ?? leftVal;
+
+    // Map 0..3 height to Braille dots
+    let charCode = BRAILLE_CHAR_BASE;
+    if (leftVal >= 1) charCode |= 0x40; // dot 7
+    if (leftVal >= 2) charCode |= 0x04; // dot 3
+    if (leftVal >= 3) charCode |= 0x01; // dot 1
+
+    if (rightVal >= 1) charCode |= 0x80; // dot 8
+    if (rightVal >= 2) charCode |= 0x20; // dot 6
+    if (rightVal >= 3) charCode |= 0x02; // dot 2
+
+    sparkline += String.fromCharCode(charCode);
+  }
+
+  return sparkline;
+}
+
+export interface GraphNode {
+  id: string;
+  label: string;
+}
+
+export interface GraphEdge {
+  from: string;
+  to: string;
+  label?: string;
+}
+
+/**
+ * Render a simple ASCII graph representation of dependency nodes and edges.
+ */
+export function renderAsciiGraph(nodes: GraphNode[], edges: GraphEdge[]): string[] {
+  const lines: string[] = [];
+
+  for (const node of nodes) {
+    lines.push(` ┌──────────────┐`);
+    lines.push(` │ ${node.label.padEnd(12)} │`);
+    lines.push(` └──────────────┘`);
+
+    const outEdges = edges.filter((e) => e.from === node.id);
+    for (const edge of outEdges) {
+      const target = nodes.find((n) => n.id === edge.to);
+      if (target) {
+        lines.push(`        │ ${edge.label ? `[${edge.label}]` : "-->"} ${target.label}`);
+      }
+    }
+  }
+
+  return lines;
+}