pi-harness-runtime 0.10.43 → 1.1.1

package/packages/model-registry/test/registry.test.ts

@@ -0,0 +1,342 @@
+/**
+ * Model Registry Tests (RFC-0053)
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+	createModelRegistry,
+	type InMemoryModelRegistry,
+	DEFAULT_MODELS,
+	findModels,
+	getCheapestModel,
+	getLargestContextModel,
+	filterByCostEfficiency,
+	calculateCost,
+	getCostPer1M,
+	calculateSavings,
+} from "../src/index.js";
+import type { ModelInfo } from "../src/types.js";
+
+describe("ModelRegistry", () => {
+	let registry: InMemoryModelRegistry;
+
+	beforeEach(() => {
+		registry = createModelRegistry(true);
+	});
+
+	describe("initialization", () => {
+		it("should load default models", () => {
+			const models = registry.list();
+			expect(models.length).toBeGreaterThan(0);
+		});
+
+		it("should have OpenAI models", () => {
+			const models = registry.list("openai");
+			expect(models.length).toBeGreaterThan(0);
+		});
+
+		it("should have Anthropic models", () => {
+			const models = registry.list("anthropic");
+			expect(models.length).toBeGreaterThan(0);
+		});
+
+		it("should have MiniMax models", () => {
+			const models = registry.list("minimax");
+			expect(models.length).toBeGreaterThan(0);
+		});
+	});
+
+	describe("register and unregister", () => {
+		it("should register a new model", () => {
+			const newModel: ModelInfo = {
+				id: "test-model",
+				providerId: "test-provider",
+				name: "Test Model",
+				contextWindow: 100000,
+				maxOutputTokens: 4096,
+				pricing: {
+					currency: "USD",
+					inputPer1M: 0.5,
+					outputPer1M: 1.0,
+				},
+				capabilities: ["code_generation"],
+				aliases: ["test", "test-model-v1"],
+				status: "active",
+			};
+
+			registry.register(newModel);
+
+			const retrieved = registry.get("test-provider", "test-model");
+			expect(retrieved).toBeDefined();
+			expect(retrieved!.name).toBe("Test Model");
+		});
+
+		it("should unregister a model", () => {
+			registry.unregister("openai", "gpt-4o");
+
+			const retrieved = registry.get("openai", "gpt-4o");
+			expect(retrieved).toBeUndefined();
+		});
+
+		it("should track events", () => {
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			const newModel: ModelInfo = {
+				id: "event-test",
+				providerId: "test",
+				name: "Event Test",
+				contextWindow: 50000,
+				maxOutputTokens: 2048,
+				pricing: { currency: "USD", inputPer1M: 1, outputPer1M: 2 },
+				capabilities: [],
+				aliases: [],
+				status: "active",
+			};
+
+			registry.register(newModel);
+
+			expect(events).toContainEqual({
+				type: "model.registered",
+				providerId: "test",
+				modelId: "event-test",
+			});
+		});
+	});
+
+	describe("get and getByAlias", () => {
+		it("should get model by provider and ID", () => {
+			const model = registry.get("anthropic", "claude-sonnet-4");
+			expect(model).toBeDefined();
+			expect(model!.name).toBe("Claude Sonnet 4");
+		});
+
+		it("should get model by alias", () => {
+			const model = registry.getByAlias("sonnet");
+			expect(model).toBeDefined();
+			expect(model!.id).toBe("claude-sonnet-4");
+		});
+
+		it("should return undefined for unknown alias", () => {
+			const model = registry.getByAlias("unknown-model");
+			expect(model).toBeUndefined();
+		});
+	});
+
+	describe("list and listActive", () => {
+		it("should list all models", () => {
+			const models = registry.list();
+			expect(models.length).toBe(DEFAULT_MODELS.length);
+		});
+
+		it("should list models by provider", () => {
+			const models = registry.list("openai");
+			expect(models.every((m) => m.providerId === "openai")).toBe(true);
+		});
+
+		it("should list only active models", () => {
+			const active = registry.listActive();
+			expect(active.every((m) => m.status === "active")).toBe(true);
+		});
+	});
+
+	describe("find", () => {
+		it("should find by provider", () => {
+			const models = registry.find({ providerId: "openai" });
+			expect(models.every((m) => m.providerId === "openai")).toBe(true);
+		});
+
+		it("should find by minimum context window", () => {
+			const models = registry.find({ minContextWindow: 200000 });
+			expect(models.every((m) => m.contextWindow >= 200000)).toBe(true);
+		});
+
+		it("should find by max cost", () => {
+			const models = registry.find({ maxCostPer1M: 5 });
+			expect(models.every((m) => getCostPer1M(m.pricing) <= 5)).toBe(true);
+		});
+
+		it("should find by capabilities", () => {
+			const models = registry.find({ capabilities: ["vision"] });
+			expect(models.every((m) => m.capabilities.includes("vision"))).toBe(true);
+		});
+
+		it("should find by status", () => {
+			const models = registry.find({ status: "active" });
+			expect(models.every((m) => m.status === "active")).toBe(true);
+		});
+
+		it("should sort by cost ascending", () => {
+			const models = registry.find({});
+			for (let i = 1; i < models.length; i++) {
+				expect(getCostPer1M(models[i - 1].pricing)).toBeLessThanOrEqual(
+					getCostPer1M(models[i].pricing),
+				);
+			}
+		});
+
+		it("should emit query event", () => {
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			registry.find({ providerId: "openai" });
+
+			expect(events).toContainEqual(
+				expect.objectContaining({
+					type: "model.queried",
+					filters: { providerId: "openai" },
+				}),
+			);
+		});
+	});
+
+	describe("updateStatus", () => {
+		it("should update model status", () => {
+			registry.updateStatus("openai", "gpt-4o", "deprecated");
+
+			const model = registry.get("openai", "gpt-4o");
+			expect(model!.status).toBe("deprecated");
+			expect(model!.deprecatedAt).toBeDefined();
+		});
+
+		it("should emit status change event", () => {
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			registry.updateStatus("openai", "gpt-4o", "disabled");
+
+			expect(events).toContainEqual(
+				expect.objectContaining({
+					type: "model.status_changed",
+					providerId: "openai",
+					modelId: "gpt-4o",
+					status: "disabled",
+				}),
+			);
+		});
+	});
+});
+
+describe("Cost Functions", () => {
+	describe("calculateCost", () => {
+		it("should calculate basic cost", () => {
+			const model: ModelInfo = {
+				id: "test",
+				providerId: "test",
+				name: "Test",
+				contextWindow: 100000,
+				maxOutputTokens: 4096,
+				pricing: { currency: "USD", inputPer1M: 1, outputPer1M: 2 },
+				capabilities: [],
+				aliases: [],
+				status: "active",
+			};
+
+			// 1M input, 500k output
+			const cost = calculateCost(model, 1_000_000, 500_000);
+			expect(cost).toBe(2); // $1 + $1
+		});
+
+		it("should apply batch discount", () => {
+			const model: ModelInfo = {
+				id: "test",
+				providerId: "test",
+				name: "Test",
+				contextWindow: 100000,
+				maxOutputTokens: 4096,
+				pricing: {
+					currency: "USD",
+					inputPer1M: 1,
+					outputPer1M: 2,
+					batchInputPer1M: 0.1,
+				},
+				capabilities: [],
+				aliases: [],
+				status: "active",
+			};
+
+			const withBatch = calculateCost(model, 1_000_000, 0, { useBatch: true });
+			const withoutBatch = calculateCost(model, 1_000_000, 0);
+
+			expect(withBatch).toBeLessThan(withoutBatch);
+		});
+	});
+
+	describe("getCostPer1M", () => {
+		it("should sum input and output costs", () => {
+			const cost = getCostPer1M({
+				currency: "USD",
+				inputPer1M: 1,
+				outputPer1M: 2,
+			});
+			expect(cost).toBe(3);
+		});
+	});
+
+	describe("calculateSavings", () => {
+		it("should calculate absolute and percentage savings", () => {
+			const current: ModelInfo = {
+				id: "current",
+				providerId: "test",
+				name: "Current",
+				contextWindow: 100000,
+				maxOutputTokens: 4096,
+				pricing: { currency: "USD", inputPer1M: 1, outputPer1M: 2 },
+				capabilities: [],
+				aliases: [],
+				status: "active",
+			};
+
+			const cheaper: ModelInfo = {
+				id: "cheaper",
+				providerId: "test",
+				name: "Cheaper",
+				contextWindow: 100000,
+				maxOutputTokens: 4096,
+				pricing: { currency: "USD", inputPer1M: 0.5, outputPer1M: 1 },
+				capabilities: [],
+				aliases: [],
+				status: "active",
+			};
+
+			const savings = calculateSavings(current, cheaper, 1_000_000, 500_000);
+			// current: 1M@$1 + 0.5M@$2 = $2
+			// cheaper: 1M@$0.5 + 0.5M@$1 = $1
+			// savings: $2 - $1 = $1
+			expect(savings.absolute).toBe(1);
+			expect(savings.percentage).toBe(50); // 50%
+		});
+	});
+});
+
+describe("Query Functions", () => {
+	let models: ModelInfo[];
+
+	beforeEach(() => {
+		const registry = createModelRegistry(true);
+		models = registry.list();
+	});
+
+	describe("getCheapestModel", () => {
+		it("should return the cheapest model", () => {
+			const cheapest = getCheapestModel(models);
+			expect(cheapest).toBeDefined();
+		});
+	});
+
+	describe("getLargestContextModel", () => {
+		it("should return the model with largest context", () => {
+			const largest = getLargestContextModel(models);
+			expect(largest).toBeDefined();
+			const maxWindow = Math.max(...models.map((m) => m.contextWindow));
+			expect(largest!.contextWindow).toBe(maxWindow);
+		});
+	});
+
+	describe("filterByCostEfficiency", () => {
+		it("should sort by cost per context", () => {
+			const sorted = filterByCostEfficiency(models);
+			expect(sorted.length).toBe(models.length);
+		});
+	});
+});

package/packages/nextjs-plugin/README.md

@@ -0,0 +1 @@
+# nextjs-plugin

package/packages/nextjs-plugin/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@pi-harness/nextjs-plugin",
+  "version": "0.10.30",
+  "description": "Next.js framework detection and analysis for pi-harness-runtime (RFC-0062)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "keywords": [
+    "pi-harness",
+    "nextjs",
+    "framework",
+    "detection"
+  ]
+}

package/packages/nextjs-plugin/test/analyzer.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Next.js Plugin Tests (RFC-0062)
+ */
+
+import { describe, it, expect, afterEach } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { analyzeNextJs } from "../src/analyzer.js";
+
+const roots: string[] = [];
+
+async function mkdtemp(): Promise<string> {
+	const d = await fs.mkdtemp(path.join(os.tmpdir(), "nextjs-plugin-"));
+	roots.push(d);
+	return d;
+}
+
+afterEach(async () => {
+	for (const d of roots) {
+		try {
+			await fs.rm(d, { recursive: true, force: true });
+		} catch {
+			/* ignore */
+		}
+	}
+	roots.length = 0;
+});
+
+describe("analyzeNextJs", () => {
+	it("returns null for non-nextjs workspace", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(path.join(dir, "package.json"), "{}", "utf-8");
+		expect(await analyzeNextJs(dir)).toBeNull();
+	});
+
+	it("detects next.js workspace via next.config", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(
+			path.join(dir, "next.config.js"),
+			"module.exports = {}",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "package.json"),
+			JSON.stringify({
+				dependencies: { next: "14.0.0" },
+			}),
+			"utf-8",
+		);
+		const result = await analyzeNextJs(dir);
+		expect(result).not.toBeNull();
+		expect(result!.framework.id).toBe("nextjs");
+		expect(result!.version).toBe("14.0.0");
+	});
+
+	it("detects app router", async () => {
+		const dir = await mkdtemp();
+		await fs.mkdir(path.join(dir, "app"), { recursive: true });
+		await fs.mkdir(path.join(dir, "app", "dashboard"), { recursive: true });
+		await fs.writeFile(
+			path.join(dir, "app", "page.tsx"),
+			"export default function Page() {}",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "app", "dashboard", "page.tsx"),
+			"export default function Dashboard() {}",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "next.config.js"),
+			"module.exports = {}",
+			"utf-8",
+		);
+		const result = await analyzeNextJs(dir);
+		expect(result!.usingAppRouter).toBe(true);
+		expect(result!.appRoutes.length).toBeGreaterThanOrEqual(2);
+	});
+
+	it("lists API routes", async () => {
+		const dir = await mkdtemp();
+		await fs.mkdir(path.join(dir, "pages", "api", "posts"), {
+			recursive: true,
+		});
+		await fs.writeFile(
+			path.join(dir, "pages", "api", "users.ts"),
+			"export default function handler(req, res) {}",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "pages", "api", "posts", "[id].ts"),
+			"export default function handler(req, res) {}",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "next.config.js"),
+			"module.exports = {}",
+			"utf-8",
+		);
+		const result = await analyzeNextJs(dir);
+		expect(result!.usingPagesRouter).toBe(true);
+		expect(result!.apiRoutes.some((r) => r.includes("users"))).toBe(true);
+	});
+
+	it("extracts environment variables", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(
+			path.join(dir, ".env.example"),
+			[
+				"# Database",
+				"DATABASE_URL=postgres://...",
+				"API_KEY=secret",
+				"",
+				"NEXT_PUBLIC_APP_URL=https://example.com",
+			].join("\n"),
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "next.config.js"),
+			"module.exports = {}",
+			"utf-8",
+		);
+		const result = await analyzeNextJs(dir);
+		expect(result!.environmentVars).toContain("DATABASE_URL");
+		expect(result!.environmentVars).toContain("API_KEY");
+		expect(result!.environmentVars).toContain("NEXT_PUBLIC_APP_URL");
+		expect(result!.environmentVars).not.toContain(
+			"DATABASE_URL=postgres://...",
+		);
+	});
+
+	it("finds middleware file", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(
+			path.join(dir, "middleware.ts"),
+			"import { NextResponse } from 'next/server'",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "next.config.js"),
+			"module.exports = {}",
+			"utf-8",
+		);
+		const result = await analyzeNextJs(dir);
+		expect(result!.middleware).toBeDefined();
+		expect(result!.middleware).toContain("middleware.ts");
+	});
+});

package/packages/notification/adapters/email-adapter.ts

@@ -0,0 +1,126 @@
+/**
+ * Email Adapter — RFC-0022
+ *
+ * Sends notifications via SMTP.
+ */
+
+import type {
+	NotificationPayload,
+	NotificationResult,
+	EmailConfig,
+} from "../types.js";
+import { BaseChannelAdapter } from "../base-adapter.js";
+
+// Simple SMTP client using built-in net module
+async function sendSmtpEmail(
+	host: string,
+	port: number,
+	user: string,
+	password: string,
+	from: string,
+	to: string[],
+	subject: string,
+	body: string,
+	tls: boolean = false,
+): Promise<void> {
+	// For a production implementation, you'd use a proper SMTP library
+	// This is a placeholder that logs the email
+	console.log(`[Email] Would send to ${to.join(", ")}`);
+	console.log(`[Email] Subject: ${subject}`);
+	console.log(`[Email] Body: ${body}`);
+
+	// In practice, you'd use something like:
+	// import { createClient } from "nodemailer";
+	// const transporter = nodemailer.createTransport({ ... });
+	// await transporter.sendMail({ ... });
+}
+
+export class EmailAdapter extends BaseChannelAdapter {
+	readonly id = "email";
+	readonly type = "email";
+
+	constructor(config: EmailConfig) {
+		super({ id: "email", type: "email", enabled: true, config });
+	}
+
+	async initialize(): Promise<boolean> {
+		// Verify SMTP connection
+		try {
+			const cfg = this.config.config as EmailConfig;
+			// In production, verify SMTP credentials
+			return Boolean(
+				cfg.smtpHost && cfg.smtpUser && cfg.from && cfg.to.length > 0,
+			);
+		} catch {
+			return false;
+		}
+	}
+
+	async send(payload: NotificationPayload): Promise<NotificationResult> {
+		try {
+			const cfg = this.config.config as EmailConfig;
+			const subject = `${this.getEmoji(payload.event)} ${payload.title}`;
+			const body = this.formatBody(payload);
+
+			await sendSmtpEmail(
+				cfg.smtpHost,
+				cfg.smtpPort,
+				cfg.smtpUser,
+				cfg.smtpPassword,
+				cfg.from,
+				cfg.to,
+				subject,
+				body,
+				cfg.tls,
+			);
+
+			return { success: true, channel: this.id };
+		} catch (error) {
+			return {
+				success: false,
+				channel: this.id,
+				error: String(error),
+			};
+		}
+	}
+
+	private formatBody(payload: NotificationPayload): string {
+		const lines = [
+			payload.message,
+			"",
+			"---",
+			`Event: ${payload.event}`,
+			`Time: ${payload.timestamp}`,
+		];
+
+		if (payload.details?.taskTitle) {
+			lines.push(`Task: ${payload.details.taskTitle}`);
+		}
+		if (payload.details?.jobId) {
+			lines.push(`Job ID: ${payload.details.jobId}`);
+		}
+		if (payload.details?.error) {
+			lines.push("", `Error: ${payload.details.error}`);
+		}
+
+		return lines.join("\n");
+	}
+
+	private getEmoji(event: NotificationPayload["event"]): string {
+		const map: Record<string, string> = {
+			JobStarted: "[🚀]",
+			TaskCompleted: "[✅]",
+			TaskFailed: "[❌]",
+			QuotaPaused: "[⏸]",
+			ResumeScheduled: "[▶]",
+			ContextCompacted: "[📦]",
+			OutputLimitContinued: "[🔄]",
+			E2EFailed: "[🧪]",
+			HumanReviewNeeded: "[👤]",
+			ReadyForClient: "[🎉]",
+			JobCancelled: "[🚫]",
+			Error: "[⚠]",
+		};
+		return map[event] ?? "[📢]";
+	}
+}