pi-harness-runtime 0.10.43 → 1.1.1

package/packages/quota-manager/tui-usage-monitor.ts

@@ -0,0 +1,355 @@
+/**
+ * TUI Usage Monitor — Unified TUI Message Parser
+ *
+ * Hooks into pi's TUI messages to capture quota signals from all providers.
+ * Handles OpenAI, GLM, and any other provider that reports via TUI.
+ *
+ * Usage:
+ * ```typescript
+ * const monitor = new TUIUsageMonitor(quotaManager);
+ *
+ * // Hook into pi
+ * pi.on("error", (event) => monitor.processMessage(event.message));
+ * pi.on("message", (event) => monitor.processMessage(event.message));
+ * ```
+ */
+
+import { EventEmitter } from "node:events";
+import type { QuotaManager } from "./quota-manager.js";
+
+export interface TUIUsageSignal {
+	provider: "openai" | "glm" | "anthropic" | "openrouter" | "unknown";
+	timestamp: string;
+	/** Usage percentage (0-100), if available */
+	usedPct?: number;
+	/** Remaining percentage (0-100) */
+	remainingPct: number;
+	/** If exhausted */
+	exhausted: boolean;
+	/** Reset time */
+	resetsAt?: string;
+	/** Which limit was hit */
+	limitType: "tokens" | "context_window" | "rate_limit" | "unknown";
+	/** Original message */
+	originalMessage: string;
+}
+
+export interface TUIUsageMonitorConfig {
+	/** QuotaManager instance to feed signals into */
+	quotaManager: QuotaManager;
+	/** Enable debug logging */
+	debug?: boolean;
+}
+
+/**
+ * Provider-specific patterns
+ */
+const PROVIDER_PATTERNS = {
+	openai: [
+		/(?:^|\s)OpenAI(?:$|\s)/i,
+		/(?:^|\s)GPT(?:$|\s)/i,
+		/openai.*(?:quota|limit|exhausted)/i,
+		/gpt.*(?:quota|limit|exhausted)/i,
+		/insufficient_quota/i,
+		/context_length_exceeded/i,
+		/openai.*rate.?limit/i,
+		/429.*openai/i,
+		/openai.*context.*(?:window|length)/i,
+	],
+	glm: [
+		/(?:^|\s)GLM(?:$|\s)/i,
+		/(?:^|\s)Zhipu(?:$|\s)/i,
+		/glm.*(?:quota|limit|exhausted)/i,
+		/zhipu.*(?:quota|limit|exhausted)/i,
+		/glm.*context.*(?:window|length)/i,
+		/glm.*rate.?limit/i,
+	],
+	anthropic: [
+		/(?:^|\s)Claude(?:$|\s)/i,
+		/(?:^|\s)Anthropic(?:$|\s)/i,
+		/anthropic.*(?:quota|limit|exhausted)/i,
+		/claude.*(?:quota|limit|exhausted)/i,
+		/overloaded_error/i,
+		/rate_limit_error/i,
+	],
+	openrouter: [
+		/(?:^|\s)OpenRouter(?:$|\s)/i,
+		/openrouter.*(?:quota|limit|exhausted)/i,
+	],
+};
+
+const RESET_TIME_PATTERNS = [
+	/reset(?:s)?\s+(?:at|in)\s+(\d{1,2}):(\d{2})/i,
+	/(?:at|in)\s+(\d{1,2}):(\d{2})/i,
+	/retry\s+after\s+(\d{1,2}):(\d{2})/i,
+	/(\d{1,2}):(\d{2})\s*(?:am|pm)/i,
+];
+
+const PERCENTAGE_PATTERN = /(\d+)%/;
+
+export class TUIUsageMonitor extends EventEmitter {
+	private readonly quotaManager: QuotaManager;
+	private readonly debug: boolean;
+	private lastSignals: Map<string, TUIUsageSignal> = new Map();
+
+	constructor(config: TUIUsageMonitorConfig) {
+		super();
+		this.quotaManager = config.quotaManager;
+		this.debug = config.debug ?? false;
+	}
+
+	/**
+	 * Process a TUI message and extract quota signals
+	 */
+	processMessage(message: string): TUIUsageSignal | null {
+		// Try to identify provider
+		const provider = this.detectProvider(message);
+		if (!provider) {
+			return null;
+		}
+
+		// Parse the signal
+		const signal = this.parseSignal(message, provider);
+		if (!signal) {
+			return null;
+		}
+
+		// Store last signal
+		this.lastSignals.set(provider, signal);
+
+		// Record to QuotaManager
+		this.recordToQuotaManager(signal);
+
+		// Emit event
+		this.emit("signal", signal);
+
+		// Debug log
+		if (this.debug) {
+			console.log(`[TUIUsageMonitor] Detected ${provider}:`, signal);
+		}
+
+		return signal;
+	}
+
+	/**
+	 * Detect which provider the message is about
+	 */
+	detectProvider(
+		message: string,
+	): "openai" | "glm" | "anthropic" | "openrouter" | null {
+		for (const [provider, patterns] of Object.entries(PROVIDER_PATTERNS)) {
+			for (const pattern of patterns) {
+				if (pattern.test(message)) {
+					return provider as "openai" | "glm" | "anthropic" | "openrouter";
+				}
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Get the last signal for a provider
+	 */
+	getLastSignal(
+		provider: "openai" | "glm" | "anthropic" | "openrouter",
+	): TUIUsageSignal | null {
+		return this.lastSignals.get(provider) ?? null;
+	}
+
+	/**
+	 * Get all last signals
+	 */
+	getAllLastSignals(): Map<string, TUIUsageSignal> {
+		return new Map(this.lastSignals);
+	}
+
+	/**
+	 * Clear stored signals
+	 */
+	clear(): void {
+		this.lastSignals.clear();
+	}
+
+	/**
+	 * Parse the quota signal from message
+	 */
+	private parseSignal(
+		message: string,
+		provider: "openai" | "glm" | "anthropic" | "openrouter",
+	): TUIUsageSignal | null {
+		// Determine limit type
+		const limitType = this.detectLimitType(message);
+
+		// Parse reset time
+		const resetsAt = this.parseResetTime(message);
+
+		// Parse percentage if available
+		const pctMatch = message.match(PERCENTAGE_PATTERN);
+		const usedPct = pctMatch ? parseInt(pctMatch[1], 10) : undefined;
+
+		// Determine if exhausted
+		const exhausted =
+			usedPct !== undefined
+				? usedPct >= 100
+				: this.containsExhaustedKeywords(message);
+
+		if (!exhausted && !resetsAt) {
+			// Not a quota signal
+			return null;
+		}
+
+		return {
+			provider,
+			timestamp: new Date().toISOString(),
+			usedPct,
+			remainingPct: usedPct !== undefined ? 100 - usedPct : 0,
+			exhausted,
+			resetsAt,
+			limitType,
+			originalMessage: message,
+		};
+	}
+
+	/**
+	 * Detect the type of limit that was hit
+	 */
+	private detectLimitType(
+		message: string,
+	): "tokens" | "context_window" | "rate_limit" | "unknown" {
+		const lowerMsg = message.toLowerCase();
+
+		// Context window
+		if (
+			lowerMsg.includes("context") &&
+			(lowerMsg.includes("window") ||
+				lowerMsg.includes("length") ||
+				lowerMsg.includes("full") ||
+				lowerMsg.includes("exceeded"))
+		) {
+			return "context_window";
+		}
+
+		// Rate limit
+		if (
+			lowerMsg.includes("rate") ||
+			lowerMsg.includes("429") ||
+			lowerMsg.includes("too many requests")
+		) {
+			return "rate_limit";
+		}
+
+		// Tokens/quota exhausted
+		if (
+			lowerMsg.includes("quota") ||
+			lowerMsg.includes("exhausted") ||
+			lowerMsg.includes("ran out") ||
+			lowerMsg.includes("limit")
+		) {
+			return "tokens";
+		}
+
+		return "unknown";
+	}
+
+	/**
+	 * Check if message contains exhausted keywords
+	 */
+	private containsExhaustedKeywords(message: string): boolean {
+		const keywords = [
+			"exhausted",
+			"quota",
+			"limit",
+			"rate limit",
+			"429",
+			"exceeded",
+			"ran out",
+		];
+		const lowerMsg = message.toLowerCase();
+		return keywords.some((kw) => lowerMsg.includes(kw));
+	}
+
+	/**
+	 * Parse reset time from message
+	 */
+	private parseResetTime(message: string): string | undefined {
+		for (const pattern of RESET_TIME_PATTERNS) {
+			const match = message.match(pattern);
+			if (match) {
+				let hour = parseInt(match[1], 10);
+				const minute = parseInt(match[2], 10);
+
+				// Handle AM/PM
+				const matchIndex = message.indexOf(match[0]);
+				const afterMatch = message.slice(matchIndex, matchIndex + 20);
+				const isPM = /pm/i.test(afterMatch);
+				const isAM = /am/i.test(afterMatch);
+
+				if (isPM && hour < 12) hour += 12;
+				if (isAM && hour === 12) hour = 0;
+
+				// Convert to ISO string
+				const now = new Date();
+				const resetTime = new Date(now);
+				resetTime.setHours(hour, minute, 0, 0);
+
+				// If time has passed today, assume tomorrow
+				if (resetTime <= now) {
+					resetTime.setDate(resetTime.getDate() + 1);
+				}
+
+				return resetTime.toISOString();
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * Record signal to QuotaManager
+	 */
+	private recordToQuotaManager(signal: TUIUsageSignal): void {
+		// Map limit type to window type
+		let windowType: "5h" | "daily" | "weekly" | "monthly" = "5h";
+
+		if (signal.limitType === "context_window") {
+			// Context window is usually daily or 5h depending on provider
+			windowType = "daily";
+		}
+
+		// Record to QuotaManager
+		this.quotaManager.recordSignal({
+			provider: signal.provider,
+			source: "tui_message",
+			windowType,
+			usedPct: signal.usedPct,
+			exhausted: signal.exhausted,
+			resetsAt: signal.resetsAt,
+		});
+	}
+}
+
+/**
+ * Create a TUI usage monitor and automatically hook into pi
+ */
+export function createTUIUsageMonitor(
+	quotaManager: QuotaManager,
+	pi: {
+		on: (event: string, handler: (event: { message: string }) => void) => void;
+	},
+	config?: { debug?: boolean },
+): TUIUsageMonitor {
+	const monitor = new TUIUsageMonitor({
+		quotaManager,
+		debug: config?.debug,
+	});
+
+	// Hook into pi events
+	pi.on("error", (event: { message: string }) => {
+		monitor.processMessage(event.message);
+	});
+
+	pi.on("message", (event: { message: string }) => {
+		monitor.processMessage(event.message);
+	});
+
+	return monitor;
+}

package/packages/rate-limiter/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi/rate-limiter",
+  "version": "0.10.30",
+  "type": "module",
+  "description": "Rate limiting with token bucket algorithm (RFC-0023)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0"
+  }
+}

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

@@ -0,0 +1,128 @@
+/**
+ * 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/README.md

@@ -0,0 +1 @@
+# react-vite-plugin

package/packages/react-vite-plugin/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@pi/react-vite-plugin",
+  "version": "0.10.30",
+  "description": "React/Vite framework analysis — components, config, TypeScript setup",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}

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

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

package/packages/release-manager/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi/release-manager",
+  "version": "0.10.30",
+  "type": "module",
+  "description": "Release management for pi-harness",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0"
+  }
+}