pi-harness-runtime 1.1.445 → 1.1.447

package/packages/provider-adapter-sdk/src/registry.ts

@@ -1,486 +0,0 @@
-/**
- * Provider Adapter SDK - Registry
- *
- * Registry for managing provider adapters with lifecycle hooks.
- */
-
-import { EventEmitter } from "node:events";
-import { SDK_VERSION } from "./types.js";
-import type {
-	AdapterInfo,
-	AdapterLifecycle,
-	AdapterResult,
-	AdapterState,
-	AdapterVersion,
-	CompatibilityResult,
-	ErrorAnalysis,
-	HealthCheckResult,
-	ProviderCapability,
-	ProviderMessage,
-	ProviderRequest,
-} from "./types.js";
-import type { BuiltAdapter } from "./builder.js";
-import {
-	AdapterAlreadyRegisteredError,
-	AdapterNotFoundError,
-	AdapterStateError,
-	CompatibilityError,
-	LifecycleError,
-} from "./errors.js";
-
-/**
- * Registry configuration
- */
-export interface RegistryConfig {
-	/** Enable automatic health checks */
-	autoHealthCheck?: boolean;
-	/** Health check interval in ms (default: 60000) */
-	healthCheckInterval?: number;
-	/** Timeout for health checks in ms (default: 5000) */
-	healthCheckTimeout?: number;
-	/** Enable lifecycle hooks */
-	enableLifecycle?: boolean;
-}
-
-/**
- * Registry entry
- */
-interface RegistryEntry {
-	adapter: BuiltAdapter;
-	lifecycle?: AdapterLifecycle;
-	state: AdapterState;
-	version?: AdapterVersion;
-	registeredAt: string;
-	lastHealthCheck?: HealthCheckResult;
-	healthCheckTimer?: ReturnType<typeof setInterval>;
-}
-
-/**
- * Adapter registry with lifecycle management
- */
-export class AdapterRegistry extends EventEmitter {
-	private readonly adapters: Map<string, RegistryEntry> = new Map();
-	private readonly config: Required<RegistryConfig>;
-
-	constructor(config: RegistryConfig = {}) {
-		super();
-		this.config = {
-			autoHealthCheck: config.autoHealthCheck ?? false,
-			healthCheckInterval: config.healthCheckInterval ?? 60000,
-			healthCheckTimeout: config.healthCheckTimeout ?? 5000,
-			enableLifecycle: config.enableLifecycle ?? true,
-		};
-	}
-
-	/**
-	 * Register an adapter
-	 */
-	async register(
-		adapter:
-			| BuiltAdapter
-			| {
-					name: string;
-					provider?: string;
-					complete: (
-						prompt: string,
-						options?: Record<string, unknown>,
-					) => Promise<{ content: string }>;
-			  },
-		lifecycle?: AdapterLifecycle,
-	): Promise<AdapterInfo> {
-		const id = "id" in adapter ? adapter.id : adapter.name;
-
-		if (this.adapters.has(id)) {
-			throw new AdapterAlreadyRegisteredError(id);
-		}
-
-		// Wrap plain adapters into BuiltAdapter-compatible object
-		let wrappedAdapter: BuiltAdapter;
-		if ("invoke" in adapter) {
-			wrappedAdapter = adapter as BuiltAdapter;
-		} else {
-			// Wrap simple adapter
-			const simpleAdapter = adapter as {
-				name: string;
-				provider?: string;
-				complete: Function;
-			};
-			wrappedAdapter = {
-				id,
-				name: simpleAdapter.name,
-				provider: simpleAdapter.provider,
-				invoke: async (request: ProviderRequest) => {
-					const prompt = request.messages
-						.filter((m: ProviderMessage) => m.role === "user")
-						.map((m: ProviderMessage) => m.content)
-						.join("\n");
-					return simpleAdapter.complete(prompt);
-				},
-				parseError: () => ({
-					quotaExceeded: false,
-					rateLimited: false,
-					timeout: false,
-					serverError: false,
-					clientError: false,
-				}),
-				getCapabilities: () => [],
-				getModels: () => [],
-			} as unknown as BuiltAdapter;
-		}
-
-		// Check compatibility
-		const compatibility = this.checkCompatibility(wrappedAdapter);
-		if (!compatibility.compatible) {
-			throw new CompatibilityError(id, compatibility.issues, SDK_VERSION);
-		}
-
-		// Initialize lifecycle if enabled
-		if (lifecycle?.onInit && this.config.enableLifecycle) {
-			try {
-				await lifecycle.onInit();
-			} catch (error) {
-				throw new LifecycleError("onInit", id, error);
-			}
-		}
-
-		// Create version info
-		const version: AdapterVersion = {
-			sdk: SDK_VERSION,
-			capabilities: wrappedAdapter.getCapabilities(),
-		};
-
-		// Create registry entry
-		const entry: RegistryEntry = {
-			adapter: wrappedAdapter,
-			lifecycle,
-			state: "ready",
-			version,
-			registeredAt: new Date().toISOString(),
-		};
-
-		this.adapters.set(id, entry);
-
-		// Emit events
-		const info = this.createAdapterInfo(entry);
-		this.emit("adapterRegistered", info);
-
-		// Start health check timer if enabled
-		if (this.config.autoHealthCheck) {
-			this.startHealthCheck(id);
-		}
-
-		return info;
-	}
-
-	/**
-	 * Unregister an adapter
-	 */
-	async unregister(id: string): Promise<void> {
-		const entry = this.adapters.get(id);
-		if (!entry) {
-			throw new AdapterNotFoundError(id);
-		}
-
-		// Stop health check timer
-		if (entry.healthCheckTimer) {
-			clearInterval(entry.healthCheckTimer);
-		}
-
-		// Run teardown lifecycle
-		if (entry.lifecycle?.onTeardown && this.config.enableLifecycle) {
-			try {
-				await entry.lifecycle.onTeardown();
-			} catch (error) {
-				console.error(`[Registry] Teardown failed for ${id}:`, error);
-			}
-		}
-
-		this.adapters.delete(id);
-		this.emit("adapterUnregistered", id);
-	}
-
-	/**
-	 * Get an adapter by ID
-	 */
-	getAdapter(id: string): BuiltAdapter | undefined {
-		return this.adapters.get(id)?.adapter;
-	}
-
-	/**
-	 * Get adapter by ID (alias)
-	 */
-	get(id: string): BuiltAdapter | undefined {
-		return this.getAdapter(id);
-	}
-
-	/**
-	 * Check if adapter exists
-	 */
-	has(id: string): boolean {
-		return this.adapters.has(id);
-	}
-
-	/**
-	 * List all adapters (alias)
-	 */
-	listAll(): AdapterInfo[] {
-		return this.listAdapters();
-	}
-
-	/**
-	 * Get adapter info
-	 */
-	getAdapterInfo(id: string): AdapterInfo | undefined {
-		const entry = this.adapters.get(id);
-		return entry ? this.createAdapterInfo(entry) : undefined;
-	}
-
-	/**
-	 * List all adapters
-	 */
-	listAdapters(): AdapterInfo[] {
-		return Array.from(this.adapters.values()).map((entry) =>
-			this.createAdapterInfo(entry),
-		);
-	}
-
-	/**
-	 * List adapters by capability
-	 */
-	listByCapability(capability: ProviderCapability): AdapterInfo[] {
-		return this.listAdapters().filter((info) =>
-			info.capabilities.includes(capability),
-		);
-	}
-
-	/**
-	 * Check if provider is supported
-	 */
-	supportsCapability(capability: ProviderCapability): boolean {
-		return this.listByCapability(capability).length > 0;
-	}
-
-	/**
-	 * Get adapters in a specific state
-	 */
-	listByState(state: AdapterState): AdapterInfo[] {
-		return this.listAdapters().filter((info) => info.state === state);
-	}
-
-	/**
-	 * Invoke an adapter
-	 */
-	async invoke(id: string, request: ProviderRequest): Promise<AdapterResult> {
-		const entry = this.adapters.get(id);
-		if (!entry) {
-			throw new AdapterNotFoundError(id);
-		}
-
-		if (entry.state !== "ready") {
-			throw new AdapterStateError(id, "ready", entry.state);
-		}
-
-		return entry.adapter.invoke(request);
-	}
-
-	/**
-	 * Parse error for an adapter
-	 */
-	parseError(id: string, error: unknown): ErrorAnalysis {
-		const entry = this.adapters.get(id);
-		if (!entry) {
-			throw new AdapterNotFoundError(id);
-		}
-		return entry.adapter.parseError(error);
-	}
-
-	/**
-	 * Health check for a single adapter
-	 */
-	async healthCheck(id: string): Promise<HealthCheckResult> {
-		const entry = this.adapters.get(id);
-		if (!entry) {
-			throw new AdapterNotFoundError(id);
-		}
-
-		const timeout = this.config.healthCheckTimeout;
-		const healthCheckPromise = entry.adapter.healthCheck();
-
-		const timeoutPromise = new Promise<HealthCheckResult>((resolve) =>
-			setTimeout(
-				() =>
-					resolve({
-						healthy: false,
-						message: "Health check timed out",
-						timestamp: new Date().toISOString(),
-					}),
-				timeout,
-			),
-		);
-
-		const result = await Promise.race([healthCheckPromise, timeoutPromise]);
-
-		// Update entry
-		entry.lastHealthCheck = result;
-
-		// Update state based on health
-		const wasHealthy = entry.state === "ready";
-		if (!result.healthy && wasHealthy) {
-			entry.state = "error";
-			this.emit("adapterStateChanged", id, "error");
-			this.emit("healthCheckFailed", id, result);
-		} else if (result.healthy && entry.state === "error") {
-			entry.state = "ready";
-			this.emit("adapterStateChanged", id, "ready");
-		}
-
-		return result;
-	}
-
-	/**
-	 * Health check all adapters
-	 */
-	async healthCheckAll(): Promise<Map<string, HealthCheckResult>> {
-		const results = new Map<string, HealthCheckResult>();
-		await Promise.allSettled(
-			Array.from(this.adapters.keys()).map(async (id) => {
-				const result = await this.healthCheck(id);
-				results.set(id, result);
-			}),
-		);
-		return results;
-	}
-
-	/**
-	 * Start automatic health checks for an adapter
-	 */
-	private startHealthCheck(id: string): void {
-		const entry = this.adapters.get(id);
-		if (!entry) return;
-
-		// Clear existing timer
-		if (entry.healthCheckTimer) {
-			clearInterval(entry.healthCheckTimer);
-		}
-
-		// Start new timer
-		entry.healthCheckTimer = setInterval(async () => {
-			await this.healthCheck(id);
-		}, this.config.healthCheckInterval);
-	}
-
-	/**
-	 * Stop automatic health checks for an adapter
-	 */
-	stopHealthCheck(id: string): void {
-		const entry = this.adapters.get(id);
-		if (entry?.healthCheckTimer) {
-			clearInterval(entry.healthCheckTimer);
-			entry.healthCheckTimer = undefined;
-		}
-	}
-
-	/**
-	 * Stop all health checks
-	 */
-	stopAllHealthChecks(): void {
-		for (const [id] of this.adapters) {
-			this.stopHealthCheck(id);
-		}
-	}
-
-	/**
-	 * Check adapter compatibility with SDK
-	 */
-	private checkCompatibility(adapter: BuiltAdapter): CompatibilityResult {
-		const issues: string[] = [];
-		const warnings: string[] = [];
-
-		// Check if adapter has required methods
-		if (typeof adapter.invoke !== "function") {
-			issues.push("Adapter missing invoke method");
-		}
-		if (typeof adapter.parseError !== "function") {
-			issues.push("Adapter missing parseError method");
-		}
-
-		// Check models
-		if (adapter.getModels().length === 0) {
-			warnings.push("Adapter has no models specified");
-		}
-
-		return {
-			compatible: issues.length === 0,
-			issues,
-			warnings,
-		};
-	}
-
-	/**
-	 * Create adapter info from entry
-	 */
-	private createAdapterInfo(entry: RegistryEntry): AdapterInfo {
-		return {
-			id: entry.adapter.id,
-			name: entry.adapter.name,
-			version: entry.version,
-			capabilities: entry.adapter.getCapabilities(),
-			models: entry.adapter.getModels(),
-			registeredAt: entry.registeredAt,
-			state: entry.state,
-			lastHealthCheck: entry.lastHealthCheck,
-		};
-	}
-
-	/**
-	 * Get registry statistics
-	 */
-	getStats(): {
-		total: number;
-		byState: Record<AdapterState, number>;
-		byCapability: Record<ProviderCapability, number>;
-	} {
-		const byState: Record<AdapterState, number> = {
-			registered: 0,
-			initializing: 0,
-			ready: 0,
-			error: 0,
-			unavailable: 0,
-		};
-
-		const byCapability: Record<ProviderCapability, number> = {
-			code: 0,
-			review: 0,
-			plan: 0,
-			test: 0,
-			e2e: 0,
-			refactor: 0,
-			analysis: 0,
-			debug: 0,
-		};
-
-		for (const entry of this.adapters.values()) {
-			byState[entry.state]++;
-			for (const cap of entry.adapter.getCapabilities()) {
-				byCapability[cap as ProviderCapability]++;
-			}
-		}
-
-		return {
-			total: this.adapters.size,
-			byState,
-			byCapability,
-		};
-	}
-}
-
-// --- Factory Function ------------------------------------------------------
-
-/**
- * Create a new adapter registry
- */
-export function createAdapterRegistry(
-	config?: RegistryConfig,
-): AdapterRegistry {
-	return new AdapterRegistry(config);
-}