osdy-pi 1.2.0 → 1.4.0

package/extensions/osdy-pi/agent-coexistence-setup.test.ts

@@ -0,0 +1,163 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { registerHooks } from "node:module";
+import test from "node:test";
+
+registerHooks({ resolve(specifier, context, nextResolve) {
+	if (specifier === "./agent-coexistence-setup.js" && context.parentURL?.endsWith(".test.ts"))
+		return { shortCircuit: true, url: new URL("./agent-coexistence-setup.ts", context.parentURL).href };
+	return nextResolve(specifier, context);
+} });
+const { setupJokerAgents } = await import("./agent-coexistence-setup.js");
+
+async function fixture() {
+	const root = await mkdtemp(join(tmpdir(), "osdy-joker-"));
+	const agentDir = join(root, ".pi", "agent");
+	const gentle = join(root, "gentle");
+	await mkdir(agentDir, { recursive: true });
+	await mkdir(gentle);
+	await writeFile(join(gentle, "package.json"), '{"name":"gentle-pi"}');
+	const settingsPath = join(agentDir, "settings.json");
+	const packages = ["npm:other", { source: gentle, extensions: ["-extensions/gentle-todo.ts"], themes: [], skills: ["skills/*"] }, "npm:gentle-pi@1.2.0", { source: "npm:gentle-pi", extensions: ["-extensions/gentle-agents.ts"] }];
+	await writeFile(settingsPath, JSON.stringify({ theme: "dark", packages }));
+	return { root, agentDir, gentle, settingsPath, packages };
+}
+
+const base = (f: Awaited<ReturnType<typeof fixture>>) => ({
+	agentDir: f.agentDir, home: f.root, cwd: f.root, env: {},
+});
+
+void test("installs Joker then narrowly reconciles every Gentle entry using latest settings", async () => {
+	const f = await fixture();
+	let calls = 0;
+	const install = async () => {
+		calls++;
+		const latest = JSON.parse(await readFile(f.settingsPath, "utf8")) as { packages: unknown[] };
+		latest.packages.push("npm:pi-subagents-j0k3r", "npm:newly-added");
+		await writeFile(f.settingsPath, JSON.stringify(latest));
+	};
+	await setupJokerAgents({ ...base(f), install });
+	const settings = JSON.parse(await readFile(f.settingsPath, "utf8")) as { packages: unknown[]; theme: string };
+	assert.equal(calls, 1);
+	assert.deepEqual(settings.packages, [
+		"npm:other",
+		{ source: f.gentle, extensions: ["-extensions/gentle-todo.ts", "-extensions/gentle-agents.ts"], themes: [], skills: ["skills/*"] },
+		{ source: "npm:gentle-pi@1.2.0", extensions: ["-extensions/gentle-agents.ts"] },
+		{ source: "npm:gentle-pi", extensions: ["-extensions/gentle-agents.ts"] },
+		"npm:pi-subagents-j0k3r", "npm:newly-added",
+	]);
+	assert.equal(settings.theme, "dark");
+	await setupJokerAgents({ ...base(f), install: () => Promise.reject(new Error("duplicate install")) });
+	assert.equal((await readFile(f.settingsPath, "utf8")).includes("duplicate"), false);
+});
+
+void test("relative Gentle sources resolve from settings and project overrides fail closed", async () => {
+	const f = await fixture();
+	const local = join(f.agentDir, "gentle-local");
+	await mkdir(local);
+	await writeFile(join(local, "package.json"), '{"name":"gentle-pi"}');
+	await writeFile(f.settingsPath, '{"packages":["./gentle-local","npm:pi-subagents-j0k3r"]}');
+	await setupJokerAgents({ ...base(f), install: () => Promise.reject(new Error("should skip")) });
+	const result = JSON.parse(await readFile(f.settingsPath, "utf8")) as { packages: unknown[] };
+	assert.deepEqual(result.packages[0], { source: "./gentle-local", extensions: ["-extensions/gentle-agents.ts"] });
+	const project = join(f.root, "project");
+	await mkdir(join(project, ".pi", "gentle"), { recursive: true });
+	await writeFile(join(project, ".pi", "gentle", "package.json"), '{"name":"gentle-pi"}');
+	await writeFile(join(project, ".pi", "settings.json"), '{"packages":["./gentle"]}');
+	await assert.rejects(setupJokerAgents({ ...base(f), cwd: project }), /project-local Gentle/i);
+});
+
+void test("bare, tilde, and file URL local Gentle entries get the narrow personal filter", async () => {
+	const f = await fixture();
+	const bare = join(f.agentDir, "gentle");
+	await mkdir(bare);
+	await writeFile(join(bare, "package.json"), '{"name":"gentle-pi"}');
+	await writeFile(f.settingsPath, JSON.stringify({ packages: ["gentle", "~/gentle", pathToFileURL(f.gentle).href, "npm:pi-subagents-j0k3r"] }));
+	const result = await setupJokerAgents({ ...base(f), install: () => Promise.reject(new Error("no install")) });
+	assert.equal(result.gentleCount, 3);
+	const settings = JSON.parse(await readFile(f.settingsPath, "utf8")) as { packages: Array<{ source: string; extensions: string[] }> };
+	assert.deepEqual(settings.packages.slice(0, 3).map((entry) => entry.extensions), Array(3).fill(["-extensions/gentle-agents.ts"]));
+});
+
+void test("bare project Gentle override and ambiguous Gentle local path fail before install", async () => {
+	const f = await fixture();
+	const project = join(f.root, "project");
+	await mkdir(join(project, ".pi", "gentle"), { recursive: true });
+	await writeFile(join(project, ".pi", "gentle", "package.json"), '{"name":"gentle-pi"}');
+	await writeFile(join(project, ".pi", "settings.json"), '{"packages":["gentle"]}');
+	let calls = 0;
+	const install = () => { calls++; return Promise.resolve(); };
+	await assert.rejects(setupJokerAgents({ ...base(f), cwd: project, install }), /project-local Gentle/i);
+	await writeFile(join(project, ".pi", "settings.json"), '{"packages":[]}');
+	await writeFile(f.settingsPath, '{"packages":["gentle","npm:pi-subagents-j0k3r"]}');
+	await assert.rejects(setupJokerAgents({ ...base(f), install }), /Gentle.*resolve|Gentle.*source/i);
+	assert.equal(calls, 0);
+});
+
+void test("recognizable remote Gentle sources fail closed before install, but unrelated Git packages remain", async () => {
+	const f = await fixture();
+	let calls = 0;
+	const install = () => { calls++; return Promise.resolve(); };
+	for (const remote of [
+		"git:github.com/Gentleman-Programming/gentle-pi",
+		"https://github.com/Gentleman-Programming/gentle-pi.git",
+	]) {
+		await writeFile(f.settingsPath, JSON.stringify({ packages: [remote, "git:github.com/owner/other-package"] }));
+		await assert.rejects(setupJokerAgents({ ...base(f), install }), /remote Gentle.*local.*npm/i);
+		const project = join(f.root, "project");
+		await mkdir(join(project, ".pi"), { recursive: true });
+		await writeFile(join(project, ".pi", "settings.json"), JSON.stringify({ packages: [remote] }));
+		await writeFile(f.settingsPath, '{"packages":["npm:pi-subagents-j0k3r"]}');
+		await assert.rejects(setupJokerAgents({ ...base(f), cwd: project, install }), /remote Gentle.*local.*npm/i);
+		await writeFile(join(project, ".pi", "settings.json"), '{"packages":[]}');
+	}
+	assert.equal(calls, 0);
+	await writeFile(f.settingsPath, '{"packages":["git:github.com/owner/other-package","npm:pi-subagents-j0k3r"]}');
+	const result = await setupJokerAgents({ ...base(f), install });
+	assert.equal(result.gentleCount, 0);
+});
+
+void test("invalid Gentle filters or duplicate Joker declarations block setup before further writes", async () => {
+	const f = await fixture();
+	let calls = 0;
+	const install = () => { calls++; return Promise.resolve(); };
+	await writeFile(f.settingsPath, '{"packages":[{"source":"npm:gentle-pi","extensions":false}]}');
+	await assert.rejects(setupJokerAgents({ ...base(f), install }), /Gentle extensions/i);
+	await writeFile(f.settingsPath, '{"packages":["npm:pi-subagents-j0k3r","npm:pi-subagents-j0k3r"]}');
+	await assert.rejects(setupJokerAgents({ ...base(f), install }), /duplicate Joker/i);
+	assert.equal(calls, 0);
+});
+
+void test("without Gentle, only Joker installation changes settings", async () => {
+	const f = await fixture();
+	await writeFile(f.settingsPath, '{"packages":["npm:other"]}');
+	await setupJokerAgents({ ...base(f), install: async () => {
+		await writeFile(f.settingsPath, '{"packages":["npm:other","npm:pi-subagents-j0k3r"]}');
+	} });
+	assert.deepEqual(JSON.parse(await readFile(f.settingsPath, "utf8")) as unknown, { packages: ["npm:other", "npm:pi-subagents-j0k3r"] });
+});
+
+void test("rejects alternate agent directories and project-local Gentle overrides before install", async () => {
+	const f = await fixture();
+	let calls = 0;
+	const install = () => { calls++; return Promise.resolve(); };
+	await assert.rejects(setupJokerAgents({ ...base(f), agentDir: join(f.root, "isolated"), install }), /personal|agent/i);
+	await assert.rejects(setupJokerAgents({ ...base(f), env: { PI_CODING_AGENT_DIR: f.agentDir }, install }), /override|normal/i);
+	const project = join(f.root, "project");
+	await mkdir(join(project, ".pi"), { recursive: true });
+	await writeFile(join(project, ".pi", "settings.json"), '{"packages":["npm:gentle-pi"]}');
+	await assert.rejects(setupJokerAgents({ ...base(f), cwd: project, install }), /project|Gentle/i);
+	assert.equal(calls, 0);
+});
+
+void test("failed installer or malformed latest settings cannot rewrite personal settings", async () => {
+	const f = await fixture();
+	const original = await readFile(f.settingsPath, "utf8");
+	await assert.rejects(setupJokerAgents({ ...base(f), install: () => Promise.reject(new Error("install failed")) }), /install failed/);
+	assert.equal(await readFile(f.settingsPath, "utf8"), original);
+	await assert.rejects(setupJokerAgents({ ...base(f), install: async () => { await writeFile(f.settingsPath, "{bad"); } }), /settings/i);
+	assert.equal(await readFile(f.settingsPath, "utf8"), "{bad");
+});

package/extensions/osdy-pi/agent-coexistence-setup.ts

@@ -0,0 +1,196 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { lstat, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+
+const runFile = promisify(execFile);
+const JOKER = "npm:pi-subagents-j0k3r";
+const GENTLE_EXCLUSION = "-extensions/gentle-agents.ts";
+
+type Settings = Record<string, unknown> & { packages?: unknown[] };
+
+type SetupOptions = {
+	agentDir: string;
+	home?: string;
+	cwd: string;
+	env?: NodeJS.ProcessEnv;
+	install?: () => Promise<void>;
+};
+
+function object(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function source(entry: unknown): string | undefined {
+	if (typeof entry === "string") return entry;
+	return object(entry) && typeof entry.source === "string" ? entry.source : undefined;
+}
+
+function npmGentle(entry: unknown): boolean {
+	return /^npm:gentle-pi(?:@[^\s]+)?$/i.test(source(entry) ?? "");
+}
+
+function joker(entry: unknown): boolean {
+	return /^npm:pi-subagents-j0k3r(?:@[^\s]+)?$/i.test(source(entry) ?? "");
+}
+
+async function gentle(entry: unknown, settingsDir: string, home: string): Promise<boolean> {
+	if (npmGentle(entry)) return true;
+	const value = source(entry);
+	if (!value || /^npm:/i.test(value)) return false;
+	if (/^(?:git:|https?:\/\/)/i.test(value)) {
+		if (/(?:^|\/)gentle-pi(?:\.git)?(?:[@#?][^\s]*)?$/i.test(value))
+			throw new Error("Remote Gentle source unsupported: register a local gentle-pi checkout or npm:gentle-pi in personal Pi, then rerun agents setup.");
+		return false;
+	}
+	let path: string;
+	try {
+		if (value.startsWith("file:")) path = fileURLToPath(value);
+		else if (value === "~" || value.startsWith("~/")) path = resolve(home, value.slice(value === "~" ? 1 : 2));
+		else if (!value.includes(":")) path = resolve(settingsDir, value);
+		else return false;
+	} catch {
+		throw new Error(`Gentle source cannot be resolved: ${value}`);
+	}
+	try {
+		const manifest: unknown = JSON.parse(await readFile(join(path, "package.json"), "utf8"));
+		return object(manifest) && manifest.name === "gentle-pi";
+	} catch {
+		if (/(?:^|[\\/])gentle(?:-pi)?$/i.test(path))
+			throw new Error(`Gentle source cannot be resolved: ${value}`);
+		return false;
+	}
+}
+
+function validateGentleFilters(entry: unknown): void {
+	if (!object(entry) || entry.extensions === undefined) return;
+	if (!Array.isArray(entry.extensions) || !entry.extensions.every((value: unknown) => typeof value === "string"))
+		throw new Error("Gentle extensions filter must be an array of strings.");
+}
+
+async function regularSettings(path: string): Promise<Settings> {
+	if (!(await lstat(path)).isFile()) throw new Error("Personal settings.json must be a regular file, not a link.");
+	let value: unknown;
+	try {
+		value = JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		throw new Error("Personal settings.json must contain valid JSON.");
+	}
+	if (!object(value) || (value.packages !== undefined && !Array.isArray(value.packages)))
+		throw new Error("Personal settings.json must have an object root and array packages.");
+	return value;
+}
+
+async function assertNoProjectGentle(cwd: string, home: string): Promise<void> {
+	let directory = resolve(cwd);
+	while (true) {
+		const local = join(directory, ".pi", "settings.json");
+		let text: string;
+		try {
+			text = await readFile(local, "utf8");
+		} catch (error) {
+			if (object(error) && error.code === "ENOENT") {
+				const parent = dirname(directory);
+				if (parent === directory) return;
+				directory = parent;
+				continue;
+			}
+			throw error;
+		}
+		let settings: unknown;
+		try { settings = JSON.parse(text); }
+		catch { throw new Error(`Project settings invalid at ${local}; cannot guarantee Gentle filtering.`); }
+		if (!object(settings) || (settings.packages !== undefined && !Array.isArray(settings.packages)))
+			throw new Error(`Project settings invalid at ${local}; cannot guarantee Gentle filtering.`);
+		for (const entry of settings.packages ?? []) {
+			if (await gentle(entry, dirname(local), home)) throw new Error(`Project-local Gentle package at ${local} can override the personal filter.`);
+		}
+		const parent = dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+}
+
+async function installJoker(): Promise<void> {
+	await runFile("pi", ["install", JOKER], { cwd: homedir(), maxBuffer: 4096 });
+}
+
+export async function inspectJokerAgents(options: Omit<SetupOptions, "install">): Promise<{ jokerInstalled: boolean; gentleCount: number; filtered: boolean }> {
+	const target = await validateTarget(options);
+	const settings = await regularSettings(join(target, "settings.json"));
+	const packages = settings.packages ?? [];
+	const flags = await Promise.all(packages.map((entry) => gentle(entry, target, options.home ?? homedir())));
+	return {
+		jokerInstalled: packages.some(joker),
+		gentleCount: flags.filter(Boolean).length,
+		filtered: flags.every((isGentle, index) => !isGentle ||
+			(object(packages[index]) && Array.isArray(packages[index].extensions) && packages[index].extensions.includes(GENTLE_EXCLUSION))),
+	};
+}
+
+async function validateTarget(options: Omit<SetupOptions, "install">): Promise<string> {
+	const home = resolve(options.home ?? homedir());
+	const target = resolve(options.agentDir);
+	if (options.env?.PI_CODING_AGENT_DIR !== undefined || !isAbsolute(options.agentDir))
+		throw new Error("Agents setup requires normal personal Pi; agent directory override or isolated profile is unsupported.");
+	let personal: boolean;
+	try {
+		personal = (await realpath(target)) === (await realpath(join(home, ".pi", "agent")));
+	} catch {
+		personal = false;
+	}
+	if (!personal)
+		throw new Error("Agents setup requires the normal personal Pi agent directory, not an isolated profile.");
+	await assertNoProjectGentle(options.cwd, home);
+	return target;
+}
+
+export async function setupJokerAgents(options: SetupOptions): Promise<{ installed: boolean; changed: boolean; gentleCount: number }> {
+	const target = await validateTarget(options);
+	const path = join(target, "settings.json");
+	const before = await regularSettings(path);
+	const original = before.packages ?? [];
+	if (original.some((entry) => entry !== null && typeof entry !== "string" && !object(entry)))
+		throw new Error("Personal settings packages contain an invalid entry.");
+	const initialGentle = await Promise.all(original.map((entry) => gentle(entry, target, options.home ?? homedir())));
+	if (original.filter(joker).length > 1) throw new Error("Personal settings contain duplicate Joker entries.");
+	const alreadyJoker = original.some(joker);
+	for (const [index, isGentle] of initialGentle.entries()) {
+		if (isGentle) validateGentleFilters(original[index]);
+	}
+	const filtered = initialGentle.every((isGentle, index) => !isGentle ||
+		(object(original[index]) && Array.isArray(original[index].extensions) && original[index].extensions.includes(GENTLE_EXCLUSION)));
+	if (alreadyJoker && filtered) return { installed: false, changed: false, gentleCount: initialGentle.filter(Boolean).length };
+	if (!alreadyJoker) await (options.install ?? installJoker)();
+	// Install owns only Joker. Re-read the latest settings instead of replaying a stale snapshot.
+	await assertNoProjectGentle(options.cwd, options.home ?? homedir());
+	const latest = await regularSettings(path);
+	const packages = latest.packages ?? [];
+	if (!packages.some(joker)) throw new Error("Pi install did not register Joker in personal settings; no Gentle filters were changed.");
+	if (packages.filter(joker).length > 1) throw new Error("Personal settings contain duplicate Joker entries.");
+	const gentleFlags = await Promise.all(packages.map((entry) => gentle(entry, target, options.home ?? homedir())));
+	let changed = false;
+	const updated = packages.map((entry, index) => {
+		if (!gentleFlags[index]) return entry;
+		if (typeof entry !== "string" && !object(entry)) throw new Error("Gentle package entry is invalid.");
+		const item = typeof entry === "string" ? { source: entry } : entry;
+		validateGentleFilters(item);
+		const extensions = item.extensions as string[] | undefined;
+		if (extensions?.includes(GENTLE_EXCLUSION)) return entry;
+		changed = true;
+		return { ...item, extensions: [...(extensions ?? []), GENTLE_EXCLUSION] };
+	});
+	if (changed) {
+		const temporary = join(target, `.settings.${randomUUID()}.tmp`);
+		try {
+			await writeFile(temporary, `${JSON.stringify({ ...latest, packages: updated }, null, 2)}\n`, { flag: "wx", mode: 0o600 });
+			await rename(temporary, path);
+		} finally {
+			await unlink(temporary).catch(() => {});
+		}
+	}
+	return { installed: !alreadyJoker, changed, gentleCount: gentleFlags.filter(Boolean).length };
+}

package/extensions/osdy-pi/animation.test.ts

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { registerHooks } from "node:module";
+import test from "node:test";
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+import { HEADER_VARIANTS } from "./constants.ts";
+import type { SimpleTheme } from "./types.js";
+
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (
+			context.parentURL?.includes("/extensions/osdy-pi/") &&
+			specifier.startsWith("./") &&
+			specifier.endsWith(".js")
+		) {
+			return nextResolve(`${specifier.slice(0, -3)}.ts`, context);
+		}
+		return nextResolve(specifier, context);
+	},
+});
+
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+const { colorAsciiCharacter } = await import("./animation.ts");
+
+class RecordingTheme implements SimpleTheme {
+	readonly calls: Array<{ name: string; text: string }> = [];
+
+	fg(name: string, text: string): string {
+		this.calls.push({ name, text });
+		return `<${name}:${text}>`;
+	}
+}
+
+function neonPalette() {
+	const palette = HEADER_VARIANTS.neon.headerTonePalette;
+	assert.ok(palette);
+	return palette;
+}
+
+void test("Neon renders fixed white and near-black as foreground RGB", () => {
+	const palette = neonPalette();
+	const theme = new RecordingTheme();
+
+	assert.equal(
+		colorAsciiCharacter(theme, palette.c, "W"),
+		"\u001B[38;2;255;255;255mW\u001B[39m",
+	);
+	assert.equal(
+		colorAsciiCharacter(theme, palette.d, "B"),
+		"\u001B[38;2;18;1;27mB\u001B[39m",
+	);
+	assert.deepEqual(theme.calls, []);
+});
+
+void test("Neon renders main and dark pink through bounded accent styling", () => {
+	const palette = neonPalette();
+	const theme = new RecordingTheme();
+
+	const main = colorAsciiCharacter(theme, palette.h, "H");
+	const dark = [palette.l, palette.m, palette.p].map((color, index) =>
+		colorAsciiCharacter(theme, color, `D${index}`),
+	);
+	assert.equal(main, "<accent:H>");
+	assert.deepEqual(dark, [
+		"\u001B[2m<accent:D0>\u001B[22m",
+		"\u001B[2m<accent:D1>\u001B[22m",
+		"\u001B[2m<accent:D2>\u001B[22m",
+	]);
+	assert.deepEqual(theme.calls, [
+		{ name: "accent", text: "H" },
+		{ name: "accent", text: "D0" },
+		{ name: "accent", text: "D1" },
+		{ name: "accent", text: "D2" },
+	]);
+	assert.equal(`${main}${dark.join("")}`.includes("\u001B[48;"), false);
+});
+
+void test("Neon never maps a tone to mdHeading or mdLink", () => {
+	for (const color of Object.values(neonPalette())) {
+		if (typeof color === "string") {
+			assert.notEqual(color, "mdHeading");
+			assert.notEqual(color, "mdLink");
+		}
+	}
+});

package/extensions/osdy-pi/animation.ts

@@ -1,6 +1,9 @@
 import { ANIMATION_ENABLED } from "./constants.js";
 import type { AnimationMode, SimpleTheme } from "./types.js";
-import type { MascotTonePalette } from "./constants.js";
+import type {
+	MascotTonePalette,
+	ThemeForegroundColor,
+} from "./constants.js";
 import { positiveModulo } from "./utils.js";
 
 export type AsciiAnimationStyle = "static" | "animated";
@@ -25,12 +28,12 @@ export function asciiAnimationMode(): AnimationMode {
 	return getAnimationOverrideMode(process.env.OSDY_PI_ANIMATION) ?? "intro";
 }
 
-function getAnimatedAsciiColor(
+function getAnimatedAsciiColor<Color>(
 	wave: number,
-	baseColor: string,
-	highlightColor: string,
-	trailColor: string,
-): string {
+	baseColor: Color,
+	highlightColor: Color,
+	trailColor: Color,
+): Color {
 	if (wave <= 3) return highlightColor;
 	if (wave <= 8) return trailColor;
 	return baseColor;
@@ -50,11 +53,17 @@ const GLOW_TRAIL_TONES = {
 	v: "c",
 } as const;
 
-function colorAsciiCharacter(
+export function colorAsciiCharacter(
 	theme: SimpleTheme,
-	color: string,
+	color: string | ThemeForegroundColor,
 	character: string,
 ): string {
+	if (typeof color !== "string") {
+		const themedCharacter = theme.fg(color.token, character);
+		return color.dimmed
+			? `\u001B[2m${themedCharacter}\u001B[22m`
+			: themedCharacter;
+	}
 	const hexMatch = RAW_HEX_COLOR.exec(color);
 	if (!hexMatch) return theme.fg(color, character);
 	const red = Number.parseInt(hexMatch[1] ?? "", 16);