anima-core 1.1.3 → 1.3.0

data/lib/tui/decorators/write_decorator.rb

@@ -2,8 +2,9 @@
 
 module TUI
   module Decorators
-    # Renders write tool calls and responses.
-    # Calls show the file path with a memo icon.
+    # Renders write_file tool calls and responses.
+    # Calls show the file path with a memo icon in the unified tool color.
+    # Responses use the CRUD Create color (light_green) to signal new content.
     class WriteDecorator < BaseDecorator
       ICON = "\u{1F4DD}" # memo
 
@@ -11,8 +12,8 @@ module TUI
         ICON
       end
 
-      def color
-        "yellow"
+      def response_color
+        "light_green"
       end
     end
   end

data/lib/tui/flash.rb

@@ -22,7 +22,7 @@ module TUI
   # @example Dismissing
   #   flash.dismiss!
   class Flash
-    AUTO_DISMISS_SECONDS = 5.0
+    AUTO_DISMISS_SECONDS = 20.0
 
     # Flash area occupies at most 1/3 of the chat pane height.
     MAX_HEIGHT_FRACTION = 3

data/lib/tui/formatting.rb

@@ -16,6 +16,28 @@ module TUI
       "[#{label} tok]"
     end
 
+    # Returns a semantic color for token count display.
+    # Visually flags expensive messages so runaway tool calls or bloated
+    # responses jump out immediately in debug mode.
+    #
+    # Thresholds (empirically tuned from real agent sessions):
+    #   < 1k  → dark_gray  (routine, ignorable)
+    #   < 3k  → white      (normal)
+    #   < 10k → yellow     (notable)
+    #   < 20k → 208/orange (expensive)
+    #   ≥ 20k → red        (alarm — likely runaway)
+    #
+    # @param tokens [Integer] token count
+    # @return [String, Integer] named color or 256-color index
+    def token_count_color(tokens)
+      return "dark_gray" if tokens < 1_000
+      return "white" if tokens < 3_000
+      return "yellow" if tokens < 10_000
+      return 208 if tokens < 20_000 # orange (256-color)
+
+      "red"
+    end
+
     # Converts nanosecond-precision timestamp to human-readable HH:MM:SS.
     # @param ns [Integer, nil] nanosecond timestamp
     # @return [String] formatted time, or "--:--:--" when nil

data/lib/tui/message_store.rb

@@ -5,25 +5,25 @@ module TUI
   # Replaces {Events::Subscribers::MessageCollector} in the WebSocket-based
   # TUI, with no dependency on Rails or the Events module.
   #
-  # Accepts Action Cable event payloads and stores typed entries:
-  # - `{type: :rendered, data:, event_type:, id:}` for events with structured decorator output
+  # Accepts Action Cable message payloads and stores typed entries:
+  # - `{type: :rendered, data:, message_type:, id:}` for messages with structured decorator output
   # - `{type: :message, role:, content:, id:}` for user/agent messages (fallback)
   # - `{type: :tool_counter, calls:, responses:}` for tool activity
   #
-  # Structured data takes priority when available. Events with nil
-  # rendered content fall back to existing behavior: tool events aggregate
-  # into counters, messages store role and content.
+  # Structured data takes priority when available. Messages with nil
+  # rendered content fall back to existing behavior: tool messages aggregate
+  # into counters, conversation messages store role and content.
   #
-  # Entries with event IDs are maintained in ID order (ascending)
+  # Entries with message IDs are maintained in ID order (ascending)
   # regardless of arrival order, preventing misordering from race
   # conditions between live broadcasts and viewport replays.
   # Duplicate IDs are deduplicated by updating the existing entry.
   #
   # Tool counters aggregate per agent turn: a new counter starts when a
-  # tool_call arrives after a message entry. Consecutive tool events
-  # increment the same counter until the next message breaks the chain.
+  # tool_call arrives after a conversation entry. Consecutive tool messages
+  # increment the same counter until the next conversation message breaks the chain.
   #
-  # When an event arrives with `"action" => "update"` and a known `"id"`,
+  # When a message arrives with `"action" => "update"` and a known `"id"`,
   # the existing entry is replaced in-place, preserving display order.
   class MessageStore
     MESSAGE_TYPES = %w[user_message agent_message].freeze
@@ -36,6 +36,8 @@ module TUI
     def initialize
       @entries = []
       @entries_by_id = {}
+      @pending_entries = []
+      @pending_by_id = {}
       @mutex = Mutex.new
       @version = 0
     end
@@ -48,14 +50,14 @@ 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
 
     # Processes a raw event payload from the WebSocket channel.
@@ -69,16 +71,16 @@ module TUI
     #   and optionally "rendered" (hash of mode => lines), "id", "action"
     # @return [Boolean] true if the event type was recognized and handled
     def process_event(event_data)
-      event_id = event_data["id"]
+      message_id = event_data["id"]
 
-      if event_data["action"] == "update" && event_id
-        return update_existing(event_data, event_id)
+      if event_data["action"] == "update" && message_id
+        return update_existing(event_data, message_id)
       end
 
       rendered = extract_rendered(event_data)
 
       if rendered
-        record_rendered(rendered, event_type: event_data["type"], id: event_id)
+        record_rendered(rendered, message_type: event_data["type"], id: message_id)
       else
         case event_data["type"]
         when "tool_call" then record_tool_call
@@ -90,44 +92,75 @@ module TUI
     end
 
     # Removes all entries. Called on view mode change and session switch
-    # to prepare for re-decorated viewport events from the server.
+    # to prepare for re-decorated viewport messages from the server.
     # @return [void]
     def clear
       @mutex.synchronize do
         @entries = []
         @entries_by_id = {}
+        @pending_entries = []
+        @pending_by_id = {}
         @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[:event_type] == "user_message"
+        entry = @pending_entries.last
+        return nil unless entry
 
-          if entry[:type] == :rendered && entry.dig(:data, "status") == "pending"
-            return {id: entry[:id], content: entry.dig(:data, "content")}
-          end
-
-          # Only check the most recent user message
-          break
-        end
-        nil
+        {pending_message_id: entry[:pending_message_id], content: entry.dig(:data, "content")}
       end
     end
 
-    # Removes an entry by its event ID. Used when a pending message is
+    # Removes an entry by its message ID. Used when a pending message is
     # recalled for editing or deleted by another client.
     #
-    # @param event_id [Integer] database ID of the event to remove
+    # @param message_id [Integer] database ID of the message to remove
     # @return [Boolean] true if the entry was found and removed
-    def remove_by_id(event_id)
+    def remove_by_id(message_id)
       @mutex.synchronize do
-        entry = @entries_by_id.delete(event_id)
+        entry = @entries_by_id.delete(message_id)
         return false unless entry
 
         @entries.delete(entry)
@@ -136,17 +169,17 @@ module TUI
       end
     end
 
-    # Removes entries by their event IDs. Used when the brain reports
-    # that events have left the LLM's viewport (context window eviction).
+    # Removes entries by their message IDs. Used when the brain reports
+    # that messages have left the LLM's viewport (context window eviction).
     # Acquires the mutex once for the entire batch.
     #
-    # @param event_ids [Array<Integer>] database IDs of events to remove
+    # @param message_ids [Array<Integer>] database IDs of messages to remove
     # @return [Integer] count of entries actually removed
-    def remove_by_ids(event_ids)
+    def remove_by_ids(message_ids)
       @mutex.synchronize do
         removed = 0
-        event_ids.each do |event_id|
-          entry = @entries_by_id.delete(event_id)
+        message_ids.each do |message_id|
+          entry = @entries_by_id.delete(message_id)
           next unless entry
 
           @entries.delete(entry)
@@ -159,17 +192,17 @@ module TUI
 
     private
 
-    # Replaces data on an existing entry matched by event ID.
+    # Replaces data on an existing entry matched by message ID.
     # Only updates rendered entries — tool counters and plain messages
     # are not individually addressable by ID.
     #
     # @return [Boolean] true if the entry was found and updated
-    def update_existing(event_data, event_id)
+    def update_existing(event_data, message_id)
       rendered = extract_rendered(event_data)
       return false unless rendered
 
       @mutex.synchronize do
-        entry = @entries_by_id[event_id]
+        entry = @entries_by_id[message_id]
         return false unless entry
 
         entry[:data] = rendered
@@ -190,28 +223,25 @@ module TUI
 
     # Inserts a rendered entry at the correct chronological position.
     # System prompt entries (no ID) are always placed at position 0.
-    def record_rendered(data, event_type: nil, id: nil)
+    def record_rendered(data, message_type: nil, id: nil)
       @mutex.synchronize do
-        entry = {type: :rendered, data: data, event_type: event_type, id: id}
+        entry = {type: :rendered, data: data, message_type: message_type, id: id}
         insert_ordered(entry)
         @version += 1
       end
       true
     end
 
-    # Inserts an entry in event-ID order. Entries without an ID are
+    # 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[:event_type] == "system_prompt"
-        @entries.unshift(entry)
-        return
-      end
-
       id = entry[:id]
       unless id
         @entries << entry
@@ -222,7 +252,7 @@ module TUI
       if existing
         existing[:data] = entry[:data] if entry.key?(:data)
         existing[:content] = entry[:content] if entry.key?(:content)
-        existing[:event_type] = entry[:event_type] if entry.key?(:event_type)
+        existing[:message_type] = entry[:message_type] if entry.key?(:message_type)
         return
       end
 
@@ -230,10 +260,14 @@ module TUI
       @entries_by_id[id] = entry
     end
 
-    # Inserts an entry in sorted order by event ID. Optimized for the
-    # common case where events 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,15 +281,25 @@ 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)
     end
 
-    # Returns the highest event ID in the entries array, scanning from the
+    # 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 event ID, or nil if no entries have IDs
+    # @return [Integer, nil] the highest message ID, or nil if no entries have IDs
     def last_entry_id
       @entries.reverse_each { |e| return e[:id] if e[:id] }
       nil