pi-harness-runtime 1.1.440 → 1.1.441

package/packages/quota-manager/test/quota.test.ts

@@ -1,432 +0,0 @@
-/**
- * Quota Manager Tests
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	QuotaManager,
-	parseMiniMaxError,
-	parseOpenAIError,
-} from "../src/quota-manager.js";
-import { TUIUsageMonitor } from "../src/tui-usage-monitor.js";
-
-describe("QuotaManager", () => {
-	let manager: QuotaManager;
-
-	beforeEach(() => {
-		manager = new QuotaManager(30 * 60 * 1000);
-	});
-
-	describe("recordSignal", () => {
-		it("records a basic signal", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 50,
-			});
-
-			const signal = manager.getLatestSignal("minimax", "5h");
-			expect(signal).not.toBeNull();
-			expect(signal!.usedPct).toBe(50);
-			expect(signal!.remainingPct).toBe(50);
-			expect(signal!.exhausted).toBe(false);
-		});
-
-		it("records exhausted signal", () => {
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "daily",
-				usedPct: 100,
-				exhausted: true,
-			});
-
-			const signal = manager.getLatestSignal("openai", "daily");
-			expect(signal!.exhausted).toBe(true);
-		});
-
-		it("stores multiple signals per provider", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 30,
-			});
-			manager.recordSignal({
-				provider: "minimax",
-				source: "playwright",
-				windowType: "daily",
-				usedPct: 70,
-			});
-
-			const signals = manager.getSignals("minimax");
-			expect(signals.length).toBeGreaterThanOrEqual(2);
-		});
-	});
-
-	describe("getLatestSignal", () => {
-		it("returns most recent by capturedAt", async () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 10,
-			});
-			await new Promise((r) => setTimeout(r, 2));
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 80,
-			});
-
-			const latest = manager.getLatestSignal("minimax", "5h");
-			expect(latest!.usedPct).toBe(80);
-		});
-
-		it("returns null for unknown provider", () => {
-			expect(manager.getLatestSignal("unknown")).toBeNull();
-		});
-	});
-
-	describe("getProviderState", () => {
-		it("available when under 90%", () => {
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "daily",
-				usedPct: 50,
-			});
-
-			const state = manager.getProviderState("openai");
-			expect(state.available).toBe(true);
-			expect(state.limited).toBe(false);
-			expect(state.exhausted).toBe(false);
-		});
-
-		it("limited when at 90%+", () => {
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "daily",
-				usedPct: 95,
-			});
-
-			const state = manager.getProviderState("openai");
-			expect(state.limited).toBe(true);
-			expect(state.available).toBe(false);
-		});
-
-		it("exhausted when at 100%", () => {
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "daily",
-				usedPct: 100,
-			});
-
-			const state = manager.getProviderState("openai");
-			expect(state.exhausted).toBe(true);
-		});
-
-		it("exhausted when explicit flag set", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				exhausted: true,
-			});
-
-			const state = manager.getProviderState("minimax");
-			expect(state.exhausted).toBe(true);
-		});
-
-		it("includes next available time", () => {
-			const future = new Date(Date.now() + 3600000).toISOString();
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "daily",
-				exhausted: true,
-				resetsAt: future,
-			});
-
-			const state = manager.getProviderState("openai");
-			expect(state.nextAvailableAt).toBeDefined();
-		});
-	});
-
-	describe("isAvailable / isExhausted", () => {
-		it("isAvailable true when under 90%", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 50,
-			});
-			expect(manager.isAvailable("minimax")).toBe(true);
-		});
-
-		it("isExhausted true when exhausted", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				exhausted: true,
-			});
-			expect(manager.isExhausted("minimax")).toBe(true);
-		});
-	});
-
-	describe("selectBestProvider", () => {
-		it("returns provider with most remaining quota", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 80,
-			});
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 30,
-			});
-
-			const best = manager.selectBestProvider(["minimax", "openai"]);
-			expect(best).toBe("openai");
-		});
-
-		it("returns null when all exhausted", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				exhausted: true,
-			});
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "5h",
-				exhausted: true,
-			});
-
-			expect(manager.selectBestProvider(["minimax", "openai"])).toBeNull();
-		});
-
-		it("returns null for empty list", () => {
-			expect(manager.selectBestProvider([])).toBeNull();
-		});
-	});
-
-	describe("clearStale", () => {
-		it("clears old signals", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 50,
-			});
-
-			// Manually add a stale signal (simulated)
-			manager.clearStale();
-
-			const signals = manager.getSignals("minimax");
-			expect(signals.length).toBeGreaterThanOrEqual(0);
-		});
-	});
-
-	describe("generateReport", () => {
-		it("generates report for known providers", () => {
-			manager.recordSignal({
-				provider: "minimax",
-				source: "api_response",
-				windowType: "5h",
-				usedPct: 45,
-			});
-
-			const report = manager.generateReport(["minimax"]);
-			expect(report).toContain("minimax");
-			expect(report).toContain("AVAILABLE");
-		});
-
-		it("shows EXHAUSTED for exhausted providers", () => {
-			manager.recordSignal({
-				provider: "openai",
-				source: "api_response",
-				windowType: "daily",
-				exhausted: true,
-			});
-
-			const report = manager.generateReport(["openai"]);
-			expect(report).toContain("EXHAUSTED");
-		});
-	});
-});
-
-describe("parseMiniMaxError", () => {
-	it("parses quota error code 2056", () => {
-		const result = parseMiniMaxError({
-			message: "Error code: 2056 - Rate limit exceeded",
-		});
-		expect(result).not.toBeNull();
-		expect(result!.provider).toBe("minimax");
-		expect(result!.exhausted).toBe(true);
-	});
-
-	it("parses quota keyword", () => {
-		const result = parseMiniMaxError({ message: "quota exceeded" });
-		expect(result).not.toBeNull();
-		expect(result!.exhausted).toBe(true);
-	});
-
-	it("returns null for unrelated errors", () => {
-		const result = parseMiniMaxError({ message: "Invalid request" });
-		expect(result).toBeNull();
-	});
-
-	it("extracts retry time in seconds", () => {
-		const result = parseMiniMaxError({
-			message: "rate limit exceeded. Retry after 30 seconds",
-		});
-		expect(result).not.toBeNull();
-		expect(result!.retryAfterMs).toBe(30000);
-	});
-
-	it("extracts retry time in minutes", () => {
-		const result = parseMiniMaxError({
-			message: "rate limit exceeded. Retry after 2 minutes",
-		});
-		expect(result).not.toBeNull();
-		expect(result!.retryAfterMs).toBe(120000);
-	});
-});
-
-describe("parseOpenAIError", () => {
-	it("parses insufficient_quota", () => {
-		const result = parseOpenAIError({
-			code: "insufficient_quota",
-			message: "Quota exceeded",
-		});
-		expect(result).not.toBeNull();
-		expect(result!.provider).toBe("openai");
-		expect(result!.exhausted).toBe(true);
-	});
-
-	it("parses context_length_exceeded", () => {
-		const result = parseOpenAIError({
-			code: "context_length_exceeded",
-			message: "Too many tokens",
-		});
-		expect(result).not.toBeNull();
-		expect(result!.exhausted).toBe(true);
-	});
-
-	it("parses 429 rate limit", () => {
-		const result = parseOpenAIError({
-			message: "HTTP 429: Rate limit exceeded",
-		});
-		expect(result).not.toBeNull();
-		expect(result!.exhausted).toBe(true);
-		expect(result!.windowType).toBe("5h");
-	});
-
-	it("returns null for unrelated errors", () => {
-		const result = parseOpenAIError({
-			code: "invalid_request_error",
-			message: "Bad request",
-		});
-		expect(result).toBeNull();
-	});
-});
-
-describe("TUIUsageMonitor", () => {
-	let manager: QuotaManager;
-	let monitor: TUIUsageMonitor;
-
-	beforeEach(() => {
-		manager = new QuotaManager();
-		monitor = new TUIUsageMonitor({ quotaManager: manager });
-	});
-
-	describe("detectProvider", () => {
-		it("detects OpenAI", () => {
-			expect(monitor.detectProvider("OpenAI GPT-4 quota exceeded")).toBe(
-				"openai",
-			);
-		});
-
-		it("detects GLM", () => {
-			expect(monitor.detectProvider("GLM rate limit exceeded")).toBe("glm");
-		});
-
-		it("detects Anthropic Claude", () => {
-			expect(monitor.detectProvider("Claude overloaded_error")).toBe(
-				"anthropic",
-			);
-		});
-
-		it("detects OpenRouter", () => {
-			expect(monitor.detectProvider("OpenRouter quota exhausted")).toBe(
-				"openrouter",
-			);
-		});
-
-		it("returns null for unknown", () => {
-			expect(monitor.detectProvider("Random message")).toBeNull();
-		});
-	});
-
-	describe("processMessage", () => {
-		it("processes OpenAI quota message", () => {
-			const signal = monitor.processMessage(
-				"OpenAI insufficient_quota: daily limit reached",
-			);
-			expect(signal).not.toBeNull();
-			expect(signal!.provider).toBe("openai");
-		});
-
-		it("processes rate limit message", () => {
-			const signal = monitor.processMessage(
-				"Claude rate_limit_error: try again in 30 seconds",
-			);
-			expect(signal).not.toBeNull();
-			expect(signal!.provider).toBe("anthropic");
-			expect(signal!.limitType).toBe("rate_limit");
-		});
-
-		it("processes context window message", () => {
-			const signal = monitor.processMessage(
-				"OpenAI context_length_exceeded: too many tokens",
-			);
-			expect(signal).not.toBeNull();
-			expect(signal!.limitType).toBe("context_window");
-		});
-
-		it("returns null for non-quota messages", () => {
-			const signal = monitor.processMessage("Hello world, this is just a test");
-			expect(signal).toBeNull();
-		});
-
-		it("records to QuotaManager", () => {
-			monitor.processMessage("OpenAI quota exhausted at 100%");
-			expect(manager.getSignals("openai").length).toBeGreaterThan(0);
-		});
-
-		it("stores last signal per provider", () => {
-			monitor.processMessage("OpenAI quota exhausted at 100%");
-			monitor.processMessage("GLM quota exhausted");
-			const openaiSignal = monitor.getLastSignal("openai");
-			const glmSignal = monitor.getLastSignal("glm");
-			expect(openaiSignal?.provider).toBe("openai");
-			expect(glmSignal?.provider).toBe("glm");
-		});
-
-		it("clears stored signals", () => {
-			monitor.processMessage("OpenAI GPT-4 quota exhausted");
-			monitor.clear();
-			expect(monitor.getLastSignal("openai")).toBeNull();
-		});
-	});
-});

package/packages/rate-limiter/test/limiter.test.ts

@@ -1,128 +0,0 @@
-/**
- * Rate Limiter Tests (RFC-0023)
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import { RateLimiter } from "../src/index.js";
-
-describe("RateLimiter", () => {
-  it("allows requests within capacity", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 10, refillRate: 5, refillIntervalMs: 1000 });
-    const result = limiter.consume();
-    expect(result.allowed).toBe(true);
-    expect(result.remaining).toBeLessThanOrEqual(10);
-  });
-
-  it("rejects when tokens exhausted", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 2, refillRate: 1, refillIntervalMs: 1000 });
-    limiter.consume();
-    limiter.consume();
-    const result = limiter.consume();
-    expect(result.allowed).toBe(false);
-    expect(result.retryAfterMs).toBeGreaterThan(0);
-  });
-
-  it("refills tokens over time", async () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 5, refillRate: 10, refillIntervalMs: 10 });
-    limiter.consume();
-    limiter.consume();
-    await new Promise((r) => setTimeout(r, 30));
-    const result = limiter.consume();
-    expect(result.allowed).toBe(true);
-  });
-
-  it("consumes multiple tokens at once", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 5, refillRate: 1, refillIntervalMs: 1000 });
-    const result = limiter.consume(undefined, 5);
-    expect(result.allowed).toBe(true);
-    expect(result.remaining).toBeLessThanOrEqual(0);
-  });
-
-  it("per-client scope has separate buckets", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 3, refillRate: 1, refillIntervalMs: 1000, scope: "per-client" });
-    limiter.consume("client1");
-    limiter.consume("client1");
-    limiter.consume("client2");
-    const c1 = limiter.peek("client1");
-    const c2 = limiter.peek("client2");
-    expect(c1.tokens).not.toBe(c2.tokens);
-  });
-
-  it("global scope shares single bucket", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 3, refillRate: 1, refillIntervalMs: 1000, scope: "global" });
-    limiter.consume("client1");
-    limiter.consume("client2");
-    expect(limiter.size()).toBe(1); // only global bucket
-  });
-
-  it("reset restores full capacity", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 5, refillRate: 1, refillIntervalMs: 1000 });
-    limiter.consume();
-    limiter.consume();
-    limiter.reset();
-    const result = limiter.consume();
-    expect(result.allowed).toBe(true);
-    expect(result.remaining).toBeLessThanOrEqual(5);
-  });
-
-  it("peek shows current tokens without consuming", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 5, refillRate: 1, refillIntervalMs: 1000 });
-    limiter.consume();
-    const state = limiter.peek();
-    expect(state.tokens).toBeLessThan(5);
-    // Second peek shouldn't consume
-    const state2 = limiter.peek();
-    expect(state.tokens).toBe(state2.tokens);
-  });
-
-  it("getStats tracks requests", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 10, refillRate: 5, refillIntervalMs: 1000 });
-    limiter.consume();
-    limiter.consume();
-    limiter.consume();
-    const stats = limiter.getStats();
-    expect(stats.totalRequests).toBe(3);
-    expect(stats.allowedRequests).toBe(3);
-  });
-
-  it("getStats records rejections", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 1, refillRate: 1, refillIntervalMs: 1000 });
-    limiter.consume();
-    limiter.consume();
-    limiter.consume();
-    const stats = limiter.getStats();
-    expect(stats.rejectedRequests).toBeGreaterThan(0);
-  });
-
-  it("listKeys returns client keys", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 10, refillRate: 5, refillIntervalMs: 1000, scope: "per-client" });
-    limiter.consume("alice");
-    limiter.consume("bob");
-    const keys = limiter.listKeys();
-    expect(keys).toContain("alice");
-    expect(keys).toContain("bob");
-  });
-
-  it("reset with key resets only that key", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 3, refillRate: 1, refillIntervalMs: 1000, scope: "per-client" });
-    limiter.consume("alice");
-    limiter.consume("bob");
-    limiter.reset("alice");
-    expect(limiter.peek("alice").tokens).toBe(3);
-    expect(limiter.peek("bob").tokens).toBeLessThan(3);
-  });
-
-  it("size returns bucket count", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 10, refillRate: 5, refillIntervalMs: 1000, scope: "per-client" });
-    expect(limiter.size()).toBeGreaterThanOrEqual(1);
-    limiter.consume("a");
-    limiter.consume("b");
-    expect(limiter.size()).toBeGreaterThanOrEqual(2);
-  });
-
-  it("returns resetAt timestamp", () => {
-    const limiter = new RateLimiter({ algorithm: "token-bucket", capacity: 5, refillRate: 2, refillIntervalMs: 1000 });
-    const result = limiter.consume();
-    expect(result.resetAt).toBeGreaterThan(Date.now());
-  });
-});

package/packages/react-vite-plugin/test/analyzer.test.ts

@@ -1,139 +0,0 @@
-/**
- * React/Vite Plugin Tests (RFC-0063)
- */
-
-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 { analyzeReactVite } from "../src/analyzer.js";
-
-const roots: string[] = [];
-
-async function mkdtemp(): Promise<string> {
-	const d = await fs.mkdtemp(path.join(os.tmpdir(), "react-vite-"));
-	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("analyzeReactVite", () => {
-	it("returns null for non-vite workspace", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(path.join(dir, "package.json"), "{}", "utf-8");
-		expect(await analyzeReactVite(dir)).toBeNull();
-	});
-
-	it("detects vite workspace via vite.config.ts", async () => {
-		const dir = await mkdtemp();
-		await fs.writeFile(
-			path.join(dir, "vite.config.ts"),
-			"import react from '@vitejs/plugin-react'",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "package.json"),
-			JSON.stringify({
-				dependencies: { react: "^18.0.0", "react-dom": "^18.0.0" },
-				devDependencies: { vite: "^5.0.0", "@vitejs/plugin-react": "^4.0.0" },
-			}),
-			"utf-8",
-		);
-		const result = await analyzeReactVite(dir);
-		expect(result).not.toBeNull();
-		expect(result!.framework.id).toBe("react-vite");
-		expect(result!.plugins).toContain("@vitejs/plugin-react");
-	});
-
-	it("detects react-router", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "src"), { recursive: true });
-		await fs.writeFile(
-			path.join(dir, "vite.config.ts"),
-			"export default {}",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "package.json"),
-			JSON.stringify({
-				dependencies: { react: "^18.0.0", "react-router-dom": "^6.0.0" },
-			}),
-			"utf-8",
-		);
-		const result = await analyzeReactVite(dir);
-		expect(result!.hasRouter).toBe(true);
-		expect(result!.routerType).toBe("react-router");
-	});
-
-	it("lists components from src directory", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "src", "components"), { recursive: true });
-		await fs.writeFile(
-			path.join(dir, "src", "components", "Button.tsx"),
-			"export function Button() {}",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "src", "components", "Modal.jsx"),
-			"export function Modal() {}",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "vite.config.ts"),
-			"export default {}",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "package.json"),
-			JSON.stringify({
-				dependencies: { react: "^18.0.0" },
-			}),
-			"utf-8",
-		);
-		const result = await analyzeReactVite(dir);
-		expect(result!.components.some((c) => c.endsWith("Button.tsx"))).toBe(true);
-		expect(result!.components.some((c) => c.endsWith("Modal.jsx"))).toBe(true);
-	});
-
-	it("parses tsconfig path aliases", async () => {
-		const dir = await mkdtemp();
-		await fs.mkdir(path.join(dir, "src"), { recursive: true });
-		await fs.writeFile(
-			path.join(dir, "tsconfig.json"),
-			JSON.stringify({
-				compilerOptions: {
-					paths: {
-						"@/*": ["./src/*"],
-						"components/*": ["./src/components/*"],
-					},
-				},
-			}),
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "vite.config.ts"),
-			"export default {}",
-			"utf-8",
-		);
-		await fs.writeFile(
-			path.join(dir, "package.json"),
-			JSON.stringify({
-				dependencies: { react: "^18.0.0" },
-			}),
-			"utf-8",
-		);
-		const result = await analyzeReactVite(dir);
-		expect(result!.aliases["@"]).toBe("./src");
-		expect(result!.aliases["components"]).toBe("./src/components");
-	});
-});