samagotchi 0.2.0

data/lib/samagotchi/terminal_ui/surface.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class TerminalUI
+    # Where a terminal UI draws. Two kinds of output:
+    #
+    # - +commit(text)+: permanent output (may hold several lines). It goes to
+    #   the scrollback and is never redrawn.
+    # - Slots: named groups of rows that the UI replaces as its state changes.
+    #   +set_slot(name, rows)+ shows +rows+ in the slot, replacing what it
+    #   held, and +clear_slot(name)+ removes them. clear_slot returns whether
+    #   it erased anything. +set_slots(name => rows, ...)+ changes several
+    #   at once (empty rows clear a slot); a live region draws them as one
+    #   frame.
+    #
+    # The slots, top down around the prompt: +activity+ (spinner, thinking
+    # preview), +editor+ (the prompt), +status+, +notes+ (question choices),
+    # +hints+. An implementation without a live region (LegacySurface) may
+    # print a slot's rows as plain output instead, so the rows stay on screen.
+    #
+    # Instead of rows, a slot may hold content that lays itself out: anything
+    # with +fit(width:, height:)+ -> rows (height nil: no limit). A live
+    # region fits it at every frame into the rows the slots above it leave
+    # (a question's choices on a short terminal); the others fit it once.
+    #
+    # Implementations include this module for the slot names.
+    module Surface
+      SLOTS = %i[activity editor status notes hints].freeze
+
+      def set_slots(**rows_by_slot)
+        rows_by_slot.each { |name, rows| set_slot(name, rows) }
+        nil
+      end
+
+      private
+
+      # @return [Array<String>] +rows+, or the rows fitted content gives
+      def lay_out(rows, width:, height: nil)
+        rows.respond_to?(:fit) ? Array(rows.fit(width: width, height: height)) : Array(rows)
+      end
+
+      def check_slot!(name)
+        raise ArgumentError, "unknown slot #{name.inspect} (slots: #{SLOTS.join(", ")})" unless SLOTS.include?(name)
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/thinking_line.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+require_relative "../thinking_ticker"
+require_relative "formatting"
+
+module Samagotchi
+  class TerminalUI
+    # What the model is doing, as one sentence for the activity slot: the
+    # newest sentence of the generation's thinking or of its text, through a
+    # 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
+    # lane's text; the line shown keeps the label of the lane it came from.
+    class ThinkingLine
+      include Formatting
+
+      # Enough text to find the newest sentence in; scanning grows with it.
+      BUFFER_LIMIT = 2000
+      # The Qwen turn preamble's first line ("TURN: reading the config").
+      TURN_PREFIX = /\ATURN:\s*/i
+      # Where a raw stream's thinking ends: a boundary, so its last words
+      # don't run into the answer's first.
+      THOUGHT_CLOSE = %r{<channel\|>|</think>}
+
+      def initialize(clock:, dwell: ThinkingTicker::DWELL)
+        @ticker = ThinkingTicker.new(clock: clock, dwell: dwell)
+        reset
+      end
+
+      # A new generation.
+      def reset
+        @ticker.reset
+        @lane = nil
+        @buffer = +""
+        @label = nil
+        @pending_label = nil
+      end
+
+      # @return [Boolean] whether the line changed
+      def chunk(event)
+        # The Bridge's TurnAccumulator reads the lanes by the same rule.
+        if event.key?(:text)
+          changed = add(:thinking, event[:thinking])
+          add(:writing, event[:text]) || changed
+        else
+          add(:thinking, event[:content], raw: true)
+        end
+      end
+
+      # A turn joined mid-way: the newest thinking or text part so far.
+      def resume(lane, text)
+        add(lane, text.to_s, raw: true)
+      end
+
+      # @return [Boolean] whether a pending sentence came up
+      def tick
+        return false unless @ticker.tick
+
+        @label = @pending_label
+        true
+      end
+
+      def empty? = @ticker.line.empty?
+
+      # @return [Symbol, nil] :thinking or :writing
+      attr_reader :label
+
+      # The sentence as a row shows it: no TURN: prefix, markdown plain.
+      def sentence = strip_markdown(@ticker.line.sub(TURN_PREFIX, ""))
+
+      # #sentence cut to +room+ columns, with an ellipsis when cut.
+      def fit(room)
+        text = sentence
+        room = [room, 1].max
+        text.length > room ? "#{text[0, room - 1]}…" : text
+      end
+
+      private
+
+      def add(lane, piece, raw: false)
+        return false if piece.nil? || piece.empty?
+
+        if lane != @lane
+          @lane = lane
+          @buffer = +""
+        end
+        @buffer << piece
+        @buffer = @buffer[-BUFFER_LIMIT..] if @buffer.length > BUFFER_LIMIT
+        @pending_label = lane
+        return false unless @ticker.feed(raw ? OutputFormatter.remove_tokens(@buffer.gsub(THOUGHT_CLOSE, "\n")) : @buffer)
+
+        @label = lane
+        true
+      end
+    end
+  end
+end