rinco-pi-hud 1.0.0

package/extensions/hud/config/config-counts.ts

@@ -0,0 +1,87 @@
+import { createRequire } from "node:module";
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+
+export interface ConfigCounts {
+	instructionFiles: {
+		agentsMd: number;
+		claudeMd: number;
+		total: number;
+	};
+	packages: number;
+}
+
+export interface ConfigCountOptions {
+	/** Overrides Pi's agent directory; useful for isolated callers and tests. */
+	agentDir?: string;
+	/** Injection point for the Pi SDK resolver. The SDK resolver remains the default. */
+	getAgentDir?: () => string;
+}
+
+const require = createRequire(import.meta.url);
+const MAX_SETTINGS_BYTES = 1024 * 1024;
+
+function getPiAgentDir(): string {
+	try {
+		const agentModule = require("@earendil-works/pi-coding-agent") as {
+			getAgentDir?: () => string;
+		};
+		return agentModule.getAgentDir?.() ?? "";
+	} catch {
+		return "";
+	}
+}
+
+function resolveAgentDir(options: ConfigCountOptions): string {
+	let agentDir = "";
+	try {
+		agentDir = typeof options.agentDir === "string"
+			? options.agentDir
+			: options.getAgentDir
+				? options.getAgentDir()
+				: getPiAgentDir();
+	} catch {
+		return "";
+	}
+	return agentDir && isAbsolute(agentDir) ? agentDir : "";
+}
+
+function countTopLevelFile(cwd: string, name: string): number {
+	try {
+		return statSync(join(cwd, name)).isFile() ? 1 : 0;
+	} catch {
+		return 0;
+	}
+}
+
+function countPackages(agentDir: string): number {
+	if (!agentDir) return 0;
+	try {
+		const settingsPath = join(agentDir, "settings.json");
+		const stats = statSync(settingsPath);
+		if (!stats.isFile() || stats.size > MAX_SETTINGS_BYTES) return 0;
+		const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as {
+			packages?: unknown;
+		};
+		return Array.isArray(settings?.packages) ? settings.packages.length : 0;
+	} catch {
+		return 0;
+	}
+}
+
+export function countConfigEntries(cwd: string, options: ConfigCountOptions = {}): ConfigCounts {
+	const agentDir = resolveAgentDir(options);
+	const agentsMd = countTopLevelFile(cwd, "AGENTS.md");
+	const claudeMd = countTopLevelFile(cwd, "CLAUDE.md");
+
+	return {
+		instructionFiles: {
+			agentsMd,
+			claudeMd,
+			total: agentsMd + claudeMd,
+		},
+		packages: countPackages(agentDir),
+	};
+}
+
+export const getConfigCounts = countConfigEntries;

package/extensions/hud/config/config.ts

@@ -0,0 +1,65 @@
+/**
+ * Public barrel for the Zentui config module.
+ *
+ * The config surface is split across four focused files:
+ *   - `schema.ts`     — types, format-string vocabulary, and `defaultConfig`.
+ *   - `normalize.ts`  — untrusted JSON → `PolishedTuiConfig` normalization.
+ *   - `file-io.ts`    — atomic on-disk read/write of the config file.
+ *   - `persist.ts`    — `save*Patch` helpers used by the settings UI/commands.
+ *
+ * This file re-exports the full public API unchanged so existing imports of
+ * `../config/config.js` keep working without modification.
+ */
+export type {
+	ColorSourcesConfig,
+	ColorSource,
+	ColorSpec,
+	ContextStyle,
+	ContextThresholds,
+	ExtensionStatusColorMode,
+	ExtensionStatusesConfig,
+	ExtensionStatusPlacement,
+	FooterSegmentsConfig,
+	GitBranchConfig,
+	GitBranchMaxLength,
+	GitCommitConfig,
+	GitMetricsConfig,
+	IconMode,
+	PathDisplayConfig,
+	PathDisplayMode,
+	PolishedTuiConfig,
+	SeparatorStyle,
+	UiFeaturesConfig,
+} from "./schema.js";
+export {
+	configPath,
+	defaultConfig,
+	FOOTER_FORMAT_ALIASES,
+	FOOTER_FORMAT_VARIABLES,
+} from "./schema.js";
+
+export {
+	getExtensionStatusColorMode,
+	getExtensionStatusPlacement,
+	isExtensionStatusColorMode,
+	isExtensionStatusPlacement,
+	isSeparatorStyle,
+	mergeConfig,
+} from "./normalize.js";
+
+export { ensureConfigExists, loadConfig } from "./file-io.js";
+
+export {
+	saveColorSourcesPatch,
+	saveContextStylePatch,
+	saveContextThresholdsPatch,
+	saveExtensionStatusColorMode,
+	saveExtensionStatusPlacement,
+	saveFooterFormatPatch,
+	saveFooterSegmentsPatch,
+	saveGitBranchPatch,
+	saveIconsModePatch,
+	savePathDisplayPatch,
+	saveSeparatorPatch,
+	saveUiFeaturesPatch,
+} from "./persist.js";

package/extensions/hud/config/file-io.ts

@@ -0,0 +1,128 @@
+/**
+ * Config-file persistence: atomic reads/writes of `~/.pi/rinco-pi-hud.json`.
+ *
+ * `mutateConfig` is the single choke point every `save*Patch` function in
+ * `persist.ts` goes through: it loads the current on-disk record (refusing
+ * to touch a corrupt file), applies a synchronous mutation, writes the
+ * result via a temp-file + fsync + rename (so a crash mid-write cannot
+ * leave a truncated/corrupt config on disk), and returns the freshly merged
+ * `PolishedTuiConfig`.
+ */
+import { randomUUID } from "node:crypto";
+import {
+	closeSync,
+	existsSync,
+	fchmodSync,
+	fsyncSync,
+	lstatSync,
+	openSync,
+	readFileSync,
+	realpathSync,
+	renameSync,
+	statSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { isRecord, mergeConfig } from "./normalize.js";
+import { configPath, type PolishedTuiConfig } from "./schema.js";
+
+export type ConfigRecord = Record<string, unknown>;
+
+type ConfigFileState =
+	| { kind: "missing"; record: ConfigRecord; writePath: string }
+	| { kind: "valid"; record: ConfigRecord; writePath: string; mode: number }
+	| { kind: "corrupt"; error: unknown };
+
+function errorCode(error: unknown): string | undefined {
+	return typeof error === "object" && error !== null && "code" in error
+		? String(error.code)
+		: undefined;
+}
+
+function readConfigFileState(path: string): ConfigFileState {
+	let writePath = path;
+	try {
+		const pathStat = lstatSync(path);
+		if (pathStat.isSymbolicLink()) writePath = realpathSync(path);
+		const targetStat = statSync(writePath);
+		const parsed = JSON.parse(readFileSync(writePath, "utf8"));
+		return isRecord(parsed)
+			? { kind: "valid", record: parsed, writePath, mode: targetStat.mode & 0o7777 }
+			: { kind: "corrupt", error: new Error("top-level value must be a JSON object") };
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") {
+			try {
+				lstatSync(path);
+			} catch (pathError) {
+				if (errorCode(pathError) === "ENOENT")
+					return { kind: "missing", record: {}, writePath: path };
+			}
+		}
+		return { kind: "corrupt", error };
+	}
+}
+
+function writeConfigAtomically(path: string, record: ConfigRecord, mode?: number): void {
+	const tempPath = join(dirname(path), `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+	let file: number | undefined;
+	try {
+		file = openSync(tempPath, "wx", mode ?? 0o666);
+		if (mode !== undefined) fchmodSync(file, mode);
+		writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+		fsyncSync(file);
+		closeSync(file);
+		file = undefined;
+		renameSync(tempPath, path);
+	} catch (error) {
+		if (file !== undefined) {
+			try {
+				closeSync(file);
+			} catch {}
+		}
+		try {
+			unlinkSync(tempPath);
+		} catch (cleanupError) {
+			if (errorCode(cleanupError) !== "ENOENT") {
+				// Preserve the persistence failure; the best-effort cleanup error is secondary.
+			}
+		}
+		throw error;
+	}
+}
+
+export function mutateConfig(
+	path: string,
+	mutate: (record: ConfigRecord) => void,
+): PolishedTuiConfig {
+	const state = readConfigFileState(path);
+	if (state.kind === "corrupt") {
+		const detail = state.error instanceof Error ? ` (${state.error.message})` : "";
+		throw new Error(
+			`Refusing to save Zentui config because ${path} is corrupt or unreadable; fix or remove it first.${detail}`,
+		);
+	}
+	mutate(state.record);
+	writeConfigAtomically(
+		state.writePath,
+		state.record,
+		state.kind === "valid" ? state.mode : undefined,
+	);
+	return mergeConfig(state.record);
+}
+
+export function ensureConfigExists(): void {
+	// Intentionally left as a no-op. Zentui config is user-owned and
+	// compatibility-sensitive: runtime defaults come from `mergeConfig({})`, and
+	// the extension should not persist opinionated defaults unless the user
+	// explicitly changes a setting.
+}
+
+export function loadConfig(): PolishedTuiConfig {
+	try {
+		if (!existsSync(configPath)) return mergeConfig({});
+		return mergeConfig(JSON.parse(readFileSync(configPath, "utf8")));
+	} catch {
+		return mergeConfig({});
+	}
+}

package/extensions/hud/config/normalize.ts

@@ -0,0 +1,374 @@
+/**
+ * Untrusted-JSON → `PolishedTuiConfig` normalization.
+ *
+ * Every field is parsed defensively: unknown/malformed values fall back to
+ * `defaultConfig`, and free-form text (footer format, icon glyph overrides)
+ * is length-capped and stripped of control/VT characters before being stored.
+ */
+import { stripVTControlCharacters } from "node:util";
+import {
+	ICON_GLYPH_KEYS,
+	type IconGlyphs,
+	normalizeIconMode,
+	resolveConfiguredIcons,
+} from "../ui/icons.js";
+import { isSupportedColorSpec } from "../ui/style.js";
+import {
+	DEFAULT_EXTENSION_STATUS_COLOR_MODE,
+	DEFAULT_PROJECT_REFRESH_INTERVAL_MS,
+	MIN_PROJECT_REFRESH_INTERVAL_MS,
+	type ColorSource,
+	type ColorSourcesConfig,
+	type ContextStyle,
+	type ContextThresholds,
+	defaultConfig,
+	type ExtensionStatusColorMode,
+	type ExtensionStatusesConfig,
+	type ExtensionStatusPlacement,
+	type FooterSegmentsConfig,
+	type GitBranchConfig,
+	type GitBranchMaxLength,
+	type GitCommitConfig,
+	type GitMetricsConfig,
+	type PathDisplayConfig,
+	type PolishedTuiConfig,
+	type SeparatorStyle,
+	type UiFeaturesConfig,
+} from "./schema.js";
+
+export type ConfigRecord = Record<string, unknown>;
+
+export function isRecord(value: unknown): value is ConfigRecord {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function parseProjectRefreshIntervalMs(value: unknown): number {
+	if (value === 0) return 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		return DEFAULT_PROJECT_REFRESH_INTERVAL_MS;
+	}
+
+	const interval = Math.round(value);
+	if (interval <= 0) return 0;
+	return Math.max(MIN_PROJECT_REFRESH_INTERVAL_MS, interval);
+}
+
+function clampPercent(value: number): number {
+	return Math.max(0, Math.min(100, value));
+}
+
+export function parseContextStyle(value: unknown): ContextStyle {
+	if (value === "text" || value === "gauge" || value === "text+gauge") return value;
+	return defaultConfig.contextStyle;
+}
+
+export function isSeparatorStyle(value: unknown): value is SeparatorStyle {
+	return value === "pipe" || value === "dot" || value === "chevron" || value === "none";
+}
+
+export function parseSeparatorStyle(value: unknown): SeparatorStyle {
+	return isSeparatorStyle(value) ? value : defaultConfig.separator;
+}
+
+function parseContextThresholds(value: unknown): ContextThresholds {
+	const defaults = defaultConfig.contextThresholds;
+	if (!isRecord(value)) return { ...defaults };
+
+	const warningRaw = value.warning;
+	const errorRaw = value.error;
+	let warning =
+		typeof warningRaw === "number" && Number.isFinite(warningRaw)
+			? clampPercent(Math.round(warningRaw))
+			: defaults.warning;
+	let error =
+		typeof errorRaw === "number" && Number.isFinite(errorRaw)
+			? clampPercent(Math.round(errorRaw))
+			: defaults.error;
+	if (error < warning) {
+		const swapped = warning;
+		warning = error;
+		error = swapped;
+	}
+	return { warning, error };
+}
+
+function parsePathDisplay(value: unknown): PathDisplayConfig {
+	const defaults = defaultConfig.pathDisplay;
+	if (!isRecord(value)) return { ...defaults };
+	const mode = value.mode === "full" || value.mode === "basename" ? value.mode : defaults.mode;
+	const rawDepth = value.depth;
+	const depth =
+		typeof rawDepth === "number" && Number.isFinite(rawDepth) && rawDepth >= 0
+			? Math.min(5, Math.floor(rawDepth))
+			: defaults.depth;
+	return { mode, depth };
+}
+
+export function normalizeGitBranchMaxLength(value: unknown): GitBranchMaxLength {
+	if (value === "full") return value;
+	if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+	return defaultConfig.gitBranch.maxLength;
+}
+
+function parseGitBranchConfig(value: unknown): GitBranchConfig {
+	const defaults = defaultConfig.gitBranch;
+	if (!isRecord(value)) return { ...defaults };
+	return {
+		maxLength: normalizeGitBranchMaxLength(value.maxLength),
+	};
+}
+
+function stringValue(record: Record<string, unknown>, key: string): string | undefined {
+	const value = record[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+export function sanitizeConfigText(value: string, maxLength: number): string {
+	return stripVTControlCharacters(value.slice(0, maxLength * 4))
+		.replace(/[\u0000-\u001f\u007f-\u009f]/g, "")
+		.slice(0, maxLength);
+}
+
+function colorValue(record: Record<string, unknown>, key: string): string | undefined {
+	const value = stringValue(record, key);
+	return value !== undefined && isSupportedColorSpec(value) ? value : undefined;
+}
+
+function colorSourceValue(
+	record: Record<string, unknown>,
+	key: keyof ColorSourcesConfig,
+): ColorSource {
+	const value = record[key];
+	return value === "terminal" || value === "theme" ? value : defaultConfig.colorSources[key];
+}
+
+function booleanValue(record: Record<string, unknown>, key: keyof UiFeaturesConfig): boolean {
+	const value = record[key];
+	return typeof value === "boolean" ? value : defaultConfig.features[key];
+}
+
+function footerSegmentValue(
+	record: Record<string, unknown>,
+	key: keyof FooterSegmentsConfig,
+): boolean {
+	const value = record[key];
+	return typeof value === "boolean" ? value : defaultConfig.footerSegments[key];
+}
+
+function definedColors(
+	colors: Partial<Record<keyof PolishedTuiConfig["colors"], string | undefined>>,
+): Partial<PolishedTuiConfig["colors"]> {
+	return Object.fromEntries(
+		Object.entries(colors).filter(
+			(entry): entry is [keyof PolishedTuiConfig["colors"], string] => typeof entry[1] === "string",
+		),
+	) as Partial<PolishedTuiConfig["colors"]>;
+}
+
+function normalizeIconOverrides(record: Record<string, unknown>): Partial<IconGlyphs> {
+	return Object.fromEntries(
+		ICON_GLYPH_KEYS.flatMap((key) => {
+			const value = stringValue(record, key);
+			return value === undefined ? [] : [[key, sanitizeConfigText(value, 64)]];
+		}),
+	) as Partial<IconGlyphs>;
+}
+
+function normalizeColors(record: Record<string, unknown>): Partial<PolishedTuiConfig["colors"]> {
+	return definedColors({
+		cwd: colorValue(record, "cwd") ?? colorValue(record, "cwdText"),
+		gitBranch: colorValue(record, "gitBranch") ?? colorValue(record, "git"),
+		gitStatus: colorValue(record, "gitStatus"),
+		contextNormal: colorValue(record, "contextNormal"),
+		contextWarning: colorValue(record, "contextWarning"),
+		contextError: colorValue(record, "contextError"),
+		tokens: colorValue(record, "tokens"),
+		cost: colorValue(record, "cost"),
+		separator: colorValue(record, "separator"),
+		runtimePrefix: colorValue(record, "runtimePrefix"),
+		extensionStatus: colorValue(record, "extensionStatus"),
+		sessionDuration: colorValue(record, "sessionDuration"),
+		packageVersion: colorValue(record, "packageVersion"),
+		gitCommit: colorValue(record, "gitCommit"),
+		gitMetricsAdded: colorValue(record, "gitMetricsAdded"),
+		gitMetricsDeleted: colorValue(record, "gitMetricsDeleted"),
+		username: colorValue(record, "username"),
+		time: colorValue(record, "time"),
+		os: colorValue(record, "os"),
+		muted: colorValue(record, "muted"),
+	});
+}
+
+function normalizeColorSources(record: Record<string, unknown>): ColorSourcesConfig {
+	return { starship: colorSourceValue(record, "starship") };
+}
+
+function normalizeUiFeatures(record: Record<string, unknown>): UiFeaturesConfig {
+	return { statusLine: booleanValue(record, "statusLine") };
+}
+
+function normalizeFooterSegments(record: Record<string, unknown>): FooterSegmentsConfig {
+	return {
+		cwd: footerSegmentValue(record, "cwd"),
+		gitBranch: footerSegmentValue(record, "gitBranch"),
+		gitStatus: footerSegmentValue(record, "gitStatus"),
+		gitCounts: footerSegmentValue(record, "gitCounts"),
+		runtime: footerSegmentValue(record, "runtime"),
+		context: footerSegmentValue(record, "context"),
+		tokens: footerSegmentValue(record, "tokens"),
+		cost: footerSegmentValue(record, "cost"),
+		sessionDuration: footerSegmentValue(record, "sessionDuration"),
+		username: footerSegmentValue(record, "username"),
+		time: footerSegmentValue(record, "time"),
+		os: footerSegmentValue(record, "os"),
+		packageVersion: footerSegmentValue(record, "packageVersion"),
+		gitCommit: footerSegmentValue(record, "gitCommit"),
+		gitMetrics: footerSegmentValue(record, "gitMetrics"),
+		sessionName: footerSegmentValue(record, "sessionName"),
+		model: footerSegmentValue(record, "model"),
+		thinking: footerSegmentValue(record, "thinking"),
+		turnCount: footerSegmentValue(record, "turnCount"),
+		cacheDetails: footerSegmentValue(record, "cacheDetails"),
+		codexUsage: footerSegmentValue(record, "codexUsage"),
+		configCounts: footerSegmentValue(record, "configCounts"),
+		skills: footerSegmentValue(record, "skills"),
+		mcp: footerSegmentValue(record, "mcp"),
+		toolActivity: footerSegmentValue(record, "toolActivity"),
+		agentActivity: footerSegmentValue(record, "agentActivity"),
+	};
+}
+
+/** Clamp hashLength to Git's valid abbreviation range [4, 40]. */
+function normalizeGitHashLength(value: unknown): number {
+	const parsed = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(parsed)) return defaultConfig.gitCommit.hashLength;
+	const rounded = Math.round(parsed);
+	return Math.min(40, Math.max(4, rounded));
+}
+
+function normalizeGitCommitConfig(record: Record<string, unknown>): GitCommitConfig {
+	return {
+		hashLength: normalizeGitHashLength(record.hashLength),
+		onlyDetached:
+			typeof record.onlyDetached === "boolean"
+				? record.onlyDetached
+				: defaultConfig.gitCommit.onlyDetached,
+		showTag: typeof record.showTag === "boolean" ? record.showTag : defaultConfig.gitCommit.showTag,
+	};
+}
+
+function normalizeGitMetricsConfig(record: Record<string, unknown>): GitMetricsConfig {
+	return {
+		onlyNonzero:
+			typeof record.onlyNonzero === "boolean"
+				? record.onlyNonzero
+				: defaultConfig.gitMetrics.onlyNonzero,
+		ignoreSubmodules:
+			typeof record.ignoreSubmodules === "boolean"
+				? record.ignoreSubmodules
+				: defaultConfig.gitMetrics.ignoreSubmodules,
+	};
+}
+
+export function isExtensionStatusPlacement(value: unknown): value is ExtensionStatusPlacement {
+	return value === "off" || value === "left" || value === "middle" || value === "right";
+}
+
+export function isExtensionStatusColorMode(value: unknown): value is ExtensionStatusColorMode {
+	return value === "zentui" || value === "original";
+}
+
+function normalizeExtensionStatuses(record: Record<string, unknown>): ExtensionStatusesConfig {
+	const defaultPlacement = isExtensionStatusPlacement(record.defaultPlacement)
+		? record.defaultPlacement
+		: defaultConfig.extensionStatuses.defaultPlacement;
+	const placements = isRecord(record.placements)
+		? Object.fromEntries(
+				Object.entries(record.placements).filter(
+					(entry): entry is [string, ExtensionStatusPlacement] =>
+						isExtensionStatusPlacement(entry[1]),
+				),
+			)
+		: {};
+	const colorModes = isRecord(record.colorModes)
+		? Object.fromEntries(
+				Object.entries(record.colorModes).filter(
+					(entry): entry is [string, ExtensionStatusColorMode] =>
+						isExtensionStatusColorMode(entry[1]),
+				),
+			)
+		: {};
+
+	return {
+		defaultPlacement,
+		placements,
+		colorModes,
+	};
+}
+
+export function mergeConfig(parsed: unknown): PolishedTuiConfig {
+	const config = isRecord(parsed) ? parsed : {};
+	const iconsRecord = isRecord(config.icons) ? (config.icons as Record<string, unknown>) : {};
+	const iconMode = normalizeIconMode(iconsRecord.mode);
+	const iconOverrides = normalizeIconOverrides(iconsRecord);
+	const colors = isRecord(config.colors)
+		? normalizeColors(config.colors as Record<string, unknown>)
+		: {};
+	const colorSources = isRecord(config.colorSources)
+		? normalizeColorSources(config.colorSources as Record<string, unknown>)
+		: defaultConfig.colorSources;
+	const features = isRecord(config.features)
+		? normalizeUiFeatures(config.features as Record<string, unknown>)
+		: defaultConfig.features;
+	const footerSegments = isRecord(config.footerSegments)
+		? normalizeFooterSegments(config.footerSegments as Record<string, unknown>)
+		: defaultConfig.footerSegments;
+	const extensionStatuses = isRecord(config.extensionStatuses)
+		? normalizeExtensionStatuses(config.extensionStatuses as Record<string, unknown>)
+		: defaultConfig.extensionStatuses;
+	const gitCommit = isRecord(config.gitCommit)
+		? normalizeGitCommitConfig(config.gitCommit as Record<string, unknown>)
+		: defaultConfig.gitCommit;
+	const gitMetrics = isRecord(config.gitMetrics)
+		? normalizeGitMetricsConfig(config.gitMetrics as Record<string, unknown>)
+		: defaultConfig.gitMetrics;
+	const gitBranch = parseGitBranchConfig(config.gitBranch);
+	return {
+		projectRefreshIntervalMs: parseProjectRefreshIntervalMs(config.projectRefreshIntervalMs),
+		footerFormat: sanitizeConfigText(stringValue(config, "footerFormat") ?? "", 4096),
+		separator: parseSeparatorStyle(config.separator),
+		contextStyle: parseContextStyle(config.contextStyle),
+		contextThresholds: parseContextThresholds(config.contextThresholds),
+		pathDisplay: parsePathDisplay(config.pathDisplay),
+		gitBranch,
+		icons: resolveConfiguredIcons(iconMode, iconOverrides),
+		colors: {
+			...defaultConfig.colors,
+			...colors,
+		},
+		colorSources: { ...colorSources },
+		features: { ...features },
+		footerSegments: { ...footerSegments },
+		gitCommit,
+		gitMetrics,
+		extensionStatuses: {
+			defaultPlacement: extensionStatuses.defaultPlacement,
+			placements: { ...extensionStatuses.placements },
+			colorModes: { ...extensionStatuses.colorModes },
+		},
+	};
+}
+
+export function getExtensionStatusPlacement(
+	config: PolishedTuiConfig,
+	key: string,
+): ExtensionStatusPlacement {
+	return config.extensionStatuses.placements[key] ?? config.extensionStatuses.defaultPlacement;
+}
+
+export function getExtensionStatusColorMode(
+	config: PolishedTuiConfig,
+	key: string,
+): ExtensionStatusColorMode {
+	return config.extensionStatuses.colorModes[key] ?? DEFAULT_EXTENSION_STATUS_COLOR_MODE;
+}