osdy-pi 0.1.8 → 1.2.0

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

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	DEFAULT_EDITOR_MODE,
+	EDITOR_MODES,
+	resolveEffectiveEditorMode,
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+} from "./types.ts";
+
+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(
+		resolveEffectiveEditorMode(DEFAULT_EDITOR_MODE, false),
+		"extended",
+	);
+	assert.equal(resolveEffectiveEditorMode(DEFAULT_EDITOR_MODE, true), "simple");
+	assert.equal(resolveEffectiveEditorMode(EDITOR_MODES.SIMPLE, false), "simple");
+	assert.equal(
+		resolveEffectiveEditorMode(EDITOR_MODES.EXTENDED, false),
+		"extended",
+	);
+	assert.equal(
+		resolveEffectiveEditorMode(EDITOR_MODES.EXTENDED, true),
+		"simple",
+	);
+});

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

@@ -3,16 +3,13 @@ import type {
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { asciiAnimationMode } from "./animation.js";
-import {
-	THEME_NAME,
-	WORKING_TREE_WIDGET_KEY,
-	WORKING_WIDGET_KEY,
-} from "./constants.js";
+import { WORKING_TREE_WIDGET_KEY, WORKING_WIDGET_KEY } from "./constants.js";
 import { modelLabel, usageLabel } from "./metrics.js";
-import type {
-	OsdyState,
-	WorkingTreeState,
-	WorkingWidgetState,
+import {
+	resolveEffectiveEditorMode,
+	type OsdyState,
+	type WorkingTreeState,
+	type WorkingWidgetState,
 } from "./types.js";
 import {
 	createEditorComponent,
@@ -21,39 +18,82 @@ import {
 	createWorkingWidgetFactory,
 } from "./ui.js";
 import { createWorkingTreeWidgetFactory } from "./working-tree.js";
+import { isSmallResponsiveMode } from "./utils.js";
 
-function shouldRememberTheme(
-	previousThemeName: string | undefined,
-	currentTheme: string | undefined,
-): currentTheme is string {
-	return (
-		previousThemeName === undefined &&
-		currentTheme !== undefined &&
-		currentTheme !== THEME_NAME
-	);
+const RESPONSIVE_WATCH_INTERVAL_MS = 150;
+
+function workingTreeEffective(state: OsdyState): boolean {
+	return state.workingTreeEnabled && !state.smallMode && state.enabled;
+}
+
+function desiredSmallMode(state: OsdyState): boolean {
+	const tui = state.tui;
+	return tui
+		? isSmallResponsiveMode(
+				state.headerVariant,
+				tui.terminal.columns,
+				tui.terminal.rows,
+			)
+		: false;
 }
 
-export function rememberPreviousTheme(
+export function reconcileResponsiveUi(
+	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	state: OsdyState,
+	workingTreeState: WorkingTreeState,
 ): void {
-	const currentTheme = ctx.ui.theme.name;
-	if (shouldRememberTheme(state.previousThemeName, currentTheme)) {
-		state.previousThemeName = currentTheme;
+	if (!ctx.hasUI || !state.enabled) return;
+	const nextSmallMode = desiredSmallMode(state);
+	const smallModeChanged = nextSmallMode !== state.smallMode;
+	state.smallMode = nextSmallMode;
+	const editorEffective =
+		resolveEffectiveEditorMode(state.editorMode, state.smallMode) === "extended";
+	if (state.editorEffective !== editorEffective) {
+		state.editorEffective = editorEffective;
+		if (editorEffective) mountOsdyEditor(pi, ctx);
+		else unmountOsdyEditor(ctx);
 	}
+	const treeVisible = state.workingTreeEnabled && !state.smallMode;
+	if (workingTreeState.visible !== treeVisible) {
+		workingTreeState.visible = treeVisible;
+		if (!smallModeChanged) workingTreeState.tui?.requestRender();
+	}
+	if (smallModeChanged) (state.tui ?? workingTreeState.tui)?.requestRender();
 }
 
-export function applyOsdyTheme(ctx: ExtensionContext): void {
-	const osdyTheme = ctx.ui.getTheme(THEME_NAME);
-	const themeResult = osdyTheme
-		? ctx.ui.setTheme(osdyTheme)
-		: ctx.ui.setTheme(THEME_NAME);
-	if (!themeResult.success) {
-		ctx.ui.notify(
-			`osdy-pi theme failed: ${themeResult.error ?? "unknown error"}`,
-			"warning",
-		);
-	}
+export function createResponsiveCoordinator(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingTreeState: WorkingTreeState,
+) {
+	let timer: ReturnType<typeof setInterval> | undefined;
+	return {
+		start(): void {
+			if (timer) return;
+			reconcileResponsiveUi(pi, ctx, state, workingTreeState);
+			timer = setInterval(() => {
+				if (!state.enabled) return;
+				const nextSmallMode = desiredSmallMode(state);
+				if (nextSmallMode !== state.smallMode) {
+					reconcileResponsiveUi(pi, ctx, state, workingTreeState);
+				}
+			}, RESPONSIVE_WATCH_INTERVAL_MS);
+		},
+		stop(): void {
+			if (timer) clearInterval(timer);
+			timer = undefined;
+		},
+	};
+}
+
+export function mountOsdyEditor(pi: ExtensionAPI, ctx: ExtensionContext): void {
+	ctx.ui.setEditorComponent(createEditorComponent(pi, ctx));
+}
+
+export function unmountOsdyEditor(ctx: ExtensionContext): void {
+	ctx.ui.setEditorComponent(undefined);
 }
 
 export function mountOsdyUi(
@@ -64,9 +104,10 @@ export function mountOsdyUi(
 	workingTreeState: WorkingTreeState,
 ): void {
 	ctx.ui.setHeader(createHeaderComponent(pi, ctx, state));
-	ctx.ui.setFooter((_tui, theme, footerData) =>
-		createFooterComponent(ctx, footerData, theme),
-	);
+	ctx.ui.setFooter((tui, theme, footerData) => {
+		state.tui = tui;
+		return createFooterComponent(pi, ctx, state, footerData, theme);
+	});
 	ctx.ui.setWorkingVisible(false);
 	ctx.ui.setWidget(
 		WORKING_WIDGET_KEY,
@@ -75,10 +116,14 @@ export function mountOsdyUi(
 	);
 	ctx.ui.setWidget(
 		WORKING_TREE_WIDGET_KEY,
-		createWorkingTreeWidgetFactory(workingTreeState),
+		createWorkingTreeWidgetFactory(
+			workingTreeState,
+			workingState,
+			state.workingTreePlacement,
+		),
 		{ placement: state.workingTreePlacement },
 	);
-	ctx.ui.setEditorComponent(createEditorComponent(pi, ctx));
+	reconcileResponsiveUi(pi, ctx, state, workingTreeState);
 }
 
 export function applyOsdyPi(
@@ -90,8 +135,6 @@ export function applyOsdyPi(
 	notify = false,
 ): void {
 	if (!ctx.hasUI) return;
-	rememberPreviousTheme(ctx, state);
-	applyOsdyTheme(ctx);
 	mountOsdyUi(pi, ctx, state, workingState, workingTreeState);
 	if (notify) ctx.ui.notify("osdy-pi enabled", "info");
 }
@@ -104,15 +147,15 @@ export function disableOsdyPi(ctx: ExtensionContext, state: OsdyState): void {
 	ctx.ui.setWidget(WORKING_WIDGET_KEY, undefined);
 	ctx.ui.setWidget(WORKING_TREE_WIDGET_KEY, undefined);
 	ctx.ui.setWorkingVisible(true);
-	const targetTheme = state.previousThemeName ?? "dark";
-	const result = ctx.ui.setTheme(targetTheme);
-	if (!result.success && targetTheme !== "dark") ctx.ui.setTheme("dark");
+	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"} · working-tree ${state.workingTreeEnabled ? "on" : "off"} · 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) ? "visible" : "hidden"} · widget ${state.workingTreePlacement === "aboveEditor" ? "top" : "bottom"} · theme ${ctx.ui.theme.name ?? "unknown"} · style ${state.headerVariant} · animation ${asciiAnimationMode()} · ${modelLabel(ctx)} · ${usageLabel(ctx).trim()}`,
 		"info",
 	);
 }

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

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+import { PLUGIN_EVENTS, subscribeQuestionPromptAudioNotification } from "./plugin-events.ts";
+
+class TestEventBus {
+	event: string | undefined;
+	handler: ((data: unknown) => void) | undefined;
+
+	on(event: string, handler: (data: unknown) => void): () => void {
+		this.event = event;
+		this.handler = handler;
+		return () => {
+			this.handler = undefined;
+		};
+	}
+
+	emit(event: string, data: unknown): void {
+		if (event === this.event) this.handler?.(data);
+	}
+}
+
+class TestExtensionApi {
+	readonly events = new TestEventBus();
+	lifecycleOnCallCount = 0;
+
+	on(): void {
+		this.lifecycleOnCallCount += 1;
+	}
+}
+
+class TestSessionContextProvider {
+	context: ExtensionContext | undefined;
+
+	getCurrentSessionContext(): ExtensionContext | undefined {
+		return this.context;
+	}
+}
+
+void test("question prompts subscribe through the plugin event bus", () => {
+	const api = new TestExtensionApi();
+	const sessionContextProvider = new TestSessionContextProvider();
+	const notifiedContexts: ExtensionContext[] = [];
+
+	subscribeQuestionPromptAudioNotification(
+		api,
+		sessionContextProvider,
+		{ onQuestionRequested: (ctx) => notifiedContexts.push(ctx) },
+	);
+
+	assert.equal(api.events.event, PLUGIN_EVENTS.QUESTION_PROMPT);
+	assert.equal(api.lifecycleOnCallCount, 0);
+	api.events.emit(PLUGIN_EVENTS.QUESTION_PROMPT, undefined);
+	assert.deepEqual(notifiedContexts, []);
+
+	// SAFETY: The notification contract only passes this context through unchanged.
+	const sessionContext = {} as ExtensionContext;
+	sessionContextProvider.context = sessionContext;
+	api.events.emit(PLUGIN_EVENTS.QUESTION_PROMPT, { question: "Continue?" });
+	assert.deepEqual(notifiedContexts, [sessionContext]);
+});