osdy-pi 0.1.8 → 1.2.0

package/extensions/osdy-pi/ui.ts

@@ -20,66 +20,329 @@ import {
 import { fitBorder } from "./border.js";
 import {
 	ANIMATION_INTERVAL_MS,
+	COMPACT_HEADER_HIDDEN_COLUMNS,
 	headerWidth,
-	HEADER_FALLBACK,
 	HEADER_VARIANTS,
 	INTRO_ANIMATION_FRAMES,
 	MASCOT_GAP,
-	MASCOT_MIN_ROWS,
-	mascotWidth,
+	mascotWidthForRows,
+	scaleHeader,
+	scaleMascot,
+	STACKED_CONTENT_MAX_ROWS,
+	STACKED_HEADER_MAX_ROWS,
+	STACKED_HEADER_MIN_ROWS,
+	type ScaledHeaderArt,
 	WORKING_SPINNER_FRAMES,
 } from "./constants.js";
 import { formatPath } from "./format.js";
+import { modelLabel, usageLabel } from "./metrics.js";
 import {
-	modelLabel,
-	renderHeaderMetadata,
-	renderMetaRows,
-	usageLabel,
-} from "./metrics.js";
-import type { OsdyState, SimpleTheme, WorkingWidgetState } from "./types.js";
+	formatModelMetadata,
+	resolveActiveProfileLabel,
+	resolveEditorTitleLabel,
+} from "./profile-label.js";
 import {
+	shouldShowFooterMetadata,
+	type HeaderVariant,
+	type OsdyState,
+	type SimpleTheme,
+	type WorkingWidgetState,
+} from "./types.js";
+import {
+	compactMascotWidthBudget,
 	composeSideBySide,
 	fitCenterVisible,
 	internalLineTarget,
 	sanitizeStatusText,
 } from "./utils.js";
 
+const THINKING_THEME_TOKENS = {
+	off: "thinkingOff",
+	minimal: "thinkingMinimal",
+	low: "thinkingLow",
+	medium: "thinkingMedium",
+	high: "thinkingHigh",
+	xhigh: "thinkingXhigh",
+	max: "thinkingXhigh",
+} satisfies Record<ReturnType<ExtensionAPI["getThinkingLevel"]>, string>;
+
+const PI_LENS_STATUS_KEY = "pi-lens-lsp";
+
+function stackedHeaderRowBudget(terminalRows: number): number {
+	const contentRows = Math.min(terminalRows, STACKED_CONTENT_MAX_ROWS);
+	return Math.min(STACKED_HEADER_MAX_ROWS, Math.floor(contentRows / 3));
+}
+
+type HeaderLayout = {
+	canUseFullHeader: boolean;
+	hasMascot: boolean;
+	compactHeader: ScaledHeaderArt | undefined;
+	fullHeaderWidth: number;
+	mascotRowBudget: number;
+	mascotWidthBudget: number;
+	renderWidth: number;
+};
+
+type HeaderConfig = (typeof HEADER_VARIANTS)[HeaderVariant];
+
+function calculateHeaderLayout(
+	variantName: HeaderVariant,
+	variant: HeaderConfig,
+	width: number,
+	terminalColumns: number,
+	terminalRows: number,
+): HeaderLayout {
+	const renderWidth = Math.max(1, width);
+	const fullHeaderWidth = headerWidth(variantName);
+	const mascotArt = {
+		mascot: variant.mascot ?? [],
+		toneMap: variant.mascotMap ?? [],
+	};
+	const hasMascot = mascotArt.mascot.length > 0 && mascotArt.toneMap.length > 0;
+	const heightLimitedMascotWidth = hasMascot
+		? mascotWidthForRows(mascotArt, terminalRows)
+		: 0;
+	const canUseFullHeader =
+		hasMascot &&
+		renderWidth >= fullHeaderWidth + MASCOT_GAP + heightLimitedMascotWidth &&
+		terminalRows >= variant.header.length;
+	const canShowCompactHeader =
+		!canUseFullHeader &&
+		terminalColumns >= COMPACT_HEADER_HIDDEN_COLUMNS &&
+		renderWidth >= COMPACT_HEADER_HIDDEN_COLUMNS;
+	const compactHeaderRows = stackedHeaderRowBudget(terminalRows);
+	const compactHeader =
+		canShowCompactHeader && compactHeaderRows >= STACKED_HEADER_MIN_ROWS
+			? scaleHeader(variantName, renderWidth, compactHeaderRows)
+			: undefined;
+	const contentRowBudget = Math.min(terminalRows, STACKED_CONTENT_MAX_ROWS);
+	return {
+		canUseFullHeader,
+		hasMascot,
+		compactHeader,
+		fullHeaderWidth,
+		mascotRowBudget: canUseFullHeader
+			? terminalRows
+			: Math.max(1, contentRowBudget - (compactHeader?.header.length ?? 0)),
+		mascotWidthBudget: canUseFullHeader
+			? Math.max(1, renderWidth - fullHeaderWidth - MASCOT_GAP)
+			: compactMascotWidthBudget(renderWidth),
+		renderWidth,
+	};
+}
+
+function renderMascotLines(
+	variant: HeaderConfig,
+	mascotArt: ReturnType<typeof scaleMascot>,
+	frame: number,
+	theme: SimpleTheme,
+	animationStyle: "animated" | "static",
+): string[] {
+	return mascotArt.mascot.map((line, index) => {
+		const toneLine = mascotArt.toneMap[index];
+		if (toneLine && variant.mascotTonePalette) {
+			return animateAsciiLineWithToneMap(
+				line,
+				toneLine,
+				index,
+				frame,
+				theme,
+				variant.mascotTonePalette,
+				animationStyle,
+			);
+		}
+		return animateAsciiLine(
+			line,
+			index,
+			frame,
+			theme,
+			variant.mascotPalette.baseColor,
+			variant.mascotPalette.highlightColor,
+			variant.mascotPalette.trailColor,
+			animationStyle,
+		);
+	});
+}
+
+function renderHeaderLines(
+	variant: HeaderConfig,
+	header: readonly string[],
+	toneMap: readonly string[] | undefined,
+	sourceIndexes: readonly number[],
+	frame: number,
+	theme: SimpleTheme,
+	animationStyle: "animated" | "static",
+): string[] {
+	return header.map((line, index) => {
+		const sourceIndex = sourceIndexes[index] ?? index;
+		const toneLine = toneMap?.[index];
+		if (toneLine && variant.headerTonePalette) {
+			return animateAsciiLineWithToneMap(
+				line,
+				toneLine,
+				index,
+				frame,
+				theme,
+				variant.headerTonePalette,
+				animationStyle,
+			);
+		}
+		const palette = variant.linePalette(sourceIndex);
+		return animateAsciiLine(
+			line,
+			index,
+			frame,
+			theme,
+			palette.baseColor,
+			palette.highlightColor,
+			palette.trailColor,
+			animationStyle,
+		);
+	});
+}
+
+function renderResponsiveHeader(
+	state: OsdyState,
+	width: number,
+	terminalColumns: number,
+	terminalRows: number,
+	frame: number,
+	theme: SimpleTheme,
+	animationStyle: "animated" | "static",
+): string[] {
+	const variant = HEADER_VARIANTS[state.headerVariant];
+	const layout = calculateHeaderLayout(
+		state.headerVariant,
+		variant,
+		width,
+		terminalColumns,
+		terminalRows,
+	);
+	const mascotArt = layout.hasMascot
+		? scaleMascot(
+				{ mascot: variant.mascot ?? [], toneMap: variant.mascotMap ?? [] },
+				layout.mascotWidthBudget,
+				layout.mascotRowBudget,
+			)
+		: { mascot: [], toneMap: [] };
+	const mascotLines = renderMascotLines(
+		variant,
+		mascotArt,
+		frame,
+		theme,
+		animationStyle,
+	);
+	if (!layout.canUseFullHeader && !layout.compactHeader) {
+		return mascotLines.map((line) => fitCenterVisible(line, layout.renderWidth));
+	}
+	const headerArt = layout.compactHeader;
+	const logoLines = layout.canUseFullHeader
+		? renderHeaderLines(
+				variant,
+				variant.header,
+				variant.headerMap,
+				variant.header.map((_line, index) => index),
+				frame,
+				theme,
+				animationStyle,
+			)
+		: renderHeaderLines(
+				variant,
+				headerArt?.header ?? [],
+				headerArt?.toneMap,
+				headerArt?.sourceIndexes ?? [],
+				frame,
+				theme,
+				animationStyle,
+			);
+	if (!layout.canUseFullHeader) {
+		return [...mascotLines, ...logoLines].map((line) =>
+			fitCenterVisible(line, layout.renderWidth),
+		);
+	}
+	const scaledMascotWidth = mascotArt.mascot.reduce(
+		(maximum, line) => Math.max(maximum, visibleWidth(line)),
+		0,
+	);
+	return composeSideBySide(
+		mascotLines,
+		scaledMascotWidth,
+		logoLines,
+		layout.renderWidth,
+		layout.fullHeaderWidth,
+	);
+}
+
 class OsdyFooter implements Component {
+	private readonly pi: ExtensionAPI;
 	private readonly ctx: ExtensionContext;
+	private readonly state: OsdyState;
 	private readonly footerData: ReadonlyFooterDataProvider;
 	private readonly theme: SimpleTheme;
 
 	constructor(
+		pi: ExtensionAPI,
 		ctx: ExtensionContext,
+		state: OsdyState,
 		footerData: ReadonlyFooterDataProvider,
 		theme: SimpleTheme,
 	) {
+		this.pi = pi;
 		this.ctx = ctx;
+		this.state = state;
 		this.footerData = footerData;
 		this.theme = theme;
 	}
 
 	render(width: number): string[] {
+		const ellipsis = this.theme.fg("dim", "...");
 		let location = formatPath(this.ctx.cwd);
 		const branch = this.footerData.getGitBranch?.();
 		if (branch) location = `${location} (${branch})`;
 		const locationLine = truncateToWidth(
 			this.theme.fg("dim", location),
 			width,
-			this.theme.fg("dim", "..."),
+			ellipsis,
 		);
 		const statuses = this.footerData.getExtensionStatuses?.() ?? new Map();
-		const statusEntries = Array.from(statuses.entries());
+		const statusEntries = Array.from(statuses.entries()).filter(
+			([key]) => !this.state.smallMode || key !== PI_LENS_STATUS_KEY,
+		);
 		const statusLine = statusEntries
 			.sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
 			.map(([, text]) => sanitizeStatusText(text))
 			.join(" ");
+		if (!shouldShowFooterMetadata(this.state.editorEffective)) {
+			return statusLine
+				? [locationLine, truncateToWidth(statusLine, width, ellipsis)]
+				: [locationLine];
+		}
+		const thinkingLevel = this.pi.getThinkingLevel();
+		const thinkingLine = truncateToWidth(
+			formatModelMetadata(
+				modelLabel(this.ctx),
+				this.theme.fg(
+					THINKING_THEME_TOKENS[thinkingLevel],
+					`\u001B[1m${thinkingLevel}\u001B[22m`,
+				),
+				resolveActiveProfileLabel(),
+			),
+			width,
+			ellipsis,
+		);
+		const usageLine = truncateToWidth(
+			usageLabel(this.ctx).trim(),
+			width,
+			ellipsis,
+		);
 		return statusLine
 			? [
+					thinkingLine,
+					usageLine,
 					locationLine,
-					truncateToWidth(statusLine, width, this.theme.fg("dim", "...")),
+					truncateToWidth(statusLine, width, ellipsis),
 				]
-			: [locationLine];
+			: [thinkingLine, usageLine, locationLine];
 	}
 
 	invalidate(): void {}
@@ -97,9 +360,7 @@ class OsdyWorkingWidget implements Component {
 	render(width: number): string[] {
 		if (!this.state.active) return [];
 		const frame =
-			WORKING_SPINNER_FRAMES[
-				this.state.frame % WORKING_SPINNER_FRAMES.length
-			] ??
+			WORKING_SPINNER_FRAMES[this.state.frame % WORKING_SPINNER_FRAMES.length] ??
 			WORKING_SPINNER_FRAMES[0] ??
 			"⠋";
 		const line = `${this.theme.fg("accent", frame)} ${this.theme.fg("muted", this.state.label)}`;
@@ -110,11 +371,12 @@ class OsdyWorkingWidget implements Component {
 }
 
 export function createHeaderComponent(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
+	_pi: ExtensionAPI,
+	_ctx: ExtensionContext,
 	state: OsdyState,
 ) {
 	return (_tui: TUI, theme: SimpleTheme) => {
+		state.tui = _tui;
 		let frame = 0;
 		let animationComplete = false;
 		const animationMode = asciiAnimationMode();
@@ -133,93 +395,15 @@ export function createHeaderComponent(
 			render(width: number): string[] {
 				const animationStyle =
 					animateAscii && !animationComplete ? "animated" : "static";
-				const variant = HEADER_VARIANTS[state.headerVariant];
-				const fullHeaderWidth = headerWidth(state.headerVariant);
-				const canUseFullHeader =
-					width >= fullHeaderWidth &&
-					(variant.minRowsForFull === undefined ||
-						_tui.terminal.rows >= variant.minRowsForFull);
-				const mascotLinesSource = variant.mascot ?? [];
-				const mascotToneMap = variant.mascotMap ?? [];
-				const fullMascotWidth = mascotWidth(state.headerVariant);
-				const showMascot =
-					canUseFullHeader &&
-					mascotLinesSource.length > 0 &&
-					_tui.terminal.rows >= MASCOT_MIN_ROWS &&
-					width >= fullMascotWidth + MASCOT_GAP + fullHeaderWidth;
-				const headerLines = canUseFullHeader
-					? [...variant.header]
-					: [...(variant.fallbackHeader ?? HEADER_FALLBACK)];
-				const headerToneMap = canUseFullHeader ? (variant.headerMap ?? []) : [];
-				const metadataRows = renderHeaderMetadata(pi, ctx, state, width);
-				const logoLines = headerLines.map((line, index) => {
-					const toneLine = headerToneMap[index];
-					if (toneLine && variant.headerTonePalette) {
-						return animateAsciiLineWithToneMap(
-							line,
-							toneLine,
-							index,
-							frame,
-							theme,
-							variant.headerTonePalette,
-							animationStyle,
-						);
-					}
-					const palette = canUseFullHeader
-						? variant.linePalette(index)
-						: (variant.fallbackLinePalette?.(index) ??
-							variant.linePalette(index));
-					return animateAsciiLine(
-						line,
-						index,
-						frame,
-						theme,
-						palette.baseColor,
-						palette.highlightColor,
-						palette.trailColor,
-						animationStyle,
-					);
-				});
-				const mascotLines = mascotLinesSource.map((line, index) => {
-					const toneLine = mascotToneMap[index];
-					if (toneLine && variant.mascotTonePalette) {
-						return animateAsciiLineWithToneMap(
-							line,
-							toneLine,
-							index,
-							frame,
-							theme,
-							variant.mascotTonePalette,
-							animationStyle,
-						);
-					}
-					return animateAsciiLine(
-						line,
-						index,
-						frame,
-						theme,
-						variant.mascotPalette.baseColor,
-						variant.mascotPalette.highlightColor,
-						variant.mascotPalette.trailColor,
-						animationStyle,
-					);
-				});
-				const headerBlock = showMascot
-					? composeSideBySide(
-							mascotLines,
-							fullMascotWidth,
-							logoLines,
-							width,
-							fullHeaderWidth,
-						)
-					: logoLines.map((line) => fitCenterVisible(line, width));
-				return [
-					"",
-					...headerBlock,
-					"",
-					...renderMetaRows(metadataRows, width, theme),
-					"",
-				];
+				return renderResponsiveHeader(
+					state,
+					width,
+					Math.max(1, _tui.terminal.columns),
+					Math.max(1, _tui.terminal.rows),
+					frame,
+					theme,
+					animationStyle,
+				);
 			},
 			invalidate() {},
 			dispose() {
@@ -230,11 +414,13 @@ export function createHeaderComponent(
 }
 
 export function createFooterComponent(
+	pi: ExtensionAPI,
 	ctx: ExtensionContext,
+	state: OsdyState,
 	footerData: ReadonlyFooterDataProvider,
 	theme: SimpleTheme,
 ): Component {
-	return new OsdyFooter(ctx, footerData, theme);
+	return new OsdyFooter(pi, ctx, state, footerData, theme);
 }
 
 export function createWorkingWidgetFactory(workingState: WorkingWidgetState) {
@@ -275,10 +461,7 @@ export function createEditorComponent(
 			const internalLines = bottomIndex - 1;
 			if (internalLines < target) {
 				const blank = " ".repeat(innerWidth);
-				const added = Array.from(
-					{ length: target - internalLines },
-					() => blank,
-				);
+				const added = Array.from({ length: target - internalLines }, () => blank);
 				lines.splice(bottomIndex, 0, ...added);
 				bottomIndex += added.length;
 			}
@@ -286,12 +469,13 @@ export function createEditorComponent(
 			const side = borderColor("│");
 			for (let index = 1; index < bottomIndex; index += 1) {
 				const content = truncateToWidth(lines[index] ?? "", innerWidth, "");
-				const padding = " ".repeat(
-					Math.max(0, innerWidth - visibleWidth(content)),
-				);
+				const padding = " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
 				lines[index] = `${side}${content}${padding}${side}`;
 			}
-			const topLeft = ctx.ui.theme.fg("mdLink", " Osdy-Pi ");
+			const topLeft = ctx.ui.theme.fg(
+				"mdLink",
+				` ${resolveEditorTitleLabel(resolveActiveProfileLabel())} `,
+			);
 			const topRight = ctx.ui.theme.fg(
 				"muted",
 				` ${modelLabel(ctx)} · think ${pi.getThinkingLevel()} `,

package/extensions/osdy-pi/utils.ts

@@ -1,6 +1,7 @@
 import type { TUI } from "@earendil-works/pi-tui";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { MASCOT_GAP } from "./constants.js";
+import { headerWidth, HEADER_VARIANTS, MASCOT_GAP } from "./constants.js";
+import type { HeaderVariant } from "./types.js";
 
 export function sanitizeStatusText(text: string): string {
 	return text
@@ -49,6 +50,47 @@ export function composeSideBySide(
 	return composedRows;
 }
 
+export function isSmallResponsiveMode(
+	variant: HeaderVariant,
+	columns: number,
+	rows: number,
+): boolean {
+	const header = HEADER_VARIANTS[variant];
+	const hasMascot =
+		(header.mascot?.length ?? 0) > 0 && (header.mascotMap?.length ?? 0) > 0;
+	return (
+		!hasMascot ||
+		columns < headerWidth(variant) + MASCOT_GAP + 1 ||
+		rows < header.header.length
+	);
+}
+
+// In mascot-only mode, phone-sized terminals use roughly four-fifths of the
+// available width while wider compact terminals gradually recover more detail.
+const COMPACT_MASCOT_BASE_RATIO = 0.7938;
+const COMPACT_MASCOT_MAX_RATIO = 0.87318;
+const COMPACT_MASCOT_RATIO_RAMP_START_COLUMNS = 60;
+const COMPACT_MASCOT_RATIO_RAMP_COLUMNS = 40;
+
+export function compactMascotWidthBudget(availableWidth: number): number {
+	const normalizedWidth = Math.max(1, Math.floor(availableWidth));
+	const ratioProgress = Math.max(
+		0,
+		Math.min(
+			1,
+			(normalizedWidth - COMPACT_MASCOT_RATIO_RAMP_START_COLUMNS) /
+				COMPACT_MASCOT_RATIO_RAMP_COLUMNS,
+		),
+	);
+	const widthRatio =
+		COMPACT_MASCOT_BASE_RATIO +
+		(COMPACT_MASCOT_MAX_RATIO - COMPACT_MASCOT_BASE_RATIO) * ratioProgress;
+	return Math.min(
+		normalizedWidth,
+		Math.max(1, Math.round(normalizedWidth * widthRatio)),
+	);
+}
+
 export function internalLineTarget(tui: TUI): number {
 	return tui.terminal.rows < 18 ? 3 : 4;
 }

package/extensions/osdy-pi/working-tree.ts

@@ -11,6 +11,8 @@ import type {
 	WorkingTreeFileSummary,
 	WorkingTreeSnapshot,
 	WorkingTreeState,
+	WorkingWidgetState,
+	WorkingTreePlacement,
 } from "./types.js";
 import { fitCenterVisible } from "./utils.js";
 
@@ -128,13 +130,16 @@ async function hydrateUntrackedStats(
 ): Promise<void> {
 	await Promise.all(
 		Array.from(fileMap.values()).map(async (file) => {
-			if (!file.untracked || file.additions > 0 || file.removals > 0) return;
+			if (!file.untracked || file.additions > 0 || file.removals > 0) {
+				return undefined;
+			}
 			try {
 				const content = await readFile(resolve(ctx.cwd, file.path), "utf8");
 				file.additions = content.length === 0 ? 0 : content.split("\n").length;
 			} catch {
 				file.additions = 1;
 			}
+			return undefined;
 		}),
 	);
 }
@@ -231,8 +236,8 @@ function renderSummaryLine(
 	}
 	const parts = [
 		theme.fg("mdLink", `Git changes · ${snapshot.totalFiles} files`),
-		theme.fg("success", `+${snapshot.additions}`),
-		theme.fg("error", `-${snapshot.removals}`),
+		theme.fg("toolDiffAdded", `+${snapshot.additions}`),
+		theme.fg("toolDiffRemoved", `-${snapshot.removals}`),
 		theme.fg("mdLink", `staged ${snapshot.stagedFiles}`),
 		theme.fg("mdLink", `unstaged ${snapshot.unstagedFiles}`),
 	];
@@ -249,7 +254,7 @@ class WorkingTreeWidget implements Component {
 	) {}
 
 	render(width: number): string[] {
-		if (!this.state.enabled) return [];
+		if (!this.state.enabled || !this.state.visible) return [];
 		if (this.state.loading) {
 			return [
 				fitCenterVisible(
@@ -282,9 +287,23 @@ class WorkingTreeWidget implements Component {
 	invalidate(): void {}
 }
 
-export function createWorkingTreeWidgetFactory(state: WorkingTreeState) {
+export function createWorkingTreeWidgetFactory(
+	state: WorkingTreeState,
+	workingState: WorkingWidgetState,
+	placement: WorkingTreePlacement,
+) {
 	return (tui: TUI, theme: SimpleTheme): Component => {
 		state.tui = tui;
-		return new WorkingTreeWidget(state, theme);
+		const summary = new WorkingTreeWidget(state, theme);
+		return {
+			render(width: number): string[] {
+				const lines = summary.render(width);
+				if (lines.length === 0) return [];
+				const needsLeadingBlank =
+					placement === "belowEditor" || workingState.active;
+				return [...(needsLeadingBlank ? [""] : []), ...lines, ""];
+			},
+			invalidate(): void {},
+		};
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "osdy-pi",
-	"version": "0.1.8",
+	"version": "1.2.0",
 	"description": "Osdy Pi package: themes, header, and custom editor for Pi.",
 	"license": "MIT",
 	"type": "module",
@@ -10,23 +10,40 @@
 		"theme",
 		"extension"
 	],
+	"bin": {
+		"osdy-pi": "bin/osdy-pi.mjs"
+	},
 	"scripts": {
 		"typecheck": "tsc --noEmit",
 		"lint": "eslint .",
+		"test": "node --test --experimental-strip-types extensions/osdy-pi/*.test.ts && node --test scripts/*.test.mjs",
 		"pi:dev": "node ./scripts/pi-dev.mjs"
 	},
 	"files": [
 		"README.md",
 		"LICENSE",
+		"bin",
+		"scripts/osdy-pi-account-profiles.mjs",
 		"themes",
 		"extensions",
 		"mapche1.png"
 	],
 	"pi": {
 		"themes": [
+			"./themes/osdy-pi-new.json",
 			"./themes/osdy-pi-dark.json",
-			"./themes/osdy-pi-light.json",
-			"./themes/osdy-pi-simple.json"
+			"./themes/osdy-pi-sexy.json",
+			"./themes/osdy-pi-tokyo-night.json",
+			"./themes/osdy-pi-kanagawa-wave.json",
+			"./themes/osdy-pi-kanagawa-dragon.json",
+			"./themes/osdy-pi-kanagawa-lotus.json",
+			"./themes/osdy-pi-dracula.json",
+			"./themes/osdy-pi-catppuccin-latte.json",
+			"./themes/osdy-pi-catppuccin-frappe.json",
+			"./themes/osdy-pi-catppuccin-macchiato.json",
+			"./themes/osdy-pi-catppuccin-mocha.json",
+			"./themes/osdy-pi-matrix.json",
+			"./themes/osdy-pi-lucent-orange.json"
 		],
 		"extensions": [
 			"./extensions/osdy-pi.ts"
@@ -38,8 +55,8 @@
 		"@earendil-works/pi-tui": "*"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-coding-agent": "^0.74.1",
-		"@earendil-works/pi-tui": "^0.74.1",
+		"@earendil-works/pi-coding-agent": "^0.84.4",
+		"@earendil-works/pi-tui": "^0.84.4",
 		"@eslint/js": "^9.39.1",
 		"@types/node": "^25.8.0",
 		"eslint": "^9.39.1",