osdy-pi 0.1.8 → 1.2.0

package/extensions/osdy-pi/runtime.ts

@@ -6,14 +6,26 @@ import { createAudioEventRouter } from "./audio-event-router.js";
 import { registerAudioNotificationFlags } from "./audio-notification-config.js";
 import { createAudioNotificationService } from "./audio-notification-service.js";
 import { createAudioPlaybackAdapter } from "./audio-playback.js";
+import { subscribeQuestionPromptAudioNotification } from "./plugin-events.js";
 import { createAudioSoundSettingsStore } from "./audio-sound-settings.js";
-import { applyOsdyPi, disableOsdyPi, notifyStatus } from "./runtime-helpers.js";
+import { createEditorSettingsStore } from "./editor-settings.js";
+import { registerAccountProfilesCommand } from "./account-profiles.js";
+import {
+	applyOsdyPi,
+	createResponsiveCoordinator,
+	disableOsdyPi,
+	notifyStatus,
+	reconcileResponsiveUi,
+} from "./runtime-helpers.js";
 import { runSoundSetupWizard } from "./sound-setup-wizard.js";
-import type {
-	HeaderVariant,
-	OsdyState,
-	WorkingTreeState,
-	WorkingWidgetState,
+import {
+	DEFAULT_EDITOR_MODE,
+	EDITOR_MODES,
+	type EditorMode,
+	type HeaderVariant,
+	type OsdyState,
+	type WorkingTreeState,
+	type WorkingWidgetState,
 } from "./types.js";
 import { WORKING_TREE_WIDGET_KEY, WORKING_WIDGET_KEY } from "./constants.js";
 import {
@@ -34,11 +46,15 @@ function scheduleOsdyRefresh(
 	state: OsdyState,
 	workingState: WorkingWidgetState,
 	workingTreeState: WorkingTreeState,
+	pendingRefreshes: Set<ReturnType<typeof setTimeout>>,
+	isCurrentSession: () => boolean,
 ): void {
-	setTimeout(() => {
-		if (state.enabled)
+	const timeout = setTimeout(() => {
+		pendingRefreshes.delete(timeout);
+		if (state.enabled && isCurrentSession())
 			applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
 	}, delayMs);
+	pendingRefreshes.add(timeout);
 }
 
 function claimOsdyVisualLayer(
@@ -47,6 +63,8 @@ function claimOsdyVisualLayer(
 	state: OsdyState,
 	workingState: WorkingWidgetState,
 	workingTreeState: WorkingTreeState,
+	pendingRefreshes: Set<ReturnType<typeof setTimeout>>,
+	isCurrentSession: () => boolean,
 ): void {
 	if (!state.enabled) return;
 	applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
@@ -58,37 +76,12 @@ function claimOsdyVisualLayer(
 			state,
 			workingState,
 			workingTreeState,
+			pendingRefreshes,
+			isCurrentSession,
 		);
 	}
 }
 
-function loadSessionMetadata(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	state: OsdyState,
-): void {
-	void pi
-		.exec("git", ["branch", "--show-current"], { cwd: ctx.cwd })
-		.then((result) => {
-			state.gitLabel = result.stdout.trim() || "detached";
-		})
-		.catch(() => {
-			state.gitLabel = "no-git";
-		});
-	void pi
-		.exec("find", [ctx.cwd, "-name", "AGENTS.md", "-o", "-name", "AGENTS.MD"], {
-			cwd: ctx.cwd,
-		})
-		.then((result) => {
-			state.agentsLabel = String(
-				result.stdout.split("\n").filter(Boolean).length,
-			);
-		})
-		.catch(() => {
-			state.agentsLabel = "0";
-		});
-}
-
 function parseCommandArgs(args: string): string[] {
 	return args.trim().split(/\s+/).filter(Boolean);
 }
@@ -119,8 +112,11 @@ function disableOsdyPiCommand(
 	state: OsdyState,
 	workingTreeState: WorkingTreeState,
 	controller: WorkingController,
+	stopResponsive: () => void,
 ): void {
+	stopResponsive();
 	state.enabled = false;
+	workingTreeState.visible = false;
 	controller.stopWorking();
 	clearWorkingTree(workingTreeState);
 	disableOsdyPi(ctx, state);
@@ -135,8 +131,7 @@ function setHeaderVariant(
 	variant: HeaderVariant,
 ): void {
 	state.headerVariant = variant;
-	if (state.enabled)
-		applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
+	if (state.enabled) applyOsdyPi(pi, ctx, state, workingState, workingTreeState);
 	ctx.ui.notify(`osdy-pi style: ${variant}`, "info");
 }
 
@@ -150,6 +145,7 @@ function getOsdyCommandCompletions(prefix: string) {
 			"status",
 			"sound",
 			"working-tree",
+			"editor",
 			"diff",
 			...HEADER_VARIANTS,
 		].map((value) => ({ value, label: value }));
@@ -167,6 +163,17 @@ function getOsdyCommandCompletions(prefix: string) {
 			"working-tree position bottom",
 		].map((value) => ({ value, label: value }));
 	}
+	if (trimmed === "editor") {
+		return [
+			"editor auto",
+			"editor extended",
+			"editor simple",
+			"editor on",
+			"editor off",
+			"editor toggle",
+			"editor status",
+		].map((value) => ({ value, label: value }));
+	}
 	if (parts.length === 1) {
 		const valuePrefix = parts[0] ?? "";
 		return [
@@ -175,6 +182,7 @@ function getOsdyCommandCompletions(prefix: string) {
 			"status",
 			"sound",
 			"working-tree",
+			"editor",
 			"diff",
 			...HEADER_VARIANTS,
 		]
@@ -187,6 +195,15 @@ function getOsdyCommandCompletions(prefix: string) {
 			.filter((value) => value.startsWith(valuePrefix))
 			.map((value) => ({ value: `sound ${value}`, label: `sound ${value}` }));
 	}
+	if (parts[0] === "editor" && parts.length === 2) {
+		const valuePrefix = parts[1] ?? "";
+		return ["auto", "extended", "simple", "on", "off", "toggle", "status"]
+			.filter((value) => value.startsWith(valuePrefix))
+			.map((value) => ({
+				value: `editor ${value}`,
+				label: `editor ${value}`,
+			}));
+	}
 	if (parts[0] === "working-tree" && parts.length === 2) {
 		const valuePrefix = parts[1] ?? "";
 		return ["on", "off", "toggle", "status", "position"]
@@ -260,6 +277,101 @@ function handleWorkingTreePositionCommand(
 	);
 }
 
+async function setEditorMode(
+	mode: EditorMode,
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingTreeState: WorkingTreeState,
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
+): Promise<void> {
+	state.editorMode = mode;
+	if (state.enabled) reconcileResponsiveUi(pi, ctx, state, workingTreeState);
+	try {
+		await settingsStore.save({
+			version: 1,
+			editorMode: mode,
+			workingTreeEnabled: state.workingTreeEnabled,
+		});
+		ctx.ui.notify(`osdy-pi editor mode: ${mode}`, "info");
+	} catch {
+		ctx.ui.notify(
+			"osdy-pi editor mode changed but could not be saved",
+			"warning",
+		);
+	}
+}
+
+async function handleEditorCommand(
+	action: string | undefined,
+	rest: string[],
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingTreeState: WorkingTreeState,
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
+): Promise<void> {
+	if (rest.length > 0) {
+		ctx.ui.notify(
+			"Usage: /osdy-pi editor auto | extended | simple | on | off | toggle | status",
+			"warning",
+		);
+		return;
+	}
+	const modeForAction: Record<string, EditorMode> = {
+		auto: EDITOR_MODES.AUTO,
+		extended: EDITOR_MODES.EXTENDED,
+		simple: EDITOR_MODES.SIMPLE,
+		on: EDITOR_MODES.EXTENDED,
+		off: EDITOR_MODES.SIMPLE,
+	};
+	const mode = action ? modeForAction[action] : undefined;
+	if (mode) {
+		await setEditorMode(mode, pi, ctx, state, workingTreeState, settingsStore);
+		return;
+	}
+	if (action === "toggle") {
+		await setEditorMode(
+			state.editorMode === EDITOR_MODES.EXTENDED
+				? EDITOR_MODES.SIMPLE
+				: EDITOR_MODES.EXTENDED,
+			pi,
+			ctx,
+			state,
+			workingTreeState,
+			settingsStore,
+		);
+		return;
+	}
+	if (action === "status" || action === undefined) {
+		ctx.ui.notify(
+			`osdy-pi editor mode ${state.editorMode}, effective ${state.editorEffective ? "extended" : "simple/native"}`,
+			"info",
+		);
+		return;
+	}
+	ctx.ui.notify(
+		"Usage: /osdy-pi editor auto | extended | simple | on | off | toggle | status",
+		"warning",
+	);
+}
+
+async function saveWorkingTreePreference(
+	state: OsdyState,
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
+): Promise<boolean> {
+	try {
+		await settingsStore.save({
+			version: 1,
+			editorMode: state.editorMode,
+			workingTreeEnabled: state.workingTreeEnabled,
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 async function handleWorkingTreeCommand(
 	action: string | undefined,
 	rest: string[],
@@ -268,6 +380,7 @@ async function handleWorkingTreeCommand(
 	state: OsdyState,
 	workingState: WorkingWidgetState,
 	workingTreeState: WorkingTreeState,
+	settingsStore: ReturnType<typeof createEditorSettingsStore>,
 ): Promise<void> {
 	if (action === "position") {
 		handleWorkingTreePositionCommand(
@@ -283,15 +396,29 @@ async function handleWorkingTreeCommand(
 	if (action === "on") {
 		state.workingTreeEnabled = true;
 		workingTreeState.enabled = true;
+		reconcileResponsiveUi(pi, ctx, state, workingTreeState);
+		const saved = await saveWorkingTreePreference(state, settingsStore);
 		await refreshWorkingTree(pi, ctx, workingTreeState);
-		ctx.ui.notify("osdy-pi working tree enabled", "info");
+		ctx.ui.notify(
+			saved
+				? "osdy-pi working tree enabled"
+				: "osdy-pi working tree enabled but could not be saved",
+			saved ? "info" : "warning",
+		);
 		return;
 	}
 	if (action === "off") {
 		state.workingTreeEnabled = false;
 		workingTreeState.enabled = false;
+		reconcileResponsiveUi(pi, ctx, state, workingTreeState);
 		clearWorkingTree(workingTreeState);
-		ctx.ui.notify("osdy-pi working tree disabled", "info");
+		const saved = await saveWorkingTreePreference(state, settingsStore);
+		ctx.ui.notify(
+			saved
+				? "osdy-pi working tree disabled"
+				: "osdy-pi working tree disabled but could not be saved",
+			saved ? "info" : "warning",
+		);
 		return;
 	}
 	if (action === "toggle") {
@@ -304,6 +431,7 @@ async function handleWorkingTreeCommand(
 			state,
 			workingState,
 			workingTreeState,
+			settingsStore,
 		);
 		return;
 	}
@@ -360,10 +488,13 @@ function registerCommand(
 	workingTreeState: WorkingTreeState,
 	controller: WorkingController,
 	settingsStore: ReturnType<typeof createAudioSoundSettingsStore>,
+	editorSettingsStore: ReturnType<typeof createEditorSettingsStore>,
+	startResponsive: () => void,
+	stopResponsive: () => void,
 ): void {
 	pi.registerCommand("osdy-pi", {
 		description:
-			"Manage the Osdy Pi experience: enable, disable, status, style, sound setup, working tree, or diff panel.",
+			"Manage the Osdy Pi experience: enable, disable, status, editor, style, sound setup, working tree, or diff panel.",
 		getArgumentCompletions: getOsdyCommandCompletions,
 		handler: async (args, ctx) => {
 			const [action = "status", ...rest] = parseCommandArgs(args);
@@ -376,10 +507,17 @@ function registerCommand(
 					workingTreeState,
 					controller,
 				);
+				startResponsive();
 				return;
 			}
 			if (action === "disable") {
-				disableOsdyPiCommand(ctx, state, workingTreeState, controller);
+				disableOsdyPiCommand(
+					ctx,
+					state,
+					workingTreeState,
+					controller,
+					stopResponsive,
+				);
 				return;
 			}
 			if (action === "status") {
@@ -390,6 +528,18 @@ function registerCommand(
 				await handleSoundCommand(rest, ctx, settingsStore);
 				return;
 			}
+			if (action === "editor") {
+				await handleEditorCommand(
+					rest[0],
+					rest.slice(1),
+					pi,
+					ctx,
+					state,
+					workingTreeState,
+					editorSettingsStore,
+				);
+				return;
+			}
 			if (action === "working-tree") {
 				await handleWorkingTreeCommand(
 					rest[0],
@@ -399,6 +549,7 @@ function registerCommand(
 					state,
 					workingState,
 					workingTreeState,
+					editorSettingsStore,
 				);
 				return;
 			}
@@ -407,18 +558,11 @@ function registerCommand(
 				return;
 			}
 			if (isHeaderVariant(action)) {
-				setHeaderVariant(
-					pi,
-					ctx,
-					state,
-					workingState,
-					workingTreeState,
-					action,
-				);
+				setHeaderVariant(pi, ctx, state, workingState, workingTreeState, action);
 				return;
 			}
 			ctx.ui.notify(
-				"Usage: /osdy-pi enable | disable | status | sound setup | working-tree ... | diff | osdy-theme | classic",
+				"Usage: /osdy-pi enable | disable | status | editor auto|extended|simple|on|off|toggle|status | sound setup | working-tree ... | diff | osdy-theme | classic",
 				"warning",
 			);
 		},
@@ -428,14 +572,7 @@ function registerCommand(
 		pi.registerCommand(`osdy-pi-${variant}`, {
 			description: `Switch Osdy Pi header to ${variant}.`,
 			handler: (_args, ctx) => {
-				setHeaderVariant(
-					pi,
-					ctx,
-					state,
-					workingState,
-					workingTreeState,
-					variant,
-				);
+				setHeaderVariant(pi, ctx, state, workingState, workingTreeState, variant);
 				return Promise.resolve();
 			},
 		});
@@ -445,9 +582,11 @@ function registerCommand(
 export function registerOsdyPi(pi: ExtensionAPI): void {
 	const state: OsdyState = {
 		enabled: true,
+		editorEffective: false,
+		editorMode: DEFAULT_EDITOR_MODE,
 		headerVariant: "osdy-theme",
-		gitLabel: "-",
-		agentsLabel: "-",
+		smallMode: false,
+		tui: undefined,
 		workingTreeEnabled: true,
 		workingTreePlacement: "aboveEditor",
 	};
@@ -461,13 +600,16 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 	const workingTreeState: WorkingTreeState = {
 		enabled: true,
 		loading: false,
+		visible: true,
 		snapshot: null,
 		error: undefined,
 		tui: undefined,
 	};
 	const controller = createWorkingController(state, workingState);
 	const settingsStore = createAudioSoundSettingsStore();
+	const editorSettingsStore = createEditorSettingsStore();
 	registerAudioNotificationFlags(pi);
+	registerAccountProfilesCommand(pi);
 	const audioRouter = createAudioEventRouter(
 		createAudioNotificationService(
 			pi,
@@ -475,6 +617,23 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 			settingsStore,
 		),
 	);
+	let responsiveCoordinator:
+		| ReturnType<typeof createResponsiveCoordinator>
+		| undefined;
+	let sessionContext: ExtensionContext | undefined;
+	const pendingOsdyRefreshes = new Set<ReturnType<typeof setTimeout>>();
+	const cancelOsdyRefreshes = (): void => {
+		for (const timeout of pendingOsdyRefreshes) clearTimeout(timeout);
+		pendingOsdyRefreshes.clear();
+	};
+	const startResponsive = (): void => responsiveCoordinator?.start();
+	const stopResponsive = (): void => responsiveCoordinator?.stop();
+
+	subscribeQuestionPromptAudioNotification(
+		pi,
+		{ getCurrentSessionContext: () => sessionContext },
+		audioRouter,
+	);
 
 	pi.on("agent_start", () => {
 		controller.onAgentStart();
@@ -490,17 +649,47 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 	pi.on("tool_execution_end", (event, ctx) => {
 		controller.onToolEnd();
 		audioRouter.onToolExecutionEnd(event.isError === true, ctx);
-		if (event.isError !== true && shouldRefreshWorkingTree(event.toolName)) {
+		if (
+			state.workingTreeEnabled &&
+			event.isError !== true &&
+			shouldRefreshWorkingTree(event.toolName)
+		) {
 			void refreshWorkingTree(pi, ctx, workingTreeState);
 		}
 	});
 	pi.on("session_shutdown", () => {
+		cancelOsdyRefreshes();
 		controller.onShutdown();
+		stopResponsive();
+		if (sessionContext) disableOsdyPi(sessionContext, state);
 		workingTreeState.tui = undefined;
+		sessionContext = undefined;
 	});
-	pi.on("session_start", (_event, ctx) => {
-		loadSessionMetadata(pi, ctx, state);
-		claimOsdyVisualLayer(pi, ctx, state, workingState, workingTreeState);
+	pi.on("session_start", async (_event, ctx) => {
+		cancelOsdyRefreshes();
+		stopResponsive();
+		sessionContext = ctx;
+		const editorSettings = await editorSettingsStore.load();
+		state.editorMode = editorSettings.editorMode;
+		state.workingTreeEnabled = editorSettings.workingTreeEnabled;
+		workingTreeState.enabled = editorSettings.workingTreeEnabled;
+		if (sessionContext !== ctx) return;
+		claimOsdyVisualLayer(
+			pi,
+			ctx,
+			state,
+			workingState,
+			workingTreeState,
+			pendingOsdyRefreshes,
+			() => sessionContext === ctx,
+		);
+		responsiveCoordinator = createResponsiveCoordinator(
+			pi,
+			ctx,
+			state,
+			workingTreeState,
+		);
+		responsiveCoordinator.start();
 		if (state.workingTreeEnabled) {
 			void refreshWorkingTree(pi, ctx, workingTreeState);
 		}
@@ -513,5 +702,8 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 		workingTreeState,
 		controller,
 		settingsStore,
+		editorSettingsStore,
+		startResponsive,
+		stopResponsive,
 	);
 }

package/extensions/osdy-pi/types.ts

@@ -2,16 +2,45 @@ import type { TUI } from "@earendil-works/pi-tui";
 
 export type AnimationMode = "off" | "intro" | "continuous";
 
+export const EDITOR_MODES = {
+	AUTO: "auto",
+	EXTENDED: "extended",
+	SIMPLE: "simple",
+} as const;
+
+export type EditorMode = (typeof EDITOR_MODES)[keyof typeof EDITOR_MODES];
+
+export const DEFAULT_EDITOR_MODE = EDITOR_MODES.AUTO;
+
+export interface GlobalEditorSettings {
+	version: number;
+	editorMode: EditorMode;
+	workingTreeEnabled: boolean;
+}
+
+export function resolveEffectiveEditorMode(
+	mode: EditorMode,
+	smallMode: boolean,
+): EditorMode {
+	if (smallMode || mode === EDITOR_MODES.SIMPLE) return EDITOR_MODES.SIMPLE;
+	return EDITOR_MODES.EXTENDED;
+}
+
+export function shouldShowFooterMetadata(editorEffective: boolean): boolean {
+	return !editorEffective;
+}
+
 export type HeaderVariant = "osdy-theme" | "classic";
 
 export type WorkingTreePlacement = "aboveEditor" | "belowEditor";
 
 export type OsdyState = {
 	enabled: boolean;
+	editorEffective: boolean;
+	editorMode: EditorMode;
 	headerVariant: HeaderVariant;
-	previousThemeName?: string;
-	gitLabel: string;
-	agentsLabel: string;
+	smallMode: boolean;
+	tui: TUI | undefined;
 	workingTreeEnabled: boolean;
 	workingTreePlacement: WorkingTreePlacement;
 };
@@ -46,6 +75,7 @@ export type WorkingTreeSnapshot = {
 export type WorkingTreeState = {
 	enabled: boolean;
 	loading: boolean;
+	visible: boolean;
 	snapshot: WorkingTreeSnapshot | null;
 	error: string | undefined;
 	tui: TUI | undefined;
@@ -72,13 +102,6 @@ export type AssistantSessionEntry = {
 	};
 };
 
-export type HeaderMetaRow = {
-	leftLabel: string;
-	leftValue: string;
-	rightLabel: string;
-	rightValue: string;
-};
-
 export type SimpleTheme = {
 	fg(name: string, text: string): string;
 };

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

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+import * as profileLabel from "./profile-label.ts";
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+import { shouldShowFooterMetadata } from "./types.ts";
+
+void test("footer metadata is shown only when the native editor is effective", () => {
+	assert.equal(shouldShowFooterMetadata(false), true);
+	assert.equal(shouldShowFooterMetadata(true), false);
+});
+
+void test("maximum thinking uses the existing extra-high theme color", () => {
+	const source = readFileSync(new URL("./ui.ts", import.meta.url), "utf8");
+	assert.match(source, /max:\s*"thinkingXhigh"/);
+});
+
+void test("places a managed profile beside the model in simple mode and preserves its fallback", () => {
+	assert.equal(
+		profileLabel.resolveActiveProfileLabel({ OSDY_PI_PROFILE_NAME: "work" }),
+		"work",
+	);
+	assert.equal(profileLabel.resolveActiveProfileLabel({}), undefined);
+	assert.equal(
+		profileLabel.formatModelMetadata("gpt-5", "high", "work"),
+		"gpt-5 · work · think high",
+	);
+	assert.equal(
+		profileLabel.formatModelMetadata(
+			"gpt-5",
+			"high",
+			profileLabel.resolveActiveProfileLabel({
+				OSDY_PI_PROFILE_NAME: "untrusted/profile",
+			}),
+		),
+		"gpt-5 · think high",
+	);
+});
+
+void test("replaces the extended editor Osdy-Pi title with a managed profile or preserves its fallback", () => {
+	assert.equal(profileLabel.resolveEditorTitleLabel("work"), "work");
+	assert.equal(
+		profileLabel.resolveEditorTitleLabel(
+			profileLabel.resolveActiveProfileLabel({
+				OSDY_PI_PROFILE_NAME: "untrusted/profile",
+			}),
+		),
+		"Osdy-Pi",
+	);
+});