pi-harness-runtime 1.1.439 → 1.1.441

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

@@ -1,342 +0,0 @@
-/**
- * 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/test/analyzer.test.ts

@@ -1,149 +0,0 @@
-/**
- * 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");
-	});
-});