pi-harness-runtime 0.5.0 → 0.6.3-beta.13

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/requirement-compiler/dist/ambiguity-detector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Requirement Compiler - Ambiguity Detector
+ *
+ * Detects ambiguities, contradictions, and missing information.
+ */
+import type { ClassificationResult, RequirementAmbiguity, RequirementCompilerConfig } from "./types.js";
+/**
+ * Detect ambiguities in classified statements.
+ */
+export declare function detectAmbiguities(classification: ClassificationResult, _config: RequirementCompilerConfig): RequirementAmbiguity[];
+//# sourceMappingURL=ambiguity-detector.d.ts.map

package/packages/requirement-compiler/dist/ambiguity-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambiguity-detector.d.ts","sourceRoot":"","sources":["../src/ambiguity-detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACX,oBAAoB,EACpB,oBAAoB,EACpB,yBAAyB,EACzB,MAAM,YAAY,CAAC;AAgQpB;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,cAAc,EAAE,oBAAoB,EACpC,OAAO,EAAE,yBAAyB,GAChC,oBAAoB,EAAE,CA6BxB"}

package/packages/requirement-compiler/dist/ambiguity-detector.js

@@ -0,0 +1,236 @@
+/**
+ * Requirement Compiler - Ambiguity Detector
+ *
+ * Detects ambiguities, contradictions, and missing information.
+ */
+/**
+ * Vague terms that indicate ambiguity.
+ */
+const VAGUE_TERMS = [
+    "well",
+    "fast",
+    "good",
+    "nice",
+    "modern",
+    "robust",
+    "efficient",
+    "scalable",
+    "secure",
+    "reliable",
+    "appropriate",
+    "reasonable",
+    "some",
+    "few",
+    "many",
+    "several",
+    "lots of",
+    "a bit",
+    "as needed",
+    "when necessary",
+    "properly",
+];
+/**
+ * Questions that signal missing actors.
+ */
+const ACTOR_QUESTIONS = [
+    "who should",
+    "who will",
+    "who can",
+    "who is responsible",
+    "which user",
+    "what role",
+];
+function detectVagueTerms(statements) {
+    const ambiguities = [];
+    let ambiguityIndex = 0;
+    for (const stmt of statements) {
+        const lower = stmt.normalizedText;
+        for (const term of VAGUE_TERMS) {
+            if (lower.includes(term)) {
+                ambiguities.push({
+                    id: `ambig-${ambiguityIndex++}`,
+                    question: `The term "${term}" is vague. What does "${stmt.originalText.slice(0, 50)}" specifically require?`,
+                    blocking: false,
+                    affectedGoals: [],
+                    evidence: [stmt.sourceRef],
+                    category: "vague_term",
+                });
+                break;
+            }
+        }
+    }
+    return ambiguities;
+}
+function detectMissingActors(statements) {
+    const ambiguities = [];
+    let ambiguityIndex = 0;
+    for (const stmt of statements) {
+        const lower = stmt.normalizedText;
+        for (const q of ACTOR_QUESTIONS) {
+            if (lower.includes(q)) {
+                ambiguities.push({
+                    id: `ambig-${ambiguityIndex++}`,
+                    question: `Actor not specified: ${stmt.originalText}`,
+                    blocking: true,
+                    affectedGoals: [],
+                    evidence: [stmt.sourceRef],
+                    category: "missing_actor",
+                });
+                break;
+            }
+        }
+    }
+    return ambiguities;
+}
+function detectContradictions(goals, constraints) {
+    const ambiguities = [];
+    let ambiguityIndex = 0;
+    // Normalize for contradiction comparison:
+    // Strips both modal verbs ("must", "shall") AND negation words ("not", "don't", "do not", etc.)
+    // Then collapses whitespace and lowercases.
+    // This lets "allow X" vs "must/do not allow X" both normalize to "allow x".
+    function normalizeForContradiction(text) {
+        // Normalize for comparison: remove negation phrases and modal verbs,
+        // leaving only the core action. This lets "allow X" vs "must/do not allow X"
+        // both normalize to "allow x".
+        let result = text;
+        // Remove negation phrases — "do not", "does not", "must not", "shall not"
+        // These appear with or without leading whitespace (start of sentence)
+        result = result.replace(/(?:^|\s)do(?:\s+not|\s+NOT)\s+/gi, " ");
+        result = result.replace(/(?:^|\s)does(?:\s+not|\s+NOT)\s+/gi, " ");
+        result = result.replace(/(?:^|\s)must\s+not\s+/gi, " ");
+        result = result.replace(/(?:^|\s)shall\s+not\s+/gi, " ");
+        result = result.replace(/(?:^|\s)should\s+not\s+/gi, " ");
+        result = result.replace(/(?:^|\s)will\s+not\s+/gi, " ");
+        // Remove standalone negation words (never, no, don't, cannot)
+        // surrounded by spaces — does NOT match "not" inside "anonymous"
+        result = result.replace(/\s+(?:never|no|don.t|doesn.t|can.t|cannot)\s+/gi, " ");
+        result = result.replace(/\s+not\s+/gi, " ");
+        // Remove modal verbs
+        result = result.replace(/\s+(?:must|shall|should|will|can|may|might)\s*/gi, " ");
+        result = result.replace(/\s+/g, " ").trim().toLowerCase();
+        return result;
+    }
+    // Check goal vs constraint pairs
+    for (const c of constraints) {
+        const normalizedConstr = normalizeForContradiction(c.normalizedText);
+        for (const g of goals) {
+            const normalizedGoal = normalizeForContradiction(g.normalizedText);
+            // Check if goal and constraint oppose each other after normalization
+            if (normalizedGoal === normalizedConstr && normalizedGoal.length > 3) {
+                ambiguities.push({
+                    id: `ambig-${ambiguityIndex++}`,
+                    question: `Contradiction detected: "${g.originalText}" contradicts "${c.originalText}". Which takes precedence?`,
+                    blocking: true,
+                    affectedGoals: [],
+                    evidence: [g.sourceRef, c.sourceRef],
+                    category: "contradiction",
+                });
+            }
+            // Check quantity contradictions
+            const qtyMatch = c.normalizedText.match(/\d+/);
+            const goalQtyMatch = g.normalizedText.match(/\d+/);
+            if (qtyMatch &&
+                goalQtyMatch &&
+                qtyMatch[0] !== goalQtyMatch[0] &&
+                c.normalizedText.includes("not")) {
+                ambiguities.push({
+                    id: `ambig-${ambiguityIndex++}`,
+                    question: `Quantity conflict: constraint says "${c.originalText}" but goal says "${g.originalText}". Clarify the correct value.`,
+                    blocking: true,
+                    affectedGoals: [],
+                    evidence: [g.sourceRef, c.sourceRef],
+                    category: "contradiction",
+                });
+            }
+        }
+    }
+    // Also check goal vs goal pairs (when both have negation)
+    for (let i = 0; i < goals.length; i++) {
+        for (let j = i + 1; j < goals.length; j++) {
+            const ga = goals[i];
+            const gb = goals[j];
+            const normA = normalizeForContradiction(ga.normalizedText);
+            const normB = normalizeForContradiction(gb.normalizedText);
+            if (normA === normB && normA.length > 3) {
+                // Check that one has negation and the other doesn't
+                const hasNegA = /\bnot\b|don.t|cannot/i.test(ga.normalizedText);
+                const hasNegB = /\bnot\b|don.t|cannot/i.test(gb.normalizedText);
+                if (hasNegA !== hasNegB) {
+                    ambiguities.push({
+                        id: `ambig-${ambiguityIndex++}`,
+                        question: `Contradiction detected: "${ga.originalText}" contradicts "${gb.originalText}". Which takes precedence?`,
+                        blocking: true,
+                        affectedGoals: [],
+                        evidence: [ga.sourceRef, gb.sourceRef],
+                        category: "contradiction",
+                    });
+                }
+            }
+        }
+    }
+    return ambiguities;
+}
+function detectScopeUncertainty(statements) {
+    const ambiguities = [];
+    let ambiguityIndex = 0;
+    const scopeKeywords = [
+        "maybe",
+        "possibly",
+        "or not",
+        "if possible",
+        "if needed",
+        "optional",
+        "as appropriate",
+    ];
+    for (const stmt of statements) {
+        const lower = stmt.normalizedText;
+        for (const kw of scopeKeywords) {
+            if (lower.includes(kw)) {
+                ambiguities.push({
+                    id: `ambig-${ambiguityIndex++}`,
+                    question: `Scope unclear: "${stmt.originalText}" uses "${kw}". Is this required or optional?`,
+                    blocking: false,
+                    affectedGoals: [],
+                    evidence: [stmt.sourceRef],
+                    category: "scope_unclear",
+                });
+                break;
+            }
+        }
+    }
+    return ambiguities;
+}
+/**
+ * Detect ambiguities in classified statements.
+ */
+export function detectAmbiguities(classification, _config) {
+    const allStatements = [
+        ...classification.goals,
+        ...classification.constraints,
+        ...classification.preferences,
+        ...classification.unknown,
+    ];
+    const ambiguities = [
+        ...detectVagueTerms(allStatements),
+        // Check all meaningful statements for missing actors, not just goals
+        // (preferences and unknown statements like "Who should..." may also lack actors)
+        ...detectMissingActors([
+            ...classification.goals,
+            ...classification.preferences,
+            ...classification.unknown,
+        ]),
+        ...detectContradictions(classification.goals, classification.constraints),
+        ...detectScopeUncertainty(allStatements),
+    ];
+    // De-duplicate by evidence text
+    const seen = new Set();
+    return ambiguities.filter((a) => {
+        const key = a.question;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+//# sourceMappingURL=ambiguity-detector.js.map

package/packages/requirement-compiler/dist/ambiguity-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambiguity-detector.js","sourceRoot":"","sources":["../src/ambiguity-detector.ts"],"names":[],"mappings":"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"}

package/packages/requirement-compiler/dist/classifier.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Requirement Compiler - Statement Classifier
+ *
+ * Classifies extracted statements into goals, constraints, preferences, etc.
+ */
+import type { ClassificationResult, ExtractedStatement, RequirementCompilerConfig } from "./types.js";
+/**
+ * Classify all extracted statements.
+ */
+export declare function classifyStatements(statements: ExtractedStatement[], config: RequirementCompilerConfig): ClassificationResult;
+//# sourceMappingURL=classifier.d.ts.map

package/packages/requirement-compiler/dist/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../src/classifier.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACX,oBAAoB,EACpB,kBAAkB,EAClB,yBAAyB,EACzB,MAAM,YAAY,CAAC;AA+FpB;;GAEG;AACH,wBAAgB,kBAAkB,CACjC,UAAU,EAAE,kBAAkB,EAAE,EAChC,MAAM,EAAE,yBAAyB,GAC/B,oBAAoB,CAiCtB"}