anima-core 1.2.0 → 1.4.0

data/lib/tui/message_store.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "settings"
+
 module TUI
   # Thread-safe in-memory store for chat entries displayed in the TUI.
   # Replaces {Events::Subscribers::MessageCollector} in the WebSocket-based
@@ -36,8 +38,11 @@ module TUI
     def initialize
       @entries = []
       @entries_by_id = {}
+      @pending_entries = []
+      @pending_by_id = {}
       @mutex = Mutex.new
       @version = 0
+      @token_economy = default_token_economy
     end
 
     # Monotonically increasing counter that bumps on every mutation.
@@ -48,14 +53,38 @@ module TUI
       @mutex.synchronize { @version }
     end
 
-    # @return [Array<Hash>] thread-safe copy of stored entries
+    # @return [Array<Hash>] thread-safe copy of stored entries (pending messages at the end)
     def messages
-      @mutex.synchronize { @entries.dup }
+      @mutex.synchronize { @entries.dup + @pending_entries.dup }
     end
 
-    # @return [Integer] number of stored entries (no array copy)
+    # @return [Integer] number of stored entries including pending (no array copy)
     def size
-      @mutex.synchronize { @entries.size }
+      @mutex.synchronize { @entries.size + @pending_entries.size }
+    end
+
+    # Returns aggregated token economy data for HUD display.
+    # Includes running totals, cache hit rate, and latest rate limit snapshot.
+    #
+    # @return [Hash] token economy stats:
+    #   - :input_tokens [Integer] total input tokens across all calls
+    #   - :output_tokens [Integer] total output tokens
+    #   - :cache_read_input_tokens [Integer] total cached token reads
+    #   - :cache_creation_input_tokens [Integer] total cache writes
+    #   - :call_count [Integer] number of API calls tracked
+    #   - :cache_hit_rate [Float] percentage of input served from cache (0.0-1.0)
+    #   - :rate_limits [Hash, nil] latest rate limit values from API
+    def token_economy
+      @mutex.synchronize do
+        stats = @token_economy.dup
+        total_input = stats[:input_tokens] + stats[:cache_read_input_tokens] + stats[:cache_creation_input_tokens]
+        stats[:cache_hit_rate] = if total_input > 0
+          stats[:cache_read_input_tokens].to_f / total_input
+        else
+          0.0
+        end
+        stats
+      end
     end
 
     # Processes a raw event payload from the WebSocket channel.
@@ -65,12 +94,19 @@ module TUI
     # Events with `"action" => "update"` and a matching `"id"` replace
     # the existing entry's data in-place rather than appending.
     #
+    # Extracts api_metrics when present and accumulates token economy data.
+    #
     # @param event_data [Hash] Action Cable event payload with "type", "content",
-    #   and optionally "rendered" (hash of mode => lines), "id", "action"
+    #   and optionally "rendered" (hash of mode => lines), "id", "action", "api_metrics"
     # @return [Boolean] true if the event type was recognized and handled
     def process_event(event_data)
       message_id = event_data["id"]
 
+      # Track API metrics for token economy HUD (only on create, not update)
+      if event_data["action"] != "update"
+        accumulate_api_metrics(event_data["api_metrics"])
+      end
+
       if event_data["action"] == "update" && message_id
         return update_existing(event_data, message_id)
       end
@@ -91,32 +127,65 @@ module TUI
 
     # Removes all entries. Called on view mode change and session switch
     # to prepare for re-decorated viewport messages from the server.
+    # Resets token economy totals since we're starting fresh.
     # @return [void]
     def clear
       @mutex.synchronize do
         @entries = []
         @entries_by_id = {}
+        @pending_entries = []
+        @pending_by_id = {}
+        @token_economy = default_token_economy
+        @version += 1
+      end
+    end
+
+    # Adds a pending message to the separate pending list.
+    # Pending messages always render after real messages.
+    #
+    # @param pending_message_id [Integer] PendingMessage database ID
+    # @param content [String] message text
+    # @return [void]
+    def add_pending(pending_message_id, content)
+      @mutex.synchronize do
+        entry = {
+          type: :rendered,
+          data: {"role" => "user", "content" => content, "status" => "pending"},
+          message_type: "user_message",
+          pending_message_id: pending_message_id
+        }
+        old = @pending_by_id[pending_message_id]
+        @pending_entries.delete(old) if old
+        @pending_entries << entry
+        @pending_by_id[pending_message_id] = entry
+        @version += 1
+      end
+    end
+
+    # Removes a pending message by its PendingMessage ID.
+    #
+    # @param pending_message_id [Integer] PendingMessage database ID
+    # @return [Boolean] true if found and removed
+    def remove_pending(pending_message_id)
+      @mutex.synchronize do
+        entry = @pending_by_id.delete(pending_message_id)
+        return false unless entry
+
+        @pending_entries.delete(entry)
         @version += 1
+        true
       end
     end
 
     # Returns the last pending user message for recall editing.
-    # Walks entries backwards and returns the first pending user_message found.
     #
-    # @return [Hash, nil] `{id: Integer, content: String}` or nil if none pending
+    # @return [Hash, nil] `{pending_message_id: Integer, content: String}` or nil
     def last_pending_user_message
       @mutex.synchronize do
-        @entries.reverse_each do |entry|
-          next unless entry[:message_type] == "user_message"
-
-          if entry[:type] == :rendered && entry.dig(:data, "status") == "pending"
-            return {id: entry[:id], content: entry.dig(:data, "content")}
-          end
+        entry = @pending_entries.last
+        return nil unless entry
 
-          # Only check the most recent user message
-          break
-        end
-        nil
+        {pending_message_id: entry[:pending_message_id], content: entry.dig(:data, "content")}
       end
     end
 
@@ -202,16 +271,13 @@ module TUI
     # Inserts an entry in message-ID order. Entries without an ID are
     # appended. If an entry with the same ID already exists, updates
     # it in-place (deduplication for live/viewport replay races).
-    # System prompt entries are always placed at position 0.
+    # Callers send system prompt entries with {Message::SYSTEM_PROMPT_ID}
+    # (0) so they sort before all positive-ID messages and deduplicate
+    # on subsequent broadcasts.
     #
     # @param entry [Hash] the entry to insert
     # @return [void]
     def insert_ordered(entry)
-      if entry[:message_type] == "system_prompt"
-        @entries.unshift(entry)
-        return
-      end
-
       id = entry[:id]
       unless id
         @entries << entry
@@ -230,10 +296,14 @@ module TUI
       @entries_by_id[id] = entry
     end
 
-    # Inserts an entry in sorted order by message ID. Optimized for the
-    # common case where messages arrive in order (appends without scanning).
-    # Entries without IDs (tool counters, etc.) are skipped during the
-    # sort scan and don't affect insertion position.
+    # Inserts an entry in sorted order by message ID. Optimized for two
+    # common cases: appending (live streaming, ascending order) and
+    # prepending (session history replay, descending/newest-first order).
+    # Falls back to binary scan for out-of-order arrivals.
+    #
+    # Note: prepending N messages via +unshift+ is O(n) per call. For
+    # large viewport replays this totals O(n²), acceptable at typical
+    # viewport sizes (50–100 messages).
     #
     # @param entry [Hash] entry with a non-nil +:id+
     # @return [void]
@@ -247,6 +317,15 @@ module TUI
         return
       end
 
+      # Fast path: entry belongs at the beginning (session history replay, newest-first).
+      # Only safe when the first entry has an ID — non-ID entries (tool counters)
+      # at the head would be displaced, so we fall through to the general path.
+      first_id = @entries.first&.dig(:id)
+      if first_id && id < first_id
+        @entries.unshift(entry)
+        return
+      end
+
       # Out-of-order arrival: insert before the first entry with a higher ID
       insert_pos = @entries.index { |e| e[:id] && e[:id] > id } || @entries.size
       @entries.insert(insert_pos, entry)
@@ -254,6 +333,7 @@ module TUI
 
     # Returns the highest message ID in the entries array, scanning from the
     # end for efficiency (entries with IDs are typically at the tail).
+    # Used by {#insert_sorted_by_id} to detect the append fast path.
     #
     # @return [Integer, nil] the highest message ID, or nil if no entries have IDs
     def last_entry_id
@@ -302,5 +382,57 @@ module TUI
       last = @entries.last
       last if last&.dig(:type) == :tool_counter
     end
+
+    # Default token economy state for initialization and reset.
+    # @return [Hash]
+    def default_token_economy
+      {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        call_count: 0,
+        rate_limits: nil,
+        cache_history: []
+      }
+    end
+
+    # Accumulates API metrics from a message into running totals.
+    # Updates rate limits with the latest snapshot (most recent wins).
+    #
+    # @param api_metrics [Hash, nil] metrics from API response with "usage" and "rate_limits"
+    # @return [void]
+    def accumulate_api_metrics(api_metrics)
+      return unless api_metrics.is_a?(Hash)
+
+      @mutex.synchronize do
+        usage = api_metrics["usage"]
+        if usage.is_a?(Hash)
+          input = usage["input_tokens"].to_i
+          cache_read = usage["cache_read_input_tokens"].to_i
+          cache_create = usage["cache_creation_input_tokens"].to_i
+
+          @token_economy[:input_tokens] += input
+          @token_economy[:output_tokens] += usage["output_tokens"].to_i
+          @token_economy[:cache_read_input_tokens] += cache_read
+          @token_economy[:cache_creation_input_tokens] += cache_create
+          @token_economy[:call_count] += 1
+
+          # Per-call cache hit rate for sparkline graph
+          total = input + cache_read + cache_create
+          hit_rate = (total > 0) ? cache_read.to_f / total : 0.0
+          history = @token_economy[:cache_history]
+          history.shift if history.size >= Settings.message_store_max_cache_history
+          history << hit_rate
+        end
+
+        rate_limits = api_metrics["rate_limits"]
+        if rate_limits.is_a?(Hash)
+          @token_economy[:rate_limits] = rate_limits
+        end
+
+        @version += 1
+      end
+    end
   end
 end

data/lib/tui/performance_logger.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "logger"
+require_relative "settings"
 
 module TUI
   # Frame-level performance logger for TUI render profiling.
@@ -18,8 +19,6 @@ module TUI
   #   logger.measure(:line_count) { widget.line_count(width) }
   #   logger.end_frame
   class PerformanceLogger
-    LOG_PATH = "log/tui_performance.log"
-
     # @param enabled [Boolean] whether to actually log (no-op when false)
     def initialize(enabled: false)
       @enabled = enabled
@@ -30,7 +29,7 @@ module TUI
 
       return unless @enabled
 
-      @logger = Logger.new(LOG_PATH, 1, 5 * 1024 * 1024) # 5MB rotation
+      @logger = Logger.new(Settings.performance_log_path, 1, 5 * 1024 * 1024) # 5MB rotation
       @logger.formatter = proc { |_sev, time, _prog, msg| "#{time.strftime("%H:%M:%S.%L")} #{msg}\n" }
       @logger.info("TUI Performance Logger started — pid=#{Process.pid}")
     end