@getforgeai/cli 0.1.0-beta.1

package/dist/orchestrator/stream-batcher.d.ts

@@ -0,0 +1,16 @@
+/**
+ * StreamBatcher — accumulates stdout/stderr chunks and flushes on newline
+ * OR after a configurable time window (whichever comes first).
+ * Best-effort: flush errors are caught and logged, buffer is always cleared.
+ */
+export declare class StreamBatcher {
+    private readonly onFlush;
+    private readonly flushIntervalMs;
+    private buffer;
+    private timer;
+    constructor(onFlush: (chunk: string) => void, flushIntervalMs?: number);
+    write(data: string): void;
+    flush(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=stream-batcher.d.ts.map

package/dist/orchestrator/stream-batcher.js

@@ -0,0 +1,50 @@
+import chalk from "chalk";
+/**
+ * StreamBatcher — accumulates stdout/stderr chunks and flushes on newline
+ * OR after a configurable time window (whichever comes first).
+ * Best-effort: flush errors are caught and logged, buffer is always cleared.
+ */
+export class StreamBatcher {
+    onFlush;
+    flushIntervalMs;
+    buffer = "";
+    timer = null;
+    constructor(onFlush, flushIntervalMs = 200) {
+        this.onFlush = onFlush;
+        this.flushIntervalMs = flushIntervalMs;
+    }
+    write(data) {
+        this.buffer += data;
+        if (this.buffer.includes("\n")) {
+            this.flush();
+        }
+        else {
+            this.timer ??= setTimeout(() => this.flush(), this.flushIntervalMs);
+        }
+    }
+    flush() {
+        if (!this.buffer)
+            return;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        const chunk = this.buffer;
+        this.buffer = "";
+        try {
+            this.onFlush(chunk);
+        }
+        catch {
+            // Best-effort: log warning but always clear buffer to prevent unbounded growth
+            console.warn(chalk.yellow("[stream-batcher] onFlush error, chunk dropped"));
+        }
+    }
+    destroy() {
+        this.flush();
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+//# sourceMappingURL=stream-batcher.js.map

package/dist/orchestrator/stream-json-extractor.d.ts

@@ -0,0 +1,97 @@
+export type QuestionOption = {
+    label: string;
+    description?: string;
+};
+export type QuestionData = {
+    question: string;
+    header?: string;
+    options?: QuestionOption[];
+    multiSelect?: boolean;
+};
+export type ToolActivityData = {
+    toolName: string;
+    toolDetail: string;
+    /** For Agent tool_use blocks: the block's own id */
+    toolUseId?: string;
+    /** For sub-agent tools: the parent Agent tool_use id */
+    parentToolUseId?: string;
+};
+export type TokenUsageData = {
+    inputTokens: number;
+    outputTokens: number;
+};
+export declare class StreamJsonExtractor {
+    private readonly onText;
+    private lineBuf;
+    /** Track which tool_use IDs we've already emitted (questions + activity). */
+    private readonly emittedToolUseIds;
+    /** Track which system event UUIDs we've already processed (sub-agent progress). */
+    private readonly emittedSystemUuids;
+    /** Incremented on each message_start — groups text from the same API turn. */
+    turnIndex: number;
+    private readonly onQuestion?;
+    private readonly onToolActivity?;
+    private readonly onTokenUsage?;
+    private inputTokens;
+    private outputTokens;
+    /** Error text from the last `type: "result"` event with `is_error: true`. */
+    lastError: string | null;
+    /** Session ID for log context (optional). */
+    private readonly sessionId?;
+    constructor(onText: (delta: string) => void, onQuestion?: (questions: QuestionData[]) => void, onToolActivity?: (activity: ToolActivityData) => void, onTokenUsage?: (usage: TokenUsageData) => void, sessionId?: string);
+    write(data: string): void;
+    /** Flush any remaining partial line on process exit. */
+    flush(): void;
+    private parseLine;
+    private handleMessageStart;
+    private calculateInputTokens;
+    private handleContentBlockStart;
+    private handleMessageDelta;
+    private handleStreamEvent;
+    /**
+     * Handle `type: "result"` event — contains final usage stats.
+     * Used as fallback if message_start/message_delta didn't provide usage.
+     */
+    private handleResult;
+    private handleAskUserQuestion;
+    private handleToolActivity;
+    private isValidToolUseBlock;
+    /**
+     * Handle `type: "assistant"` snapshot messages.
+     * These contain cumulative content blocks after streaming completes for each block.
+     * We extract AskUserQuestion tool_use blocks and format questions as readable text.
+     */
+    private handleAssistantSnapshot;
+    /**
+     * Handle `type: "system"` events — sub-agent progress updates.
+     * System events with `last_tool_name` + `tool_use_id` represent tools used by sub-agents.
+     * `tool_use_id` references the parent Agent tool_use block id.
+     */
+    private handleSystemEvent;
+    private extractStructuredQuestions;
+    private formatOptionLine;
+    private formatQuestionOptions;
+    private formatQuestions;
+    private static readonly BILLING_PATTERNS;
+    /**
+     * Check if the captured error (from result event or accumulated stderr)
+     * indicates a billing/token exhaustion issue.
+     * Optionally accepts extra text (e.g. stderr buffer) to scan.
+     */
+    isBillingError(extraText?: string): boolean;
+    /**
+     * Extract the usage-limit reset timestamp from error text.
+     * Handles multiple formats:
+     *   - "reset at 2026-03-08T15:00:00+00:00" (ISO datetime)
+     *   - "resets 7pm (Europe/Paris)" (time + timezone)
+     *   - "resets in 2 hours" (relative duration)
+     * Returns an ISO string if a valid future timestamp is found, otherwise null.
+     */
+    extractResetTimestamp(extraText?: string): string | null;
+    /**
+     * Resolve a time-of-day (e.g. "7pm") in a named timezone to an ISO string.
+     * Uses Intl.DateTimeFormat to avoid external dependencies.
+     */
+    private static resolveTimeInTimezone;
+}
+//# sourceMappingURL=stream-json-extractor.d.ts.map