osdy-pi 1.2.0 → 1.3.0

package/extensions/osdy-pi/editor-settings.ts

@@ -1,9 +1,20 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import type { EditorMode, GlobalEditorSettings } from "./types.js";
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+import { HEADER_VARIANT_CHOICES, MASCOT_CHOICES } from "./types.ts";
+import type {
+	EditorMode,
+	GlobalEditorSettings,
+	HeaderVariant,
+	MascotChoice,
+} from "./types.js";
 
-const SUPPORTED_EDITOR_MODES = ["auto", "extended", "simple"] as const satisfies readonly EditorMode[];
+const SUPPORTED_EDITOR_MODES = [
+	"auto",
+	"extended",
+	"simple",
+] as const satisfies readonly EditorMode[];
 const DEFAULT_EDITOR_MODE: EditorMode = "auto";
 const EDITOR_SETTINGS_VERSION = 1;
 const EDITOR_SETTINGS_FILE_NAME = "settings.json";
@@ -25,13 +36,34 @@ function getAgentDir(): string {
 function createDefaultEditorSettings(): GlobalEditorSettings {
 	return {
 		version: EDITOR_SETTINGS_VERSION,
+		enabled: true,
 		editorMode: DEFAULT_EDITOR_MODE,
 		workingTreeEnabled: true,
+		headerVariant: "osdy-theme",
+		mascot: "current",
 	};
 }
 
 function isEditorMode(value: unknown): value is EditorMode {
-	return typeof value === "string" && SUPPORTED_EDITOR_MODES.some((mode) => mode === value);
+	return (
+		typeof value === "string" &&
+		SUPPORTED_EDITOR_MODES.some((mode) => mode === value)
+	);
+}
+
+function normalizeHeaderVariant(value: unknown): HeaderVariant {
+	return typeof value === "string" &&
+		HEADER_VARIANT_CHOICES.includes(value as HeaderVariant)
+		? (value as HeaderVariant)
+		: "osdy-theme";
+}
+
+function normalizeMascotChoice(value: unknown): MascotChoice {
+	if (value === "raccoon") return "bts";
+	return typeof value === "string" &&
+		MASCOT_CHOICES.includes(value as MascotChoice)
+		? (value as MascotChoice)
+		: "current";
 }
 
 export function normalizeEditorSettings(value: unknown): GlobalEditorSettings {
@@ -44,6 +76,8 @@ export function normalizeEditorSettings(value: unknown): GlobalEditorSettings {
 	}
 	return {
 		version: EDITOR_SETTINGS_VERSION,
+		enabled:
+			typeof recordValue.enabled === "boolean" ? recordValue.enabled : true,
 		editorMode: isEditorMode(recordValue.editorMode)
 			? recordValue.editorMode
 			: DEFAULT_EDITOR_MODE,
@@ -51,6 +85,8 @@ export function normalizeEditorSettings(value: unknown): GlobalEditorSettings {
 			typeof recordValue.workingTreeEnabled === "boolean"
 				? recordValue.workingTreeEnabled
 				: true,
+		headerVariant: normalizeHeaderVariant(recordValue.headerVariant),
+		mascot: normalizeMascotChoice(recordValue.mascot),
 	};
 }
 

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

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { registerHooks } from "node:module";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+import type { ContextUsageSource } from "./metrics.ts";
+
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (
+			specifier.startsWith(".") &&
+			specifier.endsWith(".js") &&
+			context.parentURL?.endsWith(".ts")
+		) {
+			const sourceUrl = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+			if (existsSync(fileURLToPath(sourceUrl))) {
+				return { shortCircuit: true, url: sourceUrl.href };
+			}
+		}
+		return nextResolve(specifier, context);
+	},
+	load(url, context, nextLoad) {
+		if (url.endsWith(".ts")) {
+			return {
+				format: "module",
+				shortCircuit: true,
+				source: ts.transpileModule(readFileSync(fileURLToPath(url), "utf8"), {
+					compilerOptions: {
+						module: ts.ModuleKind.ESNext,
+						target: ts.ScriptTarget.ES2022,
+					},
+				}).outputText,
+			};
+		}
+		return nextLoad(url, context);
+	},
+});
+
+const { contextUsageData } = await import("./metrics.js");
+
+function createContext(percent: number | undefined): ContextUsageSource {
+	return {
+		getContextUsage: () =>
+			percent === undefined ? undefined : { percent, contextWindow: 200_000 },
+		sessionManager: {
+			getEntries: () => [
+				{
+					type: "message",
+					message: {
+						role: "assistant",
+						usage: {
+							input: 1_500,
+							output: 2_500_000,
+							cacheRead: 12,
+							cacheWrite: 34,
+							cost: { total: 1.23456 },
+						},
+					},
+				},
+			],
+		},
+	};
+}
+
+void test("returns presentation-neutral usage totals and context data", () => {
+	assert.deepEqual(contextUsageData(createContext(30)), {
+		input: 1_500,
+		output: 2_500_000,
+		cacheRead: 12,
+		cacheWrite: 34,
+		cost: 1.23456,
+		percent: 30,
+		contextWindow: 200_000,
+	});
+});
+
+void test("uses the model window when context usage omits it", () => {
+	const context = createContext(30);
+	context.getContextUsage = () => ({ percent: 30 });
+	context.model = { contextWindow: 272_000 };
+	assert.equal(contextUsageData(context).contextWindow, 272_000);
+});
+
+void test("represents unavailable context usage and window without formatting", () => {
+	assert.deepEqual(contextUsageData(createContext(undefined)), {
+		input: 1_500,
+		output: 2_500_000,
+		cacheRead: 12,
+		cacheWrite: 34,
+		cost: 1.23456,
+		percent: undefined,
+		contextWindow: undefined,
+	});
+});

package/extensions/osdy-pi/metrics.ts

@@ -34,6 +34,44 @@ function getCacheLabel(totals: UsageTotals): string {
 		: "";
 }
 
+export type ContextUsageData = {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+	percent: number | undefined;
+	contextWindow: number | undefined;
+};
+
+export type ContextUsageSource = {
+	getContextUsage():
+		| {
+				percent: number | null;
+				contextWindow?: number | null;
+		  }
+		| undefined;
+	model?:
+		| {
+				contextWindow?: number | null;
+		  }
+		| undefined;
+	sessionManager: {
+		getEntries(): readonly unknown[];
+	};
+};
+
+export function contextUsageData(ctx: ContextUsageSource): ContextUsageData {
+	const totals = collectUsageTotals(ctx);
+	const context = ctx.getContextUsage();
+	return {
+		...totals,
+		percent: context?.percent ?? undefined,
+		contextWindow:
+			context?.contextWindow ?? ctx.model?.contextWindow ?? undefined,
+	};
+}
+
 export function usageLabel(ctx: ExtensionContext): string {
 	const totals = collectUsageTotals(ctx);
 	const cacheText = getCacheLabel(totals);
@@ -74,7 +112,7 @@ function mergeUsageTotals(
 	};
 }
 
-function collectUsageTotals(ctx: ExtensionContext): UsageTotals {
+function collectUsageTotals(ctx: ContextUsageSource): UsageTotals {
 	return ctx.sessionManager.getEntries().reduce<UsageTotals>((totals, entry) => {
 		return isAssistantSessionEntry(entry)
 			? mergeUsageTotals(totals, entry)

package/extensions/osdy-pi/profile-label.ts

@@ -1,4 +1,4 @@
-const PROFILE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,62})$/;
+const PROFILE_NAME = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,62})$/;
 const RESERVED_PROFILE_NAMES = new Set(["default", "profiles", "auth.json"]);
 
 export function resolveActiveProfileLabel(
@@ -7,7 +7,7 @@ export function resolveActiveProfileLabel(
 	const profileName = env.OSDY_PI_PROFILE_NAME;
 	return typeof profileName === "string" &&
 		PROFILE_NAME.test(profileName) &&
-		!RESERVED_PROFILE_NAMES.has(profileName)
+		!RESERVED_PROFILE_NAMES.has(profileName.toLowerCase())
 		? profileName
 		: undefined;
 }

package/extensions/osdy-pi/runtime-helpers.test.ts

@@ -1,12 +1,131 @@
 import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { registerHooks } from "node:module";
 import test from "node:test";
+import { fileURLToPath } from "node:url";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import ts from "typescript";
 import {
 	DEFAULT_EDITOR_MODE,
 	EDITOR_MODES,
 	resolveEffectiveEditorMode,
-// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+	type OsdyState,
+	type WorkingTreeState,
+	type WorkingWidgetState,
+	// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
 } from "./types.ts";
 
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (
+			specifier.startsWith(".") &&
+			specifier.endsWith(".js") &&
+			context.parentURL?.endsWith(".ts")
+		) {
+			const sourceUrl = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+			if (existsSync(fileURLToPath(sourceUrl))) {
+				return { shortCircuit: true, url: sourceUrl.href };
+			}
+		}
+		return nextResolve(specifier, context);
+	},
+	load(url, context, nextLoad) {
+		if (url.endsWith(".ts")) {
+			const source = readFileSync(fileURLToPath(url), "utf8");
+			return {
+				format: "module",
+				shortCircuit: true,
+				source: ts.transpileModule(source, {
+					compilerOptions: {
+						module: ts.ModuleKind.ESNext,
+						target: ts.ScriptTarget.ES2022,
+					},
+				}).outputText,
+			};
+		}
+		return nextLoad(url, context);
+	},
+});
+
+const {
+	disableOsdyPi,
+	mountOsdyEditor,
+	mountOsdyUi,
+	syncWorkingTreeWidget,
+	unmountOsdyEditor,
+} = await import(
+	// @ts-expect-error The test hook maps production .js specifiers to TypeScript sources.
+	"./runtime-helpers.ts"
+);
+
+const GENTLE_SHELL_CHANGES_WIDGET_KEY = "gentle-shell-changes";
+const WORKING_TREE_WIDGET_KEY = "osdy-pi-working-tree";
+
+type WidgetCall = {
+	key: string;
+	factory: unknown;
+	options: unknown;
+};
+
+function createState(overrides: Partial<OsdyState> = {}): OsdyState {
+	return {
+		codexUsage: { kind: "idle" },
+		enabled: true,
+		editorEffective: false,
+		editorMode: EDITOR_MODES.SIMPLE,
+		fallbackEditorFactory: undefined,
+		headerVariant: "osdy-theme",
+		mascot: "current",
+		smallMode: false,
+		tui: undefined,
+		workingTreeEnabled: true,
+		workingTreePlacement: "aboveEditor",
+		...overrides,
+	};
+}
+
+function createWorkingTreeState(): WorkingTreeState {
+	return {
+		enabled: true,
+		loading: false,
+		visible: true,
+		snapshot: null,
+		error: undefined,
+		tui: undefined,
+	};
+}
+
+function createWorkingState(): WorkingWidgetState {
+	return {
+		active: false,
+		label: "Working...",
+		frame: 0,
+		timer: undefined,
+		tui: undefined,
+	};
+}
+
+function createContext(widgetCalls: WidgetCall[], editorCalls: unknown[]) {
+	return {
+		hasUI: true,
+		ui: {
+			setEditorComponent(component: unknown): void {
+				editorCalls.push(component);
+			},
+			notify(): void {},
+			setFooter(): void {},
+			setHeader(): void {},
+			setWorkingVisible(): void {},
+			setWidget(key: string, factory: unknown, options?: unknown): void {
+				widgetCalls.push({ key, factory, options });
+			},
+		},
+	} as unknown as ExtensionContext;
+}
+
 void test("auto editor mode is the default and small terminals use the native editor", () => {
 	assert.equal(DEFAULT_EDITOR_MODE, EDITOR_MODES.AUTO);
 	assert.equal(
@@ -24,3 +143,103 @@ void test("auto editor mode is the default and small terminals use the native ed
 		"simple",
 	);
 });
+
+void test("unmountOsdyEditor removes the custom editor without restoring the fallback", () => {
+	const editorCalls: unknown[] = [];
+	const ctx = createContext([], editorCalls);
+
+	unmountOsdyEditor(ctx);
+
+	assert.deepEqual(editorCalls, [undefined]);
+});
+
+void test("disableOsdyPi restores the captured editor and Osdy can reclaim it", () => {
+	const editorCalls: unknown[] = [];
+	const ctx = createContext([], editorCalls);
+	const fallbackEditorFactory =
+		(() => ({})) as unknown as OsdyState["fallbackEditorFactory"];
+	const state = createState({ fallbackEditorFactory });
+
+	disableOsdyPi(ctx, state);
+	mountOsdyEditor({} as ExtensionAPI, ctx, state);
+
+	assert.equal(editorCalls[0], fallbackEditorFactory);
+	assert.equal(typeof editorCalls[1], "function");
+	assert.notEqual(editorCalls[1], fallbackEditorFactory);
+});
+
+void test("syncWorkingTreeWidget unmounts a disabled widget", () => {
+	const widgetCalls: WidgetCall[] = [];
+	const ctx = createContext(widgetCalls, []);
+
+	syncWorkingTreeWidget(
+		ctx,
+		createState({ workingTreeEnabled: false }),
+		createWorkingState(),
+		createWorkingTreeState(),
+	);
+
+	assert.deepEqual(widgetCalls, [
+		{ key: WORKING_TREE_WIDGET_KEY, factory: undefined, options: undefined },
+	]);
+});
+
+void test("syncWorkingTreeWidget remounts an enabled widget", () => {
+	const widgetCalls: WidgetCall[] = [];
+	const ctx = createContext(widgetCalls, []);
+
+	syncWorkingTreeWidget(
+		ctx,
+		createState({ workingTreePlacement: "belowEditor" }),
+		createWorkingState(),
+		createWorkingTreeState(),
+	);
+
+	assert.equal(widgetCalls.length, 1);
+	assert.equal(widgetCalls[0]?.key, WORKING_TREE_WIDGET_KEY);
+	assert.equal(typeof widgetCalls[0]?.factory, "function");
+	assert.deepEqual(widgetCalls[0]?.options, { placement: "belowEditor" });
+});
+
+void test("initial UI mount clears Gentle's changed-files widget without affecting Osdy's working tree", () => {
+	const widgetCalls: WidgetCall[] = [];
+	const ctx = createContext(widgetCalls, []);
+
+	mountOsdyUi(
+		{} as ExtensionAPI,
+		ctx,
+		createState(),
+		createWorkingState(),
+		createWorkingTreeState(),
+	);
+
+	assert.deepEqual(widgetCalls[0], {
+		key: GENTLE_SHELL_CHANGES_WIDGET_KEY,
+		factory: undefined,
+		options: undefined,
+	});
+	assert.equal(widgetCalls[1]?.key, "osdy-pi-working");
+	assert.equal(widgetCalls[2]?.key, WORKING_TREE_WIDGET_KEY);
+});
+
+void test("initial UI mount leaves a persisted disabled working tree unmounted", () => {
+	const widgetCalls: WidgetCall[] = [];
+	const editorCalls: unknown[] = [];
+	const ctx = createContext(widgetCalls, editorCalls);
+
+	mountOsdyUi(
+		{} as ExtensionAPI,
+		ctx,
+		createState({ workingTreeEnabled: false }),
+		createWorkingState(),
+		createWorkingTreeState(),
+	);
+
+	const workingTreeCalls = widgetCalls.filter(
+		(call) => call.key === WORKING_TREE_WIDGET_KEY,
+	);
+	assert.deepEqual(workingTreeCalls, [
+		{ key: WORKING_TREE_WIDGET_KEY, factory: undefined, options: undefined },
+	]);
+	assert.deepEqual(editorCalls, []);
+});

package/extensions/osdy-pi/runtime-helpers.ts

@@ -20,10 +20,18 @@ import {
 import { createWorkingTreeWidgetFactory } from "./working-tree.js";
 import { isSmallResponsiveMode } from "./utils.js";
 
+const GENTLE_SHELL_CHANGES_WIDGET_KEY = "gentle-shell-changes";
 const RESPONSIVE_WATCH_INTERVAL_MS = 150;
 
-function workingTreeEffective(state: OsdyState): boolean {
-	return state.workingTreeEnabled && !state.smallMode && state.enabled;
+export function clearGentleShellChangesWidget(ctx: ExtensionContext): void {
+	ctx.ui.setWidget(GENTLE_SHELL_CHANGES_WIDGET_KEY, undefined);
+}
+
+function workingTreeEffective(
+	state: OsdyState,
+): "visible" | "hidden" | "unmounted" {
+	if (!state.enabled || !state.workingTreeEnabled) return "unmounted";
+	return state.smallMode ? "hidden" : "visible";
 }
 
 function desiredSmallMode(state: OsdyState): boolean {
@@ -51,7 +59,7 @@ export function reconcileResponsiveUi(
 		resolveEffectiveEditorMode(state.editorMode, state.smallMode) === "extended";
 	if (state.editorEffective !== editorEffective) {
 		state.editorEffective = editorEffective;
-		if (editorEffective) mountOsdyEditor(pi, ctx);
+		if (editorEffective) mountOsdyEditor(pi, ctx, state);
 		else unmountOsdyEditor(ctx);
 	}
 	const treeVisible = state.workingTreeEnabled && !state.smallMode;
@@ -88,14 +96,39 @@ export function createResponsiveCoordinator(
 	};
 }
 
-export function mountOsdyEditor(pi: ExtensionAPI, ctx: ExtensionContext): void {
-	ctx.ui.setEditorComponent(createEditorComponent(pi, ctx));
+export function mountOsdyEditor(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+): void {
+	ctx.ui.setEditorComponent(createEditorComponent(pi, ctx, state));
 }
 
 export function unmountOsdyEditor(ctx: ExtensionContext): void {
 	ctx.ui.setEditorComponent(undefined);
 }
 
+export function syncWorkingTreeWidget(
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	workingTreeState: WorkingTreeState,
+): void {
+	if (!state.enabled || !state.workingTreeEnabled) {
+		ctx.ui.setWidget(WORKING_TREE_WIDGET_KEY, undefined);
+		return;
+	}
+	ctx.ui.setWidget(
+		WORKING_TREE_WIDGET_KEY,
+		createWorkingTreeWidgetFactory(
+			workingTreeState,
+			workingState,
+			state.workingTreePlacement,
+		),
+		{ placement: state.workingTreePlacement },
+	);
+}
+
 export function mountOsdyUi(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
@@ -109,20 +142,13 @@ export function mountOsdyUi(
 		return createFooterComponent(pi, ctx, state, footerData, theme);
 	});
 	ctx.ui.setWorkingVisible(false);
+	clearGentleShellChangesWidget(ctx);
 	ctx.ui.setWidget(
 		WORKING_WIDGET_KEY,
 		createWorkingWidgetFactory(workingState),
 		{ placement: "aboveEditor" },
 	);
-	ctx.ui.setWidget(
-		WORKING_TREE_WIDGET_KEY,
-		createWorkingTreeWidgetFactory(
-			workingTreeState,
-			workingState,
-			state.workingTreePlacement,
-		),
-		{ placement: state.workingTreePlacement },
-	);
+	syncWorkingTreeWidget(ctx, state, workingState, workingTreeState);
 	reconcileResponsiveUi(pi, ctx, state, workingTreeState);
 }
 
@@ -132,17 +158,15 @@ export function applyOsdyPi(
 	state: OsdyState,
 	workingState: WorkingWidgetState,
 	workingTreeState: WorkingTreeState,
-	notify = false,
 ): void {
 	if (!ctx.hasUI) return;
 	mountOsdyUi(pi, ctx, state, workingState, workingTreeState);
-	if (notify) ctx.ui.notify("osdy-pi enabled", "info");
 }
 
 export function disableOsdyPi(ctx: ExtensionContext, state: OsdyState): void {
 	if (!ctx.hasUI) return;
 	ctx.ui.setHeader(undefined);
-	ctx.ui.setEditorComponent(undefined);
+	ctx.ui.setEditorComponent(state.fallbackEditorFactory);
 	ctx.ui.setFooter(undefined);
 	ctx.ui.setWidget(WORKING_WIDGET_KEY, undefined);
 	ctx.ui.setWidget(WORKING_TREE_WIDGET_KEY, undefined);
@@ -150,12 +174,11 @@ export function disableOsdyPi(ctx: ExtensionContext, state: OsdyState): void {
 	state.editorEffective = false;
 	state.smallMode = false;
 	state.tui = undefined;
-	ctx.ui.notify("osdy-pi disabled", "info");
 }
 
 export function notifyStatus(ctx: ExtensionContext, state: OsdyState): void {
 	ctx.ui.notify(
-		`osdy-pi ${state.enabled ? "enabled" : "disabled"} · editor ${state.editorMode}, effective ${state.editorEffective ? "extended" : "simple/native"} · working-tree desired ${state.workingTreeEnabled ? "on" : "off"}, effective ${workingTreeEffective(state) ? "visible" : "hidden"} · widget ${state.workingTreePlacement === "aboveEditor" ? "top" : "bottom"} · theme ${ctx.ui.theme.name ?? "unknown"} · style ${state.headerVariant} · animation ${asciiAnimationMode()} · ${modelLabel(ctx)} · ${usageLabel(ctx).trim()}`,
+		`osdy-pi ${state.enabled ? "enabled" : "disabled"} · editor ${state.editorMode}, effective ${state.editorEffective ? "extended" : "simple/native"} · working-tree desired ${state.workingTreeEnabled ? "on" : "off"}, effective ${workingTreeEffective(state)} · widget ${state.workingTreePlacement === "aboveEditor" ? "top" : "bottom"} · theme ${ctx.ui.theme.name ?? "unknown"} · style ${state.headerVariant} · animation ${asciiAnimationMode()} · ${modelLabel(ctx)} · ${usageLabel(ctx).trim()}`,
 		"info",
 	);
 }