@oh-my-pi/pi-coding-agent 8.1.0 → 8.2.0

package/src/extensibility/plugins/installer.ts

@@ -1,10 +1,10 @@
-import { lstatSync, symlinkSync, unlinkSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { getAgentDir } from "@oh-my-pi/pi-coding-agent/config";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import { getAgentDir } from "../../config";
 import type { InstalledPlugin } from "./types";
 
-const PLUGINS_DIR = join(getAgentDir(), "plugins");
+const PLUGINS_DIR = path.join(getAgentDir(), "plugins");
 
 // Valid npm package name pattern (scoped and unscoped)
 const VALID_PACKAGE_NAME = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*(@[a-z0-9-._^~>=<]+)?$/i;
@@ -26,8 +26,8 @@ function validatePackageName(name: string): void {
  * Ensure the plugins directory exists
  */
 async function ensurePluginsDir(): Promise<void> {
-	await mkdir(PLUGINS_DIR, { recursive: true });
-	await mkdir(join(PLUGINS_DIR, "node_modules"), { recursive: true });
+	await fs.mkdir(PLUGINS_DIR, { recursive: true });
+	await fs.mkdir(path.join(PLUGINS_DIR, "node_modules"), { recursive: true });
 }
 
 export async function installPlugin(packageName: string): Promise<InstalledPlugin> {
@@ -38,7 +38,7 @@ export async function installPlugin(packageName: string): Promise<InstalledPlugi
 	await ensurePluginsDir();
 
 	// Initialize package.json if it doesn't exist
-	const pkgJsonPath = join(PLUGINS_DIR, "package.json");
+	const pkgJsonPath = path.join(PLUGINS_DIR, "package.json");
 	const pkgJson = Bun.file(pkgJsonPath);
 	if (!(await pkgJson.exists())) {
 		await pkgJson.write(JSON.stringify({ name: "omp-plugins", private: true, dependencies: {} }, null, 2));
@@ -62,7 +62,7 @@ export async function installPlugin(packageName: string): Promise<InstalledPlugi
 	const actualName = packageName.replace(/@[^/]+$/, "").replace(/^(@[^/]+\/[^@]+).*$/, "$1");
 
 	// Read the installed package's package.json
-	const pkgPath = join(PLUGINS_DIR, "node_modules", actualName, "package.json");
+	const pkgPath = path.join(PLUGINS_DIR, "node_modules", actualName, "package.json");
 	const pkgFile = Bun.file(pkgPath);
 	if (!(await pkgFile.exists())) {
 		throw new Error(`Package installed but package.json not found at ${pkgPath}`);
@@ -73,7 +73,7 @@ export async function installPlugin(packageName: string): Promise<InstalledPlugi
 	return {
 		name: pkg.name,
 		version: pkg.version,
-		path: join(PLUGINS_DIR, "node_modules", actualName),
+		path: path.join(PLUGINS_DIR, "node_modules", actualName),
 		manifest: pkg.omp || pkg.pi || { version: pkg.version },
 		enabledFeatures: null,
 		enabled: true,
@@ -100,7 +100,7 @@ export async function uninstallPlugin(name: string): Promise<void> {
 }
 
 export async function listPlugins(): Promise<InstalledPlugin[]> {
-	const pkgJsonPath = Bun.file(join(PLUGINS_DIR, "package.json"));
+	const pkgJsonPath = Bun.file(path.join(PLUGINS_DIR, "package.json"));
 	if (!(await pkgJsonPath.exists())) {
 		return [];
 	}
@@ -110,14 +110,14 @@ export async function listPlugins(): Promise<InstalledPlugin[]> {
 
 	const plugins: InstalledPlugin[] = [];
 	for (const [name, _version] of Object.entries(deps)) {
-		const path = join(PLUGINS_DIR, "node_modules", name);
-		const fpkg = Bun.file(join(path, "package.json"));
+		const pluginPath = path.join(PLUGINS_DIR, "node_modules", name);
+		const fpkg = Bun.file(path.join(pluginPath, "package.json"));
 		if (await fpkg.exists()) {
 			const pkg = await fpkg.json();
 			plugins.push({
 				name,
 				version: pkg.version,
-				path,
+				path: pluginPath,
 				manifest: pkg.omp || pkg.pi || { version: pkg.version },
 				enabledFeatures: null,
 				enabled: true,
@@ -130,17 +130,17 @@ export async function listPlugins(): Promise<InstalledPlugin[]> {
 
 export async function linkPlugin(localPath: string): Promise<void> {
 	const cwd = process.cwd();
-	const absolutePath = resolve(cwd, localPath);
+	const absolutePath = path.resolve(cwd, localPath);
 
 	// Validate that resolved path is within cwd to prevent path traversal
-	const normalizedCwd = resolve(cwd);
-	const normalizedPath = resolve(absolutePath);
+	const normalizedCwd = path.resolve(cwd);
+	const normalizedPath = path.resolve(absolutePath);
 	if (!normalizedPath.startsWith(`${normalizedCwd}/`) && normalizedPath !== normalizedCwd) {
 		throw new Error(`Invalid path: ${localPath} resolves outside working directory`);
 	}
 
 	// Validate package.json exists
-	const pkgFile = Bun.file(join(absolutePath, "package.json"));
+	const pkgFile = Bun.file(path.join(absolutePath, "package.json"));
 	if (!(await pkgFile.exists())) {
 		throw new Error(`package.json not found at ${absolutePath}`);
 	}
@@ -167,24 +167,24 @@ export async function linkPlugin(localPath: string): Promise<void> {
 	await ensurePluginsDir();
 
 	// Create symlink in plugins/node_modules
-	const linkPath = join(PLUGINS_DIR, "node_modules", pkg.name);
+	const linkPath = path.join(PLUGINS_DIR, "node_modules", pkg.name);
 
 	// For scoped packages, ensure the scope directory exists
 	if (pkg.name.startsWith("@")) {
-		const scopeDir = join(PLUGINS_DIR, "node_modules", pkg.name.split("/")[0]);
-		await mkdir(scopeDir, { recursive: true });
+		const scopeDir = path.join(PLUGINS_DIR, "node_modules", pkg.name.split("/")[0]);
+		await fs.mkdir(scopeDir, { recursive: true });
 	}
 
 	// Remove existing if present
 	try {
-		const stat = lstatSync(linkPath);
-		if (stat.isSymbolicLink() || stat.isDirectory()) {
-			unlinkSync(linkPath);
+		const stats = await fs.lstat(linkPath);
+		if (stats.isSymbolicLink() || stats.isDirectory()) {
+			await fs.unlink(linkPath);
 		}
-	} catch {
-		// Doesn't exist, that's fine
+	} catch (err) {
+		if (!isEnoent(err)) throw err;
 	}
 
 	// Create symlink using fs instead of shell command
-	symlinkSync(absolutePath, linkPath);
+	await fs.symlink(absolutePath, linkPath);
 }

package/src/extensibility/plugins/loader.ts

@@ -4,9 +4,9 @@
  * Reads enabled plugins from the runtime config and loads their tools/hooks
  * based on manifest entries and enabled features.
  */
-
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
 import {
 	getAllProjectPluginOverridePaths,
 	getPluginsLockfile,
@@ -22,29 +22,26 @@ import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPlugi
 /**
  * Load plugin runtime config from lock file.
  */
-function loadRuntimeConfig(): PluginRuntimeConfig {
+async function loadRuntimeConfig(): Promise<PluginRuntimeConfig> {
 	const lockPath = getPluginsLockfile();
-	if (!existsSync(lockPath)) {
-		return { plugins: {}, settings: {} };
-	}
 	try {
-		return JSON.parse(readFileSync(lockPath, "utf-8"));
-	} catch {
-		return { plugins: {}, settings: {} };
+		return await Bun.file(lockPath).json();
+	} catch (err) {
+		if (isEnoent(err)) return { plugins: {}, settings: {} };
+		throw err;
 	}
 }
 
 /**
  * Load project-local plugin overrides (checks .omp and .pi directories).
  */
-function loadProjectOverrides(cwd: string): ProjectPluginOverrides {
+async function loadProjectOverrides(cwd: string): Promise<ProjectPluginOverrides> {
 	for (const overridesPath of getAllProjectPluginOverridePaths(cwd)) {
-		if (existsSync(overridesPath)) {
-			try {
-				return JSON.parse(readFileSync(overridesPath, "utf-8"));
-			} catch {
-				// Continue to next path
-			}
+		try {
+			return await Bun.file(overridesPath).json();
+		} catch (err) {
+			if (isEnoent(err)) continue;
+			// JSON parse error - continue to next path
 		}
 	}
 	return {};
@@ -58,30 +55,36 @@ function loadProjectOverrides(cwd: string): ProjectPluginOverrides {
  * Get list of enabled plugins with their resolved configurations.
  * Respects both global runtime config and project overrides.
  */
-export function getEnabledPlugins(cwd: string): InstalledPlugin[] {
+export async function getEnabledPlugins(cwd: string): Promise<InstalledPlugin[]> {
 	const pkgJsonPath = getPluginsPackageJson();
-	if (!existsSync(pkgJsonPath)) {
-		return [];
+	let pkg: { dependencies?: Record<string, string> };
+	try {
+		pkg = await Bun.file(pkgJsonPath).json();
+	} catch (err) {
+		if (isEnoent(err)) return [];
+		throw err;
 	}
 
 	const nodeModulesPath = getPluginsNodeModules();
-	if (!existsSync(nodeModulesPath)) {
+	if (!fs.existsSync(nodeModulesPath)) {
 		return [];
 	}
 
-	const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
 	const deps = pkg.dependencies || {};
-	const runtimeConfig = loadRuntimeConfig();
-	const projectOverrides = loadProjectOverrides(cwd);
+	const runtimeConfig = await loadRuntimeConfig();
+	const projectOverrides = await loadProjectOverrides(cwd);
 	const plugins: InstalledPlugin[] = [];
 
 	for (const [name] of Object.entries(deps)) {
-		const pluginPkgPath = join(nodeModulesPath, name, "package.json");
-		if (!existsSync(pluginPkgPath)) {
-			continue;
+		const pluginPkgPath = path.join(nodeModulesPath, name, "package.json");
+		let pluginPkg: { version: string; omp?: PluginManifest; pi?: PluginManifest };
+		try {
+			pluginPkg = await Bun.file(pluginPkgPath).json();
+		} catch (err) {
+			if (isEnoent(err)) continue;
+			throw err;
 		}
 
-		const pluginPkg = JSON.parse(readFileSync(pluginPkgPath, "utf-8"));
 		const manifest: PluginManifest | undefined = pluginPkg.omp || pluginPkg.pi;
 
 		if (!manifest) {
@@ -109,7 +112,7 @@ export function getEnabledPlugins(cwd: string): InstalledPlugin[] {
 		plugins.push({
 			name,
 			version: pluginPkg.version,
-			path: join(nodeModulesPath, name),
+			path: path.join(nodeModulesPath, name),
 			manifest,
 			enabledFeatures,
 			enabled: true,
@@ -133,8 +136,8 @@ export function resolvePluginToolPaths(plugin: InstalledPlugin): string[] {
 
 	// Base tools entry (always included if exists)
 	if (manifest.tools) {
-		const toolPath = join(plugin.path, manifest.tools);
-		if (existsSync(toolPath)) {
+		const toolPath = path.join(plugin.path, manifest.tools);
+		if (fs.existsSync(toolPath)) {
 			paths.push(toolPath);
 		}
 	}
@@ -148,8 +151,8 @@ export function resolvePluginToolPaths(plugin: InstalledPlugin): string[] {
 
 			if (feat.tools) {
 				for (const toolEntry of feat.tools) {
-					const toolPath = join(plugin.path, toolEntry);
-					if (existsSync(toolPath)) {
+					const toolPath = path.join(plugin.path, toolEntry);
+					if (fs.existsSync(toolPath)) {
 						paths.push(toolPath);
 					}
 				}
@@ -162,8 +165,8 @@ export function resolvePluginToolPaths(plugin: InstalledPlugin): string[] {
 
 			if (feat.tools) {
 				for (const toolEntry of feat.tools) {
-					const toolPath = join(plugin.path, toolEntry);
-					if (existsSync(toolPath)) {
+					const toolPath = path.join(plugin.path, toolEntry);
+					if (fs.existsSync(toolPath)) {
 						paths.push(toolPath);
 					}
 				}
@@ -184,8 +187,8 @@ export function resolvePluginHookPaths(plugin: InstalledPlugin): string[] {
 
 	// Base hooks entry (always included if exists)
 	if (manifest.hooks) {
-		const hookPath = join(plugin.path, manifest.hooks);
-		if (existsSync(hookPath)) {
+		const hookPath = path.join(plugin.path, manifest.hooks);
+		if (fs.existsSync(hookPath)) {
 			paths.push(hookPath);
 		}
 	}
@@ -199,8 +202,8 @@ export function resolvePluginHookPaths(plugin: InstalledPlugin): string[] {
 
 			if (feat.hooks) {
 				for (const hookEntry of feat.hooks) {
-					const hookPath = join(plugin.path, hookEntry);
-					if (existsSync(hookPath)) {
+					const hookPath = path.join(plugin.path, hookEntry);
+					if (fs.existsSync(hookPath)) {
 						paths.push(hookPath);
 					}
 				}
@@ -213,8 +216,8 @@ export function resolvePluginHookPaths(plugin: InstalledPlugin): string[] {
 
 			if (feat.hooks) {
 				for (const hookEntry of feat.hooks) {
-					const hookPath = join(plugin.path, hookEntry);
-					if (existsSync(hookPath)) {
+					const hookPath = path.join(plugin.path, hookEntry);
+					if (fs.existsSync(hookPath)) {
 						paths.push(hookPath);
 					}
 				}
@@ -236,8 +239,8 @@ export function resolvePluginCommandPaths(plugin: InstalledPlugin): string[] {
 	// Base commands (always included if exists)
 	if (manifest.commands) {
 		for (const cmdEntry of manifest.commands) {
-			const cmdPath = join(plugin.path, cmdEntry);
-			if (existsSync(cmdPath)) {
+			const cmdPath = path.join(plugin.path, cmdEntry);
+			if (fs.existsSync(cmdPath)) {
 				paths.push(cmdPath);
 			}
 		}
@@ -252,8 +255,8 @@ export function resolvePluginCommandPaths(plugin: InstalledPlugin): string[] {
 
 			if (feat.commands) {
 				for (const cmdEntry of feat.commands) {
-					const cmdPath = join(plugin.path, cmdEntry);
-					if (existsSync(cmdPath)) {
+					const cmdPath = path.join(plugin.path, cmdEntry);
+					if (fs.existsSync(cmdPath)) {
 						paths.push(cmdPath);
 					}
 				}
@@ -266,8 +269,8 @@ export function resolvePluginCommandPaths(plugin: InstalledPlugin): string[] {
 
 			if (feat.commands) {
 				for (const cmdEntry of feat.commands) {
-					const cmdPath = join(plugin.path, cmdEntry);
-					if (existsSync(cmdPath)) {
+					const cmdPath = path.join(plugin.path, cmdEntry);
+					if (fs.existsSync(cmdPath)) {
 						paths.push(cmdPath);
 					}
 				}
@@ -285,8 +288,8 @@ export function resolvePluginCommandPaths(plugin: InstalledPlugin): string[] {
 /**
  * Get all tool paths from all enabled plugins.
  */
-export function getAllPluginToolPaths(cwd: string): string[] {
-	const plugins = getEnabledPlugins(cwd);
+export async function getAllPluginToolPaths(cwd: string): Promise<string[]> {
+	const plugins = await getEnabledPlugins(cwd);
 	const paths: string[] = [];
 
 	for (const plugin of plugins) {
@@ -299,8 +302,8 @@ export function getAllPluginToolPaths(cwd: string): string[] {
 /**
  * Get all hook paths from all enabled plugins.
  */
-export function getAllPluginHookPaths(cwd: string): string[] {
-	const plugins = getEnabledPlugins(cwd);
+export async function getAllPluginHookPaths(cwd: string): Promise<string[]> {
+	const plugins = await getEnabledPlugins(cwd);
 	const paths: string[] = [];
 
 	for (const plugin of plugins) {
@@ -313,8 +316,8 @@ export function getAllPluginHookPaths(cwd: string): string[] {
 /**
  * Get all command paths from all enabled plugins.
  */
-export function getAllPluginCommandPaths(cwd: string): string[] {
-	const plugins = getEnabledPlugins(cwd);
+export async function getAllPluginCommandPaths(cwd: string): Promise<string[]> {
+	const plugins = await getEnabledPlugins(cwd);
 	const paths: string[] = [];
 
 	for (const plugin of plugins) {
@@ -328,9 +331,9 @@ export function getAllPluginCommandPaths(cwd: string): string[] {
  * Get plugin settings for use in tool/hook contexts.
  * Merges global settings with project overrides.
  */
-export function getPluginSettings(pluginName: string, cwd: string): Record<string, unknown> {
-	const runtimeConfig = loadRuntimeConfig();
-	const projectOverrides = loadProjectOverrides(cwd);
+export async function getPluginSettings(pluginName: string, cwd: string): Promise<Record<string, unknown>> {
+	const runtimeConfig = await loadRuntimeConfig();
+	const projectOverrides = await loadProjectOverrides(cwd);
 
 	const global = runtimeConfig.settings[pluginName] || {};
 	const project = projectOverrides.settings?.[pluginName] || {};