aegiscode 3.1.8 → 3.1.10

package/src/services/streaming/StreamEventParser.ts

@@ -0,0 +1,181 @@
+/**
+ * StreamEventParser — replicates Claude Code's event_parser.py
+ *
+ * Parses raw Anthropic Messages API streaming events (content_block_start/delta/stop)
+ * into typed internal events that the TranscriptBuffer consumes.
+ *
+ * This is the entry point for all streaming content. Every chunk from the API
+ * stream passes through here before being applied to the transcript.
+ */
+
+import type {
+  AnthropicStreamEvent,
+  ParsedEvent,
+  ContentBlockStartEvent,
+  ContentBlockDeltaEvent,
+  MessageStartEvent,
+} from './types.js';
+
+/**
+ * Parse a raw Anthropic stream event into one or more internal events.
+ *
+ * Returns an array of ParsedEvents (most events produce 1, content_block_start
+ * may produce 2 if there's initial text). Empty array if not recognized.
+ */
+export function parseStreamEvent(event: AnthropicStreamEvent): ParsedEvent[] {
+  const results: ParsedEvent[] = [];
+
+  switch (event.type) {
+    case 'content_block_start':
+      return parseContentBlockStart(event);
+
+    case 'content_block_delta':
+      return parseContentBlockDelta(event);
+
+    case 'content_block_stop':
+      return [{ type: 'block_stop', index: event.index }];
+
+    case 'message_start':
+      // message_start contains initial content blocks in non-streaming form.
+      // If the API sends content inline, parse them as full blocks.
+      return parseMessageContent(event);
+
+    case 'message_delta':
+      // message_delta signals completion metadata — map to complete event.
+      return [{ type: 'complete', status: event.delta.stop_reason }];
+
+    case 'message_stop':
+      // Signal final completion. If no content was streamed, this ensures
+      // the transcript shows something.
+      return [{ type: 'complete', status: 'message_stop' }];
+
+    case 'ping':
+      return [];
+
+    case 'error':
+      return [{
+        type: 'error',
+        message: event.error?.message || 'Unknown API error',
+      }];
+
+    default:
+      return [];
+  }
+}
+
+/**
+ * Parse content_block_start — produces the start event for the block type,
+ * plus potentially initial text/thinking content.
+ */
+function parseContentBlockStart(event: ContentBlockStartEvent): ParsedEvent[] {
+  const block = event.content_block;
+  const results: ParsedEvent[] = [];
+
+  switch (block.type) {
+    case 'thinking':
+      results.push({ type: 'thinking_start', index: event.index });
+      if (block.thinking) {
+        results.push({ type: 'thinking_delta', index: event.index, text: block.thinking });
+      }
+      break;
+
+    case 'text':
+      results.push({ type: 'text_start', index: event.index });
+      if (block.text) {
+        results.push({ type: 'text_delta', index: event.index, text: block.text });
+      }
+      break;
+
+    case 'tool_use':
+      results.push({
+        type: 'tool_use_start',
+        index: event.index,
+        id: block.id,
+        name: block.name,
+        input: block.input,
+      });
+      break;
+  }
+
+  return results;
+}
+
+/**
+ * Parse content_block_delta — produces delta events for the block type.
+ */
+function parseContentBlockDelta(event: ContentBlockDeltaEvent): ParsedEvent[] {
+  const delta = event.delta;
+
+  switch (delta.type) {
+    case 'text_delta':
+      return [{
+        type: 'text_delta',
+        index: event.index,
+        text: delta.text,
+      }];
+
+    case 'thinking_delta':
+      return [{
+        type: 'thinking_delta',
+        index: event.index,
+        text: delta.thinking,
+      }];
+
+    case 'input_json_delta':
+      return [{
+        type: 'tool_use_delta',
+        index: event.index,
+        partial_json: delta.partial_json,
+      }];
+
+    default:
+      return [];
+  }
+}
+
+/**
+ * Parse message content from message_start event — handles non-streaming
+ * content blocks that arrive inline.
+ */
+function parseMessageContent(event: MessageStartEvent): ParsedEvent[] {
+  const content = event.message?.content;
+  if (!Array.isArray(content) || content.length === 0) return [];
+
+  const results: ParsedEvent[] = [];
+
+  for (const block of content) {
+    if (typeof block !== 'object' || block === null) continue;
+
+    const b = block as Record<string, unknown>;
+
+    switch (b.type) {
+      case 'text':
+        results.push({ type: 'text_chunk' as const, text: String(b.text || '') });
+        break;
+
+      case 'thinking':
+        results.push({ type: 'thinking_chunk' as const, text: String(b.thinking || '') });
+        break;
+
+      case 'tool_use':
+        results.push({
+          type: 'tool_use' as const,
+          id: String(b.id || '').trim(),
+          name: String(b.name || ''),
+          input: b.input,
+        });
+        break;
+
+      case 'tool_result':
+        results.push({
+          type: 'tool_result' as const,
+          tool_use_id: String(b.tool_use_id || '').trim(),
+          content: b.content,
+          is_error: Boolean(b.is_error),
+        });
+        break;
+    }
+  }
+
+  return results;
+}

package/src/services/streaming/ThrottledRenderer.ts

@@ -0,0 +1,139 @@
+/**
+ * ThrottledRenderer — rate-limited transcript rendering with status lines.
+ *
+ * Replicates free-claude-code's ThrottledTranscriptEditor (messaging/ui_updates.py)
+ * plus the UI update loop from node_event_pipeline.py process_parsed_cli_event().
+ *
+ * Key behaviors:
+ * 1. Throttles to 1 update per second (configurable)
+ * 2. Deduplicates — skips if rendered text hasn't changed
+ * 3. Handles status line attachment
+ * 4. Integrates with RenderingProfile for platform-specific formatting
+ */
+
+import { TranscriptBuffer } from './TranscriptBuffer.js';
+import type { RenderContext } from './types.js';
+import type { RenderingProfile } from './types.js';
+
+/** Callback type for delivering rendered output */
+export type RenderOutputCallback = (text: string) => void | Promise<void>;
+
+export interface ThrottledRendererOptions {
+  /** Throttle interval in ms (default 1000) */
+  throttleMs?: number;
+  /** Debug logging */
+  debug?: boolean;
+}
+
+/**
+ * ThrottledRenderer — drives transcript rendering with rate limiting.
+ *
+ * Usage:
+ *   const renderer = new ThrottledRenderer(transcript, profile, outputCallback);
+ *   await renderer.update('🔄 Processing...');    // throttled
+ *   await renderer.update('✅ Complete', true);    // forced (no throttle)
+ */
+export class ThrottledRenderer {
+  private _transcript: TranscriptBuffer;
+  private _renderCtx: RenderContext;
+  private _outputCallback: RenderOutputCallback;
+  private _throttleMs: number;
+  private _debug: boolean;
+
+  private _lastUpdate = 0;
+  private _lastDisplayedText: string | null = null;
+  private _lastStatus: string | null = null;
+  private _pendingTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(
+    transcript: TranscriptBuffer,
+    profile: RenderingProfile,
+    outputCallback: RenderOutputCallback,
+    options: ThrottledRendererOptions = {},
+  ) {
+    this._transcript = transcript;
+    this._renderCtx = profile.renderCtx;
+    this._outputCallback = outputCallback;
+    this._throttleMs = options.throttleMs ?? 1000;
+    this._debug = options.debug ?? false;
+  }
+
+  get lastStatus(): string | null {
+    return this._lastStatus;
+  }
+
+  /**
+   * Update the rendered output.
+   * @param status Optional status line to append below transcript
+   * @param force If true, skip throttling and render immediately
+   */
+  async update(status?: string | null, force = false): Promise<void> {
+    const now = Date.now();
+
+    if (status !== undefined && status !== null) {
+      this._lastStatus = status;
+    }
+
+    if (!force && now - this._lastUpdate < this._throttleMs) {
+      // Schedule a pending update in case no more events arrive
+      if (!this._pendingTimer) {
+        this._pendingTimer = setTimeout(() => {
+          this._pendingTimer = null;
+          this._doUpdate().catch(() => {});
+        }, this._throttleMs);
+      }
+      return;
+    }
+
+    // Clear any pending timer
+    if (this._pendingTimer) {
+      clearTimeout(this._pendingTimer);
+      this._pendingTimer = null;
+    }
+
+    await this._doUpdate();
+  }
+
+  private async _doUpdate(): Promise<void> {
+    this._lastUpdate = Date.now();
+
+    let display: string;
+    try {
+      display = this._transcript.render(this._renderCtx, this._lastStatus ?? undefined);
+    } catch (err) {
+      if (this._debug) {
+        console.error('[ThrottledRenderer] render failed:', err);
+      }
+      return;
+    }
+
+    if (!display && !this._lastDisplayedText) {
+      return;
+    }
+
+    if (display === this._lastDisplayedText) {
+      return; // dedup
+    }
+
+    this._lastDisplayedText = display;
+
+    try {
+      await this._outputCallback(display);
+    } catch (err) {
+      if (this._debug) {
+        console.error('[ThrottledRenderer] output callback failed:', err);
+      }
+    }
+  }
+
+  /** Reset internal state (for new turns) */
+  reset(): void {
+    this._lastUpdate = 0;
+    this._lastDisplayedText = null;
+    this._lastStatus = null;
+    if (this._pendingTimer) {
+      clearTimeout(this._pendingTimer);
+      this._pendingTimer = null;
+    }
+  }
+}