samagotchi 0.9.0 → 0.10.0

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -10,6 +10,7 @@ require_relative "image_input"
 require_relative "line_reader"
 require_relative "question_prompt"
 require_relative "reline_seam"
+require_relative "../bridge/turn_accumulator"
 require_relative "../bridge_client"
 require_relative "../log"
 require_relative "../context_note"
@@ -50,9 +51,6 @@ module Samagotchi
       JOIN_ANSWER_LINES = 12
       JOIN_ANSWER_CHARS = 1200
 
-      # Prompt labels by the sender's client_id prefix.
-      CLIENT_LABELS = { "web" => "web", "tui" => "tui", "system" => "reminder", "delegate" => "delegate" }.freeze
-
       attr_reader :client_id
 
       # @return [String, nil] the model the worker's turns run on, as the
@@ -199,10 +197,7 @@ module Samagotchi
           end_turn
           own_turn_ended(event)
         when :prompt_restored then restore_prompt(event)
-        when :context_status
-          @status.update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
-        when :used_memories_updated
-          @status.update(used_memories: Array(event[:used_memory_names]))
+        when :context_status, :used_memories_updated then @status.take_event(event)
         # Another client's anytime command: its line now, before the cards
         # it shows (its command_ran comes when it's done).
         when :command_queued
@@ -239,7 +234,7 @@ module Samagotchi
           line = EventRenderer.init_line(event)
           @screen.commit(line) if line
         when :generation_completed
-          take_served_model(event[:served_model], event[:requested_model])
+          @status.take_event(event)
           @renderer.call(event)
         when :stream_closed
           @view.finish_thinking_spinner
@@ -968,41 +963,44 @@ module Samagotchi
         return unless turn
 
         continues = turn[:prompt].nil?
-        @renderer.turn_continues = continues
         unless continues && reminder_origin?(turn[:origin] || {})
           @screen.commit(prompt_line(turn.dig(:origin, :client_id), turn[:prompt] || "(continuing)"))
         end
-        Array(turn[:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         tail = nil
         lane = :writing
         running_tool = nil
-        Array(turn[:parts]).each do |part|
-          case part[:kind]
-          when "thinking" then tail, lane = part[:text], :thinking
-          when "text" then tail, lane = part[:text], :writing
-          when "tool"
-            if part[:status] == "running"
-              running_tool = part[:tool]
-            else
-              @screen.commit(snapshot_tool_line(part))
-            end
-          when "input" then @screen.commit("input> #{part[:text]}")
-          when "steer" then @screen.commit(format_steer_line(source: part[:source], text: part[:text]))
-          when "reminder" then @screen.commit(reminder_line(part[:reminders]))
-          when "notice" then replay_notice(part[:event])
+        Bridge::TurnAccumulator.replay_events(turn).each do |event|
+          case event[:type]
+          when :generation_chunk
+            tail, lane = event[:thinking].to_s.empty? ? [event[:text], :writing] : [event[:thinking], :thinking]
+          when :tool_call_started
+            running_tool = event[:tool]
+            @renderer.call(event)
+          when :tool_call_completed
+            running_tool = nil
+            replay_tool_completed(event)
+          when :merged_input then @screen.commit("input> #{event[:content]}")
+          when :reminder_injected then @screen.commit(reminder_line(event[:reminders]))
+          # The turn's start (its images), a plugin's steer, and its rows (a
+          # hook's notice, a retry's line), as they were drawn live.
+          # Questions are left out: the pending one is asked after the
+          # replay, answered ones showed no line.
+          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry then @renderer.call(event)
           end
         end
         @view.resume(tail: tail, lane: lane, tool: running_tool, parts: turn[:parts])
         ask(turn[:pending_question]) if turn[:pending_question]
       end
 
-      # One of the running turn's rows (Bridge::TurnNotice), drawn as it was
-      # live: a hook's notice and a retry's line. Questions are left out:
-      # the pending one is asked after the replay, answered ones showed no
-      # line.
-      def replay_notice(event)
-        event = EventRenderer.symbolize(event || {})
-        @renderer.call(event) if %i[hook_notice empty_answer_retry].include?(event[:type])
+      # A finished tool call of the joined turn: the live row (action,
+      # duration). A snapshot from an older worker has no action: its row
+      # names the tool only.
+      def replay_tool_completed(event)
+        return @renderer.call({ duration_ms: nil }.merge(event)) if event.dig(:activity, :action)
+
+        activity = event[:activity] || {}
+        @screen.commit(snapshot_tool_line({ tool: event[:tool], params: activity[:params], status: activity[:status],
+                                            images: event[:images], diff: event[:diff] }))
       end
 
       def show_enqueued(event)
@@ -1051,22 +1049,7 @@ module Samagotchi
       # The joining snapshot's session state: the worker's model and the
       # memories the session used.
       def take_session_state(state)
-        fields = { served: nil }
-        fields.merge!(model: state[:model_name], default_model: default_model_name) if state[:model_name]
-        fields[:served] = [state[:served_model], state[:served_model_for]] if state[:served_model]
-        fields[:used_memories] = Array(state[:used_memory_names]) if state.key?(:used_memory_names)
-        fields[:preloaded] = Array(state[:preloaded_memory_names]) if state.key?(:preloaded_memory_names)
-        fields[:muted] = Array(state[:muted_memory_names]) if state.key?(:muted_memory_names)
-        fields[:parent_id] = state[:parent_id] if state.key?(:parent_id)
-        # The last turn's ctx, so it shows before this client's first turn.
-        fields[:context] = state[:context_status] if state[:context_status].is_a?(Hash)
-        @status.update(**fields)
-      end
-
-      # What the worker's server said it served for a name (a generation);
-      # dropped when /model switches.
-      def take_served_model(served, served_for)
-        @status.update(served: [served, served_for]) if served
+        @status.take_state(state, default_model: (default_model_name if state[:model_name]))
       end
 
       # The config's default model, as the worker's /model names it.
@@ -1077,39 +1060,6 @@ module Samagotchi
       end
 
       def reminder_origin?(origin) = origin[:client_id].to_s.start_with?("system:")
-
-      CONTEXT_NOTE_PREVIEW = 60
-
-      # "note from slack: <first line>", cut to one line.
-      def context_note_line(label, text)
-        lines = text.to_s.strip.split("\n")
-        first = lines.first.to_s
-        if first.length > CONTEXT_NOTE_PREVIEW
-          first = "#{first[0, CONTEXT_NOTE_PREVIEW - 1]}…"
-        elsif lines.size > 1
-          first += " …"
-        end
-        paint("note from #{label || "?"}: #{first}", 2)
-      end
-
-      def reminder_line(reminders)
-        names = Array(reminders).filter_map { |r| r.is_a?(Hash) ? r[:name] : r }
-        names.empty? ? "reminder" : "reminder: #{names.join(", ")}"
-      end
-
-      def prompt_line(client_id, prompt)
-        label = client_id ? CLIENT_LABELS.fetch(client_id.to_s.split(":", 2).first, "user") : "user"
-        "#{paint("#{label}>", 35)} #{prompt}"
-      end
-
-      # A tool call from the snapshot: it has no action text, only the tool.
-      def snapshot_tool_line(part)
-        params = part[:params].to_s.strip
-        params_suffix = params.empty? ? "" : " #{paint(params, 90)}"
-        status = part[:status].to_s
-        "#{paint('tool>', 36)} #{part[:tool]}#{params_suffix}: #{paint(status, status_color(status))}" \
-          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
-      end
     end
   end
 end

data/lib/samagotchi/terminal_ui/attached_view.rb

@@ -90,7 +90,7 @@ module Samagotchi
 
       def generation_feedback_retrying(event)
         @lock.synchronize do
-          @retry = retry_text(event)
+          @retry = format_generation_retry_line(event)
           # The retry streams from the start: wait for its first token again.
           @waiting_since = @clock.call if @thinking
           redraw_status
@@ -213,15 +213,6 @@ module Samagotchi
         @waiting_since = nil
       end
 
-      # "retrying (1/4 in 0.5s): Errno::ECONNREFUSED": the attempt of all
-      # there will be, the wait before it, and what failed.
-      def retry_text(event)
-        return "retrying (attempt #{event[:attempt]})" unless event[:max_retries]
-
-        text = "retrying (#{event[:attempt]}/#{event[:max_retries].to_i + 1} in #{format("%.1f", event[:next_delay].to_f)}s)"
-        event[:error_class].to_s.empty? ? text : "#{text}: #{event[:error_class]}"
-      end
-
       def tally_key(event)
         [event[:iteration].to_i, event[:call_index].to_i]
       end

data/lib/samagotchi/terminal_ui/between_turns.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "formatting"
+require_relative "event_renderer"
+
+module Samagotchi
+  class TerminalUI
+    # What the REPL prints between turns: cards and plugins' notices shown
+    # outside a turn, anytime commands' output, plugins' init lines and load
+    # warnings, and a recap written while idle.
+    #
+    # They are announced on other threads (the Engine's observers, the idle
+    # scheduler, an anytime command's own), where they are only kept; the
+    # main thread prints them at the open prompt (#flush_recap,
+    # #flush_cards), after the command that showed them. One that comes
+    # while a turn runs prints at once (above the live region) where the
+    # turn wouldn't print it itself.
+    class BetweenTurns
+      include Formatting
+
+      # A plugin's init task and a load warning: shown between turns too.
+      INIT_EVENTS = %i[plugin_init_started plugin_init_finished guardrail_warning].freeze
+
+      # @param surface [Surface] where lines print (swapped with #surface=)
+      # @param view [AttachedView] turns the activity row for init tasks
+      # @param renderer [EventRenderer] draws cards
+      # @param turn_running [#call] whether a turn runs now
+      # @param quiet [Boolean] a --non-interactive run: no init lines
+      def initialize(surface:, view:, renderer:, turn_running:, quiet: false)
+        @surface = surface
+        @view = view
+        @renderer = renderer
+        @turn_running = turn_running
+        @quiet = quiet
+        @cards = Queue.new
+        @recap = nil
+      end
+
+      attr_writer :surface
+
+      # The Engine's observer for cards, notices and init events (any
+      # thread). A card or a plugin's notice shown outside a turn is kept
+      # for the next flush; one shown during a turn is a turn event, the
+      # turn's sink prints it where it happens (EventRenderer).
+      #
+      # An anytime command's (event[:anytime]) print as it shows them: on
+      # the main thread (the command runs at the prompt) or beside a running
+      # turn, else at the next flush.
+      #
+      # A plugin's init task (chi.init) turns the activity row while it runs
+      # and prints a line when it is done; a load warning announced before
+      # the first turn, one. Beside a running turn they print at once.
+      def observe(event)
+        if INIT_EVENTS.include?(event[:type])
+          return if @quiet
+          return @view.init_started(event) if event[:type] == :plugin_init_started
+
+          @view.init_finished(event) if event[:type] == :plugin_init_finished
+          return show(event) if turn_running?
+
+          return @cards << event
+        end
+        return unless (event[:type] == :card && !event[:in_turn]) || (event[:type] == :hook_notice && event[:between_turns])
+        return show(event) if event[:anytime] && (Thread.current == Thread.main || turn_running?)
+
+        @cards << event
+      end
+
+      # Keep an item for the next flush (any thread).
+      def keep(item)
+        @cards << item
+      end
+
+      # An anytime command's output: beside a running turn at once, else at
+      # the next flush.
+      def show_or_keep(item)
+        turn_running? ? show(item) : keep(item)
+      end
+
+      # The Engine's observer for :recap_ready (the idle scheduler's thread):
+      # kept for #flush_recap. One collected just as a turn started describes
+      # the chat before it, and is dropped.
+      def take_recap(event)
+        return unless event[:type] == :recap_ready
+        return if event[:recap].to_s.strip.empty? || turn_running?
+
+        @recap = event[:recap].to_s
+      end
+
+      # Print a recap written while idle (main thread, at the open prompt).
+      def flush_recap
+        recap = @recap
+        return unless recap
+
+        @recap = nil
+        @surface.commit(recap_block(recap))
+      end
+
+      # Print the cards, notices and anytime commands' output kept since the
+      # last flush (main thread). A card replaced later in the same batch
+      # (the same id: btw's "thinking…", then its answer) prints once, as its
+      # last.
+      def flush_cards
+        items = []
+        loop { items << @cards.pop(true) }
+      rescue ThreadError
+        items.each_with_index do |item, index|
+          replaced = item[:type] == :card && items.drop(index + 1).any? { |later| later[:type] == :card && later[:id] == item[:id] }
+          show(item) unless replaced
+        end
+        nil
+      end
+
+      # A card, a notice, an anytime command's output (:command_output), a
+      # plugin init task's done line or a load warning.
+      def show(item)
+        case item[:type]
+        when :card then @renderer.render_card(item)
+        when :command_output then @surface.commit(item[:text])
+        when :guardrail_warning then @surface.commit(EventRenderer.load_warning_line(item))
+        when :plugin_init_finished
+          line = EventRenderer.init_line(item)
+          @surface.commit(line) if line
+        else @surface.commit(EventRenderer.hook_notice_line(item))
+        end
+      end
+
+      private
+
+      def turn_running? = @turn_running.call
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -68,7 +68,9 @@ module Samagotchi
         when :tool_call_completed
           @view.clear_generation_retry
           @view.tool_call_feedback_completed(event)
-          render_streamed_tool_activity(event[:activity], duration_ms: tool_duration_ms(event), images: event[:images],
+          # A replayed row (a join) carries its duration (nil: unknown).
+          measured = tool_duration_ms(event)
+          render_streamed_tool_activity(event[:activity], duration_ms: event.fetch(:duration_ms, measured), images: event[:images],
                                                           diff: event[:diff])
         when :generation_completed, :generation_cancelled, :tool_dispatch_started
           @view.generation_feedback_finished

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -44,6 +44,16 @@ module Samagotchi
         paint("↻ #{what}, asking again (#{event[:attempt]}/#{event[:of]})", 90)
       end
 
+      # "retrying (1/3 in 0.5s): Errno::ECONNREFUSED": the retry of all the
+      # retries there will be (as the web counts), the wait before it, and
+      # what failed (generation_retrying).
+      def format_generation_retry_line(event)
+        return "retrying (attempt #{event[:attempt]})" unless event[:max_retries]
+
+        text = "retrying (#{event[:attempt]}/#{event[:max_retries]} in #{format("%.1f", event[:next_delay].to_f)}s)"
+        event[:error_class].to_s.empty? ? text : "#{text}: #{event[:error_class]}"
+      end
+
       # " → image 1280×800" after a tool line whose tool read an image.
       def format_tool_image_suffix(images)
         refs = Array(images).map { |ref| ImageStore.symbolize(ref) }
@@ -61,6 +71,45 @@ module Samagotchi
         " #{paint("+#{get.(:added).to_i}", 32)} #{paint("\u2212#{get.(:removed).to_i}", 31)}"
       end
 
+      # Prompt labels by the sender's client_id prefix (turn_events.js
+      # CLIENT_LABELS; spec/shared/labels_matrix.json).
+      CLIENT_LABELS = { "web" => "web", "tui" => "tui", "system" => "reminder", "delegate" => "delegate" }.freeze
+
+      # "web> <prompt>": a prompt, labelled by who sent it.
+      def prompt_line(client_id, prompt)
+        label = client_id ? CLIENT_LABELS.fetch(client_id.to_s.split(":", 2).first, "user") : "user"
+        "#{paint("#{label}>", 35)} #{prompt}"
+      end
+
+      # "reminder: a, b": the reminders a turn runs for (names or hashes).
+      def reminder_line(reminders)
+        names = Array(reminders).filter_map { |r| r.is_a?(Hash) ? r[:name] : r }
+        names.empty? ? "reminder" : "reminder: #{names.join(", ")}"
+      end
+
+      CONTEXT_NOTE_PREVIEW = 60
+
+      # "note from slack: <first line>", cut to one line.
+      def context_note_line(label, text)
+        lines = text.to_s.strip.split("\n")
+        first = lines.first.to_s
+        if first.length > CONTEXT_NOTE_PREVIEW
+          first = "#{first[0, CONTEXT_NOTE_PREVIEW - 1]}\u2026"
+        elsif lines.size > 1
+          first += " \u2026"
+        end
+        paint("note from #{label || "?"}: #{first}", 2)
+      end
+
+      # A tool call from the snapshot: it has no action text, only the tool.
+      def snapshot_tool_line(part)
+        params = part[:params].to_s.strip
+        params_suffix = params.empty? ? "" : " #{paint(params, 90)}"
+        status = part[:status].to_s
+        "#{paint('tool>', 36)} #{part[:tool]}#{params_suffix}: #{paint(status, status_color(status))}" \
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
+      end
+
       # A card (Engine#show_card) as a framed block: the title and its
       # source, the body as wrapped plain text (no terminal markdown), and
       # one `→ <command>` line per action, the label after it when it says
@@ -140,7 +189,8 @@ module Samagotchi
       # ── Turn ends: one set of words for the REPL, attached mode and the
       # web (timing.js cancelLineText, format.js failedTurnText) ──────────
 
-      # A cancel's reason as the UIs name it (anything else as it is).
+      # A cancel's reason as the UIs name it (anything else as it is);
+      # spec/shared/labels_matrix.json pins it for both.
       CANCEL_REASONS = { "ctrl_c" => "Ctrl-C", "user" => "stopped", "hook" => "by a hook" }.freeze
       # Under a canceled prompt turn (a canceled continue is back where it
       # started): its partial progress stays in the conversation.

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -52,6 +52,38 @@ module Samagotchi
         refresh
       end
 
+      # Take a session's state: the REPL's Engine#session_state_snapshot, or
+      # the one a worker sends an attached TUI when it joins. A key the state
+      # lacks (an older worker's) leaves its field as it was; the served pair
+      # is cleared without one, and the model is kept without a name.
+      # @param default_model [String, nil] the config's default, named beside
+      #   another model
+      def take_state(state, default_model: nil)
+        fields = { served: state[:served_model] ? [state[:served_model], state[:served_model_for]] : nil }
+        fields.merge!(model: state[:model_name], default_model: default_model) if state[:model_name]
+        STATE_LISTS.each { |field, key| fields[field] = Array(state[key]) if state.key?(key) }
+        fields[:parent_id] = state[:parent_id] if state.key?(:parent_id)
+        # The last turn's ctx, so it shows before the next turn's.
+        fields[:context] = state[:context_status] if state[:context_status].is_a?(Hash)
+        update(**fields)
+      end
+
+      # The memory lists' fields and the state keys they come from.
+      STATE_LISTS = { used_memories: :used_memory_names, preloaded: :preloaded_memory_names,
+                      muted: :muted_memory_names }.freeze
+
+      # Take what a turn event says about the row (the Engine's events in
+      # the REPL, the Bridge's in attached mode): ctx, the memories used,
+      # the model the server served. Other events change nothing.
+      def take_event(event)
+        case event[:type]
+        when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
+        when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
+        when :generation_completed
+          update(served: [event[:served_model], event[:requested_model]]) if event[:served_model]
+        end
+      end
+
       # Draw the row unless it shows that already (status.line: off draws
       # nothing).
       def refresh

data/lib/samagotchi/terminal_ui/thinking_line.rb

@@ -11,9 +11,9 @@ module Samagotchi
     # ThinkingTicker (so it changes at most once per dwell). Both TUIs use it
     # in place of the raw tail of the stream.
     #
-    # A chunk carries :text (and :thinking) when the profile splits its stream
-    # (Qwen, every chat host); otherwise the raw :content, markup stripped,
-    # stands for thinking. A switch of lane starts the next sentence from the new
+    # A chunk carries :text (and :thinking): both loops split their stream,
+    # for every profile. A chunk without them (an older worker) has its raw
+    # :content, markup stripped, stand for thinking. A switch of lane starts the next sentence from the new
     # lane's text; the line shown keeps the label of the lane it came from.
     class ThinkingLine
       include Formatting