aegiscode 3.1.10 → 3.2.0

package/src/services/streaming/StreamEventParser.ts

@@ -1,181 +0,0 @@
-/**
- * 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

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