samagotchi 0.3.0 → 0.5.0

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -50,6 +50,15 @@ module Samagotchi
         " #{paint(refs.map { |ref| "→ image #{ref[:width]}×#{ref[:height]}" }.join(", "), 90)}"
       end
 
+      # An edit/write row's change, after the row: " +3 −1" (green, red).
+      # +diff+ is EditPreview's hash, symbol or string keys (SSE, snapshot).
+      def format_tool_diff_suffix(diff)
+        return "" unless diff.is_a?(Hash)
+
+        get = ->(key) { diff[key] || diff[key.to_s] }
+        " #{paint("+#{get.(:added).to_i}", 32)} #{paint("\u2212#{get.(:removed).to_i}", 31)}"
+      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
@@ -126,6 +135,33 @@ module Samagotchi
         text.strip.empty? ? [] : lines
       end
 
+      # ── 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).
+      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.
+      ROLLBACK_HINT = "partial progress kept; !rollback restores the pre-turn state"
+
+      # "✕ turn canceled (Ctrl-C) · 3.1s"
+      def turn_canceled_line(reason, duration_ms)
+        label = reason.to_s.empty? ? nil : CANCEL_REASONS.fetch(reason.to_s, reason.to_s)
+        "#{paint("✕", 33)} turn canceled#{" (#{label})" if label}#{turn_duration_suffix(duration_ms)}"
+      end
+
+      # "✕ turn failed: <summary> · 2.0s"
+      def turn_failed_line(detail, duration_ms)
+        "#{paint("✕", 31)} turn failed: #{detail}#{turn_duration_suffix(duration_ms)}"
+      end
+
+      # A dim, indented line under a turn's end: what became of its prompt.
+      def turn_end_hint(text) = "  #{paint(text, 90)}"
+
+      def turn_duration_suffix(duration_ms)
+        duration_ms.nil? ? "" : " · #{format_elapsed_duration(duration_ms)}"
+      end
+
       private
 
       # The recap shown on return: dim, one "recap>" block, noting how many
@@ -165,9 +201,11 @@ module Samagotchi
 
       # ── The status line (the REPL's, and attached mode's idle one) ────────
 
-      # SAMAGOTCHI_STATUS_LINE=off hides it.
+      # status.line: off hides it.
+      STATUS_LINE_OFF = "off"
+
       def status_line_enabled?
-        value = ENV.fetch(STATUS_LINE_ENV, STATUS_LINE_ON).to_s.strip.downcase
+        value = Samagotchi::Config.get("status.line").to_s.strip.downcase
         !(value.empty? || value == STATUS_LINE_OFF || value == "0" || value == "false")
       end
 
@@ -195,10 +233,8 @@ module Samagotchi
         "model=#{model} (default: #{default_model})"
       end
 
-      # @param server [Hash, nil] the server's own numbers ({ctx_pct:, prompt_tokens:, ...})
       # @param estimate [Hash, nil] the kernel's estimate ({est_pct:, bucket:})
-      def status_context_text(server: nil, estimate: nil)
-        return format_server_context_segment(server) if server.is_a?(Hash)
+      def status_context_text(estimate: nil)
         return "" unless estimate.is_a?(Hash)
 
         pct = format("%.1f", estimate[:est_pct].to_f)
@@ -208,23 +244,6 @@ module Samagotchi
         "ctx=#{pct}% (#{bucket})"
       end
 
-      def format_server_context_segment(status)
-        pct = status[:ctx_pct]
-        base = pct ? "ctx=#{format('%.1f', pct)}%" : "ctx=srv"
-
-        tokens = []
-        prompt_tokens = status[:prompt_tokens]
-        completion_tokens = status[:completion_tokens]
-        total_tokens = status[:total_tokens]
-        tokens << "p=#{prompt_tokens}" if prompt_tokens
-        tokens << "c=#{completion_tokens}" if completion_tokens
-        tokens << "t=#{total_tokens}" if total_tokens
-
-        return base if tokens.empty?
-
-        "#{base} (#{tokens.join(' ')})"
-      end
-
       # @param label [String] "mem" for the used memories, "muted" for the
       #   session's --mute list
       def status_memory_text(names, limit, label: "mem")

data/lib/samagotchi/terminal_ui/input_support.rb

@@ -4,6 +4,7 @@ require "json"
 require "fileutils"
 require "reline"
 
+require_relative "../config"
 require_relative "../memory_paths"
 require_relative "../tools/memory"
 require_relative "../session_commands"
@@ -11,20 +12,18 @@ require_relative "../session_commands"
 module Samagotchi
   class TerminalUI
     # Input the REPL and the attached TUI share: the persistent prompt
-    # history, Tab completion (/commands, @path in the cwd, #memory), the
-    # #memory shorthand rewrite, multiline reads at the main prompt, and a
-    # one-shot prefill of the next read (the default input, a prompt given
-    # back after a failed turn).
+    # history, Tab completion (/commands, @path in the cwd, #memory, which
+    # inserts #name and the model reads it as typed), multiline reads at the
+    # main prompt, and a one-shot prefill of the next read (the default
+    # input, a prompt given back after a failed turn).
     #
     # Included for private use; it keeps state in @next_input_prefill and
     # reads @no_default_input.
     module InputSupport
-      PROMPT_HISTORY_ENV = "SAMAGOTCHI_HISTORY_FILE"
       XDG_STATE_HOME_ENV = "XDG_STATE_HOME"
       PROMPT_HISTORY_FILE = "history.json"
       PROMPT_HISTORY_STATE_DIR = "samagotchi"
       PROMPT_HISTORY_LIMIT = 20
-      DEFAULT_INPUT_ENV = "SAMAGOTCHI_DEFAULT_INPUT"
       AT_PATH_COMPLETION_PREFIX = "@"
       MEMORY_COMPLETION_PREFIX = "#"
       AT_PATH_COMPLETION_MAX_CANDIDATES = 200
@@ -204,23 +203,8 @@ module Samagotchi
         }
       end
 
-      def normalize_model_input(input)
-        input.to_s.gsub(/(^|[^\w\/])#((?:project|system)\/)?([a-zA-Z0-9][a-zA-Z0-9_-]*)/) do
-          prefix = Regexp.last_match(1)
-          scoped = Regexp.last_match(2).to_s
-          name = Regexp.last_match(3)
-          scope = scoped.delete_suffix("/")
-          normalized = if scope.empty?
-                         "memory \"#{name}\""
-                       else
-                         "memory \"#{name}\" in #{scope} scope"
-                       end
-          "#{prefix}#{normalized}"
-        end
-      end
-
       def history_file_path
-        explicit = ENV[PROMPT_HISTORY_ENV].to_s.strip
+        explicit = Samagotchi::Config.get("history.file").to_s.strip
         return explicit unless explicit.empty?
 
         File.join(xdg_state_home, PROMPT_HISTORY_STATE_DIR, PROMPT_HISTORY_FILE)
@@ -288,7 +272,7 @@ module Samagotchi
       def default_input_text
         return nil unless default_input_wanted?
 
-        default = ENV.fetch(DEFAULT_INPUT_ENV, nil)
+        default = Samagotchi::Config.get("default.input")
         return nil if default.nil? || default.strip.empty?
 
         default

data/lib/samagotchi/terminal_ui/plain_surface.rb

@@ -6,17 +6,19 @@ require_relative "surface"
 
 module Samagotchi
   class TerminalUI
-    # Attached mode's Surface when a live region can't be drawn (output or
+    # Both TUIs' Surface when a live region can't be drawn (output or
     # input not a terminal, TERM=dumb, or a Reline the seam doesn't support):
     # append-only output. Committed text and the notes, status and hints rows
     # print as lines. The activity slot is dropped, because redrawing it in
     # place needs cursor movement (the turn's lines still print as they end).
-    # The prompt is Reline's (or a plain read's) own, so output may cross it.
+    # The prompt is Reline's own, so output may cross it; the editor slot
+    # prints the prompt of a plain read (the REPL's ? off a terminal).
     class PlainSurface
       include Surface
 
-      # @param out [IO]
-      def initialize(out:)
+      # @param out [IO, nil] nil writes to $stdout as it is at each write
+      #   (specs swap it after the UI is built)
+      def initialize(out: nil)
         @out = out
         @lock = Monitor.new
       end
@@ -27,15 +29,15 @@ module Samagotchi
       def columns = IO.console&.winsize&.last || 80
 
       def commit(text)
-        synchronize { @out.puts(text) }
+        synchronize { out.puts(text) }
       end
 
       def set_slot(name, rows)
         check_slot!(name)
-        raise ArgumentError, "Reline draws the editor slot" if name == :editor
         return if name == :activity
+        return synchronize { out.print(Array(rows).join("\n")) && out.flush } if name == :editor
 
-        synchronize { lay_out(rows, width: columns).each { |row| @out.puts(row) } }
+        synchronize { lay_out(rows, width: columns).each { |row| out.puts(row) } }
       end
 
       # Nothing printed can be taken back.
@@ -46,6 +48,10 @@ module Samagotchi
       end
 
       def close; end
+
+      private
+
+      def out = @out || $stdout
     end
   end
 end

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -14,6 +14,8 @@ module Samagotchi
     # an optional "; reason"; a substring would pick the wrong one ("y" is
     # in "Deny").
     class QuestionPrompt
+      DIFF_CODES = { "+" => 32, "-" => 31, "@" => 2, "\\" => 2 }.freeze
+
       # A parsed answer. +error+ set: re-ask. +note+: print, then accept.
       Answer = Struct.new(:selected, :freeform, :error, :note, keyword_init: true) do
         def ok? = error.nil?
@@ -24,6 +26,8 @@ module Samagotchi
       # @param pending [Hash] Engine#pending_question (symbol or string keys)
       def initialize(pending)
         field = ->(key) { pending[key] || pending[key.to_s] }
+        approval = field.(:approval)
+        @preview = approval.is_a?(Hash) ? (approval[:preview] || approval["preview"]) : nil
         @id = field.(:id).to_s
         @question = field.(:question).to_s
         @options = Array(field.(:options)).map { |v| v.to_s.strip }.reject(&:empty?)
@@ -49,6 +53,34 @@ module Samagotchi
                          hint: slot_hint, question_code: approval? ? 33 : 94, paint: paint)
       end
 
+      # The most diff lines #preview_lines prints; the web shows them all.
+      PREVIEW_LINES = 40
+
+      # An edit/write approval's dry-run diff (approval.preview, symbol or
+      # string keys: nested keys are strings after a reload or SSE), as
+      # lines to print above the slot: coloured +/-, dim @@, cut at
+      # PREVIEW_LINES. [] for none.
+      def preview_lines(paint: ->(text, _code) { text })
+        preview = @preview
+        return [] unless preview.is_a?(Hash)
+
+        get = ->(key) { preview[key] || preview[key.to_s] }
+        return [paint.("this edit would fail: #{get.(:error)}", 33)] if get.(:error)
+        return [paint.("diff not shown: #{get.(:skipped)}", 2)] if get.(:skipped)
+
+        lines = get.(:text).to_s.split("\n")
+        return [] if lines.empty?
+
+        # TextDiff's own cut note ("… N more lines") counts toward the rest.
+        cut = lines.last.to_s[/\A… (\d+) more lines\z/, 1]
+        lines.pop if cut
+        hidden = [lines.size - PREVIEW_LINES, 0].max + cut.to_i
+        shown = lines.first(PREVIEW_LINES).map { |line| paint.(line, diff_code(line)) }
+        shown.unshift(paint.("new file", 2)) if get.(:new_file)
+        shown << paint.("… #{hidden} more lines (full diff on the web)", 2) if hidden.positive?
+        shown
+      end
+
       # The one line that stays in the scrollback once the question closes:
       # the question and what became of it.
       # @param outcome [String] the answer (#answer_text) or what closed it
@@ -148,6 +180,9 @@ module Samagotchi
         found = options.find { |o| o.downcase == tok.downcase || o.downcase.include?(tok.downcase) }
         found ? [found, nil] : [nil, "Unknown option '#{tok}'. Use numbers 1-#{options.size} or exact labels."]
       end
+
+      # "+" green, "-" red, "@@" and "\ No newline" dim, context plain.
+      def diff_code(line) = DIFF_CODES.fetch(line[0], 0)
     end
   end
 end

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "formatting"
+
+module Samagotchi
+  class TerminalUI
+    # The status row under the prompt, the same for both TUIs:
+    # `status> model=… | ↳ parent | ctx=12.3% (under20) | mem: … | muted: …`.
+    # A UI feeds it what it learns (attached mode from the Bridge's events,
+    # the REPL from its Engine's) through #update, and the row is redrawn in
+    # the surface's status slot only when its text changes.
+    class StatusRow
+      include Formatting
+
+      # Memory names shown before ", +N".
+      MEMORY_LIMIT = 8
+      # What the row shows:
+      #   model, default_model  the model in use, and the config's default
+      #                         (named beside another model)
+      #   served                [served, asked]: what the server said it
+      #                         served for the name asked (ServedModel)
+      #   parent_id             the session that delegated this one
+      #   context               the kernel's estimate {est_pct:, bucket:}
+      #   used_memories         the memories the session read
+      #   preloaded             its --memory list (shown until a turn
+      #                         records them as used)
+      #   muted                 its --mute list
+      FIELDS = %i[model default_model served parent_id context used_memories preloaded muted].freeze
+
+      # @param surface [Surface] with #columns
+      def initialize(surface)
+        @surface = surface
+        @values = { used_memories: [], preloaded: [], muted: [] }
+        @shown = nil
+      end
+
+      # The surface it draws on (the REPL swaps in a live region): the row
+      # is drawn there at the next change.
+      def surface=(surface)
+        @surface = surface
+        @shown = nil
+      end
+
+      def [](field) = @values[field]
+
+      # Change some fields; the row is redrawn when its text changed.
+      def update(**fields)
+        unknown = fields.keys - FIELDS
+        raise ArgumentError, "unknown status field(s): #{unknown.join(", ")}" if unknown.any?
+
+        @values.merge!(fields)
+        refresh
+      end
+
+      # Draw the row unless it shows that already (status.line: off draws
+      # nothing).
+      def refresh
+        return unless status_line_enabled?
+
+        rows = rows(@surface.columns - 1)
+        return if rows == @shown
+
+        @shown = rows
+        rows.empty? ? @surface.clear_slot(:status) : @surface.set_slot(:status, rows)
+      end
+
+      # @return [Array<String>] the row cut to +width+ (none with nothing to say)
+      def rows(width)
+        served, served_for = @values[:served]
+        model = @values[:model]
+        parent = @values[:parent_id]
+        segments = [model ? status_model_text(model, @values[:default_model], served: served, served_for: served_for) : "",
+                    parent ? "↳ #{parent.to_s[0, 8]}" : "",
+                    status_context_text(estimate: @values[:context]),
+                    status_memory_text(Array(@values[:used_memories]) | Array(@values[:preloaded]), MEMORY_LIMIT),
+                    status_memory_text(@values[:muted], MEMORY_LIMIT, label: "muted")].reject(&:empty?)
+        status_rows(segments, width)
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/surface.rb

@@ -15,7 +15,7 @@ module Samagotchi
     #
     # 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
+    # +hints+. An implementation without a live region (PlainSurface) 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