@pi-archimedes/core 2.0.1 → 2.1.0

package/README.md

@@ -0,0 +1,51 @@
+# @pi-archimedes/core
+
+The visual foundation and shared infrastructure for pi-archimedes.
+
+Core is what you see first — the animated splash screen, the framed editor, and styled thinking blocks. It is also the invisible glue: an event bus that lets packages talk to each other, shared text and color utilities, and a settings system. Install it standalone for polished chrome, or let the meta package include it automatically.
+
+## What you get
+
+- **Animated splash screen** — configurable reveal animations (9 styles) that set the tone when Pi starts
+- **Framed editor** — custom editor component with double-press quit guard
+- **Styled thinking blocks** — configurable label text, color, and muted theme option; optional code block unindenting
+- **Event bus** — shared pub/sub channel that lets packages communicate (subagent costs → footer, subagent questions → ask, etc.)
+- **Shared utilities** — text truncation/width calculation, color helpers, config loading, settings I/O, and startup profiling
+
+## Install
+
+```bash
+pi install npm:@pi-archimedes/core
+```
+
+Or install full meta package:
+
+```bash
+pi install npm:pi-archimedes
+```
+
+## Usage
+
+Core works automatically when Pi starts. It sets the session header, editor frame, and thinking block renderer automatically. There are no manual commands or tools to call.
+
+For configuration:
+- When using the meta package, run `/archimedes` to access the settings panel.
+- For standalone installs, edit `archimedes.core` in `~/.pi/agent/settings.json`.
+
+## Settings
+
+Core reads configuration from the `archimedes.core` namespace in `~/.pi/agent/settings.json`.
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `mutedTheme` | bool | `false` | Use subdued colors for thinking blocks |
+| `codeUnindent` | bool | `true` | Remove common indentation from code blocks inside thinking sections |
+| `labelText` | string | `Thinking...` | Custom prefix shown before thinking blocks |
+| `labelColor` | string | `255,215,0` | RGB color for the thinking label |
+| `animationStyle` | string | `vertical-up` | Splash animation style (9 options) |
+
+## Integration
+
+Core is auto-included by the `pi-archimedes` meta package. All other archimedes packages depend on `@pi-archimedes/core` for the event bus, chrome elements, and utilities. Standalone installation provides the visual chrome and bus without the other archimedes features.
+
+← Back to [pi-archimedes](../../README.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/core",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "module",
   "keywords": [
     "pi-package"

package/src/config.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("./settings-io.js", () => ({
+  loadConfig: vi.fn(),
+  saveConfig: vi.fn(),
+}));
+
+const { loadCoreConfig, saveCoreConfig, DEFAULT_CORE_CONFIG, ANIMATION_STYLES } =
+  await import("./config.js");
+const { loadConfig, saveConfig } = await import("./settings-io.js");
+
+describe("loadCoreConfig", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("uses correct namespace", () => {
+    vi.mocked(loadConfig).mockReturnValue(DEFAULT_CORE_CONFIG);
+    loadCoreConfig();
+    expect(loadConfig).toHaveBeenCalledWith("archimedes.core", DEFAULT_CORE_CONFIG);
+  });
+
+  it("returns default config when no settings exist", () => {
+    vi.mocked(loadConfig).mockReturnValue(DEFAULT_CORE_CONFIG);
+    const result = loadCoreConfig();
+    expect(result).toEqual({
+      mutedTheme: false,
+      codeUnindent: true,
+      labelText: "Thinking...",
+      labelColor: "255,215,0",
+      animationStyle: "vertical-up",
+    });
+  });
+
+  it("passes through merged config from settings-io", () => {
+    const merged = { ...DEFAULT_CORE_CONFIG, mutedTheme: true };
+    vi.mocked(loadConfig).mockReturnValue(merged);
+    const result = loadCoreConfig();
+    expect(result).toEqual(merged);
+  });
+});
+
+describe("saveCoreConfig", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("saves with correct namespace", () => {
+    saveCoreConfig(DEFAULT_CORE_CONFIG);
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.core", DEFAULT_CORE_CONFIG);
+  });
+
+  it("passes config through unchanged", () => {
+    const config = { ...DEFAULT_CORE_CONFIG, mutedTheme: true };
+    saveCoreConfig(config);
+    expect(saveConfig).toHaveBeenCalledWith("archimedes.core", config);
+  });
+});
+
+describe("DEFAULT_CORE_CONFIG", () => {
+  it("has the expected shape", () => {
+    expect(DEFAULT_CORE_CONFIG).toEqual({
+      mutedTheme: false,
+      codeUnindent: true,
+      labelText: "Thinking...",
+      labelColor: "255,215,0",
+      animationStyle: "vertical-up",
+    });
+  });
+});
+
+describe("ANIMATION_STYLES", () => {
+  it("contains all expected styles", () => {
+    expect(ANIMATION_STYLES).toEqual([
+      "diagonal",
+      "top-right",
+      "bottom-left",
+      "bottom-right",
+      "center-out",
+      "wave",
+      "horizontal",
+      "vertical",
+      "vertical-up",
+    ]);
+  });
+});

package/src/settings-io.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// ── hoisted: must use require() since vi.hoisted runs before imports ────────
+
+const { tempDir, fs, join, tmpdir, randomUUID } = vi.hoisted(() => {
+  const fs = require("node:fs");
+  const { join } = require("node:path");
+  const { tmpdir } = require("node:os");
+  const { randomUUID } = require("node:crypto");
+  const dir = join(tmpdir(), `settings-io-test-${randomUUID()}`);
+  fs.mkdirSync(dir, { recursive: true });
+  return { tempDir: dir, fs, join, tmpdir, randomUUID };
+});
+
+vi.mock("@earendil-works/pi-coding-agent", () => ({
+  getAgentDir: () => tempDir,
+}));
+
+// Import after mocks are set up
+const { loadConfig, saveConfig } = await import("./settings-io.js");
+
+describe("loadConfig", () => {
+  beforeEach(() => {
+    // Clean up settings file before each test
+    const settingsPath = join(tempDir, "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      fs.unlinkSync(settingsPath);
+    }
+  });
+
+  afterEach(() => {
+    // Clean up temp dir artifacts
+    const settingsPath = join(tempDir, "settings.json");
+    const tmpPath = settingsPath + ".tmp";
+    try { fs.unlinkSync(settingsPath); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("returns defaults when settings missing", () => {
+    const result = loadConfig("test.ns", { foo: "bar", count: 42 });
+    expect(result).toEqual({ foo: "bar", count: 42 });
+  });
+
+  it("merges settings over defaults", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    fs.writeFileSync(
+      settingsPath,
+      JSON.stringify({ "test.ns": { foo: "overridden" } }),
+      "utf-8",
+    );
+    const result = loadConfig("test.ns", { foo: "bar", count: 42 });
+    expect(result).toEqual({ foo: "overridden", count: 42 });
+  });
+
+  it("returns defaults on corrupt JSON", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    fs.writeFileSync(settingsPath, "{ invalid json }", "utf-8");
+    const result = loadConfig("test.ns", { foo: "bar", count: 42 });
+    expect(result).toEqual({ foo: "bar", count: 42 });
+  });
+});
+
+describe("saveConfig", () => {
+  beforeEach(() => {
+    const settingsPath = join(tempDir, "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      fs.unlinkSync(settingsPath);
+    }
+  });
+
+  afterEach(() => {
+    const settingsPath = join(tempDir, "settings.json");
+    const tmpPath = settingsPath + ".tmp";
+    try { fs.unlinkSync(settingsPath); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("writes atomically (tmp + rename)", () => {
+    saveConfig("test.ns", { foo: "bar" });
+    const settingsPath = join(tempDir, "settings.json");
+    expect(fs.existsSync(settingsPath)).toBe(true);
+    const tmpPath = settingsPath + ".tmp";
+    expect(fs.existsSync(tmpPath)).toBe(false);
+    const data = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    expect(data["test.ns"]).toEqual({ foo: "bar" });
+  });
+
+  it("persists data for subsequent loads", () => {
+    saveConfig("test.ns", { foo: "bar", count: 42 });
+    const result = loadConfig("test.ns", { foo: "default", count: 0 });
+    expect(result).toEqual({ foo: "bar", count: 42 });
+  });
+
+  it("writes data correctly on success path", () => {
+    saveConfig("test.ns", { foo: "bar" });
+    const settingsPath = join(tempDir, "settings.json");
+    expect(fs.existsSync(settingsPath)).toBe(true);
+    const data = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    expect(data["test.ns"]).toEqual({ foo: "bar" });
+    // No .tmp file should remain after successful rename
+    expect(fs.existsSync(settingsPath + ".tmp")).toBe(false);
+  });
+});

package/src/startup/logo.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fc from "fast-check";
+import { stripAnsi } from "../text.js";
+
+// ── Helpers for dynamic imports with controlled TRUECOLOR ────────────────────
+
+async function importLogoWithTruecolor(truecolor: boolean) {
+	vi.resetModules();
+
+	// Set env before the module loads
+	const origColorterm = process.env.COLORTERM;
+	const origTerm = process.env.TERM;
+	const origTermProgram = process.env.TERM_PROGRAM;
+	const origWtSession = process.env.WT_SESSION;
+
+	if (truecolor) {
+		process.env.COLORTERM = "truecolor";
+	} else {
+		delete process.env.COLORTERM;
+		process.env.TERM = "xterm";
+		delete process.env.TERM_PROGRAM;
+		delete process.env.WT_SESSION;
+	}
+
+	const mod = await import("./logo.js");
+
+	// Restore env
+	if (origColorterm === undefined) delete process.env.COLORTERM;
+	else process.env.COLORTERM = origColorterm;
+	if (origTerm === undefined) delete process.env.TERM;
+	else process.env.TERM = origTerm;
+	if (origTermProgram === undefined) delete process.env.TERM_PROGRAM;
+	else process.env.TERM_PROGRAM = origTermProgram;
+	if (origWtSession === undefined) delete process.env.WT_SESSION;
+	else process.env.WT_SESSION = origWtSession;
+
+	return mod;
+}
+
+// ── LOGO structure (static, no env dependency) ──────────────────────────────
+
+describe("LOGO structure", () => {
+	it("has 8 rows", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO.length).toBe(8);
+	});
+
+	it("each row has 16 characters", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		for (const row of mod.LOGO) {
+			expect(row.length).toBe(16);
+		}
+	});
+
+	it("first row is 12 blocks + 4 spaces", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO[0]).toBe("████████████    ");
+	});
+
+	it("last row is 4 blocks + 6 spaces + 4 blocks", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO[7]).toBe("████        ████");
+	});
+
+	it("LOGO contains only block chars and spaces", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		for (const row of mod.LOGO) {
+			for (const ch of row) {
+				expect(ch === " " || ch === "█").toBe(true);
+			}
+		}
+	});
+});
+
+// ── Animation constants ──────────────────────────────────────────────────────
+
+describe("animation constants", () => {
+	it("CHAR_FADE_FRAMES is 22", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.CHAR_FADE_FRAMES).toBe(22);
+	});
+
+	it("LOGO_SETTLE_FRAME is 90", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO_SETTLE_FRAME).toBe(90);
+	});
+
+	it("LOGO_PAD is 0", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO_PAD).toBe(0);
+	});
+
+	it("LOGO_GAP is 4", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.LOGO_GAP).toBe(4);
+	});
+});
+
+// ── TRUECOLOR detection ──────────────────────────────────────────────────────
+
+describe("TRUECOLOR", () => {
+	it("is true when COLORTERM contains truecolor", async () => {
+		const mod = await importLogoWithTruecolor(true);
+		expect(mod.TRUECOLOR).toBe(true);
+	});
+
+	it("is false when no truecolor env vars set", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		expect(mod.TRUECOLOR).toBe(false);
+	});
+});
+
+// ── getShinedLogo — non-truecolor ────────────────────────────────────────────
+
+describe("getShinedLogo (non-truecolor)", () => {
+	let mod: typeof import("./logo.js");
+
+	beforeEach(async () => {
+		mod = await importLogoWithTruecolor(false);
+	});
+
+	it("returns LOGO unchanged when TRUECOLOR is false", () => {
+		const result = mod.getShinedLogo(0, "wave");
+		expect(result).toBe(mod.LOGO);
+	});
+
+	it("returns LOGO at any frame when TRUECOLOR is false", () => {
+		expect(mod.getShinedLogo(999, "wave")).toBe(mod.LOGO);
+	});
+
+	it("returns 8 rows regardless of frame", () => {
+		expect(mod.getShinedLogo(50, "diagonal").length).toBe(8);
+	});
+});
+
+// ── getShinedLogo — truecolor ────────────────────────────────────────────────
+
+describe("getShinedLogo (truecolor)", () => {
+	let mod: typeof import("./logo.js");
+
+	beforeEach(async () => {
+		mod = await importLogoWithTruecolor(true);
+	});
+
+	it("returns 8 rows", () => {
+		expect(mod.getShinedLogo(0, "wave").length).toBe(8);
+	});
+
+	it("returns different output than LOGO when TRUECOLOR is true", () => {
+		const result = mod.getShinedLogo(50, "wave");
+		expect(result).not.toBe(mod.LOGO);
+	});
+
+	it("early frames show spaces for not-yet-revealed chars", () => {
+		const result = mod.getShinedLogo(0, "vertical");
+		// At frame 0, nothing should be revealed yet
+		for (const row of result) {
+			const stripped = stripAnsi(row);
+			expect(stripped).toMatch(/^[\s]*$/);
+		}
+	});
+
+	it("late frames show all characters revealed", () => {
+		const result = mod.getShinedLogo(200, "vertical");
+		for (let i = 0; i < result.length; i++) {
+			const stripped = stripAnsi(result[i]!);
+			const expected = stripAnsi(mod.LOGO[i]!);
+			expect(stripped).toBe(expected);
+		}
+	});
+
+	it("output contains ANSI gray escapes", () => {
+		const result = mod.getShinedLogo(50, "wave");
+		const joined = result.join("\n");
+		expect(joined).toMatch(/\x1b\[38;2;\d+;\d+;\d+m/);
+	});
+
+	it("default style is wave", () => {
+		const result1 = mod.getShinedLogo(50);
+		const result2 = mod.getShinedLogo(50, "wave");
+		expect(result1).toEqual(result2);
+	});
+});
+
+// ── All animation styles ─────────────────────────────────────────────────────
+
+describe("animation styles", () => {
+	const styles = [
+		"diagonal",
+		"top-right",
+		"bottom-left",
+		"bottom-right",
+		"center-out",
+		"wave",
+		"horizontal",
+		"vertical",
+		"vertical-up",
+	] as const;
+
+	it.each(styles)("style '%s' produces valid reveal times", async (style) => {
+		const mod = await importLogoWithTruecolor(true);
+		const result = mod.getShinedLogo(100, style);
+		expect(result.length).toBe(8);
+		// Each row should be a string
+		for (const row of result) {
+			expect(typeof row).toBe("string");
+		}
+	});
+
+	it.each(styles)("style '%s' fully reveals at high frame count", async (style) => {
+		const mod = await importLogoWithTruecolor(true);
+		const result = mod.getShinedLogo(500, style);
+		for (let i = 0; i < result.length; i++) {
+			const stripped = stripAnsi(result[i]!);
+			const expected = stripAnsi(mod.LOGO[i]!);
+			expect(stripped).toBe(expected);
+		}
+	});
+});
+
+// ── Properties ───────────────────────────────────────────────────────────────
+
+describe("properties", () => {
+	it("getShinedLogo always returns 8 rows (truecolor)", async () => {
+		const mod = await importLogoWithTruecolor(true);
+		fc.assert(
+			fc.property(fc.nat(1000), n => {
+				return mod.getShinedLogo(n, "wave").length === 8;
+			}),
+		);
+	});
+
+	it("each row visible width equals 16 after stripping ANSI (truecolor)", async () => {
+		const mod = await importLogoWithTruecolor(true);
+		fc.assert(
+			fc.property(fc.nat(500), n => {
+				const result = mod.getShinedLogo(n, "diagonal");
+				for (const row of result) {
+					const stripped = stripAnsi(row);
+					// stripAnsi trims, so we check the raw row length instead
+					// The actual row length (including ANSI) may vary, but the
+					// visible content should always be 16 chars
+					// Since stripAnsi trims trailing spaces, check untrimmed
+					const raw = row.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "");
+					if (raw.length !== 16) return false;
+				}
+				return true;
+			}),
+		);
+	});
+
+	it("getShinedLogo returns 8 rows (non-truecolor)", async () => {
+		const mod = await importLogoWithTruecolor(false);
+		fc.assert(
+			fc.property(fc.nat(1000), n => {
+				return mod.getShinedLogo(n, "wave").length === 8;
+			}),
+		);
+	});
+});