pi-harness-runtime 0.10.13 → 0.10.15

package/packages/quota-manager/src/tui-usage-monitor.js

@@ -0,0 +1,267 @@
+/**
+ * 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";
+/**
+ * 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 {
+    quotaManager;
+    debug;
+    lastSignals = new Map();
+    constructor(config) {
+        super();
+        this.quotaManager = config.quotaManager;
+        this.debug = config.debug ?? false;
+    }
+    /**
+     * Process a TUI message and extract quota signals
+     */
+    processMessage(message) {
+        // 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) {
+        }
+        return signal;
+    }
+    /**
+     * Detect which provider the message is about
+     */
+    detectProvider(message) {
+        for (const [provider, patterns] of Object.entries(PROVIDER_PATTERNS)) {
+            for (const pattern of patterns) {
+                if (pattern.test(message)) {
+                    return provider;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Get the last signal for a provider
+     */
+    getLastSignal(provider) {
+        return this.lastSignals.get(provider) ?? null;
+    }
+    /**
+     * Get all last signals
+     */
+    getAllLastSignals() {
+        return new Map(this.lastSignals);
+    }
+    /**
+     * Clear stored signals
+     */
+    clear() {
+        this.lastSignals.clear();
+    }
+    /**
+     * Parse the quota signal from message
+     */
+    parseSignal(message, provider) {
+        // 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
+     */
+    detectLimitType(message) {
+        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
+     */
+    containsExhaustedKeywords(message) {
+        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
+     */
+    parseResetTime(message) {
+        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
+     */
+    recordToQuotaManager(signal) {
+        // Map limit type to window type
+        let windowType = "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, pi, config) {
+    const monitor = new TUIUsageMonitor({
+        quotaManager,
+        debug: config?.debug,
+    });
+    // Hook into pi events
+    pi.on("error", (event) => {
+        monitor.processMessage(event.message);
+    });
+    pi.on("message", (event) => {
+        monitor.processMessage(event.message);
+    });
+    return monitor;
+}

package/packages/todo-bd-sync/src/detector.js

@@ -0,0 +1,131 @@
+/**
+ * Detection utilities for checking if rpiv-todo is installed
+ */
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+/**
+ * Check if @juicesharp/rpiv-todo is installed globally via npm
+ */
+export function isRpivTodoInstalled() {
+    try {
+        // Check npm global packages
+        const output = execSync("npm list -g @juicesharp/rpiv-todo 2>/dev/null || echo 'NOT_FOUND'", {
+            encoding: "utf8",
+            timeout: 5000,
+        });
+        return (output.includes("@juicesharp/rpiv-todo") && !output.includes("NOT_FOUND"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if rpiv-todo is loaded in pi extensions
+ * This checks common extension directories
+ */
+export function isRpivTodoLoaded() {
+    // Check pi-agent extensions directory
+    const extensionsDir = join(homedir(), ".pi", "agent", "extensions");
+    // Check for rpiv-todo related files
+    const possiblePaths = [
+        join(extensionsDir, "rpiv-todo"),
+        join(extensionsDir, "@juicesharp", "rpiv-todo"),
+        join(extensionsDir, "node_modules", "@juicesharp", "rpiv-todo"),
+    ];
+    for (const path of possiblePaths) {
+        if (existsSync(path)) {
+            return true;
+        }
+    }
+    // Also check if the module can be resolved
+    try {
+        require.resolve("@juicesharp/rpiv-todo");
+        return true;
+    }
+    catch {
+        // Not found via require
+    }
+    return false;
+}
+/**
+ * Get the version of rpiv-todo if installed
+ */
+export function getRpivTodoVersion() {
+    try {
+        const output = execSync("npm list -g @juicesharp/rpiv-todo --json 2>/dev/null | grep '\"version\"' | head -1", { encoding: "utf8", timeout: 5000 });
+        const match = output.match(/"version":\s*"([^"]+)"/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if bd CLI is installed
+ */
+export function isBdInstalled() {
+    try {
+        const output = execSync("which bd 2>/dev/null || echo 'NOT_FOUND'", {
+            encoding: "utf8",
+            timeout: 5000,
+        });
+        return output.includes("bd") && !output.includes("NOT_FOUND");
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if bd is initialized in the current project
+ * (i.e., .beads/ directory exists)
+ */
+export function isBdInitialized(cwd) {
+    const projectDir = cwd || process.cwd();
+    const beadsDir = join(projectDir, ".beads");
+    return existsSync(beadsDir);
+}
+/**
+ * Get the version of bd CLI if installed
+ */
+export function getBdVersion() {
+    try {
+        const output = execSync("bd --version 2>/dev/null || echo 'unknown'", {
+            encoding: "utf8",
+            timeout: 5000,
+        });
+        return output.trim().replace("bd version ", "");
+    }
+    catch {
+        return null;
+    }
+}
+export function getDependencyStatus(cwd) {
+    const installed = isBdInstalled();
+    return {
+        rpivTodo: {
+            installed: isRpivTodoInstalled(),
+            version: getRpivTodoVersion(),
+            loaded: isRpivTodoLoaded(),
+        },
+        bd: {
+            installed,
+            version: installed ? getBdVersion() : null,
+            initialized: installed ? isBdInitialized(cwd) : false,
+            installUrl: "https://github.com/gastownhall/beads",
+        },
+    };
+}
+/**
+ * Log dependency status for debugging
+ */
+export function logDependencyStatus() {
+    const status = getDependencyStatus();
+    console.log("[DEBUG todo-bd-sync] Dependency check:");
+    console.log(`  rpiv-todo: installed=${status.rpivTodo.installed}, version=${status.rpivTodo.version}, loaded=${status.rpivTodo.loaded}`);
+    console.log(`  bd: installed=${status.bd.installed}, version=${status.bd.version}, initialized=${status.bd.initialized}`);
+    if (!status.bd.installed) {
+        console.log(`  bd install: ${status.bd.installUrl}`);
+    }
+}

package/packages/todo-bd-sync/src/extension.js

@@ -0,0 +1,104 @@
+/**
+ * todo-bd-sync extension entry point
+ *
+ * This extension:
+ * 1. Detects if bd is installed and initialized
+ * 2. Auto-injects todo tool call when task is complex
+ * 3. Provides two-way sync between rpiv-todo and bd (via rpiv-todo)
+ */
+import { getDependencyStatus } from "./detector.js";
+import { getOpenBdIssues } from "./sync.js";
+import { decideAutoTodo, getTaskComplexityScore } from "./task-analyzer.js";
+/**
+ * Register the todo-bd-sync extension
+ */
+export function registerTodoBdSync(pi) {
+    const deps = getDependencyStatus();
+    // Check if bd is installed
+    if (!deps.bd.installed) {
+        console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚠️  bd (beads) is not installed
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+To use todo-bd-sync, install bd first:
+
+   https://github.com/gastownhall/beads
+
+Quick install:
+
+   npm install -g @gastownhall/beads
+
+   OR
+
+   pi install npm:@gastownhall/beads
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+        return;
+    }
+    // Check if bd is initialized in this project
+    if (!deps.bd.initialized) {
+        console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📋 bd (beads) detected but not initialized
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Run the following command to initialize:
+
+   bd init
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+    }
+    // ── Smart Auto-Todo Injection ──────────────────────────────────────────
+    // Listen to user input and inject todo tool call when task is complex
+    pi.on("input", (event) => {
+        // Only process user input (not from extensions or RPC)
+        if (event.source !== "interactive") {
+            return;
+        }
+        const text = event.text.trim();
+        if (!text || text.length < 5) {
+            return; // Skip very short inputs
+        }
+        const pendingCount = getOpenBdIssues().filter((i) => i.status !== "closed").length;
+        const decision = decideAutoTodo(text);
+        // If should create todo and phrase not already present
+        if (decision.shouldCreate) {
+            // Check if already has explicit todo instruction
+            const hasExplicitTodo = text.toLowerCase().includes("use the todo") ||
+                text.toLowerCase().includes("add to todo") ||
+                text.toLowerCase().includes("track as todo") ||
+                text.toLowerCase().includes("todo list") ||
+                text.toLowerCase().includes("create todo");
+            if (!hasExplicitTodo) {
+                const score = getTaskComplexityScore(text);
+                console.log(`[auto-todo] Task detected: ${decision.reason} (score: ${score}/100, pending: ${pendingCount})`);
+                // Clearer instruction that explicitly tells LLM to use todo tool
+                // This is more direct than just adding text - it tells LLM to CALL the todo tool
+                const injection = `
+
+IMPORTANT: Use the \`todo\` tool to track this task:
+1. Create a todo item with subject: "${text.slice(0, 80)}${text.length > 80 ? "..." : ""}"
+2. Mark it as in_progress
+3. Track your progress as you work
+
+\`\`\`json
+{"action": "create", "subject": "${text.slice(0, 80)}${text.length > 80 ? "..." : ""}", "activeForm": "working on task"}
+\`\`\`
+`;
+                return {
+                    action: "transform",
+                    text: text + injection,
+                };
+            }
+        }
+        return;
+    });
+    console.log("[todo-bd-sync] Started - smart auto-todo enabled");
+}
+// Default export for pi extension loading
+export default function todoBdSyncExtension(pi) {
+    registerTodoBdSync(pi);
+}