@pi-archimedes/core 0.2.0

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@pi-archimedes/core",
+  "version": "0.2.0",
+  "type": "module",
+  "keywords": [
+    "pi-package"
+  ],
+  "description": "Core UI modules for pi-archimedes: editor, message, startup, thinking",
+  "files": [
+    "src"
+  ],
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./bus": "./src/bus.ts",
+    "./chrome": "./src/chrome.ts",
+    "./text": "./src/text.ts",
+    "./color": "./src/color.ts",
+    "./config": "./src/config.ts"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.1.0",
+    "@earendil-works/pi-tui": ">=0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.0"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/src/bus.ts

@@ -0,0 +1,77 @@
+// ── Bus (pub/sub via globalThis Symbol) ──────────────────────────────────────
+
+const BUS_KEY = Symbol.for("archimedes:bus");
+const QUEUE_KEY = Symbol.for("archimedes:busQueue");
+
+interface Bus {
+  emit(event: string, payload: unknown): void;
+  on(event: string, listener: (payload: unknown) => void): () => void;
+}
+
+interface CostUpdatePayload {
+  source: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  cost?: number;
+}
+
+const g = globalThis as unknown as Record<symbol, unknown>;
+
+function createBus(): Bus {
+  const listeners = new Map<string, Array<(payload: unknown) => void>>();
+
+  return {
+    emit(event: string, payload: unknown): void {
+      const subs = listeners.get(event);
+      if (subs) {
+        for (const fn of subs) {
+          try {
+            fn(payload);
+          } catch {
+            /* ignore listener errors */
+          }
+        }
+      }
+    },
+    on(event: string, listener: (payload: unknown) => void): () => void {
+      if (!listeners.has(event)) {
+        listeners.set(event, []);
+      }
+      const subs = listeners.get(event)!;
+      subs.push(listener);
+      return () => {
+        const idx = subs.indexOf(listener);
+        if (idx !== -1) subs.splice(idx, 1);
+      };
+    },
+  };
+}
+
+export function getBus(): Bus {
+  let bus = g[BUS_KEY] as Bus | undefined;
+  if (!bus) {
+    bus = createBus();
+    g[BUS_KEY] = bus;
+  }
+  return bus;
+}
+
+export function initBus(): void {
+  const bus = getBus();
+  // Flush queued events (if any were emitted before init)
+  const queue = g[QUEUE_KEY] as Array<{ event: string; payload: unknown }> | undefined;
+  if (queue && queue.length > 0) {
+    for (const { event, payload } of queue) {
+      bus.emit(event, payload);
+    }
+    g[QUEUE_KEY] = [];
+  }
+}
+
+export const Events = {
+  COST_UPDATE: "archimedes:cost_update",
+} as const;
+
+export type { CostUpdatePayload };

package/src/chrome.ts

@@ -0,0 +1,91 @@
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+
+// ── ANSI constants ───────────────────────────────────────────────────────────
+
+export const RESET = "\x1b[0m";
+
+// ── Editor chrome ────────────────────────────────────────────────────────────
+
+export const PI_STR = "> ";
+export const PI_WIDTH = PI_STR.length;
+export const PI_SYMBOL_COL = 2;
+
+export const AUTOCOMPLETE_CURSOR = "›";
+export const HINT_MARGIN_RIGHT = 3;
+export const PAD_X = 1;
+
+// ── Fallback ANSI codes (neutral near-black) ─────────────────────────────────
+
+const FALLBACK_PANEL_BG = "\x1b[48;2;16;16;16m";
+const FALLBACK_PANEL_EDGE = "\x1b[38;2;16;16;16m";
+const FALLBACK_FG = "\x1b[38;2;74;74;74m"; // #4a4a4a structural gray
+
+// ── Palette ──────────────────────────────────────────────────────────────────
+
+export type ThemeBg = "selectedBg" | "userMessageBg" | "customMessageBg" | "toolPendingBg" | "toolSuccessBg" | "toolErrorBg";
+
+export interface PanePalette {
+  panelBg: string;
+  panelEdge: string;
+  frame(text: string): string;
+  prefix(text: string): string;
+  time(text: string): string;
+  hint(text: string): string;
+}
+
+function tryGetBgAnsi(theme: Theme, key: ThemeBg): string | undefined {
+  try {
+    return (theme as any).getBgAnsi(key);
+  } catch {
+    return undefined;
+  }
+}
+
+function tryFg(theme: Theme, key: ThemeColor, text: string): string | undefined {
+  try {
+    return theme.fg(key, text);
+  } catch {
+    return undefined;
+  }
+}
+
+function safeThemeColor(theme: Theme, keys: ThemeColor[], text: string): string {
+  for (const k of keys) {
+    const res = tryFg(theme, k, text);
+    if (res !== undefined) return res;
+  }
+  return fgWrap(FALLBACK_FG, text);
+}
+
+/** Convert a 48;2 or 48;5 bg ANSI code to its fg equivalent (38;…). */
+function bgToFgAnsi(bg: string): string {
+  if (bg.startsWith("\x1b[48;2;") || bg.startsWith("\x1b[48;5;")) {
+    return bg.replace("\x1b[48;", "\x1b[38;");
+  }
+  return FALLBACK_PANEL_EDGE;
+}
+
+function fgWrap(ansi: string, text: string): string {
+  return `${ansi}${text}${RESET}`;
+}
+
+export function resolvePalette(theme: Theme): PanePalette {
+  const panelBg =
+    tryGetBgAnsi(theme, "userMessageBg") ??
+    tryGetBgAnsi(theme, "customMessageBg") ??
+    FALLBACK_PANEL_BG;
+
+  return {
+    panelBg,
+    panelEdge: bgToFgAnsi(panelBg),
+    frame: (t) => safeThemeColor(theme, ["borderMuted", "border"], t),
+    prefix: (t) => safeThemeColor(theme, ["borderMuted", "border"], t),
+    time: (t) => safeThemeColor(theme, ["muted", "accent"], t),
+    hint: (t) => safeThemeColor(theme, ["dim", "muted"], t),
+  };
+}
+
+/** Set a bg color on the theme's internal bgColors map. */
+export function setThemeBg(theme: Theme, key: ThemeBg, ansi: string): void {
+  (theme as any)?.bgColors?.set(key, ansi);
+}

package/src/color.ts

@@ -0,0 +1,195 @@
+// HSL / RGB / ANSI color utilities. Pure: no external imports.
+
+export interface RGB {
+	r: number;
+	g: number;
+	b: number;
+} // each 0..255 integer
+
+export interface HSL {
+	h: number;
+	s: number;
+	l: number;
+} // h: 0..360, s/l: 0..1
+
+// xterm standard 16-color palette (ANSI codes 0..15).
+// Source: https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit
+const XTERM_16: readonly RGB[] = [
+	{ r: 0x00, g: 0x00, b: 0x00 }, // 0  black
+	{ r: 0x80, g: 0x00, b: 0x00 }, // 1  maroon
+	{ r: 0x00, g: 0x80, b: 0x00 }, // 2  green
+	{ r: 0x80, g: 0x80, b: 0x00 }, // 3  olive
+	{ r: 0x00, g: 0x00, b: 0x80 }, // 4  navy
+	{ r: 0x80, g: 0x80, b: 0x80 }, // 5  purple
+	{ r: 0x00, g: 0x80, b: 0x80 }, // 6  teal
+	{ r: 0xc0, g: 0xc0, b: 0xc0 }, // 7  silver
+	{ r: 0x80, g: 0x80, b: 0x80 }, // 8  grey
+	{ r: 0xff, g: 0x00, b: 0x00 }, // 9  red
+	{ r: 0x00, g: 0xff, b: 0x00 }, // 10 lime
+	{ r: 0xff, g: 0xff, b: 0x00 }, // 11 yellow
+	{ r: 0x00, g: 0x00, b: 0xff }, // 12 blue
+	{ r: 0xff, g: 0x00, b: 0xff }, // 13 fuchsia
+	{ r: 0x00, g: 0xff, b: 0xff }, // 14 aqua
+	{ r: 0xff, g: 0xff, b: 0xff }, // 15 white
+];
+
+// 6x6x6 cube levels for ANSI 16..231.
+const CUBE_LEVELS: readonly number[] = [0, 95, 135, 175, 215, 255];
+
+const clamp = (v: number, lo: number, hi: number): number =>
+	v < lo ? lo : v > hi ? hi : v;
+
+const toByte = (v: number): number => clamp(Math.round(v), 0, 255);
+
+export function hexToRgb(hex: string): RGB {
+	let s = hex.trim();
+	if (s.startsWith("#")) s = s.slice(1);
+	if (s.length === 3) {
+		s = s[0] + s[0] + s[1] + s[1] + s[2] + s[2];
+	}
+	if (s.length !== 6 || !/^[0-9a-fA-F]{6}$/.test(s)) {
+		throw new Error(`Invalid hex color: ${hex}`);
+	}
+	const n = parseInt(s, 16);
+	return {
+		r: (n >> 16) & 0xff,
+		g: (n >> 8) & 0xff,
+		b: n & 0xff,
+	};
+}
+
+export function rgbToHex(rgb: RGB): string {
+	const hex = (v: number) => toByte(v).toString(16).padStart(2, "0");
+	return `#${hex(rgb.r)}${hex(rgb.g)}${hex(rgb.b)}`;
+}
+
+export function rgbToHsl(rgb: RGB): HSL {
+	const r = rgb.r / 255;
+	const g = rgb.g / 255;
+	const b = rgb.b / 255;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const l = (max + min) / 2;
+	let h = 0;
+	let s = 0;
+	const d = max - min;
+	if (d !== 0) {
+		s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+		switch (max) {
+			case r:
+				h = ((g - b) / d + (g < b ? 6 : 0)) * 60;
+				break;
+			case g:
+				h = ((b - r) / d + 2) * 60;
+				break;
+			default:
+				h = ((r - g) / d + 4) * 60;
+				break;
+		}
+	}
+	return { h, s, l };
+}
+
+export function hslToRgb(hsl: HSL): RGB {
+	const { h, s, l } = hsl;
+	if (s === 0) {
+		const v = toByte(l * 255);
+		return { r: v, g: v, b: v };
+	}
+	const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+	const p = 2 * l - q;
+	const hk = (((h % 360) + 360) % 360) / 360;
+	const hue2rgb = (t: number): number => {
+		let tt = t;
+		if (tt < 0) tt += 1;
+		if (tt > 1) tt -= 1;
+		if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+		if (tt < 1 / 2) return q;
+		if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+		return p;
+	};
+	return {
+		r: toByte(hue2rgb(hk + 1 / 3) * 255),
+		g: toByte(hue2rgb(hk) * 255),
+		b: toByte(hue2rgb(hk - 1 / 3) * 255),
+	};
+}
+
+export function ansi256ToRgb(code: number): RGB {
+	const c = Math.floor(code);
+	if (c < 0 || c > 255) {
+		throw new Error(`ANSI 256 code out of range: ${code}`);
+	}
+	if (c < 16) {
+		return { ...XTERM_16[c] };
+	}
+	if (c < 232) {
+		const idx = c - 16;
+		const r = CUBE_LEVELS[Math.floor(idx / 36) % 6];
+		const g = CUBE_LEVELS[Math.floor(idx / 6) % 6];
+		const b = CUBE_LEVELS[idx % 6];
+		return { r, g, b };
+	}
+	const v = 8 + (c - 232) * 10;
+	return { r: v, g: v, b: v };
+}
+
+export function parseAnsiFgToRgb(ansi: string): RGB | null {
+	if (!ansi) return null;
+	// Match a leading CSI SGR sequence: ESC [ params m
+	const tc = /^\x1b\[38;2;(\d{1,3});(\d{1,3});(\d{1,3})m/.exec(ansi);
+	if (tc) {
+		return {
+			r: clamp(parseInt(tc[1], 10), 0, 255),
+			g: clamp(parseInt(tc[2], 10), 0, 255),
+			b: clamp(parseInt(tc[3], 10), 0, 255),
+		};
+	}
+	const palette = /^\x1b\[38;5;(\d{1,3})m/.exec(ansi);
+	if (palette) {
+		const code = parseInt(palette[1], 10);
+		if (code < 0 || code > 255) return null;
+		return ansi256ToRgb(code);
+	}
+	return null;
+}
+
+export function deriveDimColor(
+	input: string | number,
+	anchorLightness: number,
+	saturationFactor?: number,
+): string {
+	const rgb = typeof input === "number" ? ansi256ToRgb(input) : hexToRgb(input);
+	const hsl = rgbToHsl(rgb);
+	const factor = saturationFactor ?? 0.5;
+	const target: HSL = {
+		h: hsl.h,
+		s: hsl.s * factor,
+		l: Math.min(hsl.l, anchorLightness),
+	};
+	return rgbToHex(hslToRgb(target));
+}
+
+export function rgbToTruecolorFg(rgb: RGB): string {
+	return `\x1b[38;2;${toByte(rgb.r)};${toByte(rgb.g)};${toByte(rgb.b)}m`;
+}
+
+// ── Color helpers (from utils/ansi.ts) ───────────────────────────────────────
+
+export function gray(level: number, text: string): string {
+  const l = Math.max(0, Math.min(255, Math.floor(level)));
+  return `\x1b[38;2;${l};${l};${l}m${text}\x1b[0m`;
+}
+
+export function rgb(r: number, g: number, b: number, text: string): string {
+  return `\x1b[38;2;${Math.floor(r)};${Math.floor(g)};${Math.floor(b)}m${text}\x1b[0m`;
+}
+
+export function extractRgb(themed: string): [number, number, number] {
+  const m = themed.match(/\x1b\[38;2;(\d+);(\d+);(\d+)m/);
+  return m ? [+m[1], +m[2], +m[3]] : [100, 100, 100];
+}
+
+export function lerp(a: number, b: number, t: number): number {
+  return a + (b - a) * t;
+}

package/src/config.ts

@@ -0,0 +1,59 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export const ANIMATION_STYLES = [
+  "diagonal",
+  "top-right",
+  "bottom-left",
+  "bottom-right",
+  "center-out",
+  "wave",
+  "horizontal",
+  "vertical",
+  "vertical-up",
+] as const;
+export type AnimationStyle = (typeof ANIMATION_STYLES)[number];
+
+export interface CoreConfig {
+  mutedTheme: boolean;
+  codeUnindent: boolean;
+  labelText: string;
+  labelColor: string;
+  animationStyle: AnimationStyle;
+}
+
+const SETTINGS_PATH = join(getAgentDir(), "settings.json");
+
+export const DEFAULT_CORE_CONFIG: CoreConfig = {
+  mutedTheme: false,
+  codeUnindent: true,
+  labelText: "Thinking...",
+  labelColor: "255,215,0",
+  animationStyle: "vertical-up",
+};
+
+export function loadCoreConfig(): CoreConfig {
+  if (existsSync(SETTINGS_PATH)) {
+    try {
+      const full = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+      return { ...DEFAULT_CORE_CONFIG, ...(full["archimedes.core"] ?? {}) };
+    } catch {
+      /* ignore corrupt file */
+    }
+  }
+  return DEFAULT_CORE_CONFIG;
+}
+
+export function saveCoreConfig(config: CoreConfig): void {
+  let full: Record<string, unknown> = {};
+  if (existsSync(SETTINGS_PATH)) {
+    try {
+      full = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+    } catch {
+      /* ignore corrupt file */
+    }
+  }
+  full["archimedes.core"] = config;
+  writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
+}

package/src/editor/index.ts

@@ -0,0 +1,199 @@
+import {
+  CustomEditor,
+  type Theme,
+  type KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import {
+  type TUI,
+  type EditorTheme,
+  truncateToWidth,
+  isKeyRelease,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+
+import {
+  RESET,
+  PAD_X,
+  PI_STR,
+  PI_WIDTH,
+  PI_SYMBOL_COL,
+  AUTOCOMPLETE_CURSOR,
+  HINT_MARGIN_RIGHT,
+  resolvePalette,
+} from "../chrome.js";
+import { isParentBorder, formatKey } from "../text.js";
+
+const DOUBLE_PRESS_WINDOW_MS = 500;
+
+export class HephaestusEditor extends CustomEditor {
+  private readonly piKeybindings: KeybindingsManager;
+  private readonly getTheme: () => Theme;
+  private readonly isIdle: () => boolean;
+  private readonly shutdown: () => void;
+  private hintTimer: ReturnType<typeof setTimeout> | undefined;
+  private hintMessage: string | undefined;
+  private pendingQuitUntil = 0;
+
+  constructor(
+    tui: TUI,
+    editorTheme: EditorTheme,
+    keybindings: KeybindingsManager,
+    {
+      getTheme,
+      isIdle,
+      shutdown,
+    }: {
+      getTheme: () => Theme;
+      isIdle: () => boolean;
+      shutdown: () => void;
+    },
+  ) {
+    super(tui, editorTheme, keybindings);
+    this.piKeybindings = keybindings;
+    this.getTheme = getTheme;
+    this.isIdle = isIdle;
+    this.shutdown = shutdown;
+  }
+
+  // ── Quit hint ─────────────────────────────────────────────
+
+  private clearHint(resetWindow = true): void {
+    clearTimeout(this.hintTimer);
+    this.hintTimer = undefined;
+    this.hintMessage = undefined;
+    if (resetWindow) this.pendingQuitUntil = 0;
+    this.tui.requestRender();
+  }
+
+  private showHint(message: string): void {
+    this.clearHint(false);
+    this.hintMessage = message;
+    this.tui.requestRender();
+    this.hintTimer = setTimeout(() => {
+      this.hintMessage = undefined;
+      this.hintTimer = undefined;
+      this.pendingQuitUntil = 0;
+      this.tui.requestRender();
+    }, DOUBLE_PRESS_WINDOW_MS);
+  }
+
+  // ── Input ─────────────────────────────────────────────────
+
+  override handleInput(data: string): void {
+    if (isKeyRelease(data)) {
+      super.handleInput(data);
+      return;
+    }
+
+    if (!this.piKeybindings.matches(data, "app.clear")) {
+      this.clearHint();
+      super.handleInput(data);
+      return;
+    }
+
+    const now = Date.now();
+
+    if (this.getText().length > 0) {
+      this.clearHint();
+      this.pendingQuitUntil = now + DOUBLE_PRESS_WINDOW_MS;
+      this.setText("");
+      return;
+    }
+
+    if (!this.isIdle()) {
+      this.clearHint();
+      super.handleInput(data);
+      return;
+    }
+
+    if (this.pendingQuitUntil > 0 && now <= this.pendingQuitUntil) {
+      this.clearHint();
+      this.shutdown();
+      return;
+    }
+
+    this.pendingQuitUntil = now + DOUBLE_PRESS_WINDOW_MS;
+    this.showHint(
+      `${formatKey(this.piKeybindings.getKeys("app.clear")[0])} to quit`,
+    );
+  }
+
+  // ── Render ────────────────────────────────────────────────
+
+  override render(width: number): string[] {
+    try {
+      const p = resolvePalette(this.getTheme());
+      const cw = width - PAD_X * 2;
+      const inner = cw - 2;
+      const rightPad = 1;
+      const superLines = super.render(cw - PI_WIDTH - rightPad);
+
+      let bottomIdx = superLines.length - 1;
+      for (let i = superLines.length - 1; i >= 1; i--) {
+        if (isParentBorder(superLines[i]!)) {
+          bottomIdx = i;
+        }
+      }
+      const contentLines = superLines.slice(1, bottomIdx);
+      const autoLines = superLines.slice(bottomIdx + 1).map(
+        (line) =>
+          " ".repeat(PI_SYMBOL_COL) +
+          truncateToWidth(
+            line.replace("→", AUTOCOMPLETE_CURSOR),
+            cw - PI_SYMBOL_COL,
+            "",
+            true,
+          ),
+      );
+
+      const topLine =
+        p.frame("┌") + p.frame("─".repeat(inner)) + p.frame("┐");
+      const botLine =
+        p.frame("└") + p.frame("─".repeat(inner)) + p.frame("┘");
+
+      const piPrefix = p.prefix(PI_STR);
+
+      const midLines = contentLines.map((line, i) => {
+        if (i !== 0) {
+          return (
+            " ".repeat(PI_WIDTH) +
+            truncateToWidth(line, cw - PI_WIDTH, "", true)
+          );
+        }
+
+        if (this.hintMessage) {
+          const hint =
+            p.hint(this.hintMessage) + " ".repeat(HINT_MARGIN_RIGHT);
+          return (
+            piPrefix +
+            truncateToWidth(
+              line,
+              cw - PI_WIDTH - visibleWidth(hint),
+              "",
+              true,
+            ) +
+            hint
+          );
+        }
+        return piPrefix + truncateToWidth(line, cw - PI_WIDTH, "", true);
+      });
+
+      const spacer = autoLines.length > 0 ? [" ".repeat(cw)] : [];
+      const raw = [topLine, ...midLines, ...spacer, ...autoLines, botLine];
+
+      const pad = " ".repeat(PAD_X);
+      const wrap = (line: string): string => {
+        const patched = line.replaceAll(RESET, RESET + p.panelBg);
+        return p.panelBg + pad + patched + pad + RESET;
+      };
+
+      const topEdge = p.panelEdge + "▁".repeat(width) + RESET;
+      const botEdge = p.panelEdge + "▔".repeat(width) + RESET;
+
+      return [topEdge, ...raw.map(wrap), botEdge];
+    } catch (e) {
+      console.error("HephaestusEditor render error:", e);
+      throw e;
+    }
+  }
+}