osdy-pi 0.1.9 → 1.2.0

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

@@ -0,0 +1,163 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	createEditorSettingsStore,
+	normalizeEditorSettings,
+	type EditorSettingsFileSystem,
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+} from "./editor-settings.ts";
+// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
+import { EDITOR_MODES } from "./types.ts";
+
+class MemoryEditorSettingsFileSystem implements EditorSettingsFileSystem {
+	content: string | undefined;
+	mkdirPaths: string[] = [];
+	writePaths: string[] = [];
+	renameCalls: Array<[string, string]> = [];
+
+	mkdir(directory: string): Promise<void> {
+		this.mkdirPaths.push(directory);
+		return Promise.resolve();
+	}
+
+	readFile(): Promise<string> {
+		return this.content === undefined
+			? Promise.reject(new Error("missing settings"))
+			: Promise.resolve(this.content);
+	}
+
+	rename(source: string, destination: string): Promise<void> {
+		this.renameCalls.push([source, destination]);
+		this.content = this.pendingContent;
+		return Promise.resolve();
+	}
+
+	writeFile(filePath: string, content: string): Promise<void> {
+		this.writePaths.push(filePath);
+		this.pendingContent = content;
+		return Promise.resolve();
+	}
+
+	private pendingContent = "";
+}
+
+void test("editor settings normalize only supported versioned modes", () => {
+	assert.deepEqual(
+		normalizeEditorSettings({ version: 1, editorMode: "simple" }),
+		{
+			version: 1,
+			editorMode: EDITOR_MODES.SIMPLE,
+			workingTreeEnabled: true,
+		},
+	);
+	assert.deepEqual(
+		normalizeEditorSettings({ version: 1, editorMode: "invalid" }),
+		{
+			version: 1,
+			editorMode: EDITOR_MODES.AUTO,
+			workingTreeEnabled: true,
+		},
+	);
+	assert.deepEqual(
+		normalizeEditorSettings({ version: 2, editorMode: "extended" }),
+		{
+			version: 1,
+			editorMode: EDITOR_MODES.AUTO,
+			workingTreeEnabled: true,
+		},
+	);
+	assert.deepEqual(normalizeEditorSettings(null), {
+		version: 1,
+		editorMode: EDITOR_MODES.AUTO,
+		workingTreeEnabled: true,
+	});
+});
+
+void test("working-tree visibility defaults safely and persists globally", async () => {
+	assert.equal(
+		normalizeEditorSettings({
+			version: 1,
+			editorMode: "auto",
+			workingTreeEnabled: false,
+		}).workingTreeEnabled,
+		false,
+	);
+	assert.equal(
+		normalizeEditorSettings({
+			version: 1,
+			editorMode: "auto",
+			workingTreeEnabled: "disabled",
+		}).workingTreeEnabled,
+		true,
+	);
+
+	const fileSystem = new MemoryEditorSettingsFileSystem();
+	const firstStore = createEditorSettingsStore(
+		"/agent/extensions/osdy-pi/settings.json",
+		fileSystem,
+	);
+	await firstStore.save({
+		version: 1,
+		editorMode: EDITOR_MODES.AUTO,
+		workingTreeEnabled: false,
+	});
+	const reloadedStore = createEditorSettingsStore(
+		"/agent/extensions/osdy-pi/settings.json",
+		fileSystem,
+	);
+	assert.equal((await reloadedStore.load()).workingTreeEnabled, false);
+});
+
+void test("editor settings load safely and save atomically", async () => {
+	const fileSystem = new MemoryEditorSettingsFileSystem();
+	const store = createEditorSettingsStore(
+		"/agent/extensions/osdy-pi/settings.json",
+		fileSystem,
+	);
+
+	assert.equal((await store.load()).editorMode, EDITOR_MODES.AUTO);
+	assert.equal((await store.load()).workingTreeEnabled, true);
+	fileSystem.content = JSON.stringify({ version: 1, editorMode: "extended" });
+	assert.equal((await store.load()).editorMode, EDITOR_MODES.EXTENDED);
+	assert.equal((await store.load()).workingTreeEnabled, true);
+	fileSystem.content = "{ invalid JSON";
+	assert.equal((await store.load()).workingTreeEnabled, true);
+
+	await store.save({
+		version: 1,
+		editorMode: EDITOR_MODES.SIMPLE,
+		workingTreeEnabled: true,
+	});
+	assert.deepEqual(fileSystem.mkdirPaths, ["/agent/extensions/osdy-pi"]);
+	assert.deepEqual(fileSystem.writePaths, [
+		"/agent/extensions/osdy-pi/settings.json.tmp",
+	]);
+	assert.deepEqual(fileSystem.renameCalls, [
+		[
+			"/agent/extensions/osdy-pi/settings.json.tmp",
+			"/agent/extensions/osdy-pi/settings.json",
+		],
+	]);
+	assert.equal((await store.load()).editorMode, EDITOR_MODES.SIMPLE);
+});
+
+void test("new editor settings stores load their own persisted mode", async () => {
+	const fileSystem = new MemoryEditorSettingsFileSystem();
+	fileSystem.content = JSON.stringify({ version: 1, editorMode: "auto" });
+	const firstStore = createEditorSettingsStore(
+		"/agent/extensions/osdy-pi/settings.json",
+		fileSystem,
+	);
+	assert.equal((await firstStore.load()).editorMode, EDITOR_MODES.AUTO);
+
+	await firstStore.save({
+		version: 1,
+		editorMode: EDITOR_MODES.EXTENDED,
+		workingTreeEnabled: true,
+	});
+	const reloadedStore = createEditorSettingsStore(
+		"/agent/extensions/osdy-pi/settings.json",
+		fileSystem,
+	);
+	assert.equal((await reloadedStore.load()).editorMode, EDITOR_MODES.EXTENDED);
+});

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

@@ -0,0 +1,112 @@
+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";
+
+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";
+const EDITOR_SETTINGS_RELATIVE_DIR = path.join("extensions", "osdy-pi");
+
+export interface EditorSettingsFileSystem {
+	mkdir(directory: string): Promise<void>;
+	readFile(filePath: string): Promise<string>;
+	rename(source: string, destination: string): Promise<void>;
+	writeFile(filePath: string, content: string): Promise<void>;
+}
+
+function getAgentDir(): string {
+	const configuredDir = process.env.PI_CODING_AGENT_DIR?.trim();
+	if (configuredDir) return configuredDir;
+	return path.join(os.homedir(), ".pi", "agent");
+}
+
+function createDefaultEditorSettings(): GlobalEditorSettings {
+	return {
+		version: EDITOR_SETTINGS_VERSION,
+		editorMode: DEFAULT_EDITOR_MODE,
+		workingTreeEnabled: true,
+	};
+}
+
+function isEditorMode(value: unknown): value is EditorMode {
+	return typeof value === "string" && SUPPORTED_EDITOR_MODES.some((mode) => mode === value);
+}
+
+export function normalizeEditorSettings(value: unknown): GlobalEditorSettings {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return createDefaultEditorSettings();
+	}
+	const recordValue = value as Record<string, unknown>;
+	if (recordValue.version !== EDITOR_SETTINGS_VERSION) {
+		return createDefaultEditorSettings();
+	}
+	return {
+		version: EDITOR_SETTINGS_VERSION,
+		editorMode: isEditorMode(recordValue.editorMode)
+			? recordValue.editorMode
+			: DEFAULT_EDITOR_MODE,
+		workingTreeEnabled:
+			typeof recordValue.workingTreeEnabled === "boolean"
+				? recordValue.workingTreeEnabled
+				: true,
+	};
+}
+
+const nodeEditorSettingsFileSystem: EditorSettingsFileSystem = {
+	async mkdir(directory): Promise<void> {
+		await mkdir(directory, { recursive: true });
+	},
+	readFile: (filePath) => readFile(filePath, "utf8"),
+	rename,
+	writeFile: (filePath, content) => writeFile(filePath, content, "utf8"),
+};
+
+export interface EditorSettingsStore {
+	readonly path: string;
+	load(): Promise<GlobalEditorSettings>;
+	save(settings: GlobalEditorSettings): Promise<void>;
+}
+
+class FileEditorSettingsStore implements EditorSettingsStore {
+	readonly path: string;
+	private readonly fileSystem: EditorSettingsFileSystem;
+
+	constructor(filePath: string, fileSystem: EditorSettingsFileSystem) {
+		this.path = filePath;
+		this.fileSystem = fileSystem;
+	}
+
+	async load(): Promise<GlobalEditorSettings> {
+		try {
+			const content = await this.fileSystem.readFile(this.path);
+			return normalizeEditorSettings(JSON.parse(content) as unknown);
+		} catch {
+			return createDefaultEditorSettings();
+		}
+	}
+
+	async save(settings: GlobalEditorSettings): Promise<void> {
+		const parentDir = path.dirname(this.path);
+		const tempPath = `${this.path}.tmp`;
+		const normalizedSettings = normalizeEditorSettings(settings);
+		await this.fileSystem.mkdir(parentDir);
+		await this.fileSystem.writeFile(
+			tempPath,
+			`${JSON.stringify(normalizedSettings, null, 2)}\n`,
+		);
+		await this.fileSystem.rename(tempPath, this.path);
+	}
+}
+
+export function createEditorSettingsStore(
+	filePath = path.join(
+		getAgentDir(),
+		EDITOR_SETTINGS_RELATIVE_DIR,
+		EDITOR_SETTINGS_FILE_NAME,
+	),
+	fileSystem = nodeEditorSettingsFileSystem,
+): EditorSettingsStore {
+	return new FileEditorSettingsStore(filePath, fileSystem);
+}

package/extensions/osdy-pi/metrics.ts

@@ -1,17 +1,6 @@
-import {
-	type ExtensionAPI,
-	type ExtensionContext,
-	VERSION,
-} from "@earendil-works/pi-coding-agent";
-import { truncateToWidth } from "@earendil-works/pi-tui";
-import { formatPath, shortNumber, truncateMiddle } from "./format.js";
-import type {
-	AssistantSessionEntry,
-	HeaderMetaRow,
-	OsdyState,
-	SimpleTheme,
-} from "./types.js";
-import { centerVisible, fitCenterVisible } from "./utils.js";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { shortNumber } from "./format.js";
+import type { AssistantSessionEntry } from "./types.js";
 
 function isAssistantSessionEntry(
 	entry: unknown,
@@ -86,125 +75,9 @@ function mergeUsageTotals(
 }
 
 function collectUsageTotals(ctx: ExtensionContext): UsageTotals {
-	return ctx.sessionManager
-		.getEntries()
-		.reduce<UsageTotals>((totals, entry) => {
-			return isAssistantSessionEntry(entry)
-				? mergeUsageTotals(totals, entry)
-				: totals;
-		}, createUsageTotals());
-}
-
-function getToolSources(pi: ExtensionAPI) {
-	return pi.getAllTools().map((tool) => ({
-		name: tool.name.toLowerCase(),
-		origin: tool.sourceInfo?.origin?.toLowerCase() ?? "",
-		source: tool.sourceInfo?.source?.toLowerCase() ?? "",
-		path: tool.sourceInfo?.path?.toLowerCase() ?? "",
-	}));
-}
-
-function isMcpTool(tool: ReturnType<typeof getToolSources>[number]): boolean {
-	return tool.name.includes("mcp") || tool.source.includes("mcp");
-}
-
-function getToolServerKey(
-	tool: ReturnType<typeof getToolSources>[number],
-): string {
-	return tool.source || tool.path || tool.name;
-}
-
-function getMcpServerCount(pi: ExtensionAPI): number {
-	const serverKeys = new Set(
-		getToolSources(pi).filter(isMcpTool).map(getToolServerKey),
-	);
-	return serverKeys.size;
-}
-
-function countToolsByOrigin(pi: ExtensionAPI, origin: string): number {
-	return getToolSources(pi).filter((tool) => tool.origin === origin).length;
-}
-
-function countToolsBySource(pi: ExtensionAPI, source: string): number {
-	return getToolSources(pi).filter((tool) => tool.source.includes(source))
-		.length;
-}
-
-function getPathWidth(width: number): number {
-	return width < 110 ? 34 : 52;
-}
-
-export function renderHeaderMetadata(
-	pi: ExtensionAPI,
-	ctx: ExtensionContext,
-	state: OsdyState,
-	width: number,
-): HeaderMetaRow[] {
-	const allTools = pi.getAllTools().length;
-	const git = state.gitLabel === "no-git" ? "Not a git repo" : state.gitLabel;
-	const path = truncateMiddle(formatPath(ctx.cwd), getPathWidth(width));
-	const mcpServerCount = getMcpServerCount(pi);
-	const pluginCount = countToolsByOrigin(pi, "package");
-	const extensionCount = countToolsBySource(pi, "extension");
-	return [
-		{
-			leftLabel: "GIT:",
-			leftValue: git,
-			rightLabel: "PATH:",
-			rightValue: path,
-		},
-		{
-			leftLabel: "MCP:",
-			leftValue: `${mcpServerCount} servers`,
-			rightLabel: "PLUGINS:",
-			rightValue: `${pluginCount} package`,
-		},
-		{
-			leftLabel: "AGENTS:",
-			leftValue: `${state.agentsLabel} loaded`,
-			rightLabel: "EXTENSIONS:",
-			rightValue: `${extensionCount} active`,
-		},
-		{
-			leftLabel: "VER:",
-			leftValue: VERSION,
-			rightLabel: "TOOLS:",
-			rightValue: `${allTools} customs`,
-		},
-	];
-}
-
-export function renderMetaRows(
-	rows: HeaderMetaRow[],
-	width: number,
-	theme: SimpleTheme,
-): string[] {
-	const labelWidth = 11;
-	const leftValueWidth = 32;
-	const rightValueWidth = 52;
-	const gapWidth = 10;
-	const blockWidth =
-		labelWidth +
-		1 +
-		leftValueWidth +
-		gapWidth +
-		labelWidth +
-		1 +
-		rightValueWidth;
-	return rows.map((row) => {
-		const leftLabel = theme.fg("mdLink", row.leftLabel.padEnd(labelWidth));
-		const leftValue = theme.fg(
-			"accent",
-			truncateToWidth(row.leftValue, leftValueWidth).padEnd(leftValueWidth),
-		);
-		const rightLabel = theme.fg("mdLink", row.rightLabel.padEnd(labelWidth));
-		const rightValue = theme.fg(
-			"accent",
-			truncateToWidth(row.rightValue, rightValueWidth).padEnd(rightValueWidth),
-		);
-		const rowText = `${leftLabel} ${leftValue}${" ".repeat(gapWidth)}${rightLabel} ${rightValue}`;
-		return width >= blockWidth
-			? centerVisible(rowText, width)
-			: fitCenterVisible(rowText, width);
-	});
+	return ctx.sessionManager.getEntries().reduce<UsageTotals>((totals, entry) => {
+		return isAssistantSessionEntry(entry)
+			? mergeUsageTotals(totals, entry)
+			: totals;
+	}, createUsageTotals());
 }

package/extensions/osdy-pi/plugin-events.ts

@@ -0,0 +1,26 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+export const PLUGIN_EVENTS = {
+	QUESTION_PROMPT: "rpiv:ask-user:prompt",
+} as const;
+
+export interface SessionContextProvider {
+	getCurrentSessionContext(): ExtensionContext | undefined;
+}
+
+export interface QuestionAudioNotificationRouter {
+	onQuestionRequested(ctx: ExtensionContext): void;
+}
+
+export function subscribeQuestionPromptAudioNotification(
+	api: Pick<ExtensionAPI, "events">,
+	sessionContextProvider: SessionContextProvider,
+	audioRouter: QuestionAudioNotificationRouter,
+): void {
+	api.events.on(PLUGIN_EVENTS.QUESTION_PROMPT, () => {
+		const ctx = sessionContextProvider.getCurrentSessionContext();
+		if (ctx) audioRouter.onQuestionRequested(ctx);
+	});
+}

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

@@ -0,0 +1,29 @@
+const PROFILE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,62})$/;
+const RESERVED_PROFILE_NAMES = new Set(["default", "profiles", "auth.json"]);
+
+export function resolveActiveProfileLabel(
+	env: { OSDY_PI_PROFILE_NAME?: string | undefined } = process.env,
+): string | undefined {
+	const profileName = env.OSDY_PI_PROFILE_NAME;
+	return typeof profileName === "string" &&
+		PROFILE_NAME.test(profileName) &&
+		!RESERVED_PROFILE_NAMES.has(profileName)
+		? profileName
+		: undefined;
+}
+
+export function formatModelMetadata(
+	model: string,
+	thinkingLevel: string,
+	profileName: string | undefined,
+): string {
+	return profileName === undefined
+		? `${model} · think ${thinkingLevel}`
+		: `${model} · ${profileName} · think ${thinkingLevel}`;
+}
+
+export function resolveEditorTitleLabel(
+	profileName: string | undefined,
+): string {
+	return profileName ?? "Osdy-Pi";
+}

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",
+	);
+});