pi-harness-runtime 1.1.439 → 1.1.441

package/packages/cost-optimizer/test/cost-optimizer.test.ts

@@ -1,438 +0,0 @@
-/**
- * Cost Optimizer Tests (RFC-0055)
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	createCostOptimizer,
-	type InMemoryCostOptimizer,
-	DEFAULT_CONFIG,
-	createOptimizerConfig,
-	generateCostId,
-	createCostEntry,
-	calculateSummary,
-	calculateBudgetStatus,
-	exceedsBudget,
-	calculateModelCost,
-	calculateQualityImpact,
-	findCheaperAlternatives,
-	optimizeModelSelection,
-	forecastCosts,
-	quickForecast,
-} from "../src/index.js";
-import type {
-	CostEntry,
-	CostPeriod,
-	CostBudget,
-	TaskRequirements,
-} from "../src/index.js";
-
-describe("CostOptimizer", () => {
-	let optimizer: InMemoryCostOptimizer;
-
-	beforeEach(() => {
-		optimizer = createCostOptimizer();
-	});
-
-	describe("trackCost", () => {
-		it("should track a cost entry", () => {
-			const entry = optimizer.trackCost({
-				jobId: "job-1",
-				taskId: "task-1",
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.005,
-				currency: "USD",
-			});
-
-			expect(entry.id).toBeDefined();
-			expect(entry.timestamp).toBeDefined();
-			expect(entry.cost).toBe(0.005);
-		});
-
-		it("should accumulate costs", () => {
-			optimizer.trackCost({
-				jobId: "job-1",
-				providerId: "openai",
-				modelId: "gpt-4o",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.003,
-				currency: "USD",
-			});
-
-			optimizer.trackCost({
-				jobId: "job-1",
-				providerId: "minimax",
-				modelId: "MiniMax-Text-01",
-				inputTokens: 2000,
-				outputTokens: 1000,
-				cost: 0.001,
-				currency: "USD",
-			});
-
-			const summary = optimizer.getSummary({ start: "", end: "", type: "day" });
-			expect(summary.total).toBe(0.004);
-		});
-
-		it("should emit tracked event", () => {
-			const events: any[] = [];
-			optimizer.onEvent((e) => events.push(e));
-
-			optimizer.trackCost({
-				jobId: "job-1",
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.005,
-				currency: "USD",
-			});
-
-			expect(events).toContainEqual(
-				expect.objectContaining({
-					type: "cost.tracked",
-				}),
-			);
-		});
-
-		it("should emit budget warning when threshold exceeded", () => {
-			const events: any[] = [];
-			optimizer.onEvent((e) => events.push(e));
-
-			// Track enough to exceed 80% of $10 daily budget
-			for (let i = 0; i < 9; i++) {
-				optimizer.trackCost({
-					jobId: "job-1",
-					providerId: "anthropic",
-					modelId: "claude-sonnet-4",
-					inputTokens: 1000,
-					outputTokens: 500,
-					cost: 0.95,
-					currency: "USD",
-				});
-			}
-
-			const warnings = events.filter((e) => e.type === "cost.budget_warning");
-			expect(warnings.length).toBeGreaterThan(0);
-		});
-	});
-
-	describe("getSummary", () => {
-		it("should calculate summary by provider", () => {
-			optimizer.trackCost({
-				jobId: "job-1",
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.01,
-				currency: "USD",
-			});
-
-			optimizer.trackCost({
-				jobId: "job-1",
-				providerId: "openai",
-				modelId: "gpt-4o",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.02,
-				currency: "USD",
-			});
-
-			const summary = optimizer.getSummary({ start: "", end: "", type: "day" });
-			expect(summary.total).toBe(0.03);
-			expect(summary.byProvider["anthropic"]).toBe(0.01);
-			expect(summary.byProvider["openai"]).toBe(0.02);
-		});
-
-		it("should calculate summary by job", () => {
-			optimizer.trackCost({
-				jobId: "job-1",
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.01,
-				currency: "USD",
-			});
-
-			optimizer.trackCost({
-				jobId: "job-2",
-				providerId: "openai",
-				modelId: "gpt-4o",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.02,
-				currency: "USD",
-			});
-
-			const summary = optimizer.getSummary({ start: "", end: "", type: "day" });
-			expect(summary.byJob["job-1"]).toBe(0.01);
-			expect(summary.byJob["job-2"]).toBe(0.02);
-		});
-	});
-
-	describe("getBudgetStatus", () => {
-		it("should return budget status", () => {
-			const status = optimizer.getBudgetStatus();
-			expect(status.daily).toBeDefined();
-			expect(status.weekly).toBeDefined();
-			expect(status.monthly).toBeDefined();
-			expect(status.exhausted).toBe(false);
-		});
-
-		it("should track daily usage", () => {
-			optimizer.trackCost({
-				jobId: "job-1",
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 5,
-				currency: "USD",
-			});
-
-			const status = optimizer.getBudgetStatus();
-			expect(status.daily.used).toBe(5);
-			expect(status.daily.remaining).toBe(5); // $10 budget - $5 used
-		});
-	});
-
-	describe("canAfford", () => {
-		it("should return true for affordable costs", () => {
-			expect(optimizer.canAfford(1)).toBe(true);
-		});
-
-		it("should return false when budget exhausted", () => {
-			// Exhaust daily budget
-			for (let i = 0; i < 10; i++) {
-				optimizer.trackCost({
-					jobId: "job-1",
-					providerId: "anthropic",
-					modelId: "claude-sonnet-4",
-					inputTokens: 1000,
-					outputTokens: 500,
-					cost: 1.05,
-					currency: "USD",
-				});
-			}
-
-			expect(optimizer.canAfford(1)).toBe(false);
-		});
-	});
-
-	describe("shouldSwitchToCheaper", () => {
-		it("should suggest cheaper alternatives", () => {
-			const recommendation = optimizer.shouldSwitchToCheaper(
-				{ id: "claude-sonnet-4", providerId: "anthropic" },
-				["code_generation"],
-			);
-
-			expect(recommendation).not.toBeNull();
-			expect(recommendation!.costSavings).toBeGreaterThan(0);
-		});
-
-		it("should respect quality loss limit", () => {
-			const recommendation = optimizer.shouldSwitchToCheaper(
-				{ id: "claude-sonnet-4", providerId: "anthropic" },
-				["code_generation"],
-				{ maxQualityLoss: 5 },
-			);
-
-			if (recommendation) {
-				expect(recommendation.qualityImpact).toBeLessThanOrEqual(5);
-			}
-		});
-	});
-
-	describe("forecastCosts", () => {
-		it("should forecast costs", () => {
-			const requirements: TaskRequirements[] = [
-				{
-					requiredCapabilities: ["code_generation"],
-					minContextWindow: 100000,
-					estimatedInputTokens: 5000,
-					estimatedOutputTokens: 2000,
-				},
-				{
-					requiredCapabilities: ["code_review"],
-					minContextWindow: 100000,
-					estimatedInputTokens: 3000,
-					estimatedOutputTokens: 1000,
-				},
-			];
-
-			const forecast = optimizer.forecastCosts(requirements);
-			expect(forecast.estimatedTotal).toBeGreaterThan(0);
-			expect(forecast.confidence).toBeGreaterThan(0);
-			expect(forecast.assumptions.length).toBeGreaterThan(0);
-		});
-	});
-
-	describe("optimizeModelSelection", () => {
-		it("should return optimized selections", () => {
-			const requirements: TaskRequirements = {
-				requiredCapabilities: ["code_generation"],
-				minContextWindow: 100000,
-				estimatedInputTokens: 5000,
-				estimatedOutputTokens: 2000,
-			};
-
-			const selections = optimizer.optimizeModelSelection(
-				"task-1",
-				requirements,
-			);
-			expect(selections.length).toBeGreaterThan(0);
-			expect(selections[0].model).toBeDefined();
-			expect(selections[0].estimatedCost).toBeGreaterThanOrEqual(0);
-		});
-
-		it("should filter by requirements", () => {
-			const requirements: TaskRequirements = {
-				requiredCapabilities: ["code_generation", "vision"],
-				minContextWindow: 500000,
-				estimatedInputTokens: 5000,
-				estimatedOutputTokens: 2000,
-			};
-
-			const selections = optimizer.optimizeModelSelection(
-				"task-1",
-				requirements,
-			);
-			expect(selections.length).toBeGreaterThan(0);
-			// All should have required capabilities
-			expect(selections.every((s) => s.model.id !== "MiniMax-Text-01")).toBe(
-				true,
-			);
-		});
-	});
-});
-
-describe("Utility Functions", () => {
-	describe("generateCostId", () => {
-		it("should generate unique IDs", () => {
-			const id1 = generateCostId();
-			const id2 = generateCostId();
-			expect(id1).not.toBe(id2);
-			expect(id1).toContain("cost_");
-		});
-	});
-
-	describe("createCostEntry", () => {
-		it("should create cost entry with generated id and timestamp", () => {
-			const entry = createCostEntry({
-				jobId: "job-1",
-				providerId: "anthropic",
-				modelId: "claude-sonnet-4",
-				inputTokens: 1000,
-				outputTokens: 500,
-				cost: 0.005,
-				currency: "USD",
-			});
-
-			expect(entry.id).toContain("cost_");
-			expect(entry.timestamp).toBeDefined();
-		});
-
-		it("should use provided id and timestamp", () => {
-			const entry = createCostEntry(
-				{
-					jobId: "job-1",
-					providerId: "anthropic",
-					modelId: "claude-sonnet-4",
-					inputTokens: 1000,
-					outputTokens: 500,
-					cost: 0.005,
-					currency: "USD",
-				},
-				"custom-id",
-				"2024-01-01T00:00:00Z",
-			);
-
-			expect(entry.id).toBe("custom-id");
-			expect(entry.timestamp).toBe("2024-01-01T00:00:00Z");
-		});
-	});
-
-	describe("calculateModelCost", () => {
-		it("should calculate model cost", () => {
-			const cost = calculateModelCost(
-				{
-					id: "test",
-					providerId: "test",
-					name: "Test",
-					contextWindow: 100000,
-					maxOutputTokens: 4096,
-					pricing: { inputPer1M: 1, outputPer1M: 2 },
-					capabilities: [],
-					latency: "fast",
-					qualityScore: 80,
-				},
-				1000000,
-				500000,
-			);
-
-			expect(cost).toBe(2); // $1 + $1
-		});
-	});
-
-	describe("quickForecast", () => {
-		it("should provide quick forecast", () => {
-			const cost = quickForecast(1000, 500);
-			expect(cost).toBeGreaterThan(0);
-		});
-	});
-
-	describe("calculateBudgetStatus", () => {
-		it("should calculate budget status", () => {
-			const budget: CostBudget = { daily: 10, weekly: 50, monthly: 200 };
-			const entries: CostEntry[] = [];
-			const status = calculateBudgetStatus(entries, budget);
-
-			expect(status.daily.budget).toBe(10);
-			expect(status.weekly.budget).toBe(50);
-			expect(status.monthly.budget).toBe(200);
-			expect(status.exhausted).toBe(false);
-		});
-	});
-
-	describe("exceedsBudget", () => {
-		it("should detect when cost exceeds budget", () => {
-			const budget: CostBudget = { daily: 10 };
-			const status = calculateBudgetStatus([], budget);
-
-			expect(exceedsBudget(5, budget, status)).toBe(false);
-			expect(exceedsBudget(15, budget, status)).toBe(true);
-		});
-	});
-});
-
-describe("Config", () => {
-	describe("DEFAULT_CONFIG", () => {
-		it("should have default values", () => {
-			expect(DEFAULT_CONFIG.defaultBudget.daily).toBe(10);
-			expect(DEFAULT_CONFIG.alertThreshold).toBe(0.8);
-		});
-	});
-
-	describe("createOptimizerConfig", () => {
-		it("should create custom config", () => {
-			const overrides = { defaultBudget: { daily: 20 } };
-			const config = createOptimizerConfig(overrides);
-
-			expect(config.defaultBudget.daily).toBe(20);
-			// Verify weekly is preserved from defaults
-			expect(config.defaultBudget.weekly).toBe(50);
-		});
-
-		it("should preserve defaults when not overridden", () => {
-			const config = createOptimizerConfig({});
-			expect(config.defaultBudget.daily).toBe(10);
-			expect(config.defaultBudget.weekly).toBe(50);
-			expect(config.defaultBudget.monthly).toBe(200);
-		});
-	});
-});

package/packages/dependency-analyzer/test/analyzer.test.ts

@@ -1,49 +0,0 @@
-/// <reference types="node" />
-import { describe, it } from "node:test";
-import { equal, deepEqual } from "node:assert";
-import { parseImports } from "../src/imports.js";
-
-describe("parseImports", () => {
-	it("parses ESM default import", () => {
-		const result = parseImports("import x from './y';", "file.ts");
-		deepEqual(result, ["./y"]);
-	});
-
-	it("parses ESM named import", () => {
-		const result = parseImports("import { a, b } from './x';", "file.ts");
-		deepEqual(result, ["./x"]);
-	});
-
-	it("parses ESM package import", () => {
-		const result = parseImports("import lodash from 'lodash';", "file.ts");
-		deepEqual(result, ["lodash"]);
-	});
-
-	it("parses CommonJS require", () => {
-		const result = parseImports("const x = require('./y');", "file.ts");
-		deepEqual(result, ["./y"]);
-	});
-
-	it("parses Python from-import", () => {
-		const result = parseImports("from os import path", "file.py");
-		deepEqual(result, ["os"]);
-	});
-
-	it("parses Python direct import", () => {
-		const result = parseImports("import numpy", "file.py");
-		deepEqual(result, ["numpy"]);
-	});
-
-	it("returns empty for empty file", () => {
-		const result = parseImports("", "file.ts");
-		deepEqual(result, []);
-	});
-
-	it("deduplicates imports", () => {
-		const result = parseImports(
-			"import x from './y';\nimport z from './y';",
-			"file.ts",
-		);
-		deepEqual(result, ["./y"]);
-	});
-});

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

@@ -1,195 +0,0 @@
-/**
- * Django Plugin Tests (RFC-0064)
- */
-
-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 { analyzeDjango } from "../src/analyzer.js";
-
-const roots: string[] = [];
-
-async function mkdtemp(): Promise<string> {
-	const d = await fs.mkdtemp(path.join(os.tmpdir(), "django-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("analyzeDjango", () => {
-	it("returns null for non-django workspace", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(path.join(dir, "package.json"), "{}", "utf-8");
-		expect(await analyzeDjango(dir)).toBeNull();
-	});
-
-	it("detects django workspace via manage.py", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "manage.py"),
-			"#!/usr/bin/env python",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "requirements.txt"),
-			"django>=4.0\ndjangorestframework",
-			"utf-8",
-		);
-		const result = await analyzeDjango(dir);
-		expect(result).not.toBeNull();
-		expect(result!.framework.id).toBe("django");
-	});
-
-	it("detects django workspace via settings.py", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(path.join(dir, "settings.py"), "DEBUG = True", "utf-8");
-		await fs.writeFile(
-			path.join(dir, "requirements.txt"),
-			"django>=4.0",
-			"utf-8",
-		);
-		const result = await analyzeDjango(dir);
-		expect(result).not.toBeNull();
-	});
-
-	it("extracts version from requirements.txt", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "manage.py"),
-			"#!/usr/bin/env python",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "requirements.txt"),
-			"django==4.2.10\ndjangorestframework==3.14.0",
-			"utf-8",
-		);
-		const result = await analyzeDjango(dir);
-		expect(result!.version).toBe("4.2.10");
-	});
-
-	it("parses INSTALLED_APPS from settings.py", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "settings.py"),
-			`
-INSTALLED_APPS = [
-    'django.contrib.admin',
-    'django.contrib.auth',
-    'rest_framework',
-    'myapp.core',
-]
-MIDDLEWARE = [
-    'django.middleware.security.SecurityMiddleware',
-    'django.contrib.sessions.middleware.SessionMiddleware',
-    'django.middleware.common.CommonMiddleware',
-]
-`.trim(),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "requirements.txt"),
-			"django>=4.0",
-			"utf-8",
-		);
-		const result = await analyzeDjango(dir);
-		expect(result!.middleware).toContain(
-			"django.middleware.security.SecurityMiddleware",
-		);
-	});
-
-	it("detects Django REST Framework", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "settings.py"),
-			`
-INSTALLED_APPS = [
-    'django.contrib.admin',
-    'rest_framework',
-]
-`.trim(),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "requirements.txt"),
-			"django>=4.0\ndjangorestframework",
-			"utf-8",
-		);
-		const result = await analyzeDjango(dir);
-		expect(result!.drfEnabled).toBe(true);
-	});
-
-	it("counts model classes in app models.py", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "myapp"), { recursive: true });
-		await fs.writeFile(
-			path.join(dir, "settings.py"),
-			"INSTALLED_APPS = []",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "requirements.txt"),
-			"django>=4.0",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "myapp", "models.py"),
-			`
-from django.db import models
-
-class Customer(models.Model):
-    name = models.CharField(max_length=100)
-
-class Order(models.Model):
-    customer = models.ForeignKey(Customer, on_delete=models.CASCADE)
-`,
-			"utf-8",
-		);
-		const result = await analyzeDjango(dir);
-		const myApp = result!.apps.find((a) => a.name === "myapp");
-		expect(myApp).toBeDefined();
-		// Conservative: at least 2 classes detected
-		expect(myApp!.modelCount).toBeGreaterThanOrEqual(2);
-	});
-
-	it("finds management commands", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "myapp", "management", "commands"), {
-			recursive: true,
-		});
-		await fs.writeFile(
-			path.join(dir, "settings.py"),
-			"INSTALLED_APPS = []",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "requirements.txt"),
-			"django>=4.0",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "myapp", "management", "commands", "send_email.py"),
-			"# management command",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "myapp", "management", "commands", "cleanup.py"),
-			"# cleanup",
-			"utf-8",
-		);
-		const result = await analyzeDjango(dir);
-		expect(result!.managementCommands).toContain("send_email");
-		expect(result!.managementCommands).toContain("cleanup");
-	});
-});