pi-model-profiles 0.2.0

package/src/config.ts

@@ -0,0 +1,250 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { ProfileSortOrder } from "./types.js";
+
+export const EXTENSION_NAME = "pi-model-profiles";
+
+export { ProfileSortOrder as SortOrder } from "./types.js";
+
+export interface ProfilesConfig {
+	/** Enable automatic saving of profiles on changes (default: true) */
+	autoSave: boolean;
+	/** Maximum number of profiles to retain (default: 100, min: 1, max: 1000) */
+	maxProfiles: number;
+}
+
+export interface SortingConfig {
+	/** Default sort order for profile list (default: 'date-desc') */
+	defaultSort: ProfileSortOrder;
+}
+
+export interface MultiProfilesConfig {
+	/** Enable debug logging (default: false) */
+	debug: boolean;
+	/** Profile storage configuration */
+	profiles: ProfilesConfig;
+	/** Sorting configuration */
+	sorting: SortingConfig;
+}
+
+export interface MultiProfilesConfigLoadResult {
+	config: MultiProfilesConfig;
+	created: boolean;
+	warning?: string;
+}
+
+export const DEFAULT_PROFILES_CONFIG: ProfilesConfig = {
+	autoSave: true,
+	maxProfiles: 100,
+};
+
+export const DEFAULT_SORTING_CONFIG: SortingConfig = {
+	defaultSort: "date-desc" as ProfileSortOrder,
+};
+
+export const DEFAULT_MULTI_PROFILES_CONFIG: MultiProfilesConfig = {
+	debug: false,
+	profiles: { ...DEFAULT_PROFILES_CONFIG },
+	sorting: { ...DEFAULT_SORTING_CONFIG },
+};
+
+function cloneProfilesConfig(config: ProfilesConfig = DEFAULT_PROFILES_CONFIG): ProfilesConfig {
+	return {
+		autoSave: config.autoSave,
+		maxProfiles: config.maxProfiles,
+	};
+}
+
+function cloneSortingConfig(config: SortingConfig = DEFAULT_SORTING_CONFIG): SortingConfig {
+	return {
+		defaultSort: config.defaultSort,
+	};
+}
+
+function cloneMultiProfilesConfig(config: MultiProfilesConfig = DEFAULT_MULTI_PROFILES_CONFIG): MultiProfilesConfig {
+	return {
+		debug: config.debug,
+		profiles: cloneProfilesConfig(config.profiles),
+		sorting: cloneSortingConfig(config.sorting),
+	};
+}
+
+/**
+ * Resolve the extension root directory from a module URL.
+ */
+export function resolveExtensionRoot(moduleUrl: string = import.meta.url): string {
+	const __filename = fileURLToPath(moduleUrl);
+	const __dirname = dirname(__filename);
+	// Navigate up from src/ to extension root
+	return dirname(__dirname);
+}
+
+export const EXTENSION_ROOT = resolveExtensionRoot();
+export const CONFIG_PATH = join(EXTENSION_ROOT, "config.json");
+export const DEBUG_DIR = join(EXTENSION_ROOT, "debug");
+export const DEBUG_LOG_PATH = join(DEBUG_DIR, `${EXTENSION_NAME}-debug.jsonl`);
+
+function createDefaultConfigContent(): string {
+	return JSON.stringify(DEFAULT_MULTI_PROFILES_CONFIG, null, "\t");
+}
+
+function toRecord(value: unknown): Record<string, unknown> {
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+		return value as Record<string, unknown>;
+	}
+	return {};
+}
+
+function formatValue(value: unknown): string {
+	if (typeof value === "string") {
+		return `"${value}"`;
+	}
+	if (typeof value === "number" || typeof value === "boolean") {
+		return String(value);
+	}
+	if (value === null) {
+		return "null";
+	}
+	if (Array.isArray(value)) {
+		return `[${value.map(formatValue).join(", ")}]`;
+	}
+	if (typeof value === "object") {
+		return "{...}";
+	}
+	return String(value);
+}
+
+function createValidationWarning(path: string, reason: string, fallback: unknown): string {
+	return `Config validation: '${path}' ${reason}. Using default: ${formatValue(fallback)}`;
+}
+
+function appendWarning(warnings: string[], warning: string | undefined): void {
+	if (warning) {
+		warnings.push(warning);
+	}
+}
+
+function readBoolean(value: unknown, path: string, fallback: boolean, warnings: string[]): boolean {
+	if (typeof value === "boolean") {
+		return value;
+	}
+	appendWarning(warnings, createValidationWarning(path, "must be a boolean", fallback));
+	return fallback;
+}
+
+function readNonNegativeInteger(value: unknown, path: string, fallback: number, min: number, max: number, warnings: string[]): number {
+	if (typeof value === "number" && Number.isInteger(value) && value >= min && value <= max) {
+		return value;
+	}
+	appendWarning(warnings, createValidationWarning(path, `must be an integer between ${min} and ${max}`, fallback));
+	return fallback;
+}
+
+function readStringEnum<T extends string>(value: unknown, path: string, validValues: readonly T[], fallback: T, warnings: string[]): T {
+	if (typeof value === "string" && (validValues as readonly string[]).includes(value)) {
+		return value as T;
+	}
+	appendWarning(warnings, createValidationWarning(path, `must be one of: ${validValues.join(", ")}`, fallback));
+	return fallback;
+}
+
+function normalizeProfilesConfig(value: unknown, warnings: string[]): ProfilesConfig {
+	const obj = toRecord(value);
+	const autoSave = readBoolean(obj.autoSave, "profiles.autoSave", DEFAULT_PROFILES_CONFIG.autoSave, warnings);
+	const maxProfiles = readNonNegativeInteger(
+		obj.maxProfiles,
+		"profiles.maxProfiles",
+		DEFAULT_PROFILES_CONFIG.maxProfiles,
+		1,
+		1000,
+		warnings,
+	);
+	return { autoSave, maxProfiles };
+}
+
+function normalizeSortingConfig(value: unknown, warnings: string[]): SortingConfig {
+	const obj = toRecord(value);
+	const validSortOrders: ProfileSortOrder[] = ["name-asc", "name-desc", "date-asc", "date-desc"];
+	const defaultSort = readStringEnum<ProfileSortOrder>(
+		obj.defaultSort,
+		"sorting.defaultSort",
+		validSortOrders,
+		DEFAULT_SORTING_CONFIG.defaultSort,
+		warnings,
+	);
+	return { defaultSort };
+}
+
+function normalizeConfig(raw: unknown): { config: MultiProfilesConfig; warnings: string[] } {
+	const warnings: string[] = [];
+	const obj = toRecord(raw);
+
+	const debug = readBoolean(obj.debug, "debug", DEFAULT_MULTI_PROFILES_CONFIG.debug, warnings);
+	const profiles = normalizeProfilesConfig(obj.profiles, warnings);
+	const sorting = normalizeSortingConfig(obj.sorting, warnings);
+
+	return {
+		config: { debug, profiles, sorting },
+		warnings,
+	};
+}
+
+function joinWarnings(warnings: Array<string | undefined>): string | undefined {
+	const filtered = warnings.filter((w): w is string => w !== undefined);
+	return filtered.length > 0 ? filtered.join("\n") : undefined;
+}
+
+function ensureConfigDirectory(configPath: string): void {
+	const configDir = dirname(configPath);
+	if (!existsSync(configDir)) {
+		mkdirSync(configDir, { recursive: true });
+	}
+}
+
+export function ensureMultiProfilesConfig(configPath: string = CONFIG_PATH): { created: boolean; warning?: string } {
+	if (existsSync(configPath)) {
+		return { created: false };
+	}
+
+	ensureConfigDirectory(configPath);
+	writeFileSync(configPath, createDefaultConfigContent(), "utf-8");
+	return { created: true };
+}
+
+export function loadMultiProfilesConfig(configPath: string = CONFIG_PATH): MultiProfilesConfigLoadResult {
+	const created = ensureMultiProfilesConfig(configPath);
+
+	try {
+		const content = readFileSync(configPath, "utf-8");
+		const raw = JSON.parse(content) as unknown;
+		const { config, warnings } = normalizeConfig(raw);
+		const warning = joinWarnings(warnings);
+
+		return { config, created: created.created, warning };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			config: cloneMultiProfilesConfig(DEFAULT_MULTI_PROFILES_CONFIG),
+			created: created.created,
+			warning: `Failed to parse config.json: ${message}. Using defaults.`,
+		};
+	}
+}
+
+export function saveMultiProfilesConfig(config: MultiProfilesConfig, configPath: string = CONFIG_PATH): void {
+	ensureConfigDirectory(configPath);
+	writeFileSync(configPath, JSON.stringify(config, null, "\t"), "utf-8");
+}
+
+export function ensureMultiProfilesDebugDirectory(debugDir: string = DEBUG_DIR): string | undefined {
+	try {
+		if (!existsSync(debugDir)) {
+			mkdirSync(debugDir, { recursive: true });
+		}
+		return debugDir;
+	} catch {
+		return undefined;
+	}
+}

package/src/constants.ts

@@ -0,0 +1,99 @@
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { join } from "node:path";
+import { CONFIG_PATH, DEBUG_DIR, DEBUG_LOG_PATH, EXTENSION_ROOT } from "./config.js";
+
+export const EXTENSION_NAME = "pi-model-profiles";
+export const COMMAND_NAME = "model-profiles";
+export const PROFILE_STORE_VERSION = 2 as const;
+export const PROFILE_NAME_SUFFIX = "snapshot";
+export const LEGACY_PROFILE_NAME_SUFFIX = "profile";
+export const INITIAL_PROFILE_NAME = "Current agents snapshot";
+const AGENT_DIR = getAgentDir();
+
+export const AGENTS_DIR = join(AGENT_DIR, "agents");
+export const THEMES_DIR = join(AGENT_DIR, "themes");
+export const SETTINGS_PATH = join(AGENT_DIR, "settings.json");
+export const PROFILE_STORE_PATH = join(AGENT_DIR, "extensions", EXTENSION_NAME, "profiles.json");
+
+// Re-export config paths for convenience
+export { CONFIG_PATH, DEBUG_DIR, DEBUG_LOG_PATH, EXTENSION_ROOT };
+export function resolveModalOverlayOptions(maxContentWidth: number): {
+	anchor: "center";
+	width: number;
+	maxHeight: number;
+	margin: number;
+} {
+	const terminalWidth =
+		typeof process.stdout.columns === "number" && Number.isFinite(process.stdout.columns)
+			? process.stdout.columns
+			: MODAL_MAX_WIDTH;
+	const terminalHeight =
+		typeof process.stdout.rows === "number" && Number.isFinite(process.stdout.rows)
+			? process.stdout.rows
+			: 36;
+	const margin = 1;
+	const availableWidth = Math.max(24, terminalWidth - margin * 2);
+	const preferredWidth = calculateModalWidth(maxContentWidth);
+	const minimumWidth = Math.min(MODAL_MIN_WIDTH, availableWidth);
+	const width = Math.max(minimumWidth, Math.min(preferredWidth, availableWidth));
+	const availableHeight = Math.max(10, terminalHeight - margin * 2);
+	const preferredHeight = Math.max(10, Math.floor(terminalHeight * 0.9));
+	const maxHeight = Math.min(preferredHeight, availableHeight);
+
+	return {
+		anchor: "center",
+		width,
+		maxHeight,
+		margin,
+	};
+}
+
+/**
+ * Minimum modal height in rows
+ */
+export const MODAL_MIN_HEIGHT = 20;
+
+/**
+ * Base height for modal (header, footer, padding)
+ */
+export const MODAL_BASE_HEIGHT = 10;
+
+/**
+ * Rows per agent in the details panel
+ */
+export const MODAL_ROWS_PER_AGENT = 3;
+
+/**
+ * Calculate dynamic modal height based on agent count.
+ * Formula: base height (10) + (agentCount * 3) clamped to min 20, max 90% of terminal
+ */
+export function calculateModalHeight(agentCount: number): number {
+	const terminalHeight = process.stdout.rows || 24;
+	const maxAllowedHeight = Math.floor(terminalHeight * 0.9);
+	const calculatedHeight = MODAL_BASE_HEIGHT + agentCount * MODAL_ROWS_PER_AGENT;
+	return Math.max(MODAL_MIN_HEIGHT, Math.min(calculatedHeight, maxAllowedHeight));
+}
+
+/**
+ * Minimum modal width in columns
+ */
+export const MODAL_MIN_WIDTH = 80;
+
+/**
+ * Maximum modal width in columns
+ */
+export const MODAL_MAX_WIDTH = 140;
+
+/**
+ * Base width for modal (borders, padding, labels)
+ */
+export const MODAL_BASE_WIDTH = 80;
+
+/**
+ * Calculate dynamic modal width based on content.
+ * Formula: base width (80) + maxAgentNameLength clamped to min 80, max 140
+ */
+export function calculateModalWidth(maxAgentNameLength: number): number {
+	const calculatedWidth = MODAL_BASE_WIDTH + maxAgentNameLength;
+	return Math.max(MODAL_MIN_WIDTH, Math.min(calculatedWidth, MODAL_MAX_WIDTH));
+}

package/src/debug-logger.ts

@@ -0,0 +1,351 @@
+import { appendFile, chmod } from "node:fs/promises";
+import {
+	CONFIG_PATH,
+	DEBUG_DIR,
+	DEBUG_LOG_PATH,
+	EXTENSION_NAME,
+	ensureMultiProfilesDebugDirectory,
+	loadMultiProfilesConfig,
+} from "./config.js";
+
+const DEFAULT_FLUSH_INTERVAL_MS = 5_000;
+const DEFAULT_FLUSH_ENTRY_LIMIT = 100;
+const DEFAULT_FLUSH_BYTE_LIMIT = 50 * 1024;
+const DEFAULT_MAX_BUFFERED_ENTRIES = 1_000;
+const DEFAULT_MAX_BUFFERED_BYTES = 512 * 1024;
+
+export interface MultiProfilesDebugLoggerOptions {
+	configPath?: string;
+	debugDir?: string;
+	logPath?: string;
+}
+
+function safeJsonStringify(value: unknown): string {
+	const seen = new WeakSet<object>();
+	return JSON.stringify(value, (_key, currentValue) => {
+		if (currentValue instanceof Error) {
+			return {
+				name: currentValue.name,
+				message: currentValue.message,
+				stack: currentValue.stack,
+			};
+		}
+
+		if (typeof currentValue === "bigint") {
+			return currentValue.toString();
+		}
+
+		if (typeof currentValue === "object" && currentValue !== null) {
+			if (seen.has(currentValue)) {
+				return "[Circular]";
+			}
+			seen.add(currentValue);
+		}
+
+		return currentValue;
+	});
+}
+
+function normalizePositiveInteger(value: number | undefined, fallback: number): number {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+		return Math.floor(value);
+	}
+	return fallback;
+}
+
+export interface AsyncBufferedLogWriterOptions {
+	enabled: boolean;
+	logPath: string;
+	ensureDirectory: () => string | undefined;
+	flushIntervalMs?: number;
+	flushEntryLimit?: number;
+	flushByteLimit?: number;
+	maxBufferedEntries?: number;
+	maxBufferedBytes?: number;
+	createDroppedEntriesLine?: (droppedEntries: number) => string;
+}
+
+export class AsyncBufferedLogWriter {
+	private readonly flushIntervalMs: number;
+	private readonly flushEntryLimit: number;
+	private readonly flushByteLimit: number;
+	private readonly maxBufferedEntries: number;
+	private readonly maxBufferedBytes: number;
+	private readonly createDroppedEntriesLine?: (droppedEntries: number) => string;
+	private readonly lines: string[] = [];
+	private enabled: boolean;
+	private bufferedBytes = 0;
+	private droppedEntries = 0;
+	private directoryReady = false;
+	private initializationError: string | undefined;
+	private flushTimer: ReturnType<typeof setTimeout> | null = null;
+	private flushPromise: Promise<void> | null = null;
+	private flushRequestedWhileBusy = false;
+	private shutdownHooksRegistered = false;
+
+	constructor(private readonly options: AsyncBufferedLogWriterOptions) {
+		this.enabled = options.enabled;
+		this.flushIntervalMs = normalizePositiveInteger(
+			options.flushIntervalMs,
+			DEFAULT_FLUSH_INTERVAL_MS,
+		);
+		this.flushEntryLimit = normalizePositiveInteger(
+			options.flushEntryLimit,
+			DEFAULT_FLUSH_ENTRY_LIMIT,
+		);
+		this.flushByteLimit = normalizePositiveInteger(
+			options.flushByteLimit,
+			DEFAULT_FLUSH_BYTE_LIMIT,
+		);
+		this.maxBufferedEntries = Math.max(
+			this.flushEntryLimit,
+			normalizePositiveInteger(options.maxBufferedEntries, DEFAULT_MAX_BUFFERED_ENTRIES),
+		);
+		this.maxBufferedBytes = Math.max(
+			this.flushByteLimit,
+			normalizePositiveInteger(options.maxBufferedBytes, DEFAULT_MAX_BUFFERED_BYTES),
+		);
+		this.createDroppedEntriesLine = options.createDroppedEntriesLine;
+	}
+
+	setEnabled(enabled: boolean): void {
+		if (this.enabled === enabled) {
+			return;
+		}
+
+		this.enabled = enabled;
+		if (!enabled) {
+			this.clearBuffer();
+		}
+	}
+
+	writeLine(line: string): string | undefined {
+		if (!this.enabled) {
+			return undefined;
+		}
+
+		const directoryError = this.ensureReady();
+		if (directoryError) {
+			return directoryError;
+		}
+
+		this.registerShutdownHooks();
+		this.pushLine(line);
+		if (
+			this.lines.length >= this.flushEntryLimit ||
+			this.bufferedBytes >= this.flushByteLimit
+		) {
+			void this.flush();
+		} else {
+			this.scheduleFlush();
+		}
+		return undefined;
+	}
+
+	async flush(): Promise<void> {
+		if (!this.enabled || this.lines.length === 0) {
+			return;
+		}
+
+		if (this.flushPromise) {
+			this.flushRequestedWhileBusy = true;
+			await this.flushPromise;
+			return;
+		}
+
+		this.clearFlushTimer();
+
+		const linesToFlush = [...this.lines];
+		const droppedEntries = this.droppedEntries;
+		this.clearBuffer();
+
+		this.flushPromise = this.performFlush(linesToFlush, droppedEntries);
+		try {
+			await this.flushPromise;
+		} finally {
+			this.flushPromise = null;
+			if (this.flushRequestedWhileBusy) {
+				this.flushRequestedWhileBusy = false;
+				void this.flush();
+			}
+		}
+	}
+
+	private ensureReady(): string | undefined {
+		if (this.directoryReady) {
+			return undefined;
+		}
+
+		if (this.initializationError) {
+			return this.initializationError;
+		}
+
+		try {
+			const result = this.options.ensureDirectory();
+			if (!result) {
+				this.initializationError = "Debug directory could not be created or accessed.";
+				return this.initializationError;
+			}
+			this.directoryReady = true;
+			return undefined;
+		} catch (error) {
+			this.initializationError =
+				error instanceof Error ? error.message : "Failed to initialize debug directory.";
+			return this.initializationError;
+		}
+	}
+
+	private pushLine(line: string): void {
+		const lineBytes = Buffer.byteLength(line, "utf-8");
+
+		if (
+			this.lines.length >= this.maxBufferedEntries ||
+			this.bufferedBytes + lineBytes > this.maxBufferedBytes
+		) {
+			this.droppedEntries++;
+			return;
+		}
+
+		this.lines.push(line);
+		this.bufferedBytes += lineBytes;
+	}
+
+	private clearBuffer(): void {
+		this.lines.length = 0;
+		this.bufferedBytes = 0;
+		this.droppedEntries = 0;
+	}
+
+	private scheduleFlush(): void {
+		if (this.flushTimer) {
+			return;
+		}
+
+		this.flushTimer = setTimeout(() => {
+			this.flushTimer = null;
+			void this.flush();
+		}, this.flushIntervalMs);
+	}
+
+	private clearFlushTimer(): void {
+		if (this.flushTimer) {
+			clearTimeout(this.flushTimer);
+			this.flushTimer = null;
+		}
+	}
+
+	private async performFlush(lines: string[], droppedEntries: number): Promise<void> {
+		let content = lines.join("");
+
+		if (droppedEntries > 0 && this.createDroppedEntriesLine) {
+			const droppedLine = this.createDroppedEntriesLine(droppedEntries);
+			content = droppedLine + content;
+		}
+
+		try {
+			await appendFile(this.options.logPath, content, "utf-8");
+			if (process.platform !== "win32") {
+				await chmod(this.options.logPath, 0o600);
+			}
+		} catch (error) {
+			this.initializationError =
+				error instanceof Error ? error.message : "Failed to write debug log.";
+			this.directoryReady = false;
+		}
+	}
+
+	private registerShutdownHooks(): void {
+		if (this.shutdownHooksRegistered) {
+			return;
+		}
+
+		this.shutdownHooksRegistered = true;
+
+		const flushAndExit = async (signal: string): Promise<void> => {
+			try {
+				await this.flush();
+			} finally {
+				process.removeListener(signal, flushAndExit as never);
+			}
+		};
+
+		process.on("exit", () => {
+			try {
+				const flushResult = this.flush();
+				if (flushResult && typeof flushResult.then === "function") {
+					flushResult.catch(() => {
+						// Ignore flush errors on exit
+					});
+				}
+			} catch {
+				// Ignore sync flush errors on exit
+			}
+		});
+
+		process.on("beforeExit", () => {
+			void this.flush();
+		});
+
+		process.on("SIGINT", () => {
+			void flushAndExit("SIGINT");
+		});
+
+		process.on("SIGTERM", () => {
+			void flushAndExit("SIGTERM");
+		});
+	}
+}
+
+export class MultiProfilesDebugLogger {
+	private initialized = false;
+	private readonly writer: AsyncBufferedLogWriter;
+
+	constructor(private readonly options: MultiProfilesDebugLoggerOptions = {}) {
+		this.writer = new AsyncBufferedLogWriter({
+			enabled: false,
+			logPath: this.options.logPath ?? DEBUG_LOG_PATH,
+			ensureDirectory: () => ensureMultiProfilesDebugDirectory(this.options.debugDir ?? DEBUG_DIR),
+			createDroppedEntriesLine: (droppedEntries) =>
+				`${safeJsonStringify({
+					timestamp: new Date().toISOString(),
+					level: "warn",
+					extension: EXTENSION_NAME,
+					event: "debug_log_overflow",
+					droppedEntries,
+				})}\n`,
+		});
+	}
+
+	private initialize(): void {
+		if (this.initialized) {
+			return;
+		}
+
+		this.initialized = true;
+		const configResult = loadMultiProfilesConfig(this.options.configPath ?? CONFIG_PATH);
+		this.writer.setEnabled(configResult.config.debug);
+	}
+
+	log(event: string, payload: Record<string, unknown> = {}): void {
+		try {
+			this.initialize();
+			this.writer.writeLine(
+				`${safeJsonStringify({
+					timestamp: new Date().toISOString(),
+					level: "debug",
+					extension: EXTENSION_NAME,
+					event,
+					...payload,
+				})}\n`,
+			);
+		} catch {
+			// Debug log failures must never affect extension functionality.
+		}
+	}
+
+	flush(): Promise<void> {
+		return this.writer.flush();
+	}
+}
+
+export const multiProfilesDebugLogger = new MultiProfilesDebugLogger();

package/src/errors.ts

@@ -0,0 +1,16 @@
+export class ModelProfilesError extends Error {
+	readonly code: string;
+
+	constructor(message: string, code = "MODEL_PROFILES_ERROR") {
+		super(message);
+		this.name = "ModelProfilesError";
+		this.code = code;
+	}
+}
+
+export function toErrorMessage(error: unknown): string {
+	if (error instanceof Error && error.message.trim()) {
+		return error.message;
+	}
+	return String(error);
+}