@oh-my-pi/pi-coding-agent 11.0.3 → 11.2.0

package/src/config.ts

@@ -2,6 +2,10 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $env, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import type { TSchema } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value/index.mjs";
+import { Ajv, type ErrorObject, type ValidateFunction } from "ajv";
+import { JSONC, YAML } from "bun";
 // Embed package.json at build time for config
 import packageJson from "../package.json" with { type: "json" };
 
@@ -51,29 +55,205 @@ export function getChangelogPath(): string {
 // User Config Paths (~/.omp/agent/*)
 // =============================================================================
 
-/** Get the agent config directory (e.g., ~/.omp/agent/) */
-export function getAgentDir(): string {
-	return $env.PI_CODING_AGENT_DIR || path.join(os.homedir(), CONFIG_DIR_NAME, "agent");
+function migrateJsonToYml(jsonPath: string, ymlPath: string) {
+	try {
+		if (fs.existsSync(ymlPath)) return;
+		if (!fs.existsSync(jsonPath)) return;
+
+		const content = fs.readFileSync(jsonPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (!parsed) {
+			logger.warn("migrateJsonToYml: invalid json structure", { path: jsonPath });
+			return;
+		}
+		fs.writeFileSync(ymlPath, YAML.stringify(parsed, null, 2));
+	} catch (error) {
+		logger.warn("migrateJsonToYml: migration failed", { error: String(error) });
+	}
 }
 
-/** Get path to user's custom themes directory */
-export function getCustomThemesDir(): string {
-	return path.join(getAgentDir(), "themes");
+export interface IConfigFile<T> {
+	readonly id: string;
+	readonly schema: TSchema;
+	path?(): string;
+	load(): T | null;
+	invalidate?(): void;
 }
 
-/** Get path to models.json */
-export function getModelsPath(): string {
-	return path.join(getAgentDir(), "models.json");
+export class ConfigError extends Error {
+	readonly #message: string;
+	constructor(
+		public readonly id: string,
+		public readonly schemaErrors: ErrorObject[] | null | undefined,
+		public readonly other?: { err: unknown; stage: string },
+	) {
+		let messages: string[] | undefined;
+		let cause: any | undefined;
+		let klass: string;
+
+		if (schemaErrors) {
+			klass = "Schema";
+			messages = schemaErrors.map(e => `${e.instancePath || "root"}: ${e.message}`);
+		} else if (other) {
+			klass = other.stage;
+			if (other.err instanceof Error) {
+				messages = [other.err.message];
+				cause = other.err;
+			} else {
+				messages = [String(other.err)];
+			}
+		} else {
+			klass = "Unknown";
+		}
+
+		const title = `Failed to load config file ${id}, ${klass} error:`;
+		let message: string;
+		switch (messages?.length ?? 0) {
+			case 0:
+				message = title.slice(0, -1);
+				break;
+			case 1:
+				message = `${title} ${messages![0]}`;
+				break;
+			default:
+				message = `${title}\n${messages!.map(m => `  - ${m}`).join("\n")}`;
+				break;
+		}
+
+		super(message, { cause });
+		this.name = "LoadError";
+		this.#message = message;
+	}
+
+	get message(): string {
+		return this.#message;
+	}
+
+	toString(): string {
+		return this.message;
+	}
 }
 
-/** Get path to models.yml (preferred over models.json) */
-export function getModelsYamlPath(): string {
-	return path.join(getAgentDir(), "models.yml");
+export type LoadStatus = "ok" | "error" | "not-found";
+
+export type LoadResult<T> =
+	| { value?: null; error: ConfigError; status: "error" }
+	| { value: T; error?: undefined; status: "ok" }
+	| { value?: null; error?: unknown; status: "not-found" };
+
+const ajv = new Ajv();
+export class ConfigFile<T> implements IConfigFile<T> {
+	readonly #basePath: string;
+	#cache?: LoadResult<T>;
+	#auxValidate?: (value: T) => void;
+
+	constructor(
+		public readonly id: string,
+		public readonly schema: TSchema,
+		configPath: string = path.join(getAgentDir(), `${id}.yml`),
+	) {
+		this.#basePath = configPath;
+		if (configPath.endsWith(".yml")) {
+			const jsonPath = `${configPath.slice(0, -4)}.json`;
+			migrateJsonToYml(jsonPath, configPath);
+		} else if (configPath.endsWith(".yaml")) {
+			const jsonPath = `${configPath.slice(0, -5)}.json`;
+			migrateJsonToYml(jsonPath, configPath);
+		} else if (configPath.endsWith(".json") || configPath.endsWith(".jsonc")) {
+			// JSON configs are still supported without migration.
+		} else {
+			throw new Error(`Invalid config file path: ${configPath}`);
+		}
+	}
+
+	relocate(path?: string): ConfigFile<T> {
+		if (!path || path === this.#basePath) return this;
+		const result = new ConfigFile<T>(this.id, this.schema, path);
+		result.#auxValidate = this.#auxValidate;
+		return result;
+	}
+
+	withValidation(name: string, validate: (value: T) => void): this {
+		const prev = this.#auxValidate;
+		this.#auxValidate = (value: T) => {
+			prev?.(value);
+			try {
+				validate(value);
+			} catch (error) {
+				throw new ConfigError(this.id, undefined, { err: error, stage: `Validate(${name})` });
+			}
+		};
+		return this;
+	}
+
+	createDefault() {
+		return Value.Default(this.schema, [], undefined) as T;
+	}
+
+	#storeCache(result: LoadResult<T>): LoadResult<T> {
+		this.#cache = result;
+		return result;
+	}
+
+	tryLoad(): LoadResult<T> {
+		if (this.#cache) return this.#cache;
+
+		try {
+			const content = fs.readFileSync(this.path(), "utf-8").trim();
+
+			let parsed: unknown;
+			if (this.#basePath.endsWith(".json") || this.#basePath.endsWith(".jsonc")) {
+				parsed = JSONC.parse(content);
+			} else if (this.#basePath.endsWith(".yml") || this.#basePath.endsWith(".yaml")) {
+				parsed = YAML.parse(content);
+			} else {
+				throw new Error(`Invalid config file path: ${this.#basePath}`);
+			}
+
+			const validate = ajv.compile(this.schema) as ValidateFunction<T>;
+			if (!validate(parsed)) {
+				const error = new ConfigError(this.id, validate.errors);
+				logger.warn("Failed to parse config file", { path: this.path(), error });
+				return this.#storeCache({ error, status: "error" });
+			}
+			return this.#storeCache({ value: parsed, status: "ok" });
+		} catch (error) {
+			if (!isEnoent(error)) {
+				return this.#storeCache({ status: "not-found" });
+			}
+			logger.warn("Failed to parse config file", { path: this.path(), error });
+			return this.#storeCache({
+				error: new ConfigError(this.id, undefined, { err: error, stage: "Unexpected" }),
+				status: "error",
+			});
+		}
+	}
+
+	load(): T | null {
+		return this.tryLoad().value ?? null;
+	}
+
+	loadOrDefault(): T {
+		return this.tryLoad().value ?? this.createDefault();
+	}
+
+	path(): string {
+		return this.#basePath;
+	}
+
+	invalidate() {
+		this.#cache = undefined;
+	}
+}
+
+/** Get the agent config directory (e.g., ~/.omp/agent/) */
+export function getAgentDir(): string {
+	return $env.PI_CODING_AGENT_DIR || path.join(os.homedir(), CONFIG_DIR_NAME, "agent");
 }
 
-/** Get path to auth.json */
-export function getAuthPath(): string {
-	return path.join(getAgentDir(), "auth.json");
+/** Get path to user's custom themes directory */
+export function getCustomThemesDir(): string {
+	return path.join(getAgentDir(), "themes");
 }
 
 /**
@@ -204,75 +384,6 @@ export interface ConfigFileResult<T> {
 	content: T;
 }
 
-/**
- * Read the first existing config file from priority-ordered locations.
- *
- * @param subpath - Subpath within config dirs (e.g., "settings.json", "models.json")
- * @param options - Options for filtering (same as getConfigDirs)
- * @returns The parsed content and metadata, or undefined if not found
- *
- * @example
- * const result = readConfigFile<Settings>("settings.json", { project: false });
- * if (result) {
- *   console.log(`Loaded from ${result.path}`);
- *   console.log(result.content);
- * }
- */
-export async function readConfigFile<T = unknown>(
-	subpath: string,
-	options: GetConfigDirsOptions = {},
-): Promise<ConfigFileResult<T> | undefined> {
-	const dirs = getConfigDirs("", { ...options, existingOnly: false });
-
-	for (const { path: base, source, level } of dirs) {
-		const filePath = path.join(base, subpath);
-		try {
-			const content = await Bun.file(filePath).text();
-			return {
-				path: filePath,
-				source,
-				level,
-				content: JSON.parse(content) as T,
-			};
-		} catch (error) {
-			if (isEnoent(error)) continue;
-			logger.warn("Failed to parse config file", { path: filePath, error: String(error) });
-		}
-	}
-
-	return undefined;
-}
-
-/**
- * Get all existing config files for a subpath (for merging scenarios).
- * Returns in priority order (highest first).
- */
-export async function readAllConfigFiles<T = unknown>(
-	subpath: string,
-	options: GetConfigDirsOptions = {},
-): Promise<ConfigFileResult<T>[]> {
-	const dirs = getConfigDirs("", { ...options, existingOnly: false });
-	const results: ConfigFileResult<T>[] = [];
-
-	for (const { path: base, source, level } of dirs) {
-		const filePath = path.join(base, subpath);
-		try {
-			const content = await Bun.file(filePath).text();
-			results.push({
-				path: filePath,
-				source,
-				level,
-				content: JSON.parse(content) as T,
-			});
-		} catch (error) {
-			if (isEnoent(error)) continue;
-			logger.warn("Failed to parse config file", { path: filePath, error: String(error) });
-		}
-	}
-
-	return results;
-}
-
 /**
  * Find the first existing config file (for non-JSON files like SYSTEM.md).
  * Returns just the path, or undefined if not found.
@@ -313,55 +424,12 @@ export function findConfigFileWithMeta(
 // Walk-Up Config Discovery (for monorepo scenarios)
 // =============================================================================
 
-async function isDirectory(p: string): Promise<boolean> {
-	try {
-		return (await fs.promises.stat(p)).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Find nearest config directory by walking up from cwd.
- * Checks all config bases (.omp, .pi, .claude) at each level.
- *
- * @param subpath - Subpath within config dirs (e.g., "commands", "agents")
- * @param cwd - Starting directory
- * @returns First existing directory found, or undefined
- */
-export async function findNearestProjectConfigDir(
-	subpath: string,
-	cwd: string = process.cwd(),
-): Promise<ConfigDirEntry | undefined> {
-	let currentDir = cwd;
-
-	while (true) {
-		// Check all config bases at this level, in priority order
-		for (const { base, name } of PROJECT_CONFIG_BASES) {
-			const candidate = path.join(currentDir, base, subpath);
-			if (await isDirectory(candidate)) {
-				return { path: candidate, source: name, level: "project" };
-			}
-		}
-
-		// Move up one directory
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) break; // Reached root
-		currentDir = parentDir;
-	}
-
-	return undefined;
-}
-
 /**
  * Find all nearest config directories by walking up from cwd.
  * Returns one entry per config base (.omp, .pi, .claude) - the nearest one found.
  * Results are in priority order (highest first).
  */
-export async function findAllNearestProjectConfigDirs(
-	subpath: string,
-	cwd: string = process.cwd(),
-): Promise<ConfigDirEntry[]> {
+export function findAllNearestProjectConfigDirs(subpath: string, cwd: string = process.cwd()): ConfigDirEntry[] {
 	const results: ConfigDirEntry[] = [];
 	const foundBases = new Set<string>();
 
@@ -372,10 +440,12 @@ export async function findAllNearestProjectConfigDirs(
 			if (foundBases.has(name)) continue;
 
 			const candidate = path.join(currentDir, base, subpath);
-			if (await isDirectory(candidate)) {
-				results.push({ path: candidate, source: name, level: "project" });
-				foundBases.add(name);
-			}
+			try {
+				if (fs.statSync(candidate).isDirectory()) {
+					results.push({ path: candidate, source: name, level: "project" });
+					foundBases.add(name);
+				}
+			} catch {}
 		}
 
 		const parentDir = path.dirname(currentDir);

package/src/exa/mcp-client.ts

@@ -1,10 +1,4 @@
-/**
- * Exa MCP Client
- *
- * Client for interacting with Exa MCP servers.
- */
-import * as os from "node:os";
-import { $env, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { $env, logger } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import type { CustomTool, CustomToolResult } from "../extensibility/custom-tools/types";
 import { callMCP } from "../mcp/json-rpc";
@@ -19,32 +13,8 @@ import type {
 } from "./types";
 
 /** Find EXA_API_KEY from Bun.env or .env files */
-export async function findApiKey(): Promise<string | null> {
-	// Check Bun.env first
-	if ($env.EXA_API_KEY) {
-		return $env.EXA_API_KEY;
-	}
-
-	// Try loading from .env files in cwd and home
-	const cwd = process.cwd();
-	const home = os.homedir();
-
-	for (const dir of [cwd, home]) {
-		const envPath = `${dir}/.env`;
-		try {
-			const content = await Bun.file(envPath).text();
-			const match = content.match(/^EXA_API_KEY=(.+)$/m);
-			if (match?.[1]) {
-				return match[1].trim().replace(/^["']|["']$/g, "");
-			}
-		} catch (err) {
-			if (!isEnoent(err)) {
-				logger.debug("Error reading .env file", { path: envPath, error: String(err) });
-			}
-		}
-	}
-
-	return null;
+export function findApiKey(): string | null {
+	return $env.EXA_API_KEY;
 }
 
 /** Fetch available tools from Exa MCP */
@@ -249,17 +219,14 @@ export async function fetchMCPToolSchema(
 export class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
 	public readonly name: string;
 	public readonly label: string;
-	public readonly description: string;
-	public readonly parameters: TSchema;
-
-	private readonly config: MCPToolWrapperConfig;
 
-	constructor(config: MCPToolWrapperConfig, schema: TSchema, description: string) {
-		this.config = config;
+	constructor(
+		private readonly config: MCPToolWrapperConfig,
+		public readonly parameters: TSchema,
+		public readonly description: string,
+	) {
 		this.name = config.name;
 		this.label = config.label;
-		this.description = description;
-		this.parameters = schema;
 	}
 
 	async execute(

package/src/export/html/index.ts

@@ -102,7 +102,7 @@ interface SessionData {
 /** Generate HTML from bundled template with runtime substitutions. */
 async function generateHtml(sessionData: SessionData, themeName?: string): Promise<string> {
 	const themeVars = await generateThemeVars(themeName);
-	const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toString("base64");
+	const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toBase64();
 
 	return TEMPLATE.replace("<theme-vars/>", `<style>:root { ${themeVars} }</style>`).replace(
 		"{{SESSION_DATA}}",

package/src/extensibility/extensions/loader.ts

@@ -103,17 +103,14 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	readonly logger = logger;
 	readonly typebox = TypeBox;
 	readonly pi = piCodingAgent;
-	readonly events: EventBus;
 	readonly flagValues = new Map<string, boolean | string>();
 
 	constructor(
-		private extension: Extension,
-		private runtime: IExtensionRuntime,
-		private cwd: string,
-		eventBus: EventBus,
-	) {
-		this.events = eventBus;
-	}
+		private readonly extension: Extension,
+		private readonly runtime: IExtensionRuntime,
+		private readonly cwd: string,
+		public readonly events: EventBus,
+	) {}
 
 	on<F extends HandlerFn>(event: string, handler: F): void {
 		const list = this.extension.handlers.get(event) ?? [];
@@ -214,8 +211,8 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 		return this.runtime.getThinkingLevel();
 	}
 
-	setThinkingLevel(level: ThinkingLevel): void {
-		this.runtime.setThinkingLevel(level);
+	setThinkingLevel(level: ThinkingLevel, persist?: boolean): void {
+		this.runtime.setThinkingLevel(level, persist);
 	}
 }
 

package/src/extensibility/extensions/runner.ts

@@ -105,12 +105,7 @@ const noOpUIContext: ExtensionUIContext = {
 };
 
 export class ExtensionRunner {
-	private extensions: Extension[];
-	private runtime: ExtensionRuntime;
 	private uiContext: ExtensionUIContext;
-	private cwd: string;
-	private sessionManager: SessionManager;
-	private modelRegistry: ModelRegistry;
 	private errorListeners: Set<ExtensionErrorListener> = new Set();
 	private getModel: () => Model | undefined = () => undefined;
 	private isIdleFn: () => boolean = () => true;
@@ -125,18 +120,13 @@ export class ExtensionRunner {
 	private shutdownHandler: ShutdownHandler = () => {};
 
 	constructor(
-		extensions: Extension[],
-		runtime: ExtensionRuntime,
-		cwd: string,
-		sessionManager: SessionManager,
-		modelRegistry: ModelRegistry,
+		private readonly extensions: Extension[],
+		private readonly runtime: ExtensionRuntime,
+		private readonly cwd: string,
+		private readonly sessionManager: SessionManager,
+		private readonly modelRegistry: ModelRegistry,
 	) {
-		this.extensions = extensions;
-		this.runtime = runtime;
 		this.uiContext = noOpUIContext;
-		this.cwd = cwd;
-		this.sessionManager = sessionManager;
-		this.modelRegistry = modelRegistry;
 	}
 
 	initialize(

package/src/extensibility/extensions/types.ts

@@ -839,7 +839,7 @@ export type SetModelHandler = (model: Model) => Promise<boolean>;
 
 export type GetThinkingLevelHandler = () => ThinkingLevel;
 
-export type SetThinkingLevelHandler = (level: ThinkingLevel) => void;
+export type SetThinkingLevelHandler = (level: ThinkingLevel, persist?: boolean) => void;
 
 /** Shared state created by loader, used during registration and runtime. */
 export interface ExtensionRuntimeState {

package/src/extensibility/hooks/runner.ts

@@ -62,12 +62,8 @@ const noOpUIContext: HookUIContext = {
  * HookRunner executes hooks and manages event emission.
  */
 export class HookRunner {
-	private hooks: LoadedHook[];
 	private uiContext: HookUIContext;
 	private hasUI: boolean;
-	private cwd: string;
-	private sessionManager: SessionManager;
-	private modelRegistry: ModelRegistry;
 	private errorListeners: Set<HookErrorListener> = new Set();
 	private getModel: () => Model | undefined = () => undefined;
 	private isIdleFn: () => boolean = () => true;
@@ -78,13 +74,14 @@ export class HookRunner {
 	private branchHandler: BranchHandler = async () => ({ cancelled: false });
 	private navigateTreeHandler: NavigateTreeHandler = async () => ({ cancelled: false });
 
-	constructor(hooks: LoadedHook[], cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry) {
-		this.hooks = hooks;
+	constructor(
+		private readonly hooks: LoadedHook[],
+		private readonly cwd: string,
+		private readonly sessionManager: SessionManager,
+		private readonly modelRegistry: ModelRegistry,
+	) {
 		this.uiContext = noOpUIContext;
 		this.hasUI = false;
-		this.cwd = cwd;
-		this.sessionManager = sessionManager;
-		this.modelRegistry = modelRegistry;
 	}
 
 	/**

package/src/index.ts

@@ -167,7 +167,6 @@ export {
 	discoverCustomTSCommands,
 	discoverExtensions,
 	discoverMCPServers,
-	discoverModels,
 	discoverPromptTemplates,
 	discoverSkills,
 	EditTool,

package/src/ipy/kernel.ts

@@ -16,11 +16,11 @@ const PRELUDE_INTROSPECTION_SNIPPET = "import json\nprint(json.dumps(__omp_prelu
 const debugStartup = $env.PI_DEBUG_STARTUP ? (stage: string) => process.stderr.write(`[startup] ${stage}\n`) : () => {};
 
 class SharedGatewayCreateError extends Error {
-	readonly status: number;
-
-	constructor(status: number, message: string) {
+	constructor(
+		readonly status: number,
+		message: string,
+	) {
 		super(message);
-		this.status = status;
 	}
 }
 
@@ -265,12 +265,6 @@ export function serializeWebSocketMessage(msg: JupyterMessage): ArrayBuffer {
 }
 
 export class PythonKernel {
-	readonly id: string;
-	readonly kernelId: string;
-	readonly gatewayUrl: string;
-	readonly sessionId: string;
-	readonly username: string;
-	readonly isSharedGateway: boolean;
 	readonly #authToken?: string;
 
 	#ws: WebSocket | null = null;
@@ -281,20 +275,14 @@ export class PythonKernel {
 	#pendingExecutions = new Map<string, (reason: string) => void>();
 
 	private constructor(
-		id: string,
-		kernelId: string,
-		gatewayUrl: string,
-		sessionId: string,
-		username: string,
-		isSharedGateway: boolean,
+		readonly id: string,
+		readonly kernelId: string,
+		readonly gatewayUrl: string,
+		readonly sessionId: string,
+		readonly username: string,
+		readonly isSharedGateway: boolean,
 		authToken?: string,
 	) {
-		this.id = id;
-		this.kernelId = kernelId;
-		this.gatewayUrl = gatewayUrl;
-		this.sessionId = sessionId;
-		this.username = username;
-		this.isSharedGateway = isSharedGateway;
 		this.#authToken = authToken;
 	}
 

package/src/lsp/clients/biome-client.ts

@@ -107,18 +107,15 @@ async function runBiome(
  * Parses Biome's --reporter=json output into LSP Diagnostic format.
  */
 export class BiomeClient implements LinterClient {
-	private config: ServerConfig;
-	private cwd: string;
-
 	/** Factory method for creating BiomeClient instances */
 	static create(config: ServerConfig, cwd: string): LinterClient {
 		return new BiomeClient(config, cwd);
 	}
 
-	constructor(config: ServerConfig, cwd: string) {
-		this.config = config;
-		this.cwd = cwd;
-	}
+	constructor(
+		private readonly config: ServerConfig,
+		private readonly cwd: string,
+	) {}
 
 	async format(filePath: string, content: string): Promise<string> {
 		// Write content to file first

package/src/lsp/clients/lsp-linter-client.ts

@@ -21,8 +21,6 @@ const DEFAULT_FORMAT_OPTIONS = {
  * Wraps the existing LSP client infrastructure.
  */
 export class LspLinterClient implements LinterClient {
-	private config: ServerConfig;
-	private cwd: string;
 	private client: LspClient | null = null;
 
 	/** Factory method for creating LspLinterClient instances */
@@ -30,10 +28,10 @@ export class LspLinterClient implements LinterClient {
 		return new LspLinterClient(config, cwd);
 	}
 
-	constructor(config: ServerConfig, cwd: string) {
-		this.config = config;
-		this.cwd = cwd;
-	}
+	constructor(
+		private readonly config: ServerConfig,
+		private readonly cwd: string,
+	) {}
 
 	private async getClient(): Promise<LspClient> {
 		if (!this.client) {